This chapter describes the REST architecture, RESTful web services, and the Java API for RESTful Web Services (JAX-RS, defined in JSR 339).
JAX-RS makes it easy for developers to build RESTful web services using the Java programming language.
The following topics are addressed here:
RESTful web services are loosely coupled, lightweight web services that are particularly well suited for creating APIs for clients spread out across the internet. Representational State Transfer (REST) is an architectural style of client-server application centered around the transfer of representations of resources through requests and responses. In the REST architectural style, data and functionality are considered resources and are accessed using Uniform Resource Identifiers (URIs), typically links on the Web. The resources are represented by documents and are acted upon by using a set of simple, well-defined operations.
For example, a REST resource might be the current weather conditions for a city. The representation of that resource might be an XML document, an image file, or an HTML page. A client might retrieve a particular representation, modify the resource by updating its data, or delete the resource entirely.
The REST architectural style is designed to use a stateless communication protocol, typically HTTP. In the REST architecture style, clients and servers exchange representations of resources by using a standardized interface and protocol.
The following principles encourage RESTful applications to be simple, lightweight, and fast:
Resource identification through URI: A RESTful web service exposes a set of resources that identify the targets of the interaction with its clients. Resources are identified by URIs, which provide a global addressing space for resource and service discovery. See The @Path Annotation and URI Path Templates for more information.
Uniform interface: Resources are manipulated using a fixed set of four create, read, update, delete operations: PUT, GET, POST, and DELETE. PUT creates a new resource, which can be then deleted by using DELETE. GET retrieves the current state of a resource in some representation. POST transfers a new state onto a resource. See Responding to HTTP Methods and Requests for more information.
Self-descriptive messages: Resources are decoupled from their representation so that their content can be accessed in a variety of formats, such as HTML, XML, plain text, PDF, JPEG, JSON, and other document formats. Metadata about the resource is available and used, for example, to control caching, detect transmission errors, negotiate the appropriate representation format, and perform authentication or access control. See Responding to HTTP Methods and Requests and Using Entity Providers to Map HTTP Response and Request Entity Bodies for more information.
Stateful interactions through links: Every interaction with a resource is stateless; that is, request messages are self-contained. Stateful interactions are based on the concept of explicit state transfer. Several techniques exist to exchange state, such as URI rewriting, cookies, and hidden form fields. State can be embedded in response messages to point to valid future states of the interaction. See Using Entity Providers to Map HTTP Response and Request Entity Bodies and "Building URIs" in the JAX-RS Overview document for more information.
Root resource classes are "plain old Java objects" (POJOs) that are either annotated with @Path
or have at least one method annotated with @Path
or a request method designator, such as @GET
, @PUT
, @POST
, or @DELETE
. Resource methods are methods of a resource class annotated with a request method designator. This section explains how to use JAX-RS to annotate Java classes to create RESTful web services.
JAX-RS is a Java programming language API designed to make it easy to develop applications that use the REST architecture.
The JAX-RS API uses Java programming language annotations to simplify the development of RESTful web services. Developers decorate Java programming language class files with JAX-RS annotations to define resources and the actions that can be performed on those resources. JAX-RS annotations are runtime annotations; therefore, runtime reflection will generate the helper classes and artifacts for the resource. A Java EE application archive containing JAX-RS resource classes will have the resources configured, the helper classes and artifacts generated, and the resource exposed to clients by deploying the archive to a Java EE server.
Table 29-1 lists some of the Java programming annotations that are defined by JAX-RS, with a brief description of how each is used. Further information on the JAX-RS APIs can be viewed at http://docs.oracle.com/javaee/7/api/
.
Table 29-1 Summary of JAX-RS Annotations
| Annotation | Description |
|---|---|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
The |
|
|
|
The |
The following code sample is a very simple example of a root resource class that uses JAX-RS annotations:
package javaeetutorial.hello; import javax.ws.rs.Consumes; import javax.ws.rs.GET; import javax.ws.rs.PUT; import javax.ws.rs.Path; import javax.ws.rs.Produces; import javax.ws.rs.core.Context; import javax.ws.rs.core.UriInfo; /** * Root resource (exposed at "helloworld" path) */ @Path("helloworld") public class HelloWorld { @Context private UriInfo context; /** Creates a new instance of HelloWorld */ public HelloWorld() { } /** * Retrieves representation of an instance of helloWorld.HelloWorld * @return an instance of java.lang.String */ @GET @Produces("text/html") public String getHtml() { return "
Hello, World!!
"; } }
The following sections describe the annotations used in this example.
The @Path
annotation's value is a relative URI path. In the preceding example, the Java class will be hosted at the URI path /helloworld
. This is an extremely simple use of the @Path
annotation, with a static URI path. Variables can be embedded in the URIs. URI path templates are URIs with variables embedded within the URI syntax.
The @GET
annotation is a request method designator, along with @POST
, @PUT
, @DELETE
, and @HEAD
, defined by JAX-RS and corresponding to the similarly named HTTP methods. In the example, the annotated Java method will process HTTP GET requests. The behavior of a resource is determined by the HTTP method to which the resource is responding.
The @Produces
annotation is used to specify the MIME media types a resource can produce and send back to the client. In this example, the Java method will produce representations identified by the MIME media type "text/html"
.
The @Consumes
annotation is used to specify the MIME media types a resource can consume that were sent by the client. The example could be modified to set the message returned by the getHtml
method, as shown in this code example:
@POST @Consumes("text/plain") public void postHtml(String message) { // Store the message }
The @Path
annotation identifies the URI path template to which the resource responds and is specified at the class or method level of a resource. The @Path
annotation's value is a partial URI path template relative to the base URI of the server on which the resource is deployed, the context root of the application, and the URL pattern to which the JAX-RS runtime responds.
URI path templates are URIs with variables embedded within the URI syntax. These variables are substituted at runtime in order for a resource to respond to a request based on the substituted URI. Variables are denoted by braces ({
and }
). For example, look at the following @Path
annotation:
@Path("/users/{username}")
In this kind of example, a user is prompted to type his or her name, and then a JAX-RS web service configured to respond to requests to this URI path template responds. For example, if the user types the user name "Galileo," the web service responds to the following URL:
http://example.com/users/Galileo
To obtain the value of the user name, the @PathParam
annotation may be used on the method parameter of a request method, as shown in the following code example:
@Path("/users/{username}") public class UserResource { @GET @Produces("text/xml") public String getUser(@PathParam("username") String userName) { ... } }
By default, the URI variable must match the regular expression "[^/]+?"
. This variable may be customized by specifying a different regular expression after the variable name. For example, if a user name must consist only of lowercase and uppercase alphanumeric characters, override the default regular expression in the variable definition:
@Path("users/{username: [a-zA-Z][a-zA-Z_0-9]*}")
In this example, the username
variable will match only user names that begin with one uppercase or lowercase letter and zero or more alphanumeric characters and the underscore character. If a user name does not match that template, a 404 (Not Found) response will be sent to the client.
A @Path
value isn't required to have leading or trailing slashes (/). The JAX-RS runtime parses URI path templates the same way, whether or not they have leading or trailing slashes.
A URI path template has one or more variables, with each variable name surrounded by braces: {
to begin the variable name and }
to end it. In the preceding example, username
is the variable name. At runtime, a resource configured to respond to the preceding URI path template will attempt to process the URI data that corresponds to the location of {username}
in the URI as the variable data for username
.
For example, if you want to deploy a resource that responds to the URI path template http://example.com/myContextRoot/resources/{name1}/{name2}/
, you must first deploy the application to a Java EE server that responds to requests to the http://example.com/myContextRoot
URI and then decorate your resource with the following @Path
annotation:
@Path("/{name1}/{name2}/") public class SomeResource { ... }
In this example, the URL pattern for the JAX-RS helper servlet, specified in web.xml
, is the default:
<servlet-mapping> <servlet-name>javax.ws.rs.core.Application</servlet-name> <url-pattern>/resources/*</url-pattern> </servlet-mapping>
A variable name can be used more than once in the URI path template.
If a character in the value of a variable would conflict with the reserved characters of a URI, the conflicting character should be substituted with percent encoding. For example, spaces in the value of a variable should be substituted with %20
.
When defining URI path templates, be careful that the resulting URI after substitution is valid.
Table 29-2 lists some examples of URI path template variables and how the URIs are resolved after substitution. The following variable names and values are used in the examples:
name1
: james
name2
: gatz
name3
:
location
: Main%20Street
question
: why
|
Note: The value of the |
Table 29-2 Examples of URI Path Templates
| URI Path Template | URI After Substitution |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
The behavior of a resource is determined by the HTTP methods (typically, GET, POST, PUT, or DELETE) to which the resource is responding.
Request method designator annotations are runtime annotations, defined by JAX-RS, that correspond to the similarly named HTTP methods. Within a resource class file, HTTP methods are mapped to Java programming language methods by using the request method designator annotations. The behavior of a resource is determined by which HTTP method the resource is responding to. JAX-RS defines a set of request method designators for the common HTTP methods GET, POST, PUT, DELETE, and HEAD; you can also create your own custom request method designators. Creating custom request method designators is outside the scope of this document.
The following example shows the use of the PUT method to create or update a storage container:
@PUT public Response putContainer() { System.out.println("PUT CONTAINER " + container); URI uri = uriInfo.getAbsolutePath(); Container c = new Container(container, uri.toString()); Response r; if (!MemoryStore.MS.hasContainer(c)) { r = Response.created(uri).build(); } else { r = Response.noContent().build(); } MemoryStore.MS.createContainer(c); return r; }
By default, the JAX-RS runtime will automatically support the methods HEAD and OPTIONS if not explicitly implemented. For HEAD, the runtime will invoke the implemented GET method, if present, and ignore the response entity, if set. For OPTIONS, the Allow
response header will be set to the set of HTTP methods supported by the resource. In addition, the JAX-RS runtime will return a Web Application Definition Language (WADL) document describing the resource; see http://www.w3.org/Submission/wadl/
for more information.
Methods decorated with request method designators must return void
, a Java programming language type, or a javax.ws.rs.core.Response
object. Multiple parameters may be extracted from the URI by using the @PathParam
or @QueryParam
annotations, as described in Extracting Request Parameters. Conversion between Java types and an entity body is the responsibility of an entity provider, such as MessageBodyReader
or MessageBodyWriter
. Methods that need to provide additional metadata with a response should return an instance of the Response
class. The ResponseBuilder
class provides a convenient way to create a Response
instance using a builder pattern. The HTTP PUT and POST methods expect an HTTP request body, so you should use a MessageBodyReader
for methods that respond to PUT and POST requests.
Both @PUT
and @POST
can be used to create or update a resource. POST can mean anything, so when using POST, it is up to the application to define the semantics. PUT has well-defined semantics. When using PUT for creation, the client declares the URI for the newly created resource.
PUT has very clear semantics for creating and updating a resource. The representation the client sends must be the same representation that is received using a GET, given the same media type. PUT does not allow a resource to be partially updated, a common mistake when attempting to use the PUT method. A common application pattern is to use POST to create a resource and return a 201
response with a location header whose value is the URI to the newly created resource. In this pattern, the web service declares the URI for the newly created resource.
Entity providers supply mapping services between representations and their associated Java types. The two types of entity providers are MessageBodyReader
and MessageBodyWriter
. For HTTP requests, the MessageBodyReader
is used to map an HTTP request entity body to method parameters. On the response side, a return value is mapped to an HTTP response entity body by using a MessageBodyWriter
. If the application needs to supply additional metadata, such as HTTP headers or a different status code, a method can return a Response
that wraps the entity and that can be built by using Response.ResponseBuilder
.
Table 29-3 shows the standard types that are supported automatically for HTTP request and response entity bodies. You need to write an entity provider only if you are not choosing one of these standard types.
Table 29-3 Types Supported for HTTP Request and Response Entity Bodies
| Java Type | Supported Media Types |
|---|---|
|
|
All media types ( |
|
|
All text media types ( |
|
|
All media types ( |
|
|
All media types ( |
|
|
All media types ( |
|
|
All media types ( |
|
|
XML media types ( |
|
|
XML media types ( |
|
|
Form content ( |
|
|
All media types ( |
The following example shows how to use MessageBodyReader
with the @Consumes
and @Provider
annotations:
@Consumes("application/x-www-form-urlencoded") @Provider public class FormReader implements MessageBodyReader<NameValuePair> {
The following example shows how to use MessageBodyWriter
with the @Produces
and @Provider
annotations:
@Produces("text/html") @Provider public class FormWriter implements MessageBodyWriter<Hashtable<String, String>> {
The following example shows how to use ResponseBuilder
:
@GET public Response getItem() { System.out.println("GET ITEM " + container + " " + item); Item i = MemoryStore.MS.getItem(container, item); if (i == null) throw new NotFoundException("Item not found"); Date lastModified = i.getLastModified().getTime(); EntityTag et = new EntityTag(i.getDigest()); ResponseBuilder rb = request.evaluatePreconditions(lastModified, et); if (rb != null) return rb.build(); byte[] b = MemoryStore.MS.getItemData(container, item); return Response.ok(b, i.getMimeType()). lastModified(lastModified).tag(et).build(); }
The information sent to a resource and then passed back to the client is specified as a MIME media type in the headers of an HTTP request or response. You can specify which MIME media types of representations a resource can respond to or produce by using the following annotations:
javax.ws.rs.Consumes
javax.ws.rs.Produces
By default, a resource class can respond to and produce all MIME media types of representations specified in the HTTP request and response headers.
The @Produces
annotation is used to specify the MIME media types or representations a resource can produce and send back to the client. If @Produces
is applied at the class level, all the methods in a resource can produce the specified MIME types by default. If applied at the method level, the annotation overrides any @Produces
annotations applied at the class level.
If no methods in a resource are able to produce the MIME type in a client request, the JAX-RS runtime sends back an HTTP "406 Not Acceptable" error.
The value of @Produces
is an array of String
of MIME types or a comma-separated list of MediaType
constants. For example:
@Produces({"image/jpeg,image/png"})
The following example shows how to apply @Produces
at both the class and method levels:
@Path("/myResource") @Produces("text/plain") public class SomeResource { @GET public String doGetAsPlainText() { ... } @GET @Produces("text/html") public String doGetAsHtml() { ... } }
The doGetAsPlainText
method defaults to the MIME media type of the @Produces
annotation at the class level. The doGetAsHtml
method's @Produces
annotation overrides the class-level @Produces
setting and specifies that the method can produce HTML rather than plain text.
@Produces
can also use the constants defined in the javax.ws.rs.core.MediaType
class to specify the media type. For example, specifying MediaType.APPLICATION_XML
is equivalent to specifying "application/xml"
.
@Produces(MediaType.APPLICATION_XML) @GET public Customer getCustomer() { ... }
If a resource class is capable of producing more than one MIME media type, the resource method chosen will correspond to the most acceptable media type as declared by the client. More specifically, the Accept
header of the HTTP request declares what is most acceptable. For example, if the Accept
header is Accept: text/plain
, the doGetAsPlainText
method will be invoked. Alternatively, if the Accept
header is Accept: text/plain;q=0.9, text/html
, which declares that the client can accept media types of text/plain
and text/html
but prefers the latter, the doGetAsHtml
method will be invoked.
More than one media type may be declared in the same @Produces
declaration. The following code example shows how this is done:
@Produces({"application/xml", "application/json"}) public String doGetAsXmlOrJson() { ... }
The doGetAsXmlOrJson
method will get invoked if either of the media types application/xml
or application/json
is acceptable. If both are equally acceptable, the former will be chosen because it occurs first. The preceding examples refer explicitly to MIME media types for clarity. It is possible to refer to constant values, which may reduce typographical errors. For more information, see the API documentation for the constant field values of javax.ws.rs.core.MediaType
.
The @Consumes
annotation is used to specify which MIME media types of representations a resource can accept, or consume, from the client. If @Consumes
is applied at the class level, all the response methods accept the specified MIME types by default. If applied at the method level, @Consumes
overrides any @Consumes
annotations applied at the class level.
If a resource is unable to consume the MIME type of a client request, the JAX-RS runtime sends back an HTTP 415 ("Unsupported Media Type") error.
The value of @Consumes
is an array of String
of acceptable MIME types, or a comma-separated list of MediaType
constants. For example:
@Consumes({"text/plain,text/html"})
This is the equivalent of:
@Consumes({MediaType.TEXT_PLAIN,MediaType.TEXT_HTML})
The following example shows how to apply @Consumes
at both the class and method levels:
@Path("/myResource") @Consumes("multipart/related") public class SomeResource { @POST public String doPost(MimeMultipart mimeMultipartData) { ... } @POST @Consumes("application/x-www-form-urlencoded") public String doPost2(FormURLEncodedProperties formData) { ... } }
The doPost
method defaults to the MIME media type of the @Consumes
annotation at the class level. The doPost2
method overrides the class level @Consumes
annotation to specify that it can accept URL-encoded form data.
If no resource methods can respond to the requested MIME type, an HTTP 415 ("Unsupported Media Type") error is returned to the client.
The HelloWorld
example discussed previously in this section can be modified to set the message by using @Consumes
, as shown in the following code example:
@POST @Consumes("text/html") public void postHtml(String message) { // Store the message }
In this example, the Java method will consume representations identified by the MIME media type text/plain
. Note that the resource method returns void
. This means that no representation is returned and that a response with a status code of HTTP 204 ("No Content") will be returned.
Parameters of a resource method may be annotated with parameter-based annotations to extract information from a request. A previous example presented the use of the @PathParam
parameter to extract a path parameter from the path component of the request URL that matched the path declared in @Path
.
You can extract the following types of parameters for use in your resource class:
Query
URI path
Form
Cookie
Header
Matrix
Query parameters are extracted from the request URI query parameters and are specified by using the javax.ws.rs.QueryParam
annotation in the method parameter arguments. The following example demonstrates using @QueryParam
to extract query parameters from the Query
component of the request URL:
@Path("smooth") @GET public Response smooth( @DefaultValue("2") @QueryParam("step") int step, @DefaultValue("true") @QueryParam("min-m") boolean hasMin, @DefaultValue("true") @QueryParam("max-m") boolean hasMax, @DefaultValue("true") @QueryParam("last-m") boolean hasLast, @DefaultValue("blue") @QueryParam("min-color") ColorParam minColor, @DefaultValue("green") @QueryParam("max-color") ColorParam maxColor, @DefaultValue("red") @QueryParam("last-color") ColorParam lastColor ) { ... }
If the query parameter step
exists in the query component of the request URI, the value of step
will be extracted and parsed as a 32-bit signed integer and assigned to the step
method parameter. If step
does not exist, a default value of 2, as declared in the @DefaultValue
annotation, will be assigned to the step
method parameter. If the step
value cannot be parsed as a 32-bit signed integer, an HTTP 400 ("Client Error") response is returned.
User-defined Java programming language types may be used as query parameters. The following code example shows the ColorParam
class used in the preceding query parameter example:
public class ColorParam extends Color { public ColorParam(String s) { super(getRGB(s)); } private static int getRGB(String s) { if (s.charAt(0) == '#') { try { Color c = Color.decode("0x" + s.substring(1)); return c.getRGB(); } catch (NumberFormatException e) { throw new WebApplicationException(400); } } else { try { Field f = Color.class.getField(s); return ((Color)f.get(null)).getRGB(); } catch (Exception e) { throw new WebApplicationException(400); } } } }
The constructor for ColorParam
takes a single String
parameter.
Both @QueryParam
and @PathParam
can be used only on the following Java types.
All primitive types except char
.
All wrapper classes of primitive types except Character
.
Any class with a constructor that accepts a single String
argument.
Any class with the static method named valueOf(String)
that accepts a single String
argument.
List<T>
, Set<T>
, or SortedSet<T>
, where T matches the already listed criteria. Sometimes, parameters may contain more than one value for the same name. If this is the case, these types may be used to obtain all values.
If @DefaultValue
is not used in conjunction with @QueryParam
, and the query parameter is not present in the request, the value will be an empty collection for List
, Set
, or SortedSet
; null for other object types; and the default for primitive types.
URI path parameters are extracted from the request URI, and the parameter names correspond to the URI path template variable names specified in the @Path
class-level annotation. URI parameters are specified using the javax.ws.rs.PathParam
annotation in the method parameter arguments. The following example shows how to use @Path
variables and the @PathParam
annotation in a method:
@Path("/{username}") public class MyResourceBean { ... @GET public String printUsername(@PathParam("username") String userId) { ... } }
In the preceding snippet, the URI path template variable name username
is specified as a parameter to the printUsername
method. The @PathParam
annotation is set to the variable name username
. At runtime, before printUsername
is called, the value of username
is extracted from the URI and cast to a String
. The resulting String
is then available to the method as the userId
variable.
If the URI path template variable cannot be cast to the specified type, the JAX-RS runtime returns an HTTP 400 ("Bad Request") error to the client. If the @PathParam
annotation cannot be cast to the specified type, the JAX-RS runtime returns an HTTP 404 ("Not Found") error to the client.
The @PathParam
parameter and the other parameter-based annotations (@MatrixParam
, @HeaderParam
, @CookieParam
, and @FormParam
) obey the same rules as @QueryParam
.
Cookie parameters, indicated by decorating the parameter with javax.ws.rs.CookieParam
, extract information from the cookies declared in cookie-related HTTP headers. Header parameters, indicated by decorating the parameter with javax.ws.rs.HeaderParam
, extract information from the HTTP headers. Matrix parameters, indicated by decorating the parameter with javax.ws.rs.MatrixParam
, extract information from URL path segments.
Form parameters, indicated by decorating the parameter with javax.ws.rs.FormParam
, extract information from a request representation that is of the MIME media type application/x-www-form-urlencoded
and conforms to the encoding specified by HTML forms, as described in http://www.w3.org/TR/html401/interact/forms.html#h-<IP_ADDRESS>
. This parameter is very useful for extracting information sent by POST in HTML forms.
The following example extracts the name
form parameter from the POST form data:
@POST @Consumes("application/x-www-form-urlencoded") public void post(@FormParam("name") String name) { // Store the message }
To obtain a general map of parameter names and values for query and path parameters, use the following code:
@GET public String get(@Context UriInfo ui) { MultivaluedMap<String, String> queryParams = ui.getQueryParameters(); MultivaluedMap<String, String> pathParams = ui.getPathParameters(); }
The following method extracts header and cookie parameter names and values into a map:
@GET public String get(@Context HttpHeaders hh) { MultivaluedMap<String, String> headerParams = hh.getRequestHeaders(); Map<String, Cookie> pathParams = hh.getCookies(); }
In general, @Context
can be used to obtain contextual Java types related to the request or response.
For form parameters, it is possible to do the following:
@POST @Consumes("application/x-www-form-urlencoded") public void post(MultivaluedMap<String, String> formParams) { // Store the message }
A JAX-RS application consists of at least one resource class packaged within a WAR file. The base URI from which an application's resources respond to requests can be set one of two ways:
Using the @ApplicationPath
annotation in a subclass of javax.ws.rs.core.Application
packaged within the WAR
Using the servlet-mapping
tag within the WAR's web.xml
deployment descriptor
Create a subclass of javax.ws.rs.core.Application
to manually configure the environment in which the REST resources defined in your resource classes are run, including the base URI. Add a class-level @ApplicationPath
annotation to set the base URI.
@ApplicationPath("/webapi") public class MyApplication extends Application { ... }
In the preceding example, the base URI is set to /webapi
, which means that all resources defined within the application are relative to /webapi
.
By default, all the resources in an archive will be processed for resources. Override the getClasses
method to manually register the resource classes in the application with the JAX-RS runtime.
@Override public Set<Class<?>> getClasses() { final Set<Class<?>> classes = new HashSet<>(); // register root resource classes.add(MyResource.class); return classes; }
The base URI for a JAX-RS application can be set using a servlet-mapping
tag in the web.xml
deployment descriptor, using the Application
class name as the servlet.
<servlet-mapping> <servlet-name>javax.ws.rs.core.Application</servlet-name> <url-pattern>/webapi/*</url-pattern> </servlet-mapping>
This setting will also override the path set by @ApplicationPath
when using an Application
subclass.
<servlet-mapping> <servlet-name>com.example.rest.MyApplication</servlet-name> <url-pattern>/services/*</url-pattern> </servlet-mapping>
This section provides an introduction to creating, deploying, and running your own JAX-RS applications. This section demonstrates the steps that are needed to create, build, deploy, and test a very simple web application that uses JAX-RS annotations.
This section explains how to use NetBeans IDE to create a RESTful web service using a Maven archetype. The archetype generates a skeleton for the application, and you simply need to implement the appropriate method.
You can find a version of this application at tut-install/examples/jaxrs/hello/
.
Ensure you have installed the tutorial archetypes as described in Installing the Tutorial Archetypes.
In NetBeans IDE, create a simple web application using the jaxrs-service-archetype
Maven archetype. This archetype creates a very simple "Hello, World" web application.
From the File menu, choose New Project.
From Categories, select Maven. From Projects, select Project From Archetype. Click Next.
Under Search enter jaxrs-service
, select the jaxrs-service-archetype
, and click Next.
Under Project Name enter HelloWorldApplication
, set the Project Location, and set the Package name to javaeetutorial.hello
, and click Finish.
The project is created.
In HelloWorld.java
, find the getHtml()
method. Replace the //TODO
comment with the following text, so that the finished product resembles the following method:
@GET @Produces("text/html") public String getHtml() { return "
Hello, World!!
"; }
|
Note: Because the MIME type produced is HTML, you can use HTML tags in your return statement. |
Right-click the HelloWorldApplication
project in the Projects pane and select Run.
This will build and deploy the application to GlassFish Server.
In a browser, open the following URL:
http://localhost:8080/HelloWorldApplication/HelloWorldApplication
A browser window opens and displays the return value of Hello, World!!
For other sample applications that demonstrate deploying and running JAX-RS applications using NetBeans IDE, see The rsvp Example Application and Your First Cup: An Introduction to the Java EE Platform at http://docs.oracle.com/javaee/7/firstcup/doc/
. You may also look at the tutorials on the NetBeans IDE tutorial site, such as the one titled "Getting Started with RESTful Web Services" at https://netbeans.org/kb/docs/websvc/rest.html
. This tutorial includes a section on creating a CRUD application from a database. Create, read, update, and delete (CRUD) are the four basic functions of persistent storage and relational databases.
The rsvp
example application, located in the tut-install/examples/jaxrs/rsvp/
directory, allows invitees to an event to indicate whether they will attend. The events, people invited to the event, and the responses to the invite are stored in a Java DB database using the Java Persistence API. The JAX-RS resources in rsvp
are exposed in a stateless session enterprise bean.
The three enterprise beans in the rsvp
example application are rsvp.ejb.ConfigBean
, rsvp.ejb.StatusBean
, and rsvp.ejb.ResponseBean
.
ConfigBean
is a singleton session bean that initializes the data in the database.
StatusBean
exposes a JAX-RS resource for displaying the current status of all invitees to an event. The URI path template is declared first on the class and then on the getEvent
method:
@Stateless @Named @Path("/status") public class StatusBean { ... @GET @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) @Path("{eventId}/") public Event getEvent(@PathParam("eventId") Long eventId) { ...
The combination of the two @Path
annotations results in the following URI path template:
@Path("/status/{eventId}/")
The URI path variable eventId
is a @PathParam
variable in the getEvent
method, which responds to HTTP GET requests and has been annotated with @GET
. The eventId
variable is used to look up all the current responses in the database for that particular event.
ResponseBean
exposes a JAX-RS resource for setting an invitee's response to a particular event. The URI path template for ResponseBean
is declared as follows:
@Path("/{eventId}/{inviteId}")
Two URI path variables are declared in the path template: eventId
and inviteId
. As in StatusBean
, eventId
is the unique ID for a particular event. Each invitee to that event has a unique ID for the invitation, and that is the inviteId
. Both of these path variables are used in two JAX-RS methods in ResponseBean
: getResponse
and putResponse
. The getResponse
method responds to HTTP GET requests and displays the invitee's current response and a form to change the response.
The javaeetutorial.rsvp.rest.RsvpApplication
class defines the root application path for the resources by applying the javax.ws.rs.ApplicationPath
annotation at the class level.
@ApplicationPath("/webapi") public class RsvpApplication extends Application { }
An invitee who wants to change his or her response selects the new response and submits the form data, which is processed as an HTTP POST request by the putResponse
method. The new response is extracted from the HTTP POST request and stored as the userResponse
string. The putResponse
method uses userResponse
, eventId
, and inviteId
to update the invitee's response in the database.
The events, people, and responses in rsvp
are encapsulated in Java Persistence API entities. The rsvp.entity.Event
, rsvp.entity.Person
, and rsvp.entity.Response
entities respectively represent events, invitees, and responses to an event.
The rsvp.util.ResponseEnum
class declares an enumerated type that represents all the possible response statuses an invitee may have.
The web application also includes two CDI managed beans, StatusManager
and EventManager
, which use the JAX-RS Client API to call the resources exposed in StatusBean
and ResponseBean
. For information on how the Client API is used in rsvp
, see "The Client API in the rsvp Example Application".
Both NetBeans IDE and Maven can be used to deploy and run the rsvp
example application.
To Run the rsvp Example Application Using NetBeans IDE
If the database server is not already running, start it by following the instructions in Starting and Stopping the Java DB Server.
Make sure that GlassFish Server has been started (see Starting and Stopping GlassFish Server).
From the File menu, choose Open Project.
In the Open Project dialog box, navigate to:
tut-install/examples/jaxrs
Select the rsvp
folder.
Click Open Project.
In the Projects tab, right-click the rsvp
project and select Run.
The project will be compiled, assembled, and deployed to GlassFish Server. A web browser window will open to the following URL:
http://localhost:8080/rsvp/index.xhtml
In the web browser window, click the Event status link for the Duke's Birthday event.
You'll see the current invitees and their responses.
Click the current response of one of the invitees in the Status column of the table, select a new response, and click Update your status.
The invitee's new status should now be displayed in the table of invitees and their response statuses.
To Run the rsvp Example Application Using Maven
If the database server is not already running, start it by following the instructions in Starting and Stopping the Java DB Server.
Make sure that GlassFish Server has been started (see Starting and Stopping GlassFish Server).
In a terminal window, go to:
tut-install/examples/jaxrs/rsvp/
Enter the following command:
mvn install
This command builds, assembles, and deploys rsvp
to GlassFish Server.
Open a web browser window to the following URL:
http://localhost:8080/rsvp/
In the web browser window, click the Event status link for the Duke's Birthday event.
You'll see the current invitees and their responses.
Click the current response of one of the invitees in the Status column of the table, select a new response, and click Update your status.
The invitee's new status should now be displayed in the table of invitees and their response statuses.
Most blog sites use RESTful web services. These sites involve downloading XML files, in RSS or Atom format, that contain lists of links to other resources. Other websites and web applications that use REST-like developer interfaces to data include Twitter and Amazon S3 (Simple Storage Service). With Amazon S3, buckets and objects can be created, listed, and retrieved using either a REST-style HTTP interface or a SOAP interface. The examples that ship with Jersey include a storage service example with a RESTful interface.
For more information about RESTful web services and JAX-RS, see
"Fielding Dissertation: Chapter 5: Representational State Transfer (REST)":
http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm
RESTful Web Services, by Leonard Richardson and Sam Ruby, available from O'Reilly Media at http://shop.oreilly.com/product/9780596529260.do
JSR 339: JAX-RS 2.0: The Java API for RESTful Web Services:
Jersey project:


Number density comparison between KMCS (squares) and experimental results (circles) as a function of (a) different substrate temperatures for a 20 Hz deposition rate and (b) different deposition rates for a substrate temperature of 800 °C. White squares (□) in (b) represent different E s values used during simulations.


Chocolate Orange Shreddies are back - just in time for Christmas
The festive season just got sweeter – thanks to the return of one particular cereal.
Nestle’s Coco Orange Shreddies are back on the shelves – for a limited time only.
They’re available to buy in Morrisons stores now and are priced at £2 (reduced from £2.75) for a 500g box.
There’s just one catch – the moreish cereal will only be available until 4 December.
So you have just under two weeks to grab yourself a box… or five.
Nestle announced the comeback on the official Shreddies UK Facebook page.
The post said: ‘You asked for it, so it’s here! LIMITED EDITION Coco Orange Shreddies is back! Get them in Morrisons stores while you can!’
Cereal lovers were quick to comment on the news of the relaunch.
One Facebook user commented: ‘What a time to be alive, they’re back’
Another cereal fan said: ‘Got my 15 boxes this morning. That’s me sorted. Early bird always catches the worm’
Advertisement Advertisement
While others were keen to stress that the move should be long-lasting, posting: ‘YESSSSSS! Thank you, please keep it a permanent thing!’
But the confectionery brand has stressed that the Coco Orange Shreddies will not be heading to the shelves permanently – well, not yet anyway.
Nestle said: We have brought it back as Shreddies fans tell us that they love our flavour experimenting.
‘It is again available for a limited time only though, so that our flavour development team can continue to experiment and constantly bring new and exciting flavours to the breakfast tables of Shreddies fans.’
The festive flavour was last available back in 2012.
Let’s hope it won’t be another seven years until it comes around again.


RAIDERS OF THE LOST ARK RATING: 9 / 10 --> Amazing Movie
For more reviews and movie trivia, visit http://www.joblo.com
What do you get when you slap together a movie based on a story by the legendary George Lucas, directed by virtuoso director Steven Spielberg, and starring one of the biggest box-office stars in the world, Harrison Ford? You get one hot-fudge-rockin' good time, that's what you get!!!
PLOT: Professor/archeologist Indiana Jones sets out to find the long-lost mystical Ark of the Covenant before the Nazis get their grubby fingers hands on it. Adventures, snakes, romance and mucho action ensues.
CRITIQUE: Astounding movie packed with non-stop action, stunts galore, an interesting story line, great one-liners, a solid cast, a catchy musical score, and all the fun and adventure that you could squeeze into a two-hour thrill ride. If you don't enjoy this film, then you just don't like action movies, period! If you're young, you'll enjoy its humor, its cool action sequences and its gross-out factor at times. If you're a little older, you'll appreciate the interesting plot line, the romance, and yes, the mountains of adventure. Watching this movie made me feel like a kid again, dreaming and fantasizing about fighting the bad guys, travelling to different countries, making the impossible, possible! Harrison Ford is perfect as the every-man with the brains of a scientist and the brawn of an outdoors adventurer, and Spielberg manages to achieve the ideal balance of action, fun, adventure and humor.
Now if you really want to have a good time, check into this movie on the same night as its two sequels, rent a jug of iced Coke, truckloads of nachos and salsa, an adventure hat and whip, and prepare to gag yourself into a world of action-movie heaven!
Little Known Facts about this film and its stars: This picture was nominated for eight 1981 Oscar nominations, including Best Picture. It lost that award to CHARIOTS OF FIRE, but did manage to win for Best Art Direction, Best Special Effects, Best Film Editing and Best Sound. Actor Tom Selleck was originally cast as Indiana Jones, but was committed to his hit TV show, "Magnum P.I.". In filming the Well of Souls sequence, the producers scoured every pet shop in London and the South of England for every snake they could lay their hands on. Hence there are snakes that are identifiable from many different geographical areas. However, once all the snakes were on set, it became clear that there were not nearly enough of them, so Spielberg had several hoses cut into lengths, and these were used as well. Looking closely, you can tell which are the real snakes and which are not. An early draft of the script had Indy travelling to Shanghai to recover a piece of the Staff of Ra. During his escape from the museum where it was housed, he sheltered from machine gun fire behind a giant rolling gong. Also in the same script, Indy and Marion flee the chaos caused by the opening of the Ark in a wild mine-cart chase sequence. Both of these scenes were cut from the script, but ended up in 1984's INDIANA JONES AND THE TEMPLE OF DOOM. This film begins with a shot of a peak in the jungle which is reminiscent of the Paramount Pictures logo. The same type of opening is present in its sequels. Jock's airplane at the beginning of the film has the registration number "OB-CPO". This is a reference to Obi-Wan and C-3PO from George Lucas' STAR WARS (9.5/10). Also, the hieroglyphics in the Well of Souls include engravings of R2-D2 and C-3PO. They can be seen on a post to the right of Indy and Sallah as they remove the Ark. The script originally included a long fight between a swordsman and Indiana with his whip. As legend has it, actor Harrison Ford was suffering diarrhea at the time, and asked if the scene could be shortened. Spielberg said the only way he could shorten it was if Indy pulled out his gun and just shot the guy. The entire crew laughed and that's how it was filmed. When Indy first falls in the Well of Souls and is face to face with the cobra, you can see the snake's reflection on the glass dividing it and Harrison Ford, also some fingerprints and stuff like that. When Indy is dragging along the ground, hanging onto the Nazi soldier's truck with the Ark inside, you can see the pad that he's being dragged on.
Review Date: February 28, 1999 Director: Steven Spielberg Writer: Lawrence Kasdan (story by George Lucas and Philip Kaufman) Producer: Frank Marshall Actors: Harrison Ford as Indiana Jones, Karen Allen as Marion Ravenwood Genre: Action/ Adventure Year of Release: 1981
Visit JoBlo's Movie Emporium http://www.joblo.com
(c) 1999 Berge Garabedian
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Tic Tac Toe
O won
0
time(s)
X won
0
time(s)
Restart
Maked with ❤
Github: https://github.com/eksant/tictactoe


Click any button to see gifs and add your own buttons! Click on images to play and pause gifs (may take a while to load).


DECEMBER 18
Entrance Antiphon
Collect
Grant, we pray, almighty God, that we who are weighed down from of
old by slavery beneath the yoke of sin,
may be set free by the newness of the long-awaited Nativity of your Only Begotten Son.
Who lives and reigns with you. . .
FIRST READING
Jeremiah 23:5-8 A reading from the Book of Jeremiah "Behold, the days are coming, says the LORD,
when I will raise up for David a righteous Branch, and he shall reign as king and
deal wisely, and shall execute justice and righteousness in the land. In his
days The word of the Lord
RESPONSORIAL PSALM
Psalm
72:1-2.12-13.18-19(R.See 7) R. In his days
shall justice flourish, and great peace for ever. O God, give your judgment to the king, to a king's
son your justice, that he may judge your people in justice, and your poor in right judgment. R. In his days
shall justice flourish, and great peace for ever. For he shall save the needy when they cry,
the poor, and those who are helpless. He will have pity on the
weak and the needy, and save the lives of the needy. R. In his days
shall justice flourish, and great peace for ever. Blest the LORD, God of Israel, who alone works
wonders, ever blest his glorious name. Let his glory fill the earth. Amen!
Amen! R. In his days
shall justice flourish, and great peace for ever. ALLELUIA Alleluia. O Leader of the house of GOSPEL
Matthew 1:18-24 A reading from the holy Gospel according to Matthew The birth of Jesus Christ took place in this way.

 All this took place to fulfil what the Lord had spoken by the
prophet: "Behold, a virgin shall conceive and bear a son, and his name
shall be called Emmanuel" (which means, God with us). When Joseph woke
from sleep, he did as the angel of the Lord commanded him. The Gospel of the Lord
Prayer over the Offerings
May the sacrifice to be offered to you,
O Lord, make us acceptable to your name, that we may merit for all eternity to be the companions of Christ,
by whose Death our own mortality was healed. Who lives and reigns for ever and ever.
Communion Antiphon
His name will be called Emmanuel, which means God-with-us.
Prayer after Communion May we receive your mercy in the midst of your temple, O Lord,
and show fitting honour to the coming solemnities of our redemption. Through Christ our Lord.


Make sure your other Bluetooth device is powered before attempting to connect. The connection must be initialized by the phone.
Connect to Bluetooth


NDPROXY(4) FreeBSD Kernel Interfaces Manual NDPROXY(4)
NAME
ndproxy — Neighbor Discovery Proxy
SYNOPSIS
ndproxy is a kernel module that implements IPv6 Neighbor Discovery proxying over Ethernet-like access networks, with many options to handle several use-cases.
ndproxy replies to a neighbor solicitation with a specific neighbor advertisement, in order to let the PE uplink router send further packets to a CPE downlink router, that may or may not be the same node that run ndproxy.
The hook-based pfil(9) framework is used to let ndproxy be invoked for every IPv6 incoming packet, in order to specifically handle and filter neighbor solicitations and reply with appropriate neighbor advertisements.
ND (Neighbor Discovery) packets are mainly targeted at solicited-node multicast addresses, but ndproxy has no information about the hosts to proxy, then it can not join the corresponding groups. Thus, the interface on which ndproxy listen to solicitations must be put into permanently promiscuous mode: add "promisc" to the ifconfig_<interface> variable in rc.conf(5).
For the same reason, MLD snooping must be disabled on the switches that share the PE/CPE interconnect (the layer-2 link the listening interface is attached to). Note that MLD snooping must not be disabled entirely on each switch, but only on the corresponding vlan.
The interface on which ndproxy listen to solicitations only need to be assigned a link-local address. No information about the delegated prefix and no global address are needed on this interface. It is sufficient to add "inet6 -ifdisabled -accept_rtadv auto_linklocal" to the ifconfig_<interface>_ipv6 variable in rc.conf(5).
DIFFERENCES WITH NDP
The target address to proxy must be given when using the ndp(8) command-line tool with the proxy option. On the contrary, ndproxy does not rely on a list of target addresses to proxy. Thus, RFC-4941 temporary addresses can be proxyfied. For security reasons, many operating systems use a temporary address when establishing outbound connections.
When using ndp(8) command-line tool with the proxy option, the proxyfied packets are redirected to the node that run ndp. With ndproxy, the host that run ndp can be used only to redirect packets to another IPv6 internal router, for instance a dedicated router with hardware support of IPv6 routing process.
PREFIX SUBNETTING
Connecting a flat IPv6 network to the Internet is easily done with the RFC-4861 ND protocol. But connecting a subnetted IPv6 prefix is more complicated, depending on the ISP network design choices. ndproxy can help subscribers to achieve this goal.
Here are some protocols or mechanisms the ISP need to support, when the delegated prefix must be subnetted and assigned to multiple links within the subscriber’s network. For instance, the ISP could learn routes from the subscriber router using an IGP routing protocol, but the ISP and the subscriber must agree with a common routing protocol. The ISP could also feed the PE with a static route to the CPE router, but the ISP must be informed about the subscriber router address. Finally, the ISP could use the RFC-3633 IPv6 Prefix Options with DHCPv6 to delegate the prefix from its PE router to a requesting subscriber’s router: in such a case, the ISP must support the DHCPv6 option.
ndproxy has been written for subscribers to ISP that do not support any of those mechanisms or protocols, thus not being able to natively subnet their IPv6 delegated prefix.
NETWORK DESIGN
Here is a generic network design
using ndproxy to solve such situations:
______________________ \
/ \ \
| ISP core network | \
\__________ ___________/ |
| | ISP network
| dsl to subscriber premises |
| /
+---+---------------------+ /
| PE or triple-play box | /
+-----------+-------------+
|
PE/CPE interconnect | /48 prefix \
--+---------+---------+-- \
| no mld snooping | \
| | |
+----+--------+ +----+-----+ |
| CPE | | ndproxy | |
| IPv6 router | | BSD host | |
+----+---+----+ +----------+ |
subnet1 | | subnet2 | Subscriber
----+-----+- -+-----+------ | network
| /60 | /60 |
+---+------+ +----+-----+ |
|Subscriber| |Subscriber| /
| host | | host | /
+----------+ +----------+ /
Note that many other use-cases can be handled with ndproxy: the BSD host and the CPE router can be the same node, the delegated-prefix length can be /64, the PE router can have several interfaces on the ISP/Subscriber layer-2 boundary, there can be multiple PE routers, etc.
PREFIX LENGTH
Even if the IESG and the IAB first recommended the allocations of /48 prefixes in the general case, for the boundary between the public and the private topology (see RFC-3177), and that some Regional Internet Registries (APNIC, ARIN and RIPE) have subsequently revised the end site assignment policy to encourage the assignment of /56 blocks to end sites, and that RFC-6177 finally recommended giving home sites significantly more than a single /64, in order for home sites to be given multiple subnets, some ISP currently only delegate /64 prefixes.
In such a case, the subscriber should subnet a RFC-4193 Unique Local IPv6 Unicast Addresses prefix to the internal subnetworks, for internal-to-internal communications. The /64 global prefix should be routed to the only internal subnet in which RFC-4941 temporary addresses are used by hosts when establishing outbound connections. Static routes on the CPE router should be set to let hosts on other internal subnets be able to communicate with the Internet. Using temporary addresses for outbound connections to the Internet must be disabled on hosts on those other internal subnets.
IPv6 EXTENSION HEADERS
For security reasons, ndproxy explicitely rejects neighbor solicitation packets containing any extension header. Such a packet is mainly unattended:
Fragmentation:
According to RFC-6980, IPv6 fragmentation header is forbidden in all neighbor discovery messages.
Hop-by-hop header:
commonly used for jumbograms or for MLD. Should not involve neighbor solicitation packets.
Destination mobility headers:
commonly used for mobility, ndproxy does not support these headers.
Routing header:
commonly used for mobility or source routing, ndproxy does not support these headers.
AH & ESP headers:
securing the neighbor discovery process is not done with IPsec but with the SEcure Neighbor Discovery protocol (RFC-3971). ndproxy can not support RFC-3971, since proxifying ND packets is some kind of a spoofing process.
EXCEPTION ADDRESSES
Some neigbhor solicitations sent on the PE/CPE interconnect must not be proxyfied:
1.
solicitations sent by other nodes than the PE;
2.
solicitations sent by the PE to reach any on-link address (the address filled in the target address option) owned by nodes attached to the PE/CPE interconnect, for instance to reach the CPE, the ndproxy host or other hosts attached to this layer-2 interconnect.
The target addresses filled in those solicitations that ndproxy must ignore have to be declared via sysctl (net.inet6.ndproxyconf_exception_ipv6_addresses). This list must contain the link-local and global-scoped unicast and anycast addresses of the CPE, of the ndproxy host and of any other host than the PE attached to the PE/CPE interconnect.
Failing to maintain this list correctly could lead to badly redirect some packets to the CPE, but with a simple network design, this list can be let empty.
UPLINK ROUTER ADDRESSES
ndproxy only handles packets originating from one of the PE addresses. During its address resolution process, different source addresses can be choosen by the PE, depending on the packet that triggered the process or depending on other external constraints.
Here are some cases when it can occur:
1.
The PE may have multiple interfaces;
2.
There may be multiple PE;
3.
Many routers choose to use a link-local address when sending neighbor solicitations, but when an administrator of such a router, also having a global address assigned on the same link, tries to send packets (echo request, for instance) to an on-link destination global address, the source address of the echo request packet prompting the solicitation may be global-scoped according to the selection algorithm described in RFC-6724. Therefore, the source address of the Neighbor Solicitation packet should also be selected in the same global scope, according to RFC-4861;
4.
When the uplink router does not yet know its own address, it must use the unspecified address, according to RFC-4861.
So, it can not be assumed that an uplink router will always use the same IPv6 address to send neighbor solicitations. Each assigned address that can be used as a source address by the PE on its downlink interface must then be declared to ndproxy via sysctl (net.inet6.ndproxyconf_uplink_ipv6_addresses).
ndproxy will only handle packets that come from one of these addresses.
A special care must be taken about the unsolicited address. It may be used by the PE, then it is part of the list of PE addresses and should therefore be added to the list of PE addresses. Since this address can also be used by other nodes during some initialization steps (for instance when hot-swapping an Ethernet board), another node could use this address to send neighbor solicitations that ndproxy should not handle, because they are not sent by the PE. In fact, this is not a problem because the target address option contained in a solicitation from this other node should be in the exception list. So, adding the unsolicited address in the PE addresses list should be safe.
Failing to maintain this list correctly could lead the PE not to be able to establish outbound connections to nodes on the PE/CPE interconnect, but if this list contains at least the PE link-local address, IPv6 connectivity should be correctly established between the Internet and the internal subscriber’s subnets.
CONFIGURATION
An IPv6 address can be any valid textual representation according to RFC-4291 and RFC-5952 (this means that transitional textual representation is fully supported). Other representations will trigger an error event. IPv6 address lists must be formated as series of IPv6 adresses separated by semi-colons.
The sysctl utility or rc.conf(5) are used to set ndproxy configuration parameters.
If you have installed ndproxy as a port or as a package, set the following variables in rc.conf(5) and load the module at boot time by placing the following line in rc.conf(5):
ndproxy_enable="YES"
On the contrary, if you have NOT installed ndproxy as a port or as a package but as a standalone distribution, place the sysctl entries in sysctl.conf(5) and load the module at boot time by placing the following line in loader.conf(5):
ndproxy_load="YES"
net.inet6.ndproxyconf_uplink_interface sysctl entry or ndproxy_uplink_interface rc.conf variable:
Name of the interface talking to the broadcast multi-access network connecting the PE and CPE routers.
Example: "vlan2".
net.inet6.ndproxyconf_downlink_mac_address sysctl entry or ndproxy_downlink_mac_address rc.conf variable:
MAC address of the CPE router. Neighbor advertisements sent by ndproxy will be filled with this address in the target link-layer address option. The format of this parameter is the hexadecimal representation made of 6 groups of 2 hexadecimal numbers separated by colons.
Example: "00:0C:29:B6:43:D5".
net.inet6.ndproxyconf_exception_ipv6_addresses sysctl entry or ndproxy_exception_ipv6_addresses rc.conf variable:
Target addresses not to proxy. In a simple network design, this list can be let empty. See section "EXCEPTION ADDRESSES".
Example: "fe80::20d:edff:fe7b:68b7;fe80::222:15ff:fe3b:59a".
net.inet6.ndproxyconf_uplink_ipv6_addresses sysctl entry or ndproxy_uplink_ipv6_addresses rc.conf variable:
Addresses of the PE. This list should at least contain the PE link-local address. See section "UPLINK ROUTER ADDRESSES".
Example: "fe80::207:cbff:fe4b:2d20;2a01:e35:8aae:bc60::1;::".
net.inet6.ndproxycount sysctl entry:
Number of advertisements sent.
SEE ALSO
inet6(4), rc.conf(5), loader.conf(5), sysctl.conf(5), sysctl(8), loader(8), pfil(9)
AUTHOR
Alexandre Fenyo<EMAIL_ADDRESS>- www.fenyo.net
FreeBSD 13.0 May 27, 2017 FreeBSD 13.0


Planning Document
Project Purpose
The purpose of this project is to get people who want to learn about the hobby of aqua-scaping a simple knowledge of what it is and how to start. It will show them first what aqua-scaping is. Then it will show them how to start from square one. Picking a tank. then it will give them a beginners look into what plants they should start out with. It will also show them different styles and looks that have already been made to give them inspiration and an idea of what they are making.
Target Audience
The target audience for this project I would say is pretty narrow. It mainly focuses on brand new people that are just getting into the Hobby. The reason for this is because I have found that getting people into the hobby is the hardest part. Once you are in you are hooked! No fish pun intended. The age group doesnt matter, I started when I was 15 and most people pick it up later in life. However, my site isnt just limited to beginners it can serve as a refresher for any Scaper that visits my site.
Web Pages
1. My home page for this assignment will briefly introduce what aqua-scaping is. It will also provide information on one of the largest aqua-scaping icons, Takashi Amano. This page as all pages will have modularzation for the header, nav, and footer.
2. Picking your Tank, this web page is all about the two different types of tanks you can purchase. It will give the pros and cons of both glass and acryilc tanks
3. Plant Types. This will inform the audience that plant choice is important as well as give them a few nice beginner plants. This page will be using a JSON file to pull information about the plantand put it onto the page.
4. Setting up. This web page will contain my Video. It will also give a basic overview of how to set up a aqua-scape. Hopefully with out destroying all the hard work done.
5. Plant Care. This will be my second page of JSON. This will pull information about taking care of beginner and expert plants. This page is to show how drastically different the care for different plants can be. It will hopefully encourage the viewers that they need to do research on plants and their needs before jumping in head first.
Persona
This is Bob Jones. He is 25 years old and has an interest in keeping aquariums, but wants to make the tank more lively. Bob however doesnt know where to start. From this page he can skip the whole tank selection because he already has one, so no need for him to waste time on that page. He can jump straight into learning about some plants. He can now see that not just any plants will work. He can see that he doesnt want tall plants in the front else it will block his view. He also can see some easy plants that he can start out with to see if he even wants to get into the hobby more fully. Also since he has never cared for plants, only fish, he is able to see the new products that he needs to purchase to see his new tank decors survival.


Kelvin Fichter
OmiseGO
Mark Barrasso
Cisco
Tony Crowe
Unaffiliated
Paul Berg
Chronos
Miguel Morales
Lucidity
This page is dedicated to our awesome contributors on GitHub! Come help and get your name on this page!
OmiseGO
Cisco
Unaffiliated
Chronos
Lucidity


About Me
My name is Gillian K Fitzgerald and I am a full-stack web developer in training. I earned my bachelors degree at Columbia University in political science. I am an avid outdoors woman and an accomplished equestrian. While I am currently working in business development at a small family biotech investment consulting firm, I have also been involved in the comic book industry for three years, working for the legendary comic book artist, J Scott Campbell. During both of my careers it has become apparent to me that coding and web development are valuable, high demand skills that companies and small business need in order to not only be competitive in their respective markets, but to survive and effectively reach the people that need their services. I am dedicated and excited to combine the knowledge I have gained during my career with a new coding skills set in order to build things that will make businesses and individuals lives better.


Protocols
The following protocols are available globally.
-
This was taken straight from the objc.io book “Advanced Swift.” It’s so damn useful, that I have it made into a standard tool.
The original design was done by Ole Begemann and Chris Eidhof. I have modified it slightly; but not much.
It is fast as all git-go.
A type that can efficiently “enqueue” and “dequeue” elements. It works on one element at a time. You cannot dequeue groups of elements.
See moreDeclaration
Swift
public protocol OLEB_Queue
-
If you conform to this protocol, you get a few basic Sequence attributes for free.
You’ll need to set up a sequence_contents Array (read/write), and set the Element type, and that’s about all.
This also gives you a read-only subscript.
This cannot be applied to enums, as it requires a stored property.
See moreDeclaration
Swift
public protocol RVS_SequenceProtocol : Sequence


home
about us
what we do
Agricultural Engineering
soil & water
food processing
farm machinery
web development
science
physics
biology
mathematics
objectives
bookings
contact us
<EMAIL_ADDRESS>08162480788
Home
about us
what we do
objectives
bookings
contact us
henrex
Your possibilities to a better world
Register
Login
Make a choice today
Engineering
Web development
submit


- getAddress() - Method in class com.projectBackEnd.model.Customer
-
- getAddress() - Method in class com.projectBackEnd.model.Worker
-
- getAge() - Method in class com.projectBackEnd.model.Customer
-
- getAge() - Method in class com.projectBackEnd.model.Worker
-
- getAll() - Method in class com.projectBackEnd.dao.CustomerDAO
-
Gets a handle on all of the Customer objects that exist in the database,
maps them to the Customer class, and returns them in a list.
- getAll() - Method in class com.projectBackEnd.dao.JobDAO
-
Gets a handle on all of the Job objects that exist in the database,
maps them to the Job class, and returns them in a list.
- getAll() - Method in class com.projectBackEnd.dao.TodoDAO
-
- getAll() - Method in class com.projectBackEnd.dao.WorkerDAO
-
Gets a handle on all of the Worker objects that exist in the database,
maps them to the Worker class, and returns them in a list.
- getAll() - Method in class com.projectBackEnd.rest.CustomerResource
-
Gets a handle on all of the Customer objects that exist in the database and
returns them in a list in JSON format.
- getAll() - Method in class com.projectBackEnd.rest.HelloWorldEndpoint
-
- getAll() - Method in class com.projectBackEnd.rest.JobResource
-
Gets a handle on all of the Job objects that exist in the database and
returns them in a list in JSON format.
- getAll() - Method in class com.projectBackEnd.rest.WorkerResource
-
Gets a handle on all of the Worker objects that exist in the database and
returns them in a list in JSON format.
- getContact() - Method in class com.projectBackEnd.model.Job
-
- getCustomer() - Method in class com.projectBackEnd.model.Job
-
- getCustomer(String) - Method in class com.projectBackEnd.rest.CustomerResource
-
Gets a handle on the Customer object, if one exists with the given id that
is passed in as a parameter.
- getCustomer(String) - Method in class com.projectBackEnd.rest.JobResource
-
Gets a handle on the Job object, if one exists with the given id that
is passed in as a parameter.
- getDate() - Method in class com.projectBackEnd.model.Job
-
- getDescription() - Method in class com.projectBackEnd.model.Job
-
- getDescription() - Method in class com.projectBackEnd.model.Todo
-
- getEmail() - Method in class com.projectBackEnd.model.Worker
-
- getFirebaseUid() - Method in class com.projectBackEnd.model.Customer
-
- getFirebaseUid() - Method in class com.projectBackEnd.model.Worker
-
- getFirstName() - Method in class com.projectBackEnd.model.Customer
-
- getFirstName() - Method in class com.projectBackEnd.model.Worker
-
- getId() - Method in class com.projectBackEnd.model.Customer
-
- getId() - Method in class com.projectBackEnd.model.Job
-
- getId() - Method in class com.projectBackEnd.model.Todo
-
- getId() - Method in class com.projectBackEnd.model.Worker
-
- getJobsAccepted() - Method in class com.projectBackEnd.model.Worker
-
- getJobsRequested() - Method in class com.projectBackEnd.model.Worker
-
- getLocation() - Method in class com.projectBackEnd.model.Job
-
- getPhoneNumber() - Method in class com.projectBackEnd.model.Worker
-
- getRating() - Method in class com.projectBackEnd.model.Worker
-
- getRequests() - Method in class com.projectBackEnd.model.Job
-
- getSecondName() - Method in class com.projectBackEnd.model.Customer
-
- getSecondName() - Method in class com.projectBackEnd.model.Worker
-
- getTask() - Method in class com.projectBackEnd.model.Todo
-
- getTodo(String) - Method in class com.projectBackEnd.rest.HelloWorldEndpoint
-
- getTrade() - Method in class com.projectBackEnd.model.Job
-
- getTrade() - Method in class com.projectBackEnd.model.Worker
-
- getWebsite() - Method in class com.projectBackEnd.model.Worker
-
- getWorker(String) - Method in class com.projectBackEnd.rest.WorkerResource
-
Gets a handle on the Worker object, if one exists with the given id that
is passed in as a parameter.


Definition
Average seasonal Aridity index (cm) for soil with 200 mm water-holding capacity, 10% probability level
Method of calculation
The index is computed from the water deficit (PE-P) in a manner similar to that used by Sly and Coligado (1974). Note that Aridity is in cm, water deficits are in mm. A regression equation is used to compute Arid200-10 as follows:
Arid200_10 = -7.11 + 0.13182*(Deficit5) – 0.00007854*(Deficit5)**2
Note: Regression estimates should not be used for Deficit5 values that exceed 900mm.


Page2
These buttons are secured by the following RBAC permissions
page2.button1
Object: Page2; Operation: Button1;
page2.button2
Object: Page2; Operation: Button2;
page2.button3
Object: Page2; Operation: Button3;
This is free and unencumbered software released into the public domain.


--- title: Type dispatch keywords: fastai sidebar: home_sidebar summary: "What is it, how to use it, how to use it to extend fastai." description: "What is it, how to use it, how to use it to extend fastai." ---
from fastai2.vision.all import *
Let's say we want to create a function that does floor division //
if the input is a int
and normal division /
if the input is a float
.
One way of doing that is a function that checks (with if
s conditions) the input type and executes the appropriate operation.
def same_type_div(a, b):
if type(a) is int: return a//b
if type(a) is float: return a/b
same_type_div(5, 2), same_type_div(5., 2)
Alright, works well enough.
Let's say after some time we want to include complex numbers, let's say we want our users to give the complex numbers as strings and convert to complex
internally. We now have to change the original function to the following:
def same_type_div(a, b):
if type(a) is int: return a//b
if type(a) is float: return a/b
if type(a) is str: return complex(a)/complex(b)
same_type_div('1+1j', '1j')
Simple enough right? But what happens when you can't modify the source code? (I mean, if the package is open source, you can always go to your local installation and modify the lines that you want, but good luck maintaining that updated. We should be able to modify the function behaviour without having to change the source code directly).
typedispatch
comes to our rescue, let's say the library you're using handles int
and float
:
@typedispatch
def same_type_div2(a:int, b): return a//b
@typedispatch
def same_type_div2(a:float, b): return a/b
If you're used with standard Python you may be a bit confused with what just happened in the two cells above, we declared the same function twice! Your intuition must be saying "the latter is going to overwrite the former!".
Well, typedispatch
will keep both versions for us, and when we call the function, it will dispatch the one that if finds more appropriate, let's check that:
same_type_div2(5, 2), same_type_div2(5., 2)
Now, adding your custom implementation for complex numbers is simple as:
@typedispatch
def same_type_div2(a:str, b): return complex(a)/complex(b)
same_type_div2('1+1j', '1j')
By using typedispatch
we don't need to touch the source code!
We can be even more specific and define what happens depending on the type of b
!
Let's create a function that return the modulus of the division if a
is a str
and b
an int
.
@typedispatch
def same_type_div2(a:str, b:int): return abs(complex(a)/b)
same_type_div2('1+1j', 2)
And there is more, it also works with subclasses:
class MyInt(int): pass
same_type_div2('1+1j', 2)
It correctly finds the implementation for int
and uses that. But if we define a implementation for MyInt
directly:
@typedispatch
def same_type_div2(a:str, b:MyInt): return complex(a)/b
same_type_div2('1+1j', MyInt(2))
It starts using that! typedispatch
will always try to use the "closest" implementation it can find for your type.


 Well, maybe that's not the best way to put it. Arrays are simple and hashes are complicated.
That sounds better.
There are plenty of great uses for arrays. When you've got a simple set of data you can push it into an array and use it as you wish.
Let's say you want to use the years Babe Ruth played in the majors. That array would look like this:
babe_years = [1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935]
Super simple. A list of years. If you wanted to know what the year was during Babe Ruth's 20th season you would just do babe_years[19]
(arrays start counting at 0, so the 20th season is at index 19). That search of the array would return 1933
.
Cool, Babe Ruth's 20th season was in 1933.
But there's a lot more to Babe Ruth than the years he played. There's the years he was an All-Star, the years he was an MVP, the years he lead the league in home runs, and on and on and on.
We could create a new array for each of these little groups of years.
babe_mvp_years = [1923]
babe_allstar_years = [1933, 1934]
babe_hrleader_years = [1918, 1919, 1920, 1921, 1923, 1924, 1926, 1927, 1928, 1929, 1930, 1931]
Yeah, Babe only won one MVP. Also, the All-Star Game didn't start until 1933.
We're starting to build up a decent profile on Babe Ruth. What if we wanted to have access to his full name, his jersey number, height and weight as well?
Theres a way to package all of these things together into one object in Ruby, it's called a hash.
Pulling everything into a hash will give us some standardization and readability. It's a great way to save this complicated data set we're building.
There are a shitload of ways to build a hash, but for this example I'm going to create it literally and use the GitHub Ruby style guide.
Alrighty, Babe, here we go:
Sweet! So now our hash includes all the great stuff that we figured out at the beginning of this blog and more. The items on the left side of =>
inside the hash, like :jersey_number
are called keys. And the values on the right side of the =>
are called values. More specifically, the keys are symbols because they have the :
at the start. You can also use strings as keys.
Notice how we have strings and arrays as values inside our hash.
To access the values inside our hash we can run some pretty simple code that is much like accessing an array: babe_ruth[:jersey_number]
will return "3"
Let's try our example from up above and see what year it was during Babe's 20th season: babe_ruth[:years][19]
Yep, we get 1933
just like above!


Numbers 22:10
And Balaam said unto God, Balak the son of Zippor, king of Moab, hath sent unto me, saying,


|
|
P6Spy consists of two modules that provide various types of functionality which can be modified to suit your needs. These modules, P6Log and P6Outage, are explained in this section of the documentation. Though they have distinct functions, they share some common property file settings that allow you to specify which tables to log, the log file name, the log file location, whether to show the stacktrace (where the JDBC statement is being executed), and more. Refer to the Common Property File Settings documentation for details.
P6Log is an open-source application included in the P6Spy distribution that intercepts and logs the database statements of any application that uses JDBC. This application monitors the SQL statements produced by EJB servers, enabling developers to write code that achieves maximum efficiency on the server. The P6Log module is enabled by default. Disable or enable the P6Log module by editing the spy.properties configuration file. If the module is commented out, it is not loaded, and the functionality is not available. If the module is not commented out, the functionality is available. The applicable portion of the spy.properties file follows:
#################################################################
# MODULES #
# #
# Modules provide the P6Spy functionality. If a module, such #
# as module_log is commented out, that functionality will not #
# be available. If it is not commented out (if it is active), #
# the functionality will be active. #
# #
# Values set in Modules cannot be reloaded using the #
# reloadproperties variable. Once they are loaded, they remain #
# in memory until the application is restarted. #
# #
#################################################################module.log=com.p6spy.engine.logging.P6LogSpyDriver
#module.outage=com.p6spy.engine.outage.P6OutageSpyDriver
The following are P6Log-specific properties:
This feature only logs queries that take longer than a specified threshold to execute.
P6Outage is an open-source application included in the P6Spy distribution that detects long-running statements that may be indicative of a database outage problem. The product logs any statement that surpasses the configurable time boundary during its execution. P6Outage minimizes any logging performance overhead by logging only long-running statements. The P6Outage module is disabled by default. Disable or enable the P6Outage module by editing the spy.properties configuration file. If the module is commented out, it is not loaded, and the functionality is not available. If the module is not commented out, the functionality is available.
The applicable portion of the spy.properties file follows:
#################################################################
# MODULES #
# #
# Modules provide the P6Spy functionality. If a module, such #
# as module_log is commented out, that functionality will not #
# be available. If it is not commented out (if it is active), #
# the functionality will be active. #
# #
# Values set in Modules cannot be reloaded using the #
# reloadproperties variable. Once they are loaded, they remain #
# in memory until the application is restarted. #
# #
##################################################################module.log=com.p6spy.engine.logging.P6LogSpyDriver
module.outage=com.p6spy.engine.outage.P6OutageSpyDriver
The following are P6Outage-specific properties:
This feature detects long-running statements that may be indicative of a database outage problem. When enabled, it logs any statement that surpasses the configurable time boundary during its execution. No other statements are logged except the long-running statements.
The interval property is the boundary time set in seconds. For example, if set to 2, any statement requiring at least 2 seconds is logged. The same statement will continue to be logged for as long as it executes. So, if the interval is set to 2 and a query takes 11 seconds, it is logged 5 times (at the 2, 4, 6, 8, 10-second intervals).
|
|


Thomas Nicely, a professor of mathematics at Lynchburg College, had written code to enumerate primes,
twin primes, prime triplets, and prime quadruplets.
Nicely noticed some inconsistencies in the calculations shortly after adding a Pentium system to his group of computers
After eliminating other factors he reported the issue to Intel.
This was a bug in the pentium chip due to missing entries in the lookup table used by the floating-point division circuitry.
This bug had escaped testing.
This caused Intel to take a $475M charge against earnings and the management said "don't ever let this happen again".
In 1996 they started proving properties of the Pentium processor FPU.
Then in 1997 a bug was discovered in the FIST instruction (that converts floating point numbers to integers)
in the formally verified correct Pentium Pro FPU.
It was a protocol mismatch between two blocks not accounted for in the informal arguments.
So they went back to square one and during 1997-98 the verified the entire FPU against high-level specs
so that mismatches like the FIST bug could no longer escape.
During 1997-99 the Pentium 4 processor was verified and there were no escapes.
TimSort
Tim Peters developed the Timsort hybrid sorting algorithm in 2002 - this is the standard sorting algorithm in Java, Android, Python etc.
It is a clever combination of ideas from merge sort and insertion sort, and designed to perform well on real world data.
Specifically, data is grouped into runs, sequences that are already ordered, using insertion sort if needed.
Runs are merged as in merge sort.
Run lengths are stored on a stack, which should be small for performance reasons.
After having successfully verified Counting and Radix sort implementations in Java, the Dutch-German Envisage group
turned to proving the correctness of TimSort.
After struggling to prove this, they realized they could not because the implementation was in fact wrong.
Specifically the size of the stack for run lengths was estimated based on a (growth) property of run lengths, but this did not always hold.
They proved that a modified version of the property holds, and a corresponding algorithm does work.
Conclusions from TimSort
Formal methods are often classified as irrelevant and/or impracticable by practitioners.
This is not true: the researchers found and fixed a bug in a piece of software that is used by billions of users every single day.
Even though the bug itself is unlikely to occur, it is easy to see how it could be used in an attack.
Using Formal methods
Formal methods are mathematical proofs checked by computers.
What are mathematical proofs?
How do we know that the program checking the proof is correct?
Why does everyone not do so already?
Why not always?
Formal proving takes work, so we have a trade-off between productivity and safety.
We have the same trade-off between dynamic and static typing; and often productivity wins.
Better languages and tooling can help in getting safety without losing too much productivity.
Who guards the guards?
Formal proof systems have a small trusted kernel.
All proofs are verified, directly or indirectly, by the kernel.
The trusted kernel itself should be checked independently and thoroughly several times.
For example, lean theorem prover has independent type checkers (i.e. kernels) in three languages.
Foundations: Logic, Sets, Types
The usual foundations of mathematics are Set Theory as a theory in First-order logic.
Computation can be founded on $\lambda$-calculus or two other equivalent models.
Type theory gives common foundations integrating proofs and computations.
All these are based on capabilities to perform basic operation
such as pattern matching on strings; and agreement on the meanings of such operations.
Foundations
of
Mathematics (and Computation)
Decide whether the following are true or false.
$2 < 3$
$ 3 > 4$
$3 + 12$
$3 += 4++ $
We can only ask whether an expression is true or false provided:
It is a well-formed (meaningful) expression.
It represents a statement (not an object such as a number or set).
Layers of foundations
A language, given by rules of its grammar/syntax, that specifies well-formed expressions
as well as types of these expressions.
Rules of deduction letting us conclude that a statement is true from other true statements.
Axioms: statements that are known to be true.
Rules are syntactic in nature, i.e., in terms of manipulating and pattern matching strings.
Rules can be computed quickly.
Generative grammars
The languages we consider are given by
an initial vocabulary of expressions (with types),
(introduction) rules to form new expressions from existing ones and assigning types to these,
such that the rules depend only on the types of the expressions.
Well-formed expressions are exactly those that can be formed from the vocabulary using the introduction rules.
We can prove properties of such expressions by induction.
Natural and programming languages
For example in English
The vocabulary has nouns, verbs, adjectives etc.
A single noun forms a noun phrase, e.g. lecture.
An adjective followed by a noun phrase forms a noun phrase, e.g. boring lecture.
Similarly, in most programming languages, if x and y are expressions
with type Int, we can form the expression x + y of type Int.
We can also form the Boolean expression x < y.
Mathematical expressions and their types are determined by the syntax of a generative language.
In particular, it is straightforward to generate all expressions, and to check the validity and type of an expression.
Similarly valid deductions are those given by repeated application of syntactic rules.
For example, the rule Modus Ponens says that for formulas $P$ and $Q$, from $P$ and $P \implies Q$ we can deduce $Q$.
A specific class of such languages and rules of deduction constitute First-order logic,
on which the usual foundations of mathematics are based.
Theories and Sets
A theory is a (first-order) language together with a collection of axioms, i.e., statements that are taken to be true.
A specific first-order language and set of axioms constitute Set Theory.
All of mathematics can be encoded in terms of Set Theory. However this is verbose and opaque, like Bytecode/assembly language .
Hence any practical formalization depends on using some combination of a proof assistant and more expressive foundations.
Verification in the real world
The real-world problem needs to be (correctly) modelled mathematically/logically.
The mathematical model needs to be (correctly) embedded in Set theory or other appropriate foundations.
By results of logic, statements that are deduced following the rules of syntax are true in the Set Theoretic model.
First-order Languages
Data for a language
First-order languages (e.g. Arithmetic, Sets) are specified by (possibly empty) lists of
(names of) constants, e.g. $0$, $1$, $\phi$.
(names of) functions together with their degree/arities, e.g., addition ($+$) with degree $2$.
(names of) relations together with their degree/arities, e.g.,
less than ($<$) and belongs to ($\in$) with degree $2$.
(names of) variables - these can be assumed to be independent of the language.
Expressions
We form two types of expressions:
Terms: representing numbers, sets etc.
Formulas: representing properties of numbers, sets, etc.
Both terms and formulas may depend on variables.
Terms
Terms are expressions recursively given by the rules
A variable $x$ is a term.
A constant $c$ is a term.
If $f$ is a function of degree $n$ and $t_1$, $t_2$, $\dots$, $t_n$ are terms then $f(t_1, t_2,\dots,t_n)$ is a term.
Formulas
Formulas are expressions recursively given by:
If $t_1$ and $t_2$ are terms, then $t_1 = t_2$ is a formula.
If $p$ is a relation of degree $n$ and $t_1$, $t_2$, $\dots$, $t_n$ are terms then $p(t_1, t_2,\dots,t_n)$ is a term.
If $P$ and $Q$ are formulas then $P\wedge Q$, $P\vee Q$, $P\implies Q$, $P\iff Q$, and $\neg P$ are formulas.
If $P$ is a formula and $x$ is a variable, then $\forall x P$ and $\exists x P$ are formulas.
We recursively define free variables of terms and formulas. A formula is closed if it has no free variables.

Thus, we have a relation $x \in S$, for any object $x$, corresponding to $x$ being a member of $S$.
Further, if $S$ and $T$ are sets with the same members they are equal, i.e. if
$$\forall x\ x\in S \iff x\in T$$
then $S= T$ (Axiom of extension).
Language of Sets
We have a first-order language that describes sets with
a single relation $\in$ (is a member of) of degree $2$.
a single constant $\phi$ (the empty set).
For example, the axiom of extensionality can be described in this language by the formula
$$\forall x\forall y (\forall a\ a\in x \iff a \in y) \implies x = y.$$
Here everything is a set, including members of sets.
What collections?
We need some way to construct sets.
A natural way to try to do this is to say sets are collections of objects that satisfy some property, e.g.
$$\{p: \text{$p$ is a prime number} \}.$$
We can make this formal by, for example, defining properties to be closed formulas
in the first-order language of sets (alternatively as closed formulas in some first-order language).
Russell's Paradox
Assume we had sets corresponding to all closed formulas in the first-order language of sets.
Consider the set
$$ S = \{X : X \notin X\}.$$
Question: Is $S\in S$?
We see that
if $S \notin S$ then $S \in S$,
if $S\in S$ then $S \notin S$.
Sets from Axioms
The axiom of specification allows us to define subsets of a set by a property.
Thus, if we have previously defined the natural numbers $\mathbb{N}$, then we can define the set
$$\{p \in\mathbb{N} : \text{$p$ is a prime number} \}.$$
Most axioms of set theory are statements giving us the existence of sets.
More axioms
In our setup, we need an axiom for the empty set:
$\forall x (\lnot(x\in \phi))$
We have axioms giving the unions of pairs and of arbitrary collections of sets.
The axiom of infinity, says that there exists a set $S$ such that
$\phi\in S$.
$(x\in S) \implies ((x\cup \{x\}) \in S)$
There are also two technical axioms: axioms of regularity and replacement, completing ZF.
Axiom of Choice and transfinite recursion
The axiom of choice is an axiom independent of ZF
- including this gives ZFC.
This says: let $(S_i)_{i\in I}$ be an indexed family of non-empty sets, where $I$ is the index set.
Then there is an indexed family of elements $(x_i)_{i\in I}$ such that $x_i\in S_i$ for all $i\in I$.
In the presence of the axiom of choice, we can make constructions by transfinite recursion
For instance we get the trichotomy theorem: for sets $A$ and $B$, at least one of $|A|\leq |B|$ and
$|B|\leq |A|$ holds.


Using v-model. We have some differences in checkbox mode. Note that multiple is false. If multiple is true the selected object will be an array.
Selected: {{ treeModel.selected.text }}
Checked: {{ treeModel.checked.map(el => getFullPath(el)) }}


Version control means the ability to go back in time to any point at which a file was saved or tracked. Git is the version control system. It tracks the changes every time a developer saves or, in git language, commits them. If something bad happens to a file, such as an experiment that just did not work as you thought it would, you can go back to the point in time right before you made that experimental change, and exist as if you had never made that mistake, a.k.a. learning experience. Wouldn't it be grand if life had version control, allowing us to experiment and make mistakes while avoiding living with the consequences of said mistake by jumping back to the moment before you made the mistake? Obviously, it would be friggin grand!
The great thing about using Github is that you open up your code and all its possibilities to the huge community of developers on Github. Because Github stuff is open source, anyone from the Github community has access to your code. They can use it, modify it, distribute it to others (who can then use or modify it). This means that we, as a community, can make mistakes (have learning experiences) together and improve code with exponential speed. Putting many heads together allows us to draw on the creative and skillful ability of the entire dev community. Like a virus, code can grow in nearly infinite new strains rapidly with the inferior code being constantly replaced by smoother, less buggy code. It's like "survival of the fittest" code... but faster than organic evolution.


Issued(issuer: PartyAndReference, product: P)
The Issued data class holds the details of an on ledger digital asset. In particular it gives the public credentials of the entity that created these digital tokens and the particular product represented.
P
- the class type of product underlying the definition, for example java.util.Currency.


I'm Sincy Joseph, a passionate self-taught Software engineer and Researcher from India. Currently pursuing Masters in computer science and engineering from APJ Abdul Kalam University. My passion for software lies with dreaming up ideas and making them come true with elegant interfaces. I take great care in the experience, architecture, and code quality of the things I build. I am also an open-source enthusiast and maintainer. I learned a lot from the open-source community and I love how collaboration and knowledge sharing happened through open-source.
Computer Science and Engineering
Specialization : Network and Security (Pursuing)
Institution : Govt. Engineering College, Wayanad
University : APJ Abdul Kalam Technological University
Computer Science and Engineering
Institution : Vimal Jyothi Engineering College, Chemperi
University : APJ Abdul Kalam Technological University
Institution : Govt. Higher Secondary School, Kozhichal
Board : Board of HSE, Kerala
Institution : St. John’s High School, Palavayal, Kannur
Board : Board of Public Examination, Kerala
Aim: The project provide a drip monitoring system by the use of mobile application that will monitor the rip Level, Temperature, and Pressure of the patient.
Application Environment: Languages: C++ Platform: Arduino IDE, MIT App Invento
Funded project: Kerala State Council for Science, Technology and Environment (KSCSTE)
Period : 2019 January – August 2019
Aim: The system provide a fool-proof digitized land registries using the blockchain technology, where the users can store, access, and use land record in a secure manner.
Application Environment: Languages: Solidity, HTML, JavaScript, CSS Platform: Windows/Ubuntu, Remix IDE, Visual Studio, Metamask, Ganache/Geth,Web3js, Ethereum Blockchain
Funded project: Kerala State Council for Science, Technology and Environment (KSCSTE)
Period : 2020 January – August 2020


This extension intent is to provide a set of features to improve productivity working with Pentaho Business Intelligence.
Currently, there is only one feature: Heat maps. Using Saiku Analytics plug-in, sometimes you need to analyze the reports in a heat map perspective. Heat maps allow insights of data giving visual cues about how data varies, where anomalies or highest/lowest values are concentrated.
This plugin adds heat map feature to Saiku reports inside Pentaho. Just by right-clicking the report, you can produce a heat map for each row, for each columns or even the entire table.
Please, visit the extension web site to ask for new features or to submit bugs! http://github.com/natenho/pentaho-sidekicks


Planet Year Calculator
Enter your age:
Select the gender that is most accurate
Select one
Transgender male
Cisgender female
Nonbinary
Transgender male
Transgender female
Other
Select the level of mental health issues that you experience
Select one
Mild
Moderate
Severe
Enter your average yearly income
Submit


Premonoidal categories and a graphical view of programs
Completeness proofs
Finite products
Symmetric monoidal
Symmetric premononidal
Partial traced cartesian
Appendices
Premonoidal categories and state transformers
Bibliography


Task Title: Due Date: Time Due: Repeat: None Daily Weekly Monthly Yearly List: Default Personal Shopping Wishlist Work Save Cancel New List


Another aide to Bayelsa governor resigns - Premium Times Nigeria
by Agency ReportThe Senior Special Adviser to Bayelsa Governor on Niger Delta Youth Matters, Kenedy Tonjo-West, has resigned his appointment few days to the governorship election in the state.
The election will be conducted by INEC on November 16.
In a letter dated November 13 and addressed to Governor Seriake Dickson on Wednesday, Mr Tonjo-West did not give reasons for leaving government, but expressed appreciation to the governor for giving him the opportunity to serve.
“I appreciate the rare privilege to work under your administration from October 2015 to February 2016 and from December 2016 to November 2019, an opportunity that deepened my understanding of politics, campaign promises and good governance,” he stated.
Mr Tonjo-West told News Agency of Nigeria (NAN) on telephone that he still remained a member of the Peoples Democratic Party (PDP).
Some members of Dickson’s administration including the Secretary to State Government, Kemela Okara and the Chairman, Board of Internal Revenue, Nimbofa Ayawei, had earlier resigned their appointments to contest in the governorship primaries.
(NAN)


History of the Salmon Cookie! Ghoul salmon shark marlin. Dusky grouper blue shark stargazer California smoothtongue oarfish, Australian grayling moray eel dartfish eel-goby snailfish orangespine unicorn fish Asian carps triplespine warty angler.
Store Location
Opening Hours
- 6 am
- 7 am
- 8 am
- 9 am
- 10 am
- 11 am
- 12 pm
- 1 pm
- 2 pm
- 3 pm
- 4 pm
- 5 pm
- 6 pm
- 7 pm
Salmon shirts
You can Visit one of our Stores location and buy our Store shirt to give us your support.
Own our Salmon Shirt!
Our goal is to Make you happy
Our store is the perfect store for a family When you buy our cookies your family will be mush happier, We have a more than one Cutter to create your own Shape of Samon Cookies.


HOME
ABOUT SASHA
ASK SASHA
SASHA'S REEL
SASHA'S SOCIAL MEDIA
SASHA'S REVIEWS
CONTACT SASHA
CONTACT SASHA
For session inquiries and information enter your info.
SEND