Moise Kean's dad demands Everton striker leaves England and returns to Serie A
Jean Kean says £27m forward is not settled at Everton and urges Roma switch - as he claims Juventus still owe him two tractors
by Gareth BicknellMoise Kean's dad has said his son's £27million move to Everton was a mistake - and demanded the striker return to Italy 'as soon as possible'.
Kean joined Everton from Juventus in the summer in what was regarded as something of a coup - but the Italy under-21 international's father says his son is not happy at Goodison Park.
Jean Kean wants the 19-year-old to return to Serie A, citing Roma as his preferred destination.
And he has claimed Juventus still owe him two tractors.
Jean Kean told Centro Suono Sport: "Sending my son to England was a mistake, because he's still too young, he's not feeling good at Everton, I didn't like this transfer.
"I hope he can come back to Italy as soon as possible, I hope he goes to Rome, but the important thing is that he comes back here.
"At Everton, where he is playing now, he is not settling in well. I think he was supposed to wait a few more years before he had an experience abroad.
"If there is a possibility for him to come back to Italy, I hope he can do that, so as not to ruin him."
Kean has made 10 Premier League appearances for Everton so far this season, but has started only twice and is yet to score.
His dad said Juventus owe him two tractors from an agreement made when Kean was 14.
"I believe in God and I believe in promises," he said. "But if their word was a lie I can’t trust them anymore. They promised me two tractors and they still haven’t been given to me.
"When he was 14, Marotta (Giuseppe) called me and took him to Turin, he could have ended up in England. On that occasion he promised me two tractors, to help my brothers in exchange for signing him to Juventus."
AC Milan and Roma are reported to be interested in taking the striker on loan in January.


Styles Conference
Sunday, August 24, 2014 at 9:00 a.m.
Chicago Theatre
175 N. State St.
Chicago
,
IL
60601


Erlang Term Storage, commonly referred to as ETS, is a powerful storage engine built into OTP and available to use in Elixir. In this lesson we’ll look at how to interface with ETS and how it can be employed in our applications.
Table of Contents
Overview
ETS is a robust in-memory store for Elixir and Erlang objects that comes included. ETS is capable of storing large amounts of data and offers constant time data access.
Tables in ETS are created and owned by individual processes.
When an owner process terminates, its tables are destroyed.
You can have as many ETS table as you want, the only limit is the server memory. A limit can be specified using the ERL_MAX_ETS_TABLES
environment variable.
Creating Tables
Tables are created with new/2
, which accepts a table name, and a set of options, and returns a table identifier that we can use in subsequent operations.
For our example we’ll create a table to store and look up users by their nickname:
iex> table = :ets.new(:user_lookup, [:set, :protected])
8212
Much like GenServers, there is a way to access ETS tables by name rather than identifier.
To do this we need to include the :named_table
option.
Then we can access our table directly by name:
iex> :ets.new(:user_lookup, [:set, :protected, :named_table])
:user_lookup
Table Types
There are four types of tables available in ETS:
set
— This is the default table type. One value per key. Keys are unique.ordered_set
— Similar toset
but ordered by Erlang/Elixir term. It is important to note that key comparison is different withinordered_set
. Keys need not match so long as they compare equally. 1 and 1.0 are considered equal.bag
— Many objects per key but only one instance of each object per key.duplicate_bag
— Many objects per key, with duplicates allowed.
Access Controls
Access control in ETS is similar to access control within modules:
public
— Read/Write available to all processes.protected
— Read available to all processes. Only writable by owner process. This is the default.private
— Read/Write limited to owner process.
Race Conditions
If more than one process can write to a table - whether via :public
access or by messages to the owning process - race conditions are possible.
For example, two processes each read a counter value of 0
, increment it, and write 1
; the end result reflects only a single increment.
For counters specifically, :ets.update_counter/3 provides for atomic update-and-read.
For other cases, it may be necessary for the owner process to perform custom atomic operations in response to messages, such as “add this value to the list at key :results
”.
Inserting data
ETS has no schema.
The only limitation is that data must be stored as a tuple whose first element is the key.
To add new data we can use insert/2
:
iex> :ets.insert(:user_lookup, {"doomspork", "Sean", ["Elixir", "Ruby", "Java"]})
true
When we use insert/2
with a set
or ordered_set
existing data will be replaced.
To avoid this there is insert_new/2
which returns false
for existing keys:
iex> :ets.insert_new(:user_lookup, {"doomspork", "Sean", ["Elixir", "Ruby", "Java"]})
false
iex> :ets.insert_new(:user_lookup, {"3100", "", ["Elixir", "Ruby", "JavaScript"]})
true
Data Retrieval
ETS offers us a few convenient and flexible ways to retrieve our stored data. We’ll look at how to retrieve data by key and through different forms of pattern matching.
The most efficient, and ideal, retrieval method is key lookup. While useful, matching iterates through the table and should be used sparingly especially for very large data sets.
Key Lookup
Given a key, we can use lookup/2
to retrieve all records with that key:
iex> :ets.lookup(:user_lookup, "doomspork")
[{"doomspork", "Sean", ["Elixir", "Ruby", "Java"]}]
Simple Matches
ETS was built for Erlang, so be warned that match variables may feel a little clunky.
To specify a variable in our match we use the atoms :"$1"
, :"$2"
, :"$3"
, and so on.
The variable number reflects the result position and not the match position.
For values we’re not interested in, we use the :_
variable.
Values can also be used in matching, but only variables will be returned as part of our result. Let’s put it all together and see how it works:
iex> :ets.match(:user_lookup, {:"$1", "Sean", :_})
[["doomspork"]]
Let’s look at another example to see how variables influence the resulting list order:
iex> :ets.match(:user_lookup, {:"$99", :"$1", :"$3"})
[["Sean", ["Elixir", "Ruby", "Java"], "doomspork"],
["", ["Elixir", "Ruby", "JavaScript"], "3100"]]
What if we want our original object, not a list? We can use match_object/2
, which regardless of variables returns our entire object:
iex> :ets.match_object(:user_lookup, {:"$1", :_, :"$3"})
[{"doomspork", "Sean", ["Elixir", "Ruby", "Java"]},
{"3100", "", ["Elixir", "Ruby", "JavaScript"]}]
iex> :ets.match_object(:user_lookup, {:_, "Sean", :_})
[{"doomspork", "Sean", ["Elixir", "Ruby", "Java"]}]
Advanced Lookup
We learned about simple match cases but what if we want something more akin to an SQL query? Thankfully there is a more robust syntax available to us.
To lookup our data with select/2
we need to construct a list of tuples with arity 3.
These tuples represent our pattern, zero or more guards, and a return value format.
Our match variables and two new variables, :"$$"
and :"$_"
, can be used to construct the return value.
These new variables are shortcuts for the result format; :"$$"
gets results as lists and :"$_"
gets the original data objects.
Let’s take one of our previous match/2
examples and turn it into a select/2
:
iex> :ets.match_object(:user_lookup, {:"$1", :_, :"$3"})
[{"doomspork", "Sean", ["Elixir", "Ruby", "Java"]},
{"3100", "", ["Elixir", "Ruby", "JavaScript"]}]
iex> :ets.select(:user_lookup, [{{:"$1", :_, :"$3"}, [], [:"$_"]}])
[{"doomspork", "Sean", ["Elixir", "Ruby", "Java"]},
{"3100", "", ["Elixir", "Ruby", "JavaScript"]}]
Although select/2
allows for finer control over what and how we retrieve records, the syntax is quite unfriendly and will only become more so.
To handle this the ETS module includes fun2ms/1
, which turns the functions into match_specs.
With fun2ms/1
we can create queries using a familiar function syntax.
Let’s use fun2ms/1
and select/2
to find all usernames with more than 2 languages:
iex> fun = :ets.fun2ms(fn {username, _, langs} when length(langs) > 2 -> username end)
[{{:"$1", :_, :"$2"}, [{:>, {:length, :"$2"}, 2}], [:"$1"]}]
iex> :ets.select(:user_lookup, fun)
["doomspork", "3100"]
Want to learn more about the match specification? Check out the official Erlang documentation for match_spec.
Deleting Data
Removing Records
Deleting terms is as straightforward as insert/2
and lookup/2
.
With delete/2
we only need our table and the key.
This deletes both the key and its values:
iex> :ets.delete(:user_lookup, "doomspork")
true
Removing Tables
ETS tables are not garbage collected unless the parent is terminated.
Sometimes it may be necessary to delete an entire table without terminating the owner process.
For this we can use delete/1
:
iex> :ets.delete(:user_lookup)
true
Example ETS Usage
Given what we’ve learned above, let’s put everything together and build a simple cache for expensive operations.
We’ll implement a get/4
function to take a module, function, arguments, and options.
For now the only option we’ll worry about is :ttl
.
For this example we’re assuming the ETS table has been created as part of another process, such as a supervisor:
defmodule SimpleCache do
@moduledoc """
A simple ETS based cache for expensive function calls.
"""
@doc """
Retrieve a cached value or apply the given function caching and returning
the result.
"""
def get(mod, fun, args, opts \\ []) do
case lookup(mod, fun, args) do
nil ->
ttl = Keyword.get(opts, :ttl, 3600)
cache_apply(mod, fun, args, ttl)
result ->
result
end
end
@doc """
Lookup a cached result and check the freshness
"""
defp lookup(mod, fun, args) do
case :ets.lookup(:simple_cache, [mod, fun, args]) do
[result | _] -> check_freshness(result)
[] -> nil
end
end
@doc """
Compare the result expiration against the current system time.
"""
defp check_freshness({mfa, result, expiration}) do
cond do
expiration > :os.system_time(:seconds) -> result
:else -> nil
end
end
@doc """
Apply the function, calculate expiration, and cache the result.
"""
defp cache_apply(mod, fun, args, ttl) do
result = apply(mod, fun, args)
expiration = :os.system_time(:seconds) + ttl
:ets.insert(:simple_cache, {[mod, fun, args], result, expiration})
result
end
end
To demonstrate the cache we’ll use a function that returns the system time and a TTL of 10 seconds. As you’ll see in the example below, we get the cached result until the value has expired:
defmodule ExampleApp do
def test do
:os.system_time(:seconds)
end
end
iex> :ets.new(:simple_cache, [:named_table])
:simple_cache
iex> ExampleApp.test
1451089115
iex> SimpleCache.get(ExampleApp, :test, [], ttl: 10)
1451089119
iex> ExampleApp.test
1451089123
iex> ExampleApp.test
1451089127
iex> SimpleCache.get(ExampleApp, :test, [], ttl: 10)
1451089119
After 10 seconds if we try again we should get a fresh result:
iex> ExampleApp.test
1451089131
iex> SimpleCache.get(ExampleApp, :test, [], ttl: 10)
1451089134
As you see we are able to implement a scalable and fast cache without any external dependencies and this is only one of many uses for ETS.
Disk-based ETS
We now know ETS is for in-memory term storage but what if we need disk-based storage? For that we have Disk Based Term Storage, or DETS for short.
The ETS and DETS APIs are interchangeable with the exception of how tables are created.
DETS relies on open_file/2
and doesn’t require the :named_table
option:
iex> {:ok, table} = :dets.open_file(:disk_storage, [type: :set])
{:ok, :disk_storage}
iex> :dets.insert_new(table, {"doomspork", "Sean", ["Elixir", "Ruby", "Java"]})
true
iex> select_all = :ets.fun2ms(&(&1))
[{:"$1", [], [:"$1"]}]
iex> :dets.select(table, select_all)
[{"doomspork", "Sean", ["Elixir", "Ruby", "Java"]}]
If you exit iex
and look in your local directory, you’ll see a new file disk_storage
:
$ ls | grep -c disk_storage
1
One last thing to note is that DETS does not support ordered_set
like ETS, only set
, bag
, and duplicate_bag
.
Caught a mistake or want to contribute to the lesson? Edit this page on GitHub!


In the Creating a new web application chapter, we changed the myapp application to the ROOT application. (The DocuementBase for the myapp application is C:/www/myapp.) All the examples below, such as the servlet chapter, should be practiced in the ROOT application. Write the JSP file in C:/www/myapp or its subdirectories with a regular editor, not Eclipse.
JSP has emerged as a Java-side countermeasure for ASP as Microsoft's ASP becomes popular. JSP is a servlet-based technology. Strictly speaking, JSP does not respond to client requests. The JSP is translated into a servlet1 by a servlet container, such as tomcat, and this servlet responds to the client's request. Servlets are a technique for dynamically creating HTML pages. However, it has been difficult to write Java code and HTML code together. The servlet must create the HTML design as a Java string and pass it as an argument to a method in the output stream. This means that the HTML code is inserted into the Java code in Servlet. In JSP, this is the opposite. Java code is inserted into the HTML design. This means that JSPs can be written more easily than servlets in writing design and code together.2 JSP is a useful technique when you need to show your users the dynamically generated HTML with a complex design.
Create a hello.jsp file in the top-level directory of your ROOT application (C:/www/myapp) and visit http://localhost:8080/hello.jsp.
  Hello, World!
When Tomcat first receives a /hello.jsp request, Tomcat creates a servlet from hello.jsp as follows:
// .. omit .. try { response.setContentType("text/html"); pageContext = _jspxFactory.getPageContext(this, request, response, null, true, 8192, true); _jspx_page_context = pageContext; application = pageContext.getServletContext(); config = pageContext.getServletConfig(); session = pageContext.getSession(); out = pageContext.getOut(); _jspx_out = out; out.write("\n"); out.write("\n"); out.write("Hello, World!\n"); out.write("\n"); out.write("\n"); } catch (java.lang.Throwable t) { if (!(t instanceof javax.servlet.jsp.SkipPageException)){ out = _jspx_out; if (out != null && out.getBufferSize() != 0) try { if (response.isCommitted()) { out.flush(); } else { out.clearBuffer(); } } catch (java.io.IOException e) {} if (_jspx_page_context != null) _jspx_page_context.handlePageException(t); else throw new ServletException(t); } } finally { _jspxFactory.releasePageContext(_jspx_page_context); } // .. omit ..
Because hello.jsp is created in the top-level directory of the ROOT application, the full path to the generated servlet is CATALINA_HOME\work\Catalina\localhost\_\org\apache\jsp\hello_jsp.java. Tomcat compiles this servlet, creates a servlet object from the servlet bytecode, and invokes the service method of the servlet object. When hello.jsp request arrives again, Tomcat checks whether the hello.jsp file has been changed. If hello.jsp has not changed, Tomcat checks whether the servlet object is loaded. If the servlet object is in memory, Tomcat call the service method of the servlet object. If the servlet object is not in memory, Tomcat create a servlet object. If hello.jsp is changed, Tomcat make a servlet Java source from hello.jsp.
Directives provide general information about a JSP to a Servlet Container. There are three directives: page, include, and taglib.
<%@ page {attribute="value"} %>
| attribute="value" | Description |
|---|---|
| language="scriptLanguage" | the server-side language to compile the page (mostly java) |
| import="importList" | The Java package or Java package list that the page imports. Lists are separated by commas (,). |
| session="true | false" | Sets whether the page uses session data (default is true). |
| errorPage="error_uri" | relative path of the error page that handles the JSP exception. |
| isErrorPage="true | false" | whether the page is a error page (default is false). |
| contentType="ctinfo" | Set the MIME type and charset of the response. |
| pageEncoding="charset" | the charset of the JSP file. Specifies the same as the charset specified by contentType. |
If omitted, there are many attributes to which the default value applies. Therefore, you do not need to set all attributes. The contentType attribute can only be set once and is set in most of the first page directives. You can set multiple import attributes.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="java.util.HashMap,java.util.ArrayList" %>
There are two page directives in this example. The first directive above sets the response of content type to text/html (HTML Documents) and the character set of response content to UTF-8. UTF-8 is currently the most popular character set on the Internet. The second page directive has only the import attribute set. The Java codes in JSP will use java.util.HashMap and java.util.ArrayList. You can also set the import attribute on the first page directive, but doing so is not recommended. You can change the above as follows.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="java.util.HashMap" %> <%@ page import="java.util.ArrayList" %>
It is recommended to code this way because it is easy to see.
The include directive is used to insert a document into a servlet which is made from a JSP. The document to be inserted must exist within the web application.
<%@ include file="header.jsp" %>
The taglib directive specifies the tag library used by the JSP page. A tag library is a technique for creating a tag that changes to Java code when converted to a servlet. If you can use tags instead of Java code in JSP, you can manage your design efficiently. However, with the advent of a large number of tag libraries, programmers have become increasingly reluctant to use tag libraries.
The tag library uses prefix and uri to uniquely distinguish its tag set.
<%@ taglib uri="tagLibraryURI" prefix="tagPrefix" %>
The uri is a URI Information that uniquely names the tag library. The prefix is used to distinguish the tag libraries within a JSP page.
I will not discuss how to create a tag library. The JSP Standard Tag Library (JSTL) included in the JSP specification is covered in the JSP Project.
Scripting is used to insert Java code into JSP pages. There are three scripting: Declarations, Expressions, Scriptlets,
Declarations are used to declare servlet instance variables and methods within a JSP page. The following declaration is converted to an instance variable of the servlet class.
<%! String name = new String("Alison"); %>
The following declaration is converted to instance method of the servlet class.
<%! public String getName() { return name; } %>
The expression is converted to a string by the servlet container. If the expression is not converted to a string, a ClassCastException is thrown. The following expression prints Hello, Alison to the web browser.
Hello, <%=getName()%>
You can insert Java statements freely within scriptlets. A Java statements in <% ...%> are included in the servlet's _jspSevice() method when a servlet is made from a JSP.
Actions are used to create or modify objects.
This action creates a bean or finds the bean that was created. First, it looks for objects that use the same scope and id. If the object is not found, it creates the object according to the given scope and id attributes.
<jsp:useBean id="name" scope="application" class="net.java_school.db.dbpool.OracleConnectionManager" /><jsp:useBean>'s attributes
| attribute | Description |
|---|---|
| id | The key to identify the object instance in the same scope. |
| scope | The range in which the generated bean's reference is valid, page(default), request, session, application |
| class | FQCN(Fully Qualified Class Name) 패키지를 포함한 클래스 이름 |
| type | The superclass or interface of the class defined in the class attribute. |
<jsp:useBean id="cart" scope="request" class="example.Cart" /> is like the following scriptlet:
<% example.Cart cart; cart = (example.Cart) request.getAttribute("cart"); if (cart == null) { cart = new example.Cart(); request.setAttribute("cart", cart); } %>
This action is used to set the property value of the bean.
<jsp:useBean id="login" scope="page" class="example.User" /> <jsp:setProperty name="login" property="passwd" />
The above code is like the scriptlet below.
<% example.User user; user = (example.User) pageContext.getAttribute("user"); if (user == null) { user = new example.User(); pageContext.setAttribute("user", user); } String _jspParam; _jspParam = request.getParameter("passwd"); if (_jspParam != null && !_jspParam.equals("")) user.setPasswd(_jspParam); %><jsp:setProperty>'s attributes
| Attribute | Description |
|---|---|
| name | The name of the bean instance defined in <jsp:useBean>. |
| property | Beans property to change the value. If property="*", all properties of the bean are modified by calling any setter method that matches all parameter names in the HTTP request. But if the value of the parameter is "", the property of the corresponding bean is not modified. |
| param | The value of the param attribute is one of the parameter names of the HTTP request. The value of the beans property set in the property attribute is set to the param attribute value. |
| value | Change the property of the bean to the string defined in the value attribute. |
Suppose you have the following form page.
<form action="register.jsp" method="post"> <input type="text" name="id" /> <input type="password" name="passwd" /> </form>
Suppose there is the following action in register.jsp that receives the value entered in the form by a user:
<jsp:setProperty name="user" property="*" />
The above action is like the scriptlet below.
<% String _jspParam; _jspParam = request.getParameter("passwd"); if ( _jspParam != null && !_jspParam.equals("") ) user.setPasswd(_jspParam); _jspParam = request.getParameter("id"); if ( _jspParam != null && !_jspParam.equals("") ) user.setId(_jspParam); %>
Suppose you have the following form page:
<form action="signUp.jsp" method="post"> <input type="text" name="member_id" /> </form>
Suppose you have the following action in signUp.jsp that receives a form input value:
<jsp:setProperty name="user" property="id" param="member_id" />
The above action is like the scriptlet below.
<% String _jspParam; _jspParam = request.getParameter("member_id"); if (_jspParam != null && !_jspParam.equals("")) user.setId(_jspParam); %>
As you can see in the example above, if the name of the bean's member variable and the name of the form's parameter are not equal, you need to use the param attribute.
The following is an example of the setProperty action.
<jsp:setProperty name="user" property="id" value="admin" />
The above setProperty action is like the following scriptlet.
<% user.setId("admin"); %>
As in the example above, the setProperty action is used to set the property value of the bean.
The getProperty action takes the property value of the bean and puts it into the output stream.
<jsp:getProperty name="name" property="propertyName" /><jsp:getProperty>'s attributes
| Attribute | Description |
|---|---|
| name | The name of the bean instance |
| property | a property of bean instance |
This action is used to define the parameters to pass to <jsp:include> and <jsp:forward>.
<jsp:param name="name" value="value" />
This action is used to add static (HTML) or dynamic web components (JSP, Servlets) to a JSP page.
<jsp:include page="urlSpec" flush="true"> <jsp:param ... /> </jsp:include><jsp:include>'s attributes
| Attribute | Description |
|---|---|
| page | Relative path of the resources to be included |
| flush | Whether the buffer is flushed |
This action is used for forwarding. Forwarding means that the resource that is requested by the client passes control to another resource. <jsp:forward> can have <jsp:param> as its child element, in order to pass parameters to the target resource to which control is passed. The page attribute is the relative address of the target resource to which control is passed.
<jsp:forward page="relativeURL"> <jsp:param .../> </jsp:forward>
An implicit object is an object used in a JSP and can be used immediately without any effort to obtain a reference value.
It is a reference to the instance of javax.servlet.jsp.JspWriter abstract class type. It used to write data to the response stream. Create helloworld.jsp in the root directory of your ROOT application as shown below and visit http://localhost:8080/helloWorld.jsp.
  <% out.println("Hello, World!"); %>
Compare the servlet made from hello.jsp with the servlet made from helloworld.jsp. The full path of each servlet is:
This is a reference to the instance of javax.servlet.http.HttpServletRequest interface type. This reference allows you to access request parameters, information sent by the user in the header, and information about the user. Create request.jsp in the root directory of your ROOT application as shown below and visit http://localhost:8080/request.jsp?user=alison
  <% out.println("Hello, " + request.getParameter("user")); %>
It is a reference to the instance of javax.servlet.http.HttpServletResponse interface type.
This is a reference to the instance of javax.servlet.jsp.PageContext abstract class type. It provides access to all available resources within the JSP. For example, it provides access to resources such as ServletRequest, ServletResponse, ServletContext, HttpSession, and ServletConfig.
This is a reference to the instance of javax.servlet.http.HttpSession type. It is used to read and store session data. Create session.jsp in the root directory of your ROOT application as shown below and visit http://localhost:8080/session.jsp several times.
  <title>session</title>   <% Integer count = (Integer)session.getAttribute("count"); if (count == null) { count = new Integer(1); session.setAttribute("count", count); } else { count = new Integer(count.intValue() + 1); session.setAttribute("count", count); } out.println("COUNT: " + count); %>
It is a reference to the instance of javax.servlet.ServletContext interface type.
It is a reference to the javax.servlet.ServletConfig inferface type instance. The ServletConfig type instance contains servlet initialization parameter information.
It is a reference of type Object that refers to the servlet instance. This is why you cannot declare a variable named page in JSP scripting. This is not much use.
The exception implicit object provides access to the uncaught exception that occurred in a JSP. The exception variable can only be used within pages whose page directive's isErrorPage attribute is set to true.
If you use the include directive, one servlet made from one JSP into which all JSPs combined will responds to the client's request. If you use the include action, the JSP in the include action becomes an independent servlet and participates in creating a single response. In other words, a directive is interpreted once when converted to a servlet, but in the case of an action it is interpreted each time it is requested. Therefore, theoretically, it is better to use the include directive when the content of the included page does not change on demand, and the include action if the content of the included page changes on demand.
According to the servlet specification, only one ServletContext object is created per web application. ServletContext has methods that communicate with the server-side components of the web application and the servlet container. So ServletContext serves as a common repository for server-side components such as JSPs and servlets. The resources stored in ServletContext exist for the lifetime of the web application.
If the session attribute of the page directive is set to false, such as <%@ page session="false" ..>, the page can not create a session object nor can it obtain a reference to an existing session object. If you try to access the session object while session is set to false, an error occurs.
The scope attribute of <jsp:useBean> determines how far to use the JavaBean. Depending on how the scope attribute is specified, the bean object is referenced without being destroyed on multiple pages. For example, if the scope attribute is set to session, this bean object will not be destroyed until the end of the session. The default value of scope is page. You can specify four values for the scope attribute, which are summarized as follows.
| Scope | Description |
|---|---|
| page | The default value of scope is page. If scope is not specified, page is set. A bean whose scope attribute is page is valid only on the page. A bean whose scope attribute is page is created each time a page is requested and destroyed when the page finishes execution. A bean whose scope attribute is page can not be referenced in the target page of a jsp:include or jsp:forward action. If there is a jsp:useBean action with the same id and scope bean on the target page, this action creates a new bean. (It does not refer to the bean created on the page that handed over control.) Also, a bean created on the target page of the jsp:include action can not be referenced on a page that handed over control. The page scope beans are appropriate when the state of the beans does not need to be maintained. |
| request | The bean whose scope attribute is request is stored in the HttpServletRequest object. Therefore, A bean whose scope attribute is request can also be referenced from the target page of the jsp:forward and jsp:include actions. |
| session | The bean whose scope attribute value is session is stored in the session object (HttpSession type object). Therefore, the bean whose scope attribute value is session will not be destroyed on all pages that are called during session maintenance. On the other hand, a bean whose scope attribute value is page or request is destroyed after it responds to the browser. The session object created for each user maintains a value that can be referenced by all server-side components until the session ends. Note that JSP whose session attribute of the page directive is set to false can not use the beans stored in the session object. |
| application | The bean whose scope attribute value is application is stored in the ServletContext object. Therefore, the bean whose scope attribute value is application is not destroyed until the web application is unloaded. All JSPs and servlets in the same web application that can access the ServletContext can access this bean. Beans in the ServletContext are common resources for a web application. (we have learned that the ServletContext serves as the common repository) For that reason, you should decide carefully about setting scope to application. |
JSP spec provides a way to deal with errors by providing a JSP page that can handle only errors. If there is an unhandled exception in the JSP, the servlet container passes the request to the JSP error page. The exception object that occurred at this time is also passed. Creating a JSP error page is simple. To make jsp error page, set the value of the page directive's isErrorPage attribute to true. Create the following errorPage.jsp in the ROOT application's documentbase.
<%@ page isErrorPage="true" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
 The following error has occurred.
 <%=exception.getMessage() %>

IsErrorPage="true" tells the container that this page deals with the error professionally.
<%=exception.getMessage() %> prints the error message of the exception sent to the error page. Here exception is an implicit object. The exception implicit object can only be referenced from a JSP page with the value of the page directive's isErrorPage attribute set to true. To see how the error page works, write the following JSP page into the ROOT application's documentbase.
<%@ page errorPage="errorPage.jsp" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <% if (true) { throw new Exception("Intentionally occurred Exception."); } %>
Handling errors using error pages was in the initial specification of Servlet/JSP.
You can specify an error page in the web.xml file, by HTTP status code3 and the type of exception that occurs. This spec was added in Servlet 2.3.
<error-page> <error-code>404</error-code> <location>/error.jsp</location> </error-page> <error-page> <error-code>403</error-code> <location>/error.jsp</location> </error-page> <error-page> <error-code>500</error-code> <location>/error.jsp</location> </error-page>
With this approach, you can not use implicit object exception in error.jsp. Instead, you can get the exception object with the newly added property value as follows: 4
Throwable throwable = (Throwable) request.getAttribute("javax.servlet.error.exception");
Here is a list of the attributes of the request related to the error. All of them can be accessed in the same way as above.
| javax.servlet.error.status_code |
|---|
| Error status code. java.lang.Integer type |
| javax.servlet.error.exception_type |
| Exception type. java.lang.Class type |
| javax.servlet.error.message |
| Error message. String type |
| javax.servlet.error.exception |
| Exceptions occurred. java.lang.Throwable type |
| javax.servlet.error.request_uri |
| The URI of the resource that caused the problem. String type |
| javax.servlet.error.servlet_name |
| The name of the servlet that caused the problem. String type |
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html>   <meta charset="UTF-8"> <title>Error</title>   <% //Analyze the servlet exception Throwable throwable = (Throwable) request.getAttribute("javax.servlet.error.exception"); Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code"); String servletName = (String) request.getAttribute("javax.servlet.error.servlet_name"); if (servletName == null) { servletName = "Unknown"; } String requestUri = (String) request.getAttribute("javax.servlet.error.request_uri"); if (requestUri == null) { requestUri = "Unknown"; } if(statusCode != 500){ out.write("
Error Details
"); out.write("Status Code:" + statusCode + "
"); out.write("Requested URI:"+requestUri); }else{ out.write("
Exception Details
"); out.write("

Servlet Name:" + servletName + "
"); out.write("
Exception Name:" + throwable.getClass().getName() + "
"); out.write("
Requested URI:" + requestUri + "
"); out.write("
Exception Message:" + throwable.getMessage() + "
"); out.write("
"); } %>
Visit http://localhost:8080/alison.jsp. Because you did not create the alison.jsp file in the ROOT application's document base, a 404 error will occur and the error.jsp file will respond. In IE, if the content of the error page is less than a certain byte, the error page does not work.3
It is better not to set the error page at the development stage.
Cookies are simple data stored in a web browser and sent together when sending a request. If the cookie's lifetime is specified using the setMaxAge() method, the web browser stores the cookie as a file in its own cookie store. Cookies without setMaxAge() will disappear when the web browser exits.
Cookie operation processIn step 2, the cookie value included in the response header is the following string.
Set-Cookie: name=VALUE; expires=DATE; path=PATH; domain=DOMAIN_NAME; secure
The string highlighted above is required data, Italics are the parts that need to be changed to actual values.
In the fourth step, the cookie information included in the request header is the following string.
Cookie: name1=VALUE1; name2=VALUE2;...One cookie consists of the following information:
The following is a cookie class.
The following code snippet shows how to use the Cookie class.
/* * Creates a cookie. */ Cookie cookie = new Cookie("user", "alison"); /* * If it starts with a dot, the cookie is sent to the relevant domain. * www.java-school.net, user.java-school.net, blog.java-school.net, etc. */ cookie.setDomain(".java-school.net"); /* * To create a cookie that applies to the full path of your website, set the path to '/'. * If you set a specific path, such as '/ user', cookies are sent only to requests containing '/user'. */ cookie.setPath("/"); /* * Set cookie expire time in seconds. * If a negative value is set here, the cookie is deleted when the web browser exits. */ cookie.setMaxAge(60*60*24*30); //Cookies valid for 30 days
Let's create a simple example of cookies. Create a cookie subdirectory under the document base and create the following files in it.
<!DOCTYPE html>   <meta charset="UTF-8"> <title>Cookie Test</title>
Cookie Test

Burn Cookies

Confirm Cookies

Modify Cookies

Delete Cookies

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="java.net.*" %> <% Cookie cookie = new Cookie("name", URLEncoder.encode("Alison", "UTF-8")); /* * If setPath() is not used, the path is set to the directory where setCookie.jsp is located. (path=/cookie) */ response.addCookie(cookie); %> <!DOCTYPE html>   <meta charset="UTF-8"> <title>Burn Cookies</title>   Set-Cookie: <%=cookie.getName() %>=<%=cookie.getValue() %>
 Confirm Cookies
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="java.net.*" %> <!DOCTYPE html>   <meta charset="UTF-8"> <title>Confirm Cookies</title>   <% Cookie[] cookies = request.getCookies(); if (cookies != null && cookies.length > 1) { int length = cookies.length; for (int i = 0; i < length; i++) { %> <%=cookies[i].getName() %>=<%=URLDecoder.decode(cookies[i].getValue(), "UTF-8") %>
 <% } } %> index.html
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="java.net.*" %> <% Cookie[] cookies = request.getCookies(); if (cookies != null && cookies.length > 1) { int length = cookies.length; for (int i = 0; i < length; i++) { if (cookies[i].getName().equals("name")) { Cookie cookie = new Cookie("name", URLEncoder.encode("Bill" ,"UTF-8")); response.addCookie(cookie); } } } %> <!DOCTYPE html>   <meta charset="UTF-8"> <title>Modify Cookies</title>   Cookie value changed.
 Confirm Cookies
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <% Cookie[] cookies = request.getCookies(); if (cookies != null && cookies.length > 1) { int length = cookies.length; for (int i = 0; i < length; i++) { if (cookies[i].getName().equals("name")) { Cookie cookie = new Cookie("name", ""); cookie.setMaxAge(0); response.addCookie(cookie); break; } } } %> <!DOCTYPE html>   <meta charset="UTF-8"> <title>Delete Cookies</title>   name cookie deleted.
 Confirm Cookies
Download example.zip and unzip it to the root directory of your ROOT application. Visit http://localhost:8080/example/ex1/index.jsp. Open the index.jsp file and confirm the following:
<%@ include file="sub.jsp" %>
The index.jsp includes sub.jsp. By separating the parts of the page into separate files and integrating them using the include directive, maintenance becomes easier. In the sub.jsp code, the path for files, images, style sheets, and so on should be relative to index.jsp. This is because JSP files are combined based on index.jsp. However, the paths in style sheet code, should be relative to the style sheet file not index.jsp.
The location of this example is /example/ex2/. Visit http://localhost:8080/example/ex2/index.jsp. There is work to do to test the login. The login_proc.jsp page is the page that processes the login. The login_proc.jsp uses net.java_school.user.User.java JavaBeans. To run the example, write net.java_school.user.User.java as below and compile to generate bytecode in WEB-INF/classes.
package net.java_school.user; public class User { private String id; private String passwd; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getPasswd() { return passwd; } public void setPasswd(String passwd) { this.passwd = passwd; } }
If you have finished creating and compiling User.java, Go back to http://localhost:8080/example/ex2/index.jsp and test your login. Open the file /example/ex2/index.jsp and confirm the followings.
<input type="text" name="id" />
The id parameter is sent to login_proc.jsp. Open the file /example/ex2/login_proc.jsp and check the code below.
String id = request.getParameter("id");
The value of the id parameter in login_proc.jsp can be obtained using the getParameter() method of the request implicit object. Login_proc.jsp creates a User object and sets the member variables of the User object using the passed id and passwd parameters. The login process is completed by putting this User object in the session. In order to simplify the example, I omitted the code related to the database query. Therefore, login is successful for any ID and password.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="net.java_school.user.User" %> <% String id = request.getParameter("id"); String passwd = request.getParameter("passwd"); /* * Here you need the logic to query the database for members with id and passwd. */ User user = new User(); user.setId(id); // After creating the session, save the User object as "user" in the session. session.setAttribute("user", user); %> <jsp:forward page="index.jsp" />
The location of the example is /example/ex3/. This example has the same functionality as the previous example. I just changed login_proc.jsp to use the action. If you open the login_proc.jsp file, you can see that the code has been simplified as shown below.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="net.java_school.user.User" %> <jsp:useBean id="user" scope="session" class="net.java_school.user.User" /> <jsp:setProperty name="user" property="*"/> <jsp:forward page="index.jsp" />
The jsp:useBean action finds an object whose key value is "user" in the session. If there is no such object, this action creates a User object from the net.java_school.user.User class and store it in the session with the id attribute value of the jsp:useBean action as the key value. The jsp:setProperty action passes the values of the parameters in the HTTP request as arguments to the setter method of the JSP bean. The jsp:setProperty action sets the member variables by calling the setter methods of the JSP bean with the values of the parameters in the HTTP request.
<jsp:setProperty name="user" property="*"/>
The above action calls the setId() and setPasswd() methods of the User bean. The value of the HTTP request parameter matching the setter method name is passed as the parameter value of the setter method.
| JSP or JSP bean | Code |
|---|---|
| index.jsp | <input type="text" name="id" /> |
| login_proc.jsp | <jsp:setProperty name="login" property="id" /> |
| User.java | setId(String id) |
In the "setId()" method name, the "I" in Id is an uppercase letter. (We already studied Java naming convention in Java chapter) When using the jsp:setProperty action, it will not work unless the JSP bean follows the Java naming convention. That is, when using actions, the Java naming convention is not a recommendation, but a grammar.
We already covered the file upload example in the servlet chapter. The following JSP shows a list of uploaded files in the upload folder.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="java.io.*" %> <%@ page import="java.net.*" %> <% String upload = application.getRealPath("/upload"); File dir = new File(upload); File[] files = dir.listFiles(); %> <!DOCTYPE html>   <meta charset="UTF-8"> <title>List of saved files</title>    <% int len = files.length; for (int i = 0; i < len; i++) { File file = files[i]; String filename = file.getName(); %> <a href="javascript:goDownload('<%=filename %>')"><%=file.getName() %>
 <% } %> <form id="downForm" action="download.jsp" method="post"> <input type="hidden" name="filename" /> </form>
The following is the JSP that works when you click the file name on the file list page above.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ page import="java.io.File" %> <%@ page import="java.net.URLEncoder" %> <%@ page import="java.io.OutputStream" %> <%@ page import="java.io.FileInputStream" %> <%@ page import="java.io.IOException" %> <%@ page import="org.apache.commons.io.FileUtils" %> <% request.setCharacterEncoding("UTF-8"); String filename = request.getParameter("filename"); String path = application.getRealPath("/upload"); File file = new File(path + "/" + filename); response.setContentLength((int) file.length()); String filetype = filename.substring(filename.indexOf(".") + 1, filename.length()); if (filetype.trim().equalsIgnoreCase("txt")) { response.setContentType("text/plain"); } else { response.setContentType("application/octet-stream"); } String userAgent = request.getHeader("user-agent"); boolean ie = userAgent.indexOf("MSIE") != -1; if (ie) { filename = URLEncoder.encode(filename, "UTF-8").replaceAll("\\+", " "); } else { filename = new String(filename.getBytes("UTF-8"), "8859_1"); } response.setHeader("Content-Disposition", "attachment; filename=\"" + filename + "\";"); /* response.setHeader("Content-Transfer-Encoding", "binary"); */ OutputStream outputStream = response.getOutputStream(); try { FileUtils.copyFile(file, outputStream); } finally { outputStream.flush(); } %>
The following is a JSP replacement of the file upload servlet we covered in the Servlet chapter.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import=" java.util.Iterator, java.io.File,java.util.List, javax.servlet.http.HttpServletRequest, org.apache.commons.fileupload.FileItem, org.apache.commons.fileupload.FileItemFactory, org.apache.commons.fileupload.FileUploadException, org.apache.commons.fileupload.disk.DiskFileItemFactory, org.apache.commons.fileupload.servlet.ServletFileUpload" %> <% //Check that we have a file upload request boolean isMultipart = ServletFileUpload.isMultipartContent(request); //Create a factory for disk-based file items DiskFileItemFactory factory = new DiskFileItemFactory(); //Configure a repository (to ensure a secure temp location is used) File repository = (File) application.getAttribute("javax.servlet.context.tempdir"); factory.setRepository(repository); //Create a new file upload handler ServletFileUpload upload = new ServletFileUpload(factory); upload.setHeaderEncoding("UTF-8"); //Parse the request List<FileItem> items = upload.parseRequest(request); //Process a file upload Iterator<FileItem> iter = items.iterator(); while (iter.hasNext()) { FileItem item = iter.next(); String fileName = null; if (!item.isFormField()) { String fieldName = item.getFieldName(); out.println("fieldName : " + fieldName);out.println(","); fileName = item.getName(); out.println("fileName : " + fileName);out.println(","); String contentType = item.getContentType(); out.println("contentType : " + contentType);out.println(","); boolean isInMemory = item.isInMemory(); out.println("isInMemory : " + isInMemory);out.println(","); long sizeInBytes = item.getSize(); out.println("sizeInBytes : " + sizeInBytes); } // Process a file upload String dir = application.getRealPath("/upload"); File uploadedFile = new File(dir + "/" + fileName); item.write(uploadedFile); } response.sendRedirect("upload.html"); %>Comments
<c:out value="${requestScope['javax.servlet.error.message']}" />


Based on your answers, we suggest you take design classes and learn CSS!
Based on your answers, we suggest you learn C#!
It is one of the most in demand languages and it is often used for building internal software.
Based on your answers, we suggest you learn Java!
Java is very popular among enterprise companies and it can also be used to build Android interfaces
Based on your answers, we suggest you learn PHP!
PHP is one of the most popular back-end languages today and popular among fast-paced agencies.


AMAZING PEOPLE ARE MAKING AMAZING DESIGNS IN A FUN ENVIRONMENT
When you work with us,you are part of committed collaborators. All aspects of our software development process are intergrated,interactivee and agile
Our approach unifies design,development and product management to create exceptional products.
We start each projeect by understanding your business goals,the user's needs and the product requirements
then we help translate them into effective and elegant solutions.
Before we sign a contract or write a line of code our team will spend the necessary time needed to understand your product vision
The outcome of this scoping session is a proposal or high-level statement of work.
based on your requirements,we can provide a complete offering or just the pieces you need.
Our design practice offes a full range of services including brand strategy and visual design and user experience testing.
Throughout your project,Our designers create and implement visual design and workflows solicit user feedback and work with you to make sure what gets built is what is needed
DevelopmentAll engineers are fluent in the latest enterprise, mobile and web development technologies. They collaborate with your team to write, and improve code on a daily basis, using proven practices such as test-driven development and pair programming.
Planning and development is iterative. Because we are constantly coding and testing, the products we build are always ready to go live. This iterative process allows for changes as business requirements evolve.
PROJECT ONE
PROJECT TWO
PROJECT THREE
PROJECT FOUR
PROJECT FIVE
PROJECT SIX
PROJECT SEVEN
PROJECT EIGHT


How does coaching make this happen?
First, it increases awareness. We take time to look at your life from the outside.
Second, it gets emotions and unhealthy beliefs about yourself under control. Changing from the inside out is imperative to make progress.
Finally, it demands ACTION. Coaching is about making commitments and following through for predictable results.
Coaching is starting where you are and moving forward.


×
Home
Add Machine
Delete Machine
Edit Machine
View Machines
Configure Machine
Pre-Fed Recipes
View Recipes
Logout
Copyright © Adelantos Pvt. Ltd.


CrimPapers
Articles published on 21 May 2019
On 21 May 2019, 14 new articles were published in 9 journals.
Labour Exploitation As Corporate Crime and Harm: Outsourcing Responsibility in Food Production and Cleaning Services Supply Chains
This Violence Good, That Violence Bad: Normative and State-Centric Discourses in British School Textbooks by Kieran Ford
Exploring Interrelationships Between High-Level Drug Trafficking and Other Serious and Organised Crime: An Australian Study by Caitlin Elizabeth Hughes, Jenny Chalmers, David Anthony Bright
Democratizing School Safety by Martin Alan Greenberg
Tiered Document Clustering Through Finest Centroid Assortment by P. Nagalakshmi
Are Public Misperceptions of Crime Trends A Cause of Criminality? Evidence From A Randomized Experiment by Luzi Shi
Training and Safety: Potentially Lethal Blue-on-Blue Encounters by Dawn A. O’neill, William R. Spence, William J. Lewinski, Emily J. Novak
Calvin Morrill and Michael Musheno, Navigating Conflict: How Youth Handle Trouble in High-Poverty Schools by Elizabeth Brown
A Global Analysis of Temperature, Terrorist Attacks, and Fatalities by Curtis M. Craig, Randy W. Overbeek, Elizabeth M. Niedbala
Building the Bomb: A Further Exploration of An Organizational Approach to Nuclear Terrorism by Brecht Volders
The Diffusion and Permeability of Political Violence in North and West Africa by David B. Skillicorn, Olivier Walther, Christian Leuprecht, Quan Zheng
“Now Is the Time to Wake Up”: Islamic State’s Narratives of Political Awareness by Nadia Al-Dayel
Legitimating Extremism: A Taxonomy of Justifications For Political Violence by Robert J. Vandenberg
The Online Caliphate: Internet Usage and Isis Support in the Arab World by James A. Piazza, Ahmet Guler


Amazing Grace and her incredible donation haul for bushfire victims
An idea which started from a simple Facebook post has seen a Ballarat woman collect thousands of dollars worth of goods which will all go to bushfire decimated communities.
Grace Beechey and her father Geoff will fill a truck load of goods this weekend and head on the 10-hour trek to Lithgow to deliver hundreds of packages to communities in need.
"My grandparents live in Gol Gol near Mildura and there wasn't anything really we could donate to," Ms Beechey said.
"I rang the Red Cross and all they wanted was money, but we wanted to do something that can help people right away.
"We've got everything from toiletry sets, clothes and food. I thought I'd do a little bit but it's ended up massive."
Ms Beechey said donations were still being taken until Thursday night when she and her father will start loading the truck for the trip north.
"It's only been a week and it's been insane," she said.
"We'll finish at Thursday at 4pm, so we can start putting boxes on the truck, we had to put a stop somewhere.
"It's so important and especially because it's so close to home. It could happen to us, so I think it's important we do our bit for the community."
If you have any donations you'd like to make to Grace, you can drop them off at Rotork 416 Dowling Street, Wendouree until Thursday afternoon.
You can also private message Ms Beechey on her Facebook page.


Automatic classification algorithms, such as convolutional neural networks based techniques and deep learning have shown promising results when classifying images.
The system we are using to classify images is based on a fine-tuned convolutional neural network, previously trained with ImageNet, and a Random Decision Forest classifier. The CNN is used to extract the image features and those features are eventually classified using the RDF
This web allows you to predict activities, within a list of 21 predefined labels, from your own egocentric images using the CNN & RDF classifier, and also just the CNN classifier.
The labels are: Public transport, driving, walking outdoor, walking indoor, biking, having drinks with somebody, having drinks/meal alone, having meal with somebody, socializing, attending a seminar, meeting, reading, tv, cleaning and chores, working, cooking, shopping, talking, resting, mobile, Plane
The best results are obtained through the CNN + RDF. This web will also show you the predictions based only on the CNN
{{ message }}
{% endfor %} {% endif %} {% endwith %}| file | prediction | |
| {{ path }} | {{ label }} | Check! |
Feel free to check the github of the project. You can even follow me on Twitter!


--- layout: documentation title: CompilerInformalDescriptionType ---
The CompilerInformalDescriptionType contains the informal description of this compiler instance.
| Field Name | Type | Description |
|---|---|---|
| Compiler_Name1..1 | string |
This field contains the name of the compiler. |
| Compiler_Version0..1 | string |
This field contains the version of the compiler. |


|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
Endpoint
and
ServerEndpoint
abstractions that use TCP sockets
as the underlying communication mechanism.
See:
Description
| Class Summary | |
| TcpEndpoint | An implementation of the Endpoint abstraction that uses TCP
sockets (instances of Socket ) for the underlying
communication mechanism.
|
| TcpServerEndpoint | An implementation of the ServerEndpoint abstraction that
uses TCP sockets (instances of ServerSocket ) for the
underlying communication mechanism.
|
Provides implementations of the Endpoint
and
ServerEndpoint
abstractions that use TCP sockets
as the underlying communication mechanism.
Requests and responses are framed and multiplexed over TCP connections
using the Jini(TM)
extensible remote invocation (Jini ERI) multiplexing protocol.
A TcpEndpoint
can be used to initiate
requests over a TCP connection. Each instance contains a host name
string (which may be a name or an IP address) and a TCP port number,
as well as an optional SocketFactory
for customizing
the type of Socket
instances to use. When initiating
a new request, a new TCP connection is created to the host and port,
using the socket factory if present, if an existing connection is not
already available for use.
A TcpServerEndpoint
can be used to listen
for and receive incoming requests over a TCP connection. Each
instance contains a TCP port number to listen on, a host name string
to use in Endpoint
instances derived from the instance,
an optional ServerSocketFactory
for customizing the
type of ServerSocket
instances to use, and an
optional SocketFactory
to use in derived
Endpoint
instances. When listening for requests, the
port is bound to listen for TCP connections, using the server socket
factory if present. The TcpServerEndpoint.enumerateListenEndpoints
method will produce
TcpEndpoint
instances with the same host name, port, and
client socket factory for client-side use (for example, to be embedded
in remote proxies).
TcpEndpoint
and TcpServerEndpoint
map,
respectively, OutboundRequest
and InboundRequest
instances to distinct sessions of a Jini
ERI multiplexing protocol connection. For each new request initiated,
a TcpEndpoint
starts a new session as the client of a
connection to the remote endpoint. As the server of an accepted
connection, a TcpServerEndpoint
creates a new
InboundRequest
to represent each session started by the
remote endpoint. Request data is transmitted as the data sent for the
corresponding session by the client, and response data is transmitted
as the data sent for the corresponding session by the server. TCP
connections are reused by a TcpEndpoint
when possible.
TcpEndpoint
and TcpServerEndpoint
support
the transport layer aspects of at least the following constraints:
ConnectionAbsoluteTime
ConnectionRelativeTime
ConstraintAlternatives
if at
least one element is supported
Integrity.NO
Confidentiality.NO
ClientAuthentication.NO
ServerAuthentication.NO
Delegation.NO
ClientMaxPrincipal
ClientMaxPrincipalType
ClientMinPrincipal
ClientMinPrincipalType
ServerMinPrincipal
DelegationAbsoluteTime
DelegationRelativeTime
ClientMaxPrincipal
,
ClientMaxPrincipalType
, ClientMinPrincipal
,
ClientMinPrincipalType
, ServerMinPrincipal
,
DelegationAbsoluteTime
, and
DelegationRelativeTime
constraints are trivially
supported if ClientAuthentication.YES
,
ServerAuthentication.YES
, and Delegation.YES
are not supported.)
ConnectionManager
and ServerConnectionManager
for connection
management.
Logger
named
net.jini.jeri.tcp.client
to log information at the
following levels:
| Level | Description |
|---|---|
FAILED
| exceptions thrown attempting to initiate a request |
HANDLED
| exceptions caught attempting to connect a socket, set options on a client-side socket, or reuse a connection |
FINE
| client-side socket operations (create, connect, reuse, and close) |
This implementation uses the Logger
named
net.jini.jeri.tcp.server
to log information at the
following levels:
| Level | Description |
|---|---|
WARNING
| exceptions accepting on a server socket |
HANDLED
| exceptions caught setting options on a server-side socket |
FINE
| server-side socket operations (create, accept, and close) |
com.sun.jini.jeri.tcp.useNIO
- This property is
interpreted as a boolean
value (see Boolean.getBoolean
). If
true
, then when not using a socket factory, the
implementation will use java.nio.channels
APIs to create
sockets that have associated selectable channels; specifically:
TcpEndpoint
with no socket factory will create
sockets using SocketChannel.open
, and
TcpServerEndpoint
with no server socket factory
will create server sockets using ServerSocketChannel.open
.
TcpEndpoint
with no socket factory will create
sockets using Socket.Socket()
, and
TcpServerEndpoint
with no server socket factory
will create server sockets using ServerSocket.ServerSocket(int)
.
|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Contribution Guide
- Bug Reports
- Support Questions
- Core Development Discussion
- Which Branch?
- Compiled Assets
- Security Vulnerabilities
- Coding Style
- Code of Conduct
Bug Reports
To encourage active collaboration, Laravel strongly encourages pull requests, not just bug reports. "Bug reports" may also be sent in the form of a pull request containing a failing test.
However, if you file a bug report, your issue should contain a title and a clear description of the issue. You should also include as much relevant information as possible and a code sample that demonstrates the issue. The goal of a bug report is to make it easy for yourself - and others - to replicate the bug and develop a fix.
Remember, bug reports are created in the hope that others with the same problem will be able to collaborate with you on solving it. Do not expect that the bug report will automatically see any activity or that others will jump to fix it. Creating a bug report serves to help yourself and others start on the path of fixing the problem. If you want to chip in, you can help out by fixing any bugs listed in our issue trackers. You must be authenticated with GitHub to view all of Laravel's issues.
The Laravel source code is managed on GitHub, and there are repositories for each of the Laravel projects:
- Laravel Application
- Laravel Art
- Laravel Documentation
- Laravel Dusk
- Laravel Cashier Stripe
- Laravel Cashier Paddle
- Laravel Echo
- Laravel Envoy
- Laravel Framework
- Laravel Homestead
- Laravel Homestead Build Scripts
- Laravel Horizon
- Laravel Jetstream
- Laravel Passport
- Laravel Sanctum
- Laravel Scout
- Laravel Socialite
- Laravel Telescope
- Laravel Website
Support Questions
Laravel's GitHub issue trackers are not intended to provide Laravel help or support. Instead, use one of the following channels:
Core Development Discussion
You may propose new features or improvements of existing Laravel behavior in the Laravel Ideas issue board. If you propose a new feature, please be willing to implement at least some of the code that would be needed to complete the feature.
Informal discussion regarding bugs, new features, and implementation of existing features takes place in the #internals
channel of the Laravel Discord server. Taylor Otwell, the maintainer of Laravel, is typically present in the channel on weekdays from 8am-5pm (UTC-06:00 or America/Chicago), and sporadically present in the channel at other times.
Which Branch?
All bug fixes should be sent to the latest stable branch or to the current LTS branch. Bug fixes should never be sent to the master
branch unless they fix features that exist only in the upcoming release.
Minor features that are fully backward compatible with the current release may be sent to the latest stable branch.
Major new features should always be sent to the master
branch, which contains the upcoming release.
If you are unsure if your feature qualifies as a major or minor, please ask Taylor Otwell in the #internals
channel of the Laravel Discord server.
Compiled Assets
If you are submitting a change that will affect a compiled file, such as most of the files in resources/css
or resources/js
of the laravel/laravel
repository, do not commit the compiled files. Due to their large size, they cannot realistically be reviewed by a maintainer. This could be exploited as a way to inject malicious code into Laravel. In order to defensively prevent this, all compiled files will be generated and committed by Laravel maintainers.
Security Vulnerabilities
If you discover a security vulnerability within Laravel, please send an email to Taylor Otwell at<EMAIL_ADDRESS>All security vulnerabilities will be promptly addressed.
Coding Style
Laravel follows the PSR-2 coding standard and the PSR-4 autoloading standard.
PHPDoc
Below is an example of a valid Laravel documentation block. Note that the @param
attribute is followed by two spaces, the argument type, two more spaces, and finally the variable name:
/**
* Register a binding with the container.
*
* @param string|array $abstract
* @param \Closure|string|null $concrete
* @param bool $shared
* @return void
*
* @throws \Exception
*/
public function bind($abstract, $concrete = null, $shared = false)
{
//
}
StyleCI
Don't worry if your code styling isn't perfect! StyleCI will automatically merge any style fixes into the Laravel repository after pull requests are merged. This allows us to focus on the content of the contribution and not the code style.
Code of Conduct
The Laravel code of conduct is derived from the Ruby code of conduct. Any violations of the code of conduct may be reported to Taylor Otwell (taylor@laravel.com):
- Participants will be tolerant of opposing views.
- Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
- When interpreting the words and actions of others, participants should always assume good intentions.
- Behavior that can be reasonably considered harassment will not be tolerated.


My Journey Into Mobile App Development
Kruy Vanna
/
@kruyvanna
1984
1994 (Grade 3)
1996
First Encounter with Computer
Obsessed
Typing Game
Microsoft Word (Printing)
Top Student
So Far
1997 (Grade 7)
First Encounter with NES Game
Then
Arcade Game
Result?
Skipped School
Grade 7: (99.9% = Game), (0.01% = School)
Grade 8: (99.8% = Game), (0.02% = School)
Grade 9
Retired from Gaming
Back2School
2003-2007
Computer Science@RUPP
Year 1
C
Year 2
C++
This Book Changed My Life
It Lead Me to the OOP World
Year 3
Java
Felt In Love
With Java
Java Book
Same Author
Realization of C++ and Java
Same Concept
Different Syntax
So Pick One
And Get A Solid Foundation
I Picked
Java
Year 4
Java
ASP.NET
Visual Basic (Was Not My Interest)
2008-2011
Master of IT @Waseda University, Japan
Java Tutor @Waseda
For 3 Months
2010-2014
Part-Time Job
And Software Engineer
@Asial Co., Ltd.
Clip Clap Clock (Android)
IT Pro (Android)
RSS Reader
News Ex : AU KDDI (Android)
Monaca (Android)
Hybrid App Development Platform
Monaca (iOS)
Test Automation for Monaca
Android, iOS and Web
Onsen UI
Hybrid App UI Framework
2014-Present
Khmer Smart Keyboard
iOS
with Sour Leang Chhean
Khmer Smart Keyboard
Android
with Phy Vitou
Making More ...
Take Away
Focus on one language
Build a solid foundation of it
Move on to other language/platform
Create your own project, do and learn from it
You only learn from doing not reading
Thank You


{% if request.user and number_of_email_questions == 0 %}
{% blocktrans trimmed %}
Attention! This form doesn't have a question with type "email"! It's important to collect emails of candidates correctly,
otherwise you won't be able to email them through our system. :sadpanda:
{% endblocktrans %}
{% endif %}
{% if request.user and not form_obj.application_open %}
{% blocktrans %}
Hi there! If you can see this message, it means people can't register to your event.
If you want to open registrations, go to
your form in the admin interface and
make sure "Application process" fields are correctly configured. Note: we have a
timezone problem! To be sure your
form is open, use the time given by our server (available in the top part of your admin interface). Sorry 😓
{% endblocktrans %}


Mean Girls Guide to Classes and Ids
March 27th, 2015
It's week-2 at Dev Bootcamp and we're diving head first into HTML and CSS. If you aren't familiar, HTML and CSS are source code that work in conjunction to develop and design websites. One is responsible for the nuts and bolts of a web site, HTML, and the other is used to style those nuts and bolts, CSS.
I've had the pleasure of working with HTML prior to this week, but CSS was brannnnnnd new to me. While there was a lot to learn, I was able to find some good materials that offered some well-written, detailed explanations--shout out to Code Academy and Reddit University! This is an attempt to make a contribution of my own, one that focuses on ids and classes.
Ids and classes can be easy to mix-up or misinterpret. In order to better understand their distinctions and clarify their best use, we're going to take a trip back to high school. Specifically, North Shore High from the movie Mean Girls.
Caty Heron isn't sure what to make of the student population when she first arrives at North Shore High. To fill her in, her classmate Janis whittles the student body down into different social circles and describes the characteristics they possess.
Similarly in CSS, one element, or student, may have the same characteristics, or style, as another student. A consolidated way to give these elements the same characteristics in HTML is to assign them a class in CSS.
Let’s say our elements are three different students, student's we’d classify as plastics. It looks like this in HTML:
Now that Regina, Gretchen and Karen are all classified as plastics in HTML, we use CSS to give the plastics universal characteristics. They're called styles:
Notice the period before the element plastics. The period is what tells CSS that “plastics” is a class. CSS would not be able to distinguish word “plastics” as a class without the period.
A different, and more specific, type of identifier is an id. The id is used in situations where the element is extremely unique, so unique that there is nothing else like it in the entire HTML document. Kind of like in the movie Mean Girls, there is only one protagonist. If there were two Caty Heron's in the movie, it simply wouldn't work. To id the element protagonist in HTML we'd type the following...
...and then some addional typing in CSS to style the protagonist id Caty Heron.
Notice the id name is prefaced by a #. Remember the period we use to preface a class? The # does the same job as the period; it tells CSS that Caty Heron is the id.
So there you have it, not too tricky once you take a closer look! Also wayyyy less complicated than high school. Cheers!
Take Me to The Kitchen
March 20th, 2015
There are two areas of the restaurant: the dining room and the kitchen. The dining room is where people view the menu, make their order and prepare to experience their meal. They may complain to the waiter if their food is cold. They might fuss if they wait too long for the bill. It’s an enviroment for the consumer mindset.
The kitchen, on the other hand, is a big mess. Everyone is moving quickly, focusing on their work. It’s more of a, “outta my way!” type of environment. Everyone is jumping in and getting started. Dev Bootcamp is the kitchen.
Prior to starting phase zero, my impression of DBC was that it seems like an intense, fast-paced environment. In addtion to programming knowledge, DBC promotes vulnerable and open learning. To put it in simpler terms for my family and other “non-technical’ people, I like to use a construction metaphor.
“Pretend I’m taking a course to build a house in a very short amount of time,” I say. “Imagine learning all those skills very quickly; skills like how to reading blueprints, designing a sky light or using a nail gun. I'm setting out to acquire all those skills, in a short period of time, and then build my own house. That new house will be my resume."
My expectations remain the same after seeing the video. I’d be lying if I said I wasn’t nervous, because I definitely am. Beyond feeling nervous, I think the strongest emotion is that I know what I’m in for: DBC will be fast-paced. I'll have to be vulnerable and expose my weaknesses, and a lot of my ignorance, to my cohort. Most importantly, it's me to get the work done and acquire the skills I need to build my dream house. I’m ready!
Getting Aquainted with Git
March 20th, 2015
Like how the 'save' function saves work in Micrsoft Word, version control records changes to protect work. Version control also allows developers to take detailed snapshots of their projects so they may go back and review their progress.
Version control systems are used to give people, often in different locations, access to the same project. Similiar to Dropbox, version control systems digitally store projects and allow people to edit these projects from any computer.
If Dropbox is the 'hub' where multiple people can access the same information, Git is your personal computer server. When you are ready to share those changes with the 'hub,' you can 'commit,' or save those changes, then 'push' those changes to the 'hub,' also known as GitHub.
Once the changes are pushed to GitHub, your larger network has access to your work. In a team environment, people can continously 'commit,'save, work to Git on their personal computer and then 'push,' share, that work with GitHub for collaborations. Adding, pushing and committing all happens in real-time, giving you the option to instantly share or access work in GitHub. As a result, multiple people can work of off the most up-to-date version of a project without disrupting eachother's work.


Publish, Manage, Combine, Analyze, Visualize, and Share your data. In one place.
Discover Location Intelligence
Turns location data into efficient analysis for strategic site planning
Opening Data for better community engagement
A solution to open data to the public for better transparency and community engagement.
Research Thesis at TU Wien
This is an open source project, feel free to use and improve. You can always CONTACT US for any new ideas.
All is built under open and public licenses: Open Data, Java Apache Wicket, DB PostgreSQL, Maps Leaflet JS, Charts HighCharts JS, StreetView Mapillary.


Generative Adversarial Networks or GANs are a recent unsupervised technique (introduced in 2014 by Ian Goodfellow) to train neural networks to generate plausible data using a zero sum game and then output the entire value - such as an image - in one shot.
In this lecture, I'll be giving a high level view of how GANS work and then build a GAN trained on the MNIST dataset
GANs make use of two neural networks instead of one. The first neural network - called the generator - uses a differentiable function as a genenrator network. The generator takes some random noise as input and transforms it to have a recognizable structure such as a realistic image
The generator is trained differently from a normal supervised model.  This is where a second neural network, called the discriminator, comes in which learns to guide the generator.
The discriminator is just a regular neural network classifier. During the training process the discriminator is shown real images from the training data half the time and fake images from the generator the other half. The discrimanor is trained to output the probability that the input is real so it tries to assign a probability near 1 to real images and a probability near 0 to fake images. They both get better over time
Ian Goodfellow's orignal paper talks about the generator and discrinimator playing the following two player min max game:
Two optimization algorithms are run simultaneously each minimizing one of the network’s cost with respect to its parameters.
The generator takes random values Z and maps them to output values X. Wherever the generator maps more values of Z, the probability distribution over X represented by the model becomes denser . The discriminator outputs high values wherever the density of real data is greater than the density of generated data. The generator, in simple words, moves its samples into areas where the model distribution is not yet dense enough.
Eventually, the generator’s distribution matches the real distribution and the discriminator has to output a probability of one half everywhere because every point is equally likely to be generated by the real dataset as to be generated by the model because the two densities are now equal as can be seen from the image above (Again, taken from Ian Goodfellow’s original paper on GANs)
All the code in this notebook is in python. I used tensorflow instead of keras because I felt like it was simpler implementing a GAN using tensorflow
%matplotlib inline
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data')
def model_inputs(real_dim, z_dim):
real = tf.placeholder(tf.float32, (None, real_dim), name='input_real')
z = tf.placeholder(tf.float32, (None, z_dim), name='input_z')
return real, z
def generator(z, out_dim, reuse=False):
with tf.variable_scope('generator', reuse=reuse):
h1 = tf.layers.dense(z, 128, activation=None)
h1 = tf.maximum(0.01 * h1, h1)
logits = tf.layers.dense(h1, out_dim, activation=None)
out = tf.tanh(logits)
return out
def discriminator(x, reuse=False):
with tf.variable_scope('discriminator', reuse=reuse):
h1 = tf.layers.dense(x, 128, activation=None)
h1 = tf.maximum(0.01 * h1, h1)
logits = tf.layers.dense(h1, 1, activation=None)
out = tf.sigmoid(logits)
return out, logits
input_size = 784
z_size = 100
tf.reset_default_graph()
input_real, input_z = model_inputs(input_size, z_size)
g_model = generator(input_z, input_size)
d_model_real, d_logits_real = discriminator(input_real)
d_model_fake, d_logits_fake = discriminator(g_model, reuse=True)
d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,
labels=tf.ones_like(d_logits_real)))
d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.zeros_like(d_logits_real)))
d_loss = d_loss_real + d_loss_fake
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.ones_like(d_logits_fake)))
learning_rate = 0.002
t_vars = tf.trainable_variables()
g_vars = [var for var in t_vars if var.name.startswith('generator')]
d_vars = [var for var in t_vars if var.name.startswith('discriminator')]
d_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(d_loss, var_list=d_vars)
g_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list=g_vars)
batch_size = 100
epochs = 51
samples = []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for e in range(epochs):
for stuff in range(mnist.train.num_examples//batch_size):
batch = mnist.train.next_batch(batch_size)
batch_images = batch[0].reshape((batch_size, 784))
batch_images = batch_images*2 - 1
batch_z = np.random.uniform(-1, 1, size=(batch_size, z_size))
trash = sess.run(d_train_opt, feed_dict={input_real: batch_images, input_z: batch_z})
trash2 = sess.run(g_train_opt, feed_dict={input_z: batch_z})
if e%10 == 0:
print("Epoch {}".format(e+1))
sample_z = np.random.uniform(-1, 1, size=(16, z_size))
gen_samples = sess.run(
generator(input_z, input_size, reuse=True),
feed_dict={input_z: sample_z})
samples.append(gen_samples)
if e%10 == 0:
trash, axes = plt.subplots(figsize=(7,7), nrows=4, ncols=4)
for ax, img in zip(axes.flatten(), samples[e]):
im = ax.imshow(img.reshape((28,28)), cmap='Greys_r')
Here are some resources that I went through while compiling this notebook:
Cool Applications of GANS:


Hi
I'm Chris.
Aircooled Rescue
February 20th, 2013
The aircooled VW community is pretty chill. There used to be a site that listed contact information of people willing to help out a travelling aircooled VW owner should there be a mishap on the road. The old site wasn't being maintained anymore, so I made my own. I scraped all the old info from the previous site, and made the new site accept registrations, rather than running each listing by the webmaster. Then all that info gets plotted on a map.


The Magic Lantern Software Development Kit provides a library of parts for the Java2D platform. Parts include Actors, Roles, Media References, Props, Sets and Stages.


| 1 | /** | |
| 2 | * Copyright 2013 Mozilla Foundation | |
| 3 | * | |
| 4 | * Licensed to the Apache Software Foundation (ASF) under one | |
| 5 | * or more contributor license agreements. See the NOTICE file | |
| 6 | * distributed with this work for additional information | |
| 7 | * regarding copyright ownership. The ASF licenses this file | |
| 8 | * to you under the Apache License, Version 2.0 (the | |
| 9 | * "License"); you may not use this file except in compliance | |
| 10 | * with the License. You may obtain a copy of the License at | |
| 11 | * | |
| 12 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 13 | * | |
| 14 | * Unless required by applicable law or agreed to in writing, software | |
| 15 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 16 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 17 | * See the License for the specific language governing permissions and | |
| 18 | * limitations under the License. | |
| 19 | */ | |
| 20 | package com.mozilla.pig.eval.json; | |
| 21 | ||
| 22 | import java.util.HashMap; | |
| 23 | import java.util.List; | |
| 24 | import java.util.Map; | |
| 25 | ||
| 26 | import org.apache.pig.data.Tuple; | |
| 27 | ||
| 28 | public class JsonTupleMap extends JsonMap { | |
| 29 | | |
| 30 | /** | |
| 31 | * Converts List objects to Tuple to keep Pig happy | |
| 32 | * | |
| 33 | * @param l | |
| 34 | * @return | |
| 35 | */ | |
| 36 | @SuppressWarnings("unchecked") | |
| 37 | private Tuple convertListToTuple(List<Object> l) { | |
| 38 | Tuple t = tupleFactory.newTuple(); | |
| 39 | for (Object o : l) { | |
| 40 |
2
1. convertListToTuple : negated conditional → KILLED 2. convertListToTuple : ROR: changed equals zero comparison to less than operator → KILLED |
if (o instanceof List) { |
| 41 |
1
1. convertListToTuple : removed call to org/apache/pig/data/Tuple::append → KILLED |
t.append(convertListToTuple((List<Object>) o)); |
| 42 | } else { | |
| 43 |
1
1. convertListToTuple : removed call to org/apache/pig/data/Tuple::append → KILLED |
t.append(o); |
| 44 | } | |
| 45 | } | |
| 46 | ||
| 47 |
1
1. convertListToTuple : mutated return of Object value for com/mozilla/pig/eval/json/JsonTupleMap::convertListToTuple to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return t; |
| 48 | } | |
| 49 | ||
| 50 | /** | |
| 51 | * Convert map and its values to types that Pig can handle | |
| 52 | * | |
| 53 | * @param m | |
| 54 | * @return | |
| 55 | */ | |
| 56 | @Override | |
| 57 | @SuppressWarnings("unchecked") | |
| 58 | protected Map<String, Object> makeSafe(Map<String, Object> m) { | |
| 59 | Map<String, Object> safeValues = new HashMap<String, Object>(); | |
| 60 | for (Map.Entry<String, Object> entry : m.entrySet()) { | |
| 61 | Object v = entry.getValue(); | |
| 62 |
3
1. makeSafe : ROR: changed equals zero comparison to less than operator → SURVIVED 2. makeSafe : negated conditional → KILLED 3. makeSafe : negated conditional → KILLED |
if (v != null && v instanceof List) { |
| 63 | // This is the main diff from the parent class | |
| 64 | // in that it converts lists to | |
| 65 | Tuple t = convertListToTuple((List<Object>) v); | |
| 66 | safeValues.put(entry.getKey(), t); | |
| 67 |
3
1. makeSafe : negated conditional → SURVIVED 2. makeSafe : negated conditional → SURVIVED 3. makeSafe : ROR: changed equals zero comparison to less than operator → SURVIVED |
} else if (v != null && v instanceof Map) { |
| 68 | safeValues.put(entry.getKey(), makeSafe((Map<String, Object>) v)); | |
| 69 | } else { | |
| 70 | safeValues.put(entry.getKey(), v); | |
| 71 | } | |
| 72 | } | |
| 73 | ||
| 74 |
1
1. makeSafe : mutated return of Object value for com/mozilla/pig/eval/json/JsonTupleMap::makeSafe to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return safeValues; |
| 75 | } | |
| 76 | } | |
Mutations | ||
| 40 |
1.1 2.2 |
|
| 41 |
1.1 |
|
| 43 |
1.1 |
|
| 47 |
1.1 |
|
| 62 |
1.1 2.2 3.3 |
|
| 67 |
1.1 2.2 3.3 |
|
| 74 |
1.1 |


Vendor Name:
AECO CONSULTING INC.
Reference Number:
4500211167
Contract Date:
2009-26-05
Description of Work:
Training consultants
Contract Period:
2009-19-10 to 2009-23-10
Delivery Date:
2009-23-10
Original Contract Value:
$0.00
Current Contract Value:
$11,317.00
Comments:
Competitively sourced


| DOSE: T+ 0:00 |
10 mg |
insufflated |
2C-E |
(powder / crystals) |
| T+ 0:45 |
5.0 mg |
insufflated |
2C-E |
(powder / crystals) |
What a shitty day. I was finally out of Christmas money, ending a 2 week long drinking/smoking/partying binge. I felt the withdrawal in my gut Saturday afternoon. Nothing short of a fat rail of coke could lift my spirits. These were horrible psychological conditions to trip. I was depressed, trapped in a cloud of hopelessness. Yet, I felt since it was Saturday night, I was obligated to participate in some sort of substance use. I met up with my friends, N, and Fellow. They bought a gram of cocaine and I bought some 2ce. We migrated to Fellow’s basement around 8pm.
 At a dollar an mg, insufflations seemed cost efficient enough for me to risk any additional danger. Rolled bill in hand, all eyes on me. Apprehension. A countdown. 3...2...1...gone. My brains first recognizable reaction was a sensation of smell. There is a strange, but only faint smell that colors the entire trip, giving every breath of air a laboratory or hospital like musk. My sensory experience was overwhelmed within seconds as the predicted wave of pain washed over my face. It is not a frightening pain or even one to make me cringe significantly, it is more of a 'this is serious shit' pain.
WAITING. For what seems like 15 minutes. 'Its only been 7', answers N. If I were to dissect, 2ce there would be 1 part MDMA, 1 part Ritalin/Adderall, 1 part LSD. Those are not the ingredients, but what the drug 'feels' like. There was no hangover. The first to kick in is the stimulant. I became energetic, jumped over furniture and paced around smiling helplessly. It was the energy of pure excitement. A few minutes of constant pacing later I played hand drums on a ping pong table, and the air around my hands rippled slightly. I played as fast as I could and my hands were full blurs. I knew I was beginning to trip. I purchased 5 more mg, about 45 minutes after my first dose, and it was probably the best decision I made that week.
We all moved to the car and I sat in back. I knew I would want the space, a fairly undisturbed existence. It was here, alone in the car with the dome light on that I experience the first traces of psychedelia. Sitting in bitch, the two front seats began to pump. The air seemed to be pushing and molding the heads of the seats in obscure, but flowing shapes, as the heart of the chairs pumped who the hell knows what through the large arteries. I struggled to see the map of its circulatory system, but here I hit the limit of 2ce's hallucinogenic power.
So then we were driving. Music was playing quietly and I felt it as if it were 3 times as loud. Though it was smashing pumpkins, and not worth turning up. I browsed Fellow's CD collection. Nothing recognizable. Egg. Egg. WTF? I flipped the page but ached to go back. Egg begins. Floydesque. Medieval fair style guitars rang and my trip began. I closed my eyes and put myself in 1050ad, a dark mountainside. The image was captured and the 2ce took over, flowing like a camera on a bird to a small fenced in village. I floated over the fence about 10 feet in the air and glided over the village, which was looking more like a kingdom on closer view. No one noticed me. Screen went blank. I opened my eyes, I had been lying face up in the backstead. The volume had been turned down for inane conversation. I was the only one tripping, I guess Egg isn't that great sober.
Their talking died down and I signaled them to turn it back up and I re-entered. This time, still flapping above, the large town and its people were cartoonish and vibrantly colorful. I laughed out loud when I saw the people were eggs, with thin rubbery arms and legs. They had no necks or chins, some had hats, the women had obviously died hair. They were going about their days, in peace. They lived in houses like in the Mushroom Kingdom in mario's world, and quietly went about doing trivial tasks. This was kind of boring.
I asked for a cd change but no one heard me. Did I even speak? Oh well, the Eggs will have to do. When I got back, which took a while, the Eggs were training young eggs in archery, and swordsman ship. They had pretend armor on, and marched in rows. Seconds had been days and days had been years and times of war were approaching. The guitars went minor. The dark cloud over the mountainside creeped closer, and the armies of Eggs, now large, metal covered Eggs of death, marched to the pounding snare beats of the Eggmasters.
The army waited, and waited but the storm died down, breaking off into smaller clouds that floated by as the days went on and nothing ever happened. I awoke very disappointed. The members of Egg could have written an outstanding song if they had it in them to bring the storm of death and pain right towards the Egg kingdom.
The scope and detail of my closed-eye hallucination is what sets 2ce apart from LSD or Psilocybin. If our conscious thought is like driving, down long winding stretches of neurons, then thinking on 2ce is like flying a helicopter, 50 feet off the ground. Observing the roadways, planning ahead, and seeing a much fuller picture. I see the whole network of interconnecting thoughts that I always knew was there (just like all streets are mapped) but were never able to fly over and observe at once. Conscious thought on Shrooms or Acid, to me, is on the ground level, but flying like a rollercoaster. Thinking on 2ce does not give me psychic abilities, but allows me to plan my route of thought ahead. This makes conversation, even with strangers, almost seamless. Direct and focused. These conversations grow to levels of startling.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


I spent almost all of my early life living in Seattle. As a child I loved video games, sports, and reading.
Even though current events and the news used to bore me to death, I actually really enjoy reading up on what is happening around the world and watching documenatries about other cultures.
I still try to stay active and love playing sports but unfortunately I have developed weak knees so I have had to stick to low impact excercises.
In high school I had a hard time choosing where to go to school. I eventually chose Western Washington University over Washington State University.
I never found my true passion in college even though I went through four different majors while I was in school. I ended up majoring in psychology.
Click on the cool picture of the Grand Canyon below see more cool views!
> Sign into your Yahoo Email Here!


GET /repos/:owner/:repo/deployments
(:read)POST /repos/:owner/:repo/deployments
(:write)GET /repos/:owner/:repo/deployments/:deployment_id
(:read)GET /repos/:owner/:repo/deployments/:deployment_id/statuses
(:read)POST /repos/:owner/:repo/deployments/:deployment_id/statuses
(:write)GET /repos/:owner/:repo/deployments/:deployment_id/statuses/:status_id
(:read)


https://github.com/udacity/Appify/
https://github.com/udacity/Sunflower/
https://github.com/udacity/Brokeh/