The best sweater I ever bought! James Thompson
The best sweater I ever bought!
My new dress got so many compliments. Couldn't have been happier. Jenny P.
My new dress got so many compliments. Couldn't have been happier.
The wifey was very please with her new wool hoody. Brownie points to the great sales associate who helped me pick it out. Gabriel Carey
The wifey was very please with her new wool hoody. Brownie points to the great sales associate who helped me pick it out.


Property Filters
{{acreText}}
0 - 400
400 - 1000
1000+
Filter by mile radius
Show Private Properties
Clear Filters


Donation
Solidarity is an element of human association that emphasizes the cohesive social bond that holds a group together, which is valued and understood by all group members.There are different motives for solidarity. For some, affection and shared norms and beliefs are motives, while for others, rational choice and self-interest are drivers. The concepts of trust, altruism, and reciprocity are grouped under individual acts, as they are instituted from an individual standpoint. Finally remember that every cent you paid may save a human.


Request class processes URI requests. It is used by Fuel in index.php to process the users URI request, and you need it to generate requests in an HMVC context.
Request class extends Fuel\Core\Request.
On top of HMVC Request, a internal RESTful Request allow application to send it as either "GET", "POST", "PUT" or "DELETE" method with a sub-set data as if using a cURL request without losing current authentication setting.
<?php class Controller_Credential extends \Controller_Rest { public function post_register() { // This is a simple user registration $password = \Hybrid\Input::post('register_password'); $email = \Hybrid\Input::post('register_email'); $user = \Model_User::forge(); $user->email = $email; $user->password = \Hybrid\Auth::create_hash($password); $user->save(); // Let make a HMVC + RESTful request to sign-in our user $login = \Hybrid\Request::connect('POST /credential/login.json', array( 'login_email' => $email, 'login_password' => $password, ))->execute(); } public function post_login() { $email = \Hybrid\Input::post('login_email'); $password = \Hybrid\Input::post('login_password'); /* * Login the user */ $this->response(array( 'text' => 'User logged in', ), 200); } }
HMVC + RESTful Request only work with Controllers under the same application.
Generates a new `HMVC + RESTful` request without going through HTTP connection, this allow user session can be shared between both request `client` and `server`.
The request is then set to be the active request.
| Static | Yes | |||||||||
|---|---|---|---|---|---|---|---|---|---|---|
| Parameters |
|
|||||||||
| Returns | \Hybrid\Request Object | |||||||||
| Example |
// GET method support query string \Hybrid\Request::connect('GET controller/method?hello=world'); // Alternatively \Hybrid\Request::connect('GET controller/method', array('hello' => 'world')); |
The execute method executes a request, and stores the resulting response in the request object to be used later.
| Static | No | ||||||
|---|---|---|---|---|---|---|---|
| Parameters |
|
||||||
| Returns | \Hybrid\Request Object | ||||||
| Example |
$exec = \Hybrid\Request::connect('PUT controller/method?hello=world')->execute(); |


[gecode-users] Problem with Flatzinc 1.0 on Gecode 2.0
Raffaele Cipriano
raffaele.cipriano at dimi.uniud.it
Wed Feb 6 17:51:21 CET 2008
Dear gecode developers and users,
I have installed gecode 2.0 and the flatzinc parser on a cluster with
these characteristics:
Architecture: x86_64
SO: Linux CentOS v.4.3
Kernel: 2.6.9-34.ELsmp CentOS Kernel
installing gecode 2.0 is ok; I used
$ ./configure --prefix=/home/cipriano/gecode2.0
$ make
$ make install
also installing flatzinc is (seems) ok; I used
$ ./configure --prefix=/home/cipriano/flatzinc1.0
$ make
$ make install
But when I try to invoke "fz", the exacutable for flatzinc parser e
get thie error:
fz: error while loading shared libraries: libgecodecpltset.so.9: cannot
open shared object file: No such file or directory
What can I do?
Thank you very much
Raffaele Cipriano
More information about the gecode-users
mailing list


StudyJS
Save
Save as
New
Open
Settings
f(x)
×
×
Equation Editor
×
Settings
General
Storage
General Settings
Storage Settings
Local
Default path:
Drive
Default folder:


Most of his artworks were auctioned and sold in the USA. Afterwards, they were introduced to auction houses in the UK and Germany. With consideration to the international scale, 66% of the sales remained in the USA. Katz’s average sales price is higher in the USA than it is overseas.


Current Time & Date:
Weather Dashboard
Weather Forecast Location
Where would you like to go?
City Search History
Current weather
Temp:
Humidity:
Wind Speed:
UV Index:


Web animations is to have a flash or GIF animation intergrated onto the web page. Normal web animations still require the use of plugins such as Java Applets, Shockwave, Adobe Flash. In this tutorial, we will be showing you how to create animations using javascript without the need of installing plugins.
We have been through parallel animation groups, it's time for us to do some sequential things. Just as the name suggests, children in a sequential animation group runs sequentially even if they do not have a set delay time. (Though a negative start delay can cause 2 children to overlap).
The interface for sequential animation group is:
new SeqGroup([children], {timing/timing functions});
You can see that the interfaces are very similar, even the properties of the children and timing are the same as well. That is, both children and timing are nullable but only timing is optional.
Note: for sequence groups, you have to always manually set it to play, else it would not play automatically. Hence, the following sample is a more recommended one.
var seqGr = new SeqGroup([A, B]);
seqGr.play();
Where A and B are individual animations. play() is a method to let the animation runs. In order to pause the animation, you can use pause().


com.jwetherell.augmented_reality.ui.objects
Classes
PaintableBox
PaintableBoxedText
PaintableCircle
PaintableGps
PaintableIcon
PaintableLine
PaintableObject
PaintablePoint
PaintablePosition
PaintableRadarPoints
PaintableText


public class LoadBalancer
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
static java.lang.Integer |
CAPACITY |
private java.util.Map<java.lang.String,ScalingInstance> |
instances |
private static java.util.logging.Logger |
logger |
private MSS |
mss |
private java.util.Set<java.lang.String> |
queries |
private UserRequestsCosts |
uRequestsCosts |
| Constructor and Description |
|---|
LoadBalancer(java.util.Map<java.lang.String,ScalingInstance> instances,
java.util.logging.Level level) |
| Modifier and Type | Method and Description |
|---|---|
private void |
fetchWithFilter()
Gets the Costs associated with the most recently received Requests.
|
private void |
fetchWithoutFilter()
Obtains a predefined capacity of Costs associated with its Requests.
|
private void |
healthChecks()
Performs a Health Check for each running WebServer Instance and records whether it successfully
responds to the Health Check or not.
|
private void |
newTimer()
Creates a Timer responsible for carrying out Health Checks and fetching the Costs associated
with the most recent Incoming Requests, from 30 to 30 seconds.
|
void |
onInstanceFailure(java.util.Map.Entry<ScalingInstance,java.lang.Double> instanceRequestCost)
Removes the estimated Cost of the Incoming Request from the Costs associated with the WebServer
Instance from which it was forwarded and records that its forwarding was unsuccessful,
registering it as a failed Health Check.
|
void |
onInstanceSuccess(java.lang.String query,
java.util.Map.Entry<ScalingInstance,java.lang.Double> instanceRequestCost)
Removes the estimated Cost of the Incoming Request from the Costs associated with the WebServer
Instance from which it was forwarded, adds the Request Query to the set of Queries made
recently, which will later be used to fetch the actual Cost that the request imposed on the
Instance and records that its forwarding was successful, registering it as a successful Health
Check.
|
java.util.Map.Entry<ScalingInstance,java.lang.Double> |
onReceiveRequest(UserRequest uRequest)
Gets the estimated Cost of the Incoming Request and the WebServer Instance that has the lowest
associated Cost, and adds the estimated Cost to it.
|
public static final java.lang.Integer CAPACITY
private final java.util.Map<java.lang.String,ScalingInstance> instances
private static final java.util.logging.Logger logger
private final MSS mss
private final java.util.Set<java.lang.String> queries
private final UserRequestsCosts uRequestsCosts
public LoadBalancer(java.util.Map<java.lang.String,ScalingInstance> instances, java.util.logging.Level level)
private void fetchWithFilter()
private void fetchWithoutFilter()
private void healthChecks()
private void newTimer()
public void onInstanceFailure(java.util.Map.Entry<ScalingInstance,java.lang.Double> instanceRequestCost)
instanceRequestCost
- WebServer Instance that responded to the Incoming Request and its
estimated Cost.public void onInstanceSuccess(java.lang.String query, java.util.Map.Entry<ScalingInstance,java.lang.Double> instanceRequestCost)
instanceRequestCost
- WebServer Instance that responded to the Incoming Request and its
estimated Cost.public java.util.Map.Entry<ScalingInstance,java.lang.Double> onReceiveRequest(UserRequest uRequest)
uRequest
- Incoming Request.


Alarm History
Another mechanical alarm clock was created by Levi Hutchins, of New Hampshire in the United States, in 1787. This device he made only for himself however, and it only rang at 4 AM, in order to wake him for his job. The French inventor Antoine Redier was the first to patent an adjustable mechanical alarm clock, in 1847.
When Alarm clock is invented
Burglar alarm. The alarm was patented in 1853 by the Reverend Augustus Russell Pope (1819–1858) of Somerville, Massachusetts. Edwin Holmes acquired Pope's patent rights in 1857 for US$1500 and manufactured the device in his factory in Boston, Massachusetts. He began to sell them in 1858.
- Wake up early
- No hasle
- Randomly pick for the music
- Friendly user
- Alarm Randomly
- Wake up friends!


Playstation 5
Explore uncharted virtual territories and slay dragons with this sleek Sony PlayStation 5 gaming console. The 825GB SSD allows ultra-fast load times, while 3-D audio output produces crisp acoustics. This Sony PlayStation 5 gaming console supports haptic feedback for effortless communication in multiplayer setups, and adaptive triggers allow immersive gameplay.


Extending what3words API
Click on map to display 3 word address in English, French, Italian, Spanish and German.
Search for a 3 word address:
3 word address


{% if not mode_js %}
It looks like {{ similar_site.name }} ({{ similar_site.address }}) is already in the system.
Click here to open exisiting work order (in a new tab)


{{task.title}}
{{task.reminderData.remindAt|humanizeTimestamp}}
There are currently no scheduled tasks. You can schedule a task by choosing "Schedule Task" in the task context menu. To open it click on the 3 little dots on the right of a task.


**The Croquet Virtual DOM Framework** Last Modified: 2020-08-10 # Introduction The framework uses Croquet for the network communication part and the UI part is based on the document object model of the web browser. ## The Software Architecture of Croquet Applications written using Croquet have a clear separation of "model" and "view" and should be written with this in mind. As in common usage, the model refers to the logic part of the application. However, in the case of Croquet, it is more strictly expected to satisfy the constraint that "when a model is in a state S and receives a message M, the state S' after processing the message will be the same state that can be reliably reproduced from S and M, no matter what computer the model is running on." In order to satisfy this restriction there are some innovations, such as patching `Math.random()`, so that developers can write, in a natural way, "message handlers" that specify the processing for each message of a given type. The view mediates between such a model and the user. It displays the state of the model, and when a user performs any input action the view sends a message to the equivalent model for all users in the session, so that the model will change to the same new state for all users. The model is expected to be in the same state, but the views may be different for each client, for example because of differences in screen size, or because an operation that a user is doing may be visible in the first instance only for that user, before being sent to the model. The code describing the behavior of the view is allowed to read out the state of the model. Using an analogy with network programming in the server-client model, the view's code is the client program, but it is like being able to read out the state of the server directly from that program. This also contributes to the descriptiveness of Croquet. In other words, we follow the principle that "common information among clients should be stored in the model and other information should be stored in the view". ## Virtual DOM Although it is not impossible to build an application with the basic Croquet mechanisms described above, constructing a view using the Document Object Model (DOM) provided by the browser involves a laborious process of repeatedly writing trivial pieces of code. In a nutshell, given that the information held by the DOM elements used to display on the screen is also, in most cases, what needs to be shared among participating clients, we can reduce coding effort by keeping the DOM information used by the view in the model as virtual DOM elements, so that the handlers for user operations can be written just once in the model, and the system can automatically generate and update the actual DOM elements. The Croquet Virtual DOM Framework is implemented based on this perspective. ## How Behaviors are Described Applications are defined not simply as state, but also in terms of the "behaviors" that change that state. In Croquet's Virtual DOM Framework, the basic idea is to treat code as data, with users able to change applications' behaviors with code alterations at runtime. This shared authoring environment can also be disabled if no code changes are needed. In any case, the code can also be treated as data, which contributes to the simplicity of implementation. As shown in the example below, in this framework behaviors are written in accordance with certain conventions. Although the grammar includes the "class" keyword, these are actually class extensions, inspired by the language features known as traits and expanders. Simply put, they are collections of methods that do not change the virtual DOM element itself but act as external parts, adding behaviors that can be invoked using a special `call()` syntax. ## Concepts, Terminology ### Model As described above, a model is an object that is used for defining the logic part of an application. It causes state changes by receiving external messages. The word model may refer to the entire logic of the application, but when described as `Model`, it may also refer to individual instances of classes that inherit from the `Croquet.Model` class. In other words, it is normal for the logic part of an application to be made up of multiple `Model` classes, and to use multiple instances of those classes. ### View The view displays the state of the model on the screen, and also accepts input from the user and sends messages to the model. As with `Model`, when referring to `View` this can mean multiple instances of classes that each inherit from `Croquet.View`. ### Client Basically, a browser-based Croquet application. The client participates in a certain Croquet session. The clients participating in that session all share a model with identical state. ### Reflector A server on the network that is responsible for delivering messages from a view to all the clients participating in the session. ### Virtual DOM Element In the Croquet Virtual DOM Framework, instances of the `Element` class are created in the model and mimic the interface of a real DOM. For the part of the application that must be the same across multiple clients, consistency is maintained using updates to the properties of these elements. ### Virtual DOM View When an instance of `Element` is displayed on the screen, a view object called `ElementView` is created. `ElementView` holds a reference to an actual DOM element, and when its corresponding `Element` changes, the `ElementView` is responsible for making the DOM element reflect the change. Also, when an event fires in the actual DOM element, the `ElementView` sends it to the model as a Croquet message. ### Actual DOM Element What a virtual DOM view holds onto, and what the browser actually displays on the screen. ### Virtul DOM Element Reference A reference (pointer) to a Virtual DOM Element is internally represented by a data type called `ElementRef`. ElementRef introduces a simple indirection to accommodate a slippage between the view and the model. For example, imagine that a group of users are using a graphical collaborative application. And suppose that a user sees an element on screen and tries to move the element. By the time the request arrives to the model, the object may have been already deleted by another user. Such model code needs to look up the actual object from the information sent from the view. A ElementRef serves for this need. ### expander Behavior defined as a set of methods that can be "installed" in `Element` or `ElementView`. These are JavaScript classes written according to specific conventions. # Example 1 (Counter) Let's start with a simple example. First of all, I would like to refer to `examples/counter.js` and `counter.html` in the `app/` directory. As mentioned above, code is also data, but at the moment, it is more efficient to use a normal code editor when writing code. However, as you can see in `counter.js`, you need to write your code in accordance with certain conventions. ## Invocation Run `server.py` in the top directory from a terminal using Python2 or Python3. ~~~~~~~~ # python server.py & ~~~~~~~~ Since we are using 8000 as the default port number, you can access: ~~~~~~~~ http://localhost:8000/apps/counter.html ~~~~~~~~ If the fourth argument of `makeMain()` is true, a session hash prefixed by `#` is attached to the URL. You can enter the same session from another browser by accessing this extended URL. ## File Organization Here we refer to a file like `counter.js` as a library file. A library is configured as follows: ```text <class definition> <class definition>... <function definition>... <export statement with "expanders" and "functions" properties> ``` In `counter.js` there is only one class definition: `Counter`. ~~~~~~~~~~~~~~~~~~~~~~~ JavaScript class Counter { init() { this.addEventListener("click", "Counter.reset"); if (this._get("count") === undefined) { this._set("count", 0); this.future(1000).call("Counter", "next"); } } next() { let c = this._get("count") + 1; this._set("count", c); this.value = "" + c; this.future(1000).call("Counter", "next"); } reset() { let c = 0; this._set("count", c); this.value = "" + c; } } function beCounter(parent, json) { let text = parent.createElement("TextElement"); text.style.setProperty("width", "200px"); text.style.setProperty("height", "50px"); parent.appendChild(text); text.setCode(parent.getLibrary("counter.Counter")); } export const counter = { expanders: [Counter], functions: [beCounter] }; ~~~~~~~~~~~~~~~~~~~~~~~ I'll explain it line by line below. ~~~~~~~~ class Counter { ~~~~~~~~ This defines an expander named `Counter`. Code written in a library file is processed as string data, so it is not allowed to refer to "free variables" from outside the expander. However, if you need access to other expanders' code, use the initialization-function `library` argument as described below. ~~~~~~~~ init() { ~~~~~~~~ `init()` is the name of a special method which is executed automatically when the expander is "installed" on an element. (However, the expander may be edited in the authoring tool, and in that case, `init()` is called each time it is edited). ~~~~~~~~ this.addEventListener("click", "Counter.reset"); ~~~~~~~~ This adds an event handler for when a DOM click event occurs on the virtual DOM element where this expander is installed. Internally, a click handler is added to the actual DOM element, and when the user clicks, it is delivered to this expander. `"Counter.reset"` means the `reset` method of the expander installed under the name `Counter`, which will be called when the event occurs. The `this` in the method refers not to the expander but to the DOM element where it is installed. ~~~~~~~~ if (this._get("count") === undefined) { this._set("count", 0); } ~~~~~~~~ As described above, `init()` may be called multiple times for already existing elements. Therefore, when you initialize a variable in `init()` and you want to keep the value even if the code changes a little while the same element survives, you should initialize it only when the value is not yet set, like this. Incidentally, `addEventListener` is registered only once even if you call it multiple times. Here, the property `count` is defined for the virtual DOM element. `_get()` and `_set()` are methods to read and write the properties of a virtual DOM element. A virtual DOM element can hold only JSONizable values. Were they made readable and writable using simple dot notation, that would invite inadvertently storing inappropriate values, such as functions that have free variables. Instead, one must use the verbose `_get()` and `_set()` notation, chosen so as not to clash with internal property names, and mmust keep in mind that only JSONizable values can be stored. ~~~~~~~~ this.future(1000).call("Counter", "next"); } ~~~~~~~~ `future()` is like `setTimeout()`, with an argument specifying milliseconds of logical time. Based on the heartbeat sent by the reflector, all participating clients invoke the specified method after the specified time has elapsed. Normally, this logical time is synchronized with real time, so the elapsed real time is also about 1000 milliseconds. In this case, the method is `call()`, meaning that the `next` method of the expander installed with the name `Counter` will be invoked. In the near future it is planned to make it possible to write just `this.future(1000).next()`, implicitly specifying that the method is on the same expander, as with other calls to expander methods. ~~~~~~~~ next() { let c = this._get("count") + 1; this._set("count", c); this.value = "" + c; this.future(1000).call("Counter", "next"); } ~~~~~~~~ As shown above, `next()` is executed 1000 milliseconds after the first call to `init()`. After updating the `count` property with `_get()` and `_set()`, a stringified version is written to the special property `this.value` which is compatible with a DOM text element. (The fact that `this` is a text element is specified by `beCounter()`, shown below). The last line of `next` calls `next()` itself again. Like `requestAnimationFrame()` or setTimeout, this is a standard tactic for performing processing at a regular interval. ~~~~~~~~ reset() { let c = 0; this._set("count", c); this.value = "" + c; } ~~~~~~~~ This is the method called when a click event occurs, as specified by `init()`. The `count` property is set to 0, and the `value` of the `text` element is set to "0". ~~~~~~~~ function beCounter(parent, json) { ~~~~~~~~ This is the function to create the virtual DOM element used by the application. As an image, you can think of it as embodying the manual work of interactively creating elements and setting styles and properties in an interface builder. `parent` is a virtual DOM element which is to be the parent of this "application". You can ignore `json` for the time being. ~~~~~~~~ let text = parent.createElement("TextElement"); ~~~~~~~~ Virtual DOM elements are created using the `createElement()` of some arbitrary virtual DOM element, instead of `document.createElement()`. The basic design policy is to use `div` elements for most of the processes, so that as far as possible "everything is made of the same kind of object". However, since elements that provide some special features cannot be replaced by `div`, there are text elements, video elements, iframe elements, and canvas elements, which can be created by specifying a type in the argument. In this example, we are creating a virtual text element to display the string (though in this case there would be no problem with using a `div`, since this text does not have to be collaboratively editable). ~~~~~~~~ text.style.setProperty("width", "200px"); text.style.setProperty("height", "50px"); ~~~~~~~~ A virtual DOM element has basic properties such as style and classList, which can be used to set the CSS style. How to set CSS classes will be explained later. ~~~~~~~~ parent.appendChild(text); ~~~~~~~~ Use `appendChild()` to add elements created in this way to the DOM tree. ~~~~~~~~ text.setCode(parent.getLibrary("counter.Counter")); } ~~~~~~~~ Then, we use the method `setCode` to set the behavior of the element, specifying the expander called "Counter" within the "counter" library registered in the library created in the HTML file. ~~~~~~~~ export const counter = { expanders: [Counter], functions: [beCounter] }; ~~~~~~~~ A library file like `counter.js` exports objects with properties `expanders` and `functions`. The above `parent.getLibrary("counter.Counter")` means to get the `Counter` from the library exported as `counter`. (You can think of `expanders` and `functions` as being combined into one object after some other internal processing.) The counter.html that calls it looks like this: ~~~~~~~~   <meta charset="UTF-8">

   ~~~~~~~~ Picking out some details: ~~~~~~~~  ~~~~~~~~ This loads the Croquet library copied into the croquet directory. Alternatively, you can load it from `https://croquet.io/sdk/croquet-latest.min.js`. ~~~~~~~~ import {makeMain, Library} from "./src/framework.js"; import {counter} from "./examples/counter.js"; let library = new Library(); library.addLibrary("counter", counter); window.onload = makeMain("counter.beCounter", {autoSleep: false}, library, true, false); ~~~~~~~~ Importing `makeMain` from main.js and `Library` from library.js is the same for any application as long as it follows this pattern. Import your own library, `counter.js`, and register it to an instance of `Library`. ~~~~~~~~ window.onload = makeMain("counter.beCounter", {autoSleep: false}, library, true, false); ~~~~~~~~ creates the function to be called as the `onload` handler, specifying the function registered as `counter.beCounter` as the entry point, with the `autoSleep` session option (described in the [Croquet SDK Document](https://croquet.io/sdk/docs)), and the `library` object that was created above. The last two arguments are flags specifying, respectively, whether the page access should automatically create a new shared session and add a distinguishing hash to the URL, and whether or not to launch the authoring tool at the same time. # Development and Debugging of a New Application At this point we are deliberately avoiding packaging the framework part, instead pursuing development in which you can just edit a file and reload the page to try it out immediately. To write a new application, you can create a new file like `counter.js` above, and also make your own copy of `counter.html` to call it. ## `isLocal` flag Much of application development is about making visual adjustments and other model behavior checks, with no need to test out the sharing aspects, so working with just one client is enough. To simplify such a development cycle, if the query parameter `?isLocal` is specified in the URL, the application will be executed with the reflector's role replaced by a local emulation. In the case of `counter.html`: ~~~~~~~~ http://localhost:8000/counter.html?isLocal ~~~~~~~~ will allow the application's code to be run exactly as is, but without the need for a network. ## debugger At present, there is a problem in that code written as an expander goes through a string representation before being evaluated and executed, which means that a browser debugger cannot display line numbers. By inserting a `debugger` statement the debugger can be started, or if output is generated using `console.log` then clicking on the reported line numbers in the output allows reference to the code in a "VM..." pseudo file, and the insertion of breakpoints. In the future we would like to improve the situation, such as by allowing expander code to be inserted without going through a string representation whenever possible. # Example 2 (Drawing) As an example of an application in which each client has a different view, I'll now introduce a simple drawing program. This example has multiple expanders in one library file, and also adds code to the view. ~~~~~~~~ class DrawModel { init() { this._set("color", "black"); this.subscribe(this.id, "line", "DrawModel.line"); this.subscribe(this.sessionId, "color", "DrawModel.color"); } ~~~~~~~~ This model has `color` and `lines` (described below) as state properties, and calls `subscribe()` to communicate with the view. The first and second arguments of `subscribe()` are the scope and the message name, which together constitute a key agreed among the objects interested in these messages. The third argument of `subscribe()` defines the method to be invoked when a message arrives, specified by joining the expander name and method name with a dot. In the case of "line" messages, we want only the view object that knows about this particular model to receive "line" messages from it. This is achieved by using the model's `this.id` as the scope; in effect, this declares that "only this model/view pair is interested in this message". The "color" message, by contrast, comes from a distinct virtual DOM element, and is to be received by all objects used in the session. Therefore as scope we use `this.sessionId`, a shared value that all the session's objects have access to. ~~~~~~~~ line(data) { if (!this._get("lines")) { this._set("lines", []); } ~~~~~~~~ The "line" message is sent from the view to the model when the user makes a mouse movement on the screen to draw a line. A case to watch out for in Croquet is when a new client joins after other people have already performed some actions, such as - in this application - drawing some lines. This requires that the model hold information about past line segments, so here it is stored in a property called "lines". The property could be created in `init()`, but let's try creating it when the information for the first line segment arrives. ~~~~~~~~ let line = {...data, color: this._get("color")}; this._get("lines").push(line); ~~~~~~~~ The object `{command: "line", from: {x,y}, to: {x,y}}` is sent as `data`. We augment it with `color`, and add the result to the "lines" property. ~~~~~~~~ this.publish(this.id, "drawLine", line); } ~~~~~~~~ And now we send this object in a `drawLine` message, this time from the model to the view. It is important to remember that only JSONizable objects can be sent as messages. ~~~~~~~~ color(color) { this._set("color", color); } ~~~~~~~~ When a "color" message is received, its value is stored in a property ready for the next "line" message. ~~~~~~~~ class DrawView { init() { this.addEventListener("mousedown", "DrawView.mouseDown"); ~~~~~~~~ `DrawView` is an expander installed in the `View` that corresponds to the above `DrawModel`. A `View` expander can also register event handlers for DOM events using `addEventListener`. ~~~~~~~~ this.subscribe(this.model.id, "drawLine", "DrawView.drawLine"); ~~~~~~~~ In the last line of `DrawModel.line()`, a message was sent using `this.publish(this.id, "drawLine", line);` with the model's `id` as the scope and "drawLine" as the name. An `ElementView` stores the corresponding `Element` object itself as `this.model`, and can read values (including `id`) from the model freely. To receive the "drawLine" messages, the `DrawView`'s `subscribe` specifies the same scope and the same name. This is how the sending and receiving of the "drawLine" message for a particular `DrawModel`/`DrawView` pair is set up. ~~~~~~~~ this.initDraw(); } ~~~~~~~~ This calls the method `initDraw()`, which is defined by the same expander. ~~~~~~~~ initDraw() { if (!this.model._get("lines")) {return;} this.model._get("lines").forEach(data => { this.drawLine(data); }); } ~~~~~~~~ The role of `initDraw()` is to make sure that the screen of a participant joining a session that was already running shows correctly any lines that have already been drawn. Since reading values from model objects is allowed, the virtual DOM view accesses the "lines" property from the object stored as `this.model`. If a value exists for the "lines" property, each line is drawn using `drawLine()` as if the participant had been in the session since the start. `drawLine()` is an expander method, but remember that a method within the same expander can be called using `this.`. The call `this.drawLine(data)` is equivalent to `this.call("DrawView", "drawLine", data)`, because the call itself appears in a `DrawView` expander method. ~~~~~~~~ mouseDown(evt) { ~~~~~~~~ This is the method registered in `init()` as a DOM event handler. ~~~~~~~~ let mouseMove = (evt) => { ~~~~~~~~ Like drawing, we want to track mousemove events only between the mouse button being pressed and being released, and during that time we need to handle them even if the mouse pointer leaves the DOM element's display area, and to handle a mouseup even if it occurs outside the area. Therefore, mousemove and mouseup handlers are set up afresh on mousedown and released on mouseup. This `mouseMove` function is designed for that purpose. ~~~~~~~~ if (this.lastPoint) { let p = {x: evt.offsetX, y: evt.offsetY}; this.publish(this.model.id, "line", {command: "line", from: this.lastPoint, to: p}); this.lastPoint = p; } ~~~~~~~~ In this `mouseMove`, if the view finds a property `lastPoint` it publishes a message "line" so as to draw a line from `lastPoint` to the current mousemove event's `(offsetX, offsetY)`. The scope is `this.model.id`, so as usual it will only be delivered to objects that specify the same scope. Finally, `lastPoint` is updated to the new pointer position. In the case of views, you can store arbitrary objects in properties, using the standard `this.propertyname` syntax. However, accidentally using a property name that is also used by the system will cause problems, so we may take some action on this in the future. ~~~~~~~~ let mouseUp = (evt) => { document.removeEventListener("mousemove", this.mousemove); document.removeEventListener("mouseup", this.mouseup); this.lastPoint = null; }; ~~~~~~~~ In `mouseUp`, the handler temporarily added to `document` is removed and `lastPoint` is also cleared. ~~~~~~~~ this.mousemove = mouseMove.bind(this); this.mouseup = mouseUp.bind(this); let offsetX = evt.offsetX; let offsetY = evt.offsetY; this.lastPoint = {x: offsetX, y: offsetY}; document.addEventListener("mousemove", this.mousemove); document.addEventListener("mouseup", this.mouseup); ~~~~~~~~ Still in mouseDown, we bind the above two functions to `this` and store them in properties, and also set `lastPoint` to the place where the mousedown happened. In addition, we register those functions as document-level event handlers until the mouseup occurs. What should be noted here is the actual type of events being sent. The events delivered through the virtual DOM system are "cooked", with objects containing only somewhat abstract values in a way that absorbs client differences as much as possible, whereas handlers registered directly with real DOM elements, such as `mouseMove` and `mouseUp` here, receive the original DOM events. Either the program should use values chosen specifically to avoid inconsistencies, such as always using `offsetX`, or call `this.cookEvent()` to convert an event to a virtual event. ~~~~~~~~ drawLine(data) { let ctx = this.dom.getContext("2d"); ctx.lineWidth = 2; ctx.strokeStyle = data.color; ctx.beginPath(); ctx.moveTo(data.from.x, data.from.y); ctx.lineTo(data.to.x, data.to.y); ctx.stroke(); } ~~~~~~~~ Using the data in a "drawLine" message sent from the model, draw on the actual DOM element stored in `this.dom`. ~~~~~~~~ class Color { init() { this.addEventListener("click", "Color.color"); this.style.setProperty("background-color", "black"); } ~~~~~~~~ This file defines another expander, called `Color`. It is installed in a certain model. In `init()`, the method `color` of the expander is specified to be called when a click event occurs, and the virtual-DOM style property `background-color` is set to `black`. ~~~~~~~~ randomColor() { let h = Math.floor(Math.random() * 256); let s = "100%"; let l = "80%"; return `hsl(${h}, ${s}, ${l})`; } ~~~~~~~~ `randomColor()` is used to get a random color from a hue ring. Because this `Math.random()` is executed as model code, it is guaranteed that however many times clients call it, they will all be obtaining exactly the same sequence of values. ~~~~~~~~ color() { let color = this.randomColor(); this.style.setProperty("background-color", color); this.publish(this.sessionId, "color", color); } ~~~~~~~~ The `color` method is executed when this virtual DOM element is clicked. `this.randomColor()` calls the `randomColor()` method defined by the same expander, and the `background-color` that was set to `black` in `init()` is replaced with the new color. The new color is then also published in a "color" message, using `this.sessionId` as the scope. `sessionId` is shared across the whole application, so any object in the application can subscribe to messages that have this scope. As shown above, in this example all `DrawModel`s subscribe to these "color" messages, and respond by changing their "color" property. ~~~~~~~~ function beDrawing(parent, json) { let top = parent.createElement(); let canvas = parent.createElement("CanvasElement"); canvas.setCode(parent.getLibrary("drawing.DrawModel")); canvas.setViewCode(parent.getLibrary("drawing.DrawView")); let color = parent.createElement(); color.setCode(parent.getLibrary("drawing.Color")); ~~~~~~~~ `beDrawing`, like the earlier `beCounter`, can be thought of as code that simplifies the process of assembling the DOM tree interactively. The `canvas` variable is assigned a `CanvasElement` value, and `color` a `div` element. The `CanvasElement`'s model code is set to `DrawModel` code obtained from `library`, and its view code to the library's `DrawView`. Because `color` is a common behavior across all clients, it is only given model code. ~~~~~~~~ color.style.setProperty("width", "60px"); color.style.setProperty("height", "60px"); color.style.setProperty("border-radius", "50%"); ~~~~~~~~ The styles of individual elements can also be set in this way. ~~~~~~~~ color.domId = "color"; color.setStyleClasses(` #color:hover { border: 2px dotted white; } #color { border: 2px solid white; }`); ~~~~~~~~ In addition, you can use a special method called `setStyleClasses` to pass as a string a CSS block with CSS selectors. The property `domId`, renamed because the property `id` is already reserved by Croquet, sets the DOM `id` property. The CSS block specifies the style for that id, with and without the `:hover` pseudo-class. ~~~~~~~~ top.style.setProperty("display", "flex"); top.style.setProperty("width", "550px"); top.appendChild(canvas); top.appendChild(color); parent.appendChild(top); return parent; ~~~~~~~~ These elements are made into a tree structure with `appendChild()` and added to `parent`. ~~~~~~~~ export const drawing = { expanders: [DrawModel, DrawView, Color], functions: [beDrawing] }; ~~~~~~~~ Everything is registered in the library `drawing`. `beDrawing()` will be called through `makeMain` in drawing.html. # Example 3 (Video Chat) In `apps/video-chat.html` and `examples/video-chat.js` you can find an example of video chat using SkyWay, a service provided by NTT. The file `skyway/skyway-latest.js` is a SkyWay library. To run this example, get an API key from [SkyWay](https://webrtc.ecl.ntt.com/developer.html) and create a file called `skyway/key.js` using the actual key you obtained. ~~~~~~~~ export const key = 'abcd0123-abcd-aaaa-0000-012312012abc'; ~~~~~~~~ In the video chat example, it's important to note that _almost nothing shown on the screen is being shared through Croquet_. The connection status, layout of the individual videos, etc. are also different for each client. That's why `examples/video-chat.js` only defines a view expander which, when notification of a new participant arrives from SkyWay, creates a new actual video element and sets its `srcObject` property. Another thing to note is that you cannot do JavaScript asynchronous processing in the model, because it would cause the timing of model execution to differ between participating clients. In this example, the SkyWay library and `key.js` are loaded with dynamic import, and even if such values are to be used purely by model code, it is essential that they be loaded by view-side code, and then sent to the model using messages. # Example 4 (Text Chat) In `apps/text-chat.html` and `examples/text-chat.js` you can find an example of a simple text chat. A notable feature introduced in the example is a way to specify the CSS class strings to control the appearance of the application. The initialization function `beChat` calls the `setStyleClasses()` method on `chat` element. The selectors matches with the `domId` property of the virtual DOM element that will become the `id` property of the actual DOM element, and the CSS class names added by `classList.add()`. The `setStyleClasses()` method specifies a CSS string that persists until as long as the element stays in the DOM scene tree. For a certain kind of applications, such CSS strings can be attached to different elements instead of having one large string for the top-level element. In this particular case, however, where many similar elements with the same class will be added and removed from the DOM scene tree, it is more concise to just have a single description at the top level.


Given there is a well-established relationship between the two companies, considering all else equal, if the stock price of entity 1 moves in a certain direction, then the stock price of entity 2 is also expected to m;ake a similar move. If not, then there could be a trading opportunity.
Let's assume ICICI and HDFC are two such stocks. Now, for example, all else equal, on a given day, ICICI stock price moves up by X% then given the relationship, HDFC is also expected to move up at least y%, but for whatever reason, assume HDFC stayed flat. Then we can go ahead and claim that ICICI stock price has moved higher than expected when compared to HDFC’s stock price.
In the arbitrage world – this translates to buying the cheaper stock i.e HDFC and selling expensive one i.e ICICI.
In a nutshell, this is the essence of ‘Pair Trading’.
The relationship between the two companies in the pair might face anomalies at times. This causes the price of one stock to deviate from that of the other.
An anomaly in stock prices gives us an opportunity to trade. The anomaly can happen because of anything –
Generally speaking, a price anomaly is a local event, which causes the stock price of one company reacts (or overreacts) compared to the other. I prefer to call it a local event because it affects only 1 company in our universe of two stocks J
So the relationship essentially sets the rules on how the two stock prices are related. Therefore, the bulk of the work in pair trading revolves around –
The following is a quick description from Investopedia
Pairs trading was first introduced in the mid-1980s by a group of technical analyst researchers that were employed by Morgan Stanley, the multinational investment bank and financial services company. The pairs trade strategy uses statistical and technical analysis to seek out potential market-neutral profits.
Market-neutral strategies are a key aspect of a pairs trade transaction. Market-neutral strategies involve long and short positions in two different securities with a positive correlation. The two offsetting positions form the basis for a hedging strategy that seeks to benefit from either a positive or negative trend.
A pairs trade strategy is based on the historical correlation of two securities. The securities in a pairs trade must have a high positive correlation, which is the primary driver behind the strategy’s profits. A pairs trade strategy is best deployed when a trader identifies a correlation discrepancy. Relying on the historical notion that the two securities will maintain a specified correlation, the pairs trade can be deployed when this correlation falters.
When pairs from the trade eventually deviate—as long as an investor is using a pairs trade strategy—they would seek to take a dollar matched the long position in the underperforming security and sell short the outperforming security. If the securities return to their historical correlation, a profit is made from the convergence of the prices.
When a pairs trade performs as expected, the investor profits; the investor is also able to mitigate potential losses that would have occurred in the process. Profits are generated when the underperforming security regains value, and the [outperforming] security’s price deflates. The net profit is the total gained from the two positions.
There are several limitations for pairs trading. One is that the pairs trade relies on a high statistical correlation between two securities. Most pairs trades will require a correlation of 0.80, which can be challenging to identify. Second, while historical trends can be accurate, past prices are not always indicative of future trends. Requiring only a correlation of 0.80 can also decrease the likelihood of the expected outcome.
Now, let's look at the statistical analysis and ideas behind them for choosing a pair for trading.


#include <GrTSGen.h>
Classes | |
| struct | STriInfo |
| triangle info. | |
Public Member Functions | |
| GrTSGen (const SVec3 *vertices, const SVec3 *normals, const SVec2 *uvs, unsigned int vertCount) | |
| class header. | |
| ~GrTSGen () | |
| void | GenTS (SVec3 *tangents, SVec3 *binormals) |
| public methods |
Definition at line 20 of file GrTSGen.h.
| GrTSGen::GrTSGen | ( | const SVec3 * | vertices, | |
| const SVec3 * | normals, | |||
| const SVec2 * | uvs, | |||
| unsigned int | vertCount | |||
| ) |
class header.
note, ensure that the pointers passed in persists through the life of this object. We do not assume ownership of the pointers or the data. Also, the vertices passed in must be in a triangle list format. Therefor, count must be a multiple of 3.
File: GrTSGen.cpp Author: Kevin Bray Created: 10-30-04 Copyright © 2004 Bootstrap Games project includes. class GrTSGen ctor & dtor
create the triangle list.
Definition at line 25 of file GrTSGen.cpp.
| GrTSGen::~GrTSGen | ( | ) |
Definition at line 42 of file GrTSGen.cpp.
public methods
the pointers passed in must be able to contain a tangent and binormal for every vertex specified by 'count' in the constructor.
make sure GenTS isn't called multiple times per mesh... this would be horribly costly and inexcusably redundant.
for each triangle face, generate the tangent space basis.
figure out direction of S&T for the current triangle.
if we have an acceptable amount of area...
u-tangent.
v-tangent.
we have a degenerate triangle.
now calculate the tangent and binormal for each vertex. This is similar to smoothing normals on a mesh. Since the triangle linking discriminates normals, we can simply smooth with neighbors.
for each vertex...
try to find a triangle that has a similar vertex.
skip this triangle.
found a match.
record the averaged vectors.
make something up... triangle is too small in UV space to do anything.
make something up... triangle is too small in UV space to do anything.
Definition at line 56 of file GrTSGen.cpp.


Install Docker Desktop on Windows
Estimated reading time: 4 minutesDocker Desktop for Windows is the Community version of Docker for Microsoft Windows. You can download Docker Desktop for Windows from Docker Hub.
What to know before you install
System Requirements
- Windows 10 64-bit: Pro, Enterprise, or Education (Build 15063 or later).
- Hyper-V and Containers Windows features must be enabled.
-
The following hardware prerequisites are required to successfully run Client Hyper-V on Windows 10:
- 64 bit processor with Second Level Address Translation (SLAT)
- 4GB system RAM
- BIOS-level hardware virtualization support must be enabled in the BIOS settings. For more information, see Virtualization.
Note: Docker supports Docker Desktop on Windows based on Microsoft’s support lifecycle for Windows 10 operating system. For more information, see the Windows lifecycle fact sheet.
README for Docker Toolbox and Docker Machine users: Microsoft Hyper-V is required to run Docker Desktop. The Docker Desktop Windows installer enables Hyper-V if required, and restarts your machine. When Hyper-V is enabled, VirtualBox no longer works. However, any existing VirtualBox VM images are retained.
VirtualBox VMs created with docker-machine
(including the default
one
typically created during Toolbox install) no longer start. These VMs cannot be
used side-by-side with Docker Desktop. However, you can still use
docker-machine
to manage remote VMs.
What’s included in the installer
The Docker Desktop installation includes Docker Engine, Docker CLI client, Docker Compose, Docker Machine, and Kitematic.
Containers and images created with Docker Desktop are shared between all user accounts on machines where it is installed. This is because all Windows accounts use the same VM to build and run containers.
Nested virtualization scenarios, such as running Docker Desktop on a VMWare or Parallels instance might work, but there are no guarantees. For more information, see Running Docker Desktop in nested virtualization scenarios.
Note: Refer to the Docker compatibility matrix for complete Docker compatibility information with Windows Server.
About Windows containers
Looking for information on using Windows containers?
- Switch between Windows and Linux containers describes how you can toggle between Linux and Windows containers in Docker Desktop and points you to the tutorial mentioned above.
- Getting Started with Windows Containers (Lab) provides a tutorial on how to set up and run Windows containers on Windows 10, Windows Server 2016 and Windows Server 2019. It shows you how to use a MusicStore application with Windows containers.
- Docker Container Platform for Windows articles and blog posts on the Docker website.
Install Docker Desktop on Windows
-
Double-click Docker Desktop Installer.exe to run the installer.
If you haven’t already downloaded the installer (
Docker Desktop Installer.exe
), you can get it from Docker Hub. It typically downloads to yourDownloads
folder, or you can run it from the recent downloads bar at the bottom of your web browser. -
Follow the instructions on the installation wizard to accept the license, authorize the installer, and proceed with the install.
When prompted, authorize the Docker Desktop Installer with your system password during the install process. Privileged access is needed to install networking components, links to the Docker apps, and manage the Hyper-V VMs.
-
Click Finish on the setup complete dialog and launch the Docker Desktop application.
Start Docker Desktop
Docker Desktop does not start automatically after installation. To start Docker Desktop, search for Docker, and select Docker Desktop in the search results.
When the whale icon in the status bar stays steady, Docker Desktop is up-and-running, and is accessible from any terminal window.
If the whale icon is hidden in the Notifications area, click the up arrow on the taskbar to show it. To learn more, see Docker Settings.
After installing the Docker Desktop app, you also get a pop-up success message with suggested next steps, and a link to this documentation.
When initialization is complete, click the whale icon in the Notifications area and select About Docker Desktop to verify that you have the latest version.
Congratulations! You are successfully running Docker Desktop on Windows.
Uninstall Docker Desktop
To uninstall Docker Desktop from your Windows machine:
- From the Windows Start menu, select Settings > Apps > Apps & features.
- Select Docker Desktop from the Apps & features list and then select Uninstall.
- Click Uninstall to confirm your selection.
Note: Uninstalling Docker Desktop will destroy Docker containers and images local to the machine and remove the files generated by the application.
Where to go next
- Getting started introduces Docker Desktop for Windows.
- Get started with Docker is a tutorial that teaches you how to deploy a multi-service stack.
- Troubleshooting describes common problems, workarounds, and how to get support.
- FAQs provides answers to frequently asked questions.
- Stable Release Notes or Edge Release Notes.


Rotate your HTML blocks vertically
Documentation: https://antonbobrov.github.io/rotate-html/
How to start with NPM
npm install rotate-html
How to start with CDN

Example

This is a template node element.

import rotateHtml from 'rotate-html';
rotateHtml({
selector: '#rotate-html'
});
Settings
| Option |
Type |
Default |
Description |
| selector |
string|HTMLElement |
#html-rotate |
The selector of the element. |
| rotate |
90|-90 |
-90 |
Rotation angle. |
| updateOnResize |
boolean |
true |
If you need to update the sizes of the element on resize. |


cma.experimentation.CompactGA(object)
class documentationcma.experimentation
(View In Hierarchy)
Randomized search on the binary domain {0,1}^n.
cGA samples two different solutions per iteration.
Minimal example:
dimension = 20 opt = CompactGA(dimension * [0.5]) # initialise in domain middle while opt.best.f > 0 and not opt.stop: opt.iterate(sum) print("%d: fbest=%f" % (opt.evaluation, opt.best.f))
finds argmin_{x in {0, 1}**20} sum(x) in opt.result.
Reference: Harik et al 1999.
| Method | __init__ | takes as input the initial vector of probabilities to sample 1 vs 0. |
| Method | iterate | one iteration with f as fitness function to be minimized |
| Method | stop | dictionary containing satisfied termination conditions |
| Method | result | for the time being result is the best seen solution |


The first project of this unit was to design and cut out a clock onto a record. My greatest challenge was making sure that I didn't accidently cut out parts that I wanted to keep. There were also a few close calls were I almost forgot to set lines to 'hairline'' in CorelDraw before I cut, but luckily I caught it before I took it to the machine.
For the second part of this project I designed a bookmark to engrave on leather. I have not actually engraved it yet, so we'll see how that goes.
For the thir part of this unit, I used the rotary tool to engrave on a glass. I had no problem creating the files, but when I went to print, I had messed up the dimensions and caused the design to print wrong. Because of this, I had to get rid of the cup and prnt on a second one. After the first mistake I was more careful, and the second one was engraved without a hitch.


To run the SCO RTE Conformance Utility Test, click the corresponding link from the
main Test Suite menu. A Java Plug-in Security Warning
dialog box will appear because the Test Suite is reading and writing
files from/to the local
file system via a Java Applet. Click Grant this Session or
Grant Always to allow the Test Suite applet to
run. Clicking Deny will cause the
Test Suite software to not function properly.
SCO Utility Overview
The SCO RTE Conformance Utility Test verifies that the test subject
SCO is conformant with the SCORM 2004 4th Ed. Testing Requirements.
This test will verify that the test subject:
- Can be launched by a known conformant LMS
- Supports the Run-Time Environment Application Program Interface
(API) functions defined in SCORM 2004 4th Ed.
Required
- Initialize("")
- Terminate("")
Optional
- Commit("")
- GetValue("parameter")
- SetValue("parameter_1","parameter_2")
- GetLastError()
- GetErrorString("parameter")
- GetDiagnostics()
In addition to verification of the above requirements, this test will
also audit which Run-Time Environment Data Model
elements the SCO used in the content implementation, and verify
that data elements are used in the correct manner with regard to the data
type requirements associated with the data model elements.
Operational Instructions
- The test can be run on a Single SCO or Multiple SCOs. You can also save
or load a list of SCO file paths to and from a text (.txt) file.
- Provide the SCO Title, SCO Version/Release Number and SCO
Vendor/Developer.
- Click Continue.
- Enter a timeout period (default is 20 seconds). This is the
number of seconds the Test Suite will wait for the API
method Initialize("") to be called. If the call is not made within
this time, the Test Suite will end and the SCO will be
given a conformance label.
Note: If there is a possibility that the SCO may not call
API method Initialize("") in the first 20 seconds, change this default
value. No warning or error will be logged for changing this value.
- Click Browse to select the SCO
that will be tested or a saved .txt file containing a list of SCO file paths.
-
You may click Add to List to add another SCO or .txt
file to the list.
-
Click Continue after adding SCOs to the list.
Note: If a file remains in the file input box, it will be
appended to the list after you click Continue.
-
Optionally, you may enter initialization values for any of the
following elements: Learner ID, Learner Name, Credit/No-Credit,
Mode, Comments From LMS, Launch Data, Objective Data, Scaled Passing
Score, Max Time Allowed, Time Limit Action or Completion Threshold.
These values are typically defaults that are provided by the LMS or
via a Manifest.
Note: If entering Comments From LMS or Objective Data, click
the corresponding Add button, enter the values for the initial
element of the array and click the corresponding Set button.
After adding the last element of the list, click Done.
- Click Continue.
- Then click Launch SCO.
- Follow the necessary steps that are presented by the SCO to
exercise the content.
- Click Complete Test in
the Instructions frame to finish the test.
-
If multiple SCOs were entered you will repeat steps 9 through 11 for each SCO to be tested.
- After you click Launch SCO the
Test Suite will launch the current SCO.
-
The Test Suite will then wait for a call to
Initialize(""). The Test Suite will either wait for the
call or the timeout period to expire (whichever comes first).
-
The Test Suite will wait for calls to any of the API functions listed below.
-
For Single SCO Testing: After the SCO RTE Conformance Utility Test
surrogate LMS receives a call to Terminate(""), the SCO RTE
Conformance Utility Test will end. Click Complete Test
after this test ends to close the SCO window.
-
For Multiple SCO Testing: After the SCO RTE Conformance Utility Test
surrogate LMS receives a call to Terminate(""), the current SCO RTE
Conformance Utility Test will end. Click Complete Test
to close the current SCO window. Processing will begin for the next SCO and
will continue until the last SCO is tested.
-
Use Abort Test if a call to Terminate("") is
not received from the SCO being tested. Wait for a period of time to see if
the call will be invoked. If not, Abort Test will send
a call to Terminate("") and end the testing, marking the SCO as being
non-conformant.
-
At the end of a successful test the Test Suite will
send to the Test Suite Log a set of supported features.
These indicate what SCORM features a SCO supports. SCORM 2004
4th Ed. features are:
API Support:
- Find an LMS provided API Instance
Session Methods:
Data Transfer:
- GetValue()
- SetValue()
- Commit()
Support Methods:
- GetLastError()
- GetErrorString()
- GetDiagnostic()
Data Model Support:
- SCORM 2004 4th Ed. Run-Time Environment Data Model
Additional Functionality
- Log Legend: Clicking this link will open a
window to describe the meaning of the colors and symbols
used in the Test Suite log.
- Saving a list of SCOs: To save a list of SCOs select all the
SCOs you want in the list using the Browse and Add to List
buttons. Select the .txt file you wish to save to or create a new .txt file using
the Browse dialog. Click Save The List and you will be
prompted to confirm the file to write. Click OK to save this file or
Cancel to discard it.
Note: If you want to edit
the .txt file outside the SCORTE Instructions page open the file using a text
editor. Each SCO path is entered on a separate line of the file. File
paths are not validated so each line needs to be a valid path or the test will not
work.
Loading a list of SCOs: To load a list
of SCOs that was created previously select that .txt file using
the Browse button of step 2 to select it. Click Add To
List or Continue to include the paths from that file to the list
of SCOs (this action will append the list, not overwrite it). You may continue to
add individual SCOs or load another saved list.
Operational Notes
Both Summary and Detailed Logs are automatically saved in the
folder:
<install_directory>\SCORM_2004_4th_Ed_TS_V1.1.1\TestSuite\Logs\SCO\<timestamp-test subject name>\
Note: Logs are saved in this folder as a result of a
portability enhancement. If you need to move logs, please move the entire
folder and its contents since they are required to properly render the logs
in the browser.
If using Internet Explorer, it is critical for Run-Time
API execution that the SCOs be launched from the same URL domain as
the SCO RTE Conformance Utility Test. The SCOs being tested will likely use some sort of
scripting language (i.e. JavaScript) to locate the LMS's API Adapter
object, which requires the use of cross frame and/or cross-window
scripting. For security reasons Internet Explorer requires
that content that performs cross frame or cross-window scripting be
loaded from the same domain. Refer to
http://msdn2.microsoft.com/en-us/library/ms533028.aspx
|


Overview of the Type of Language Files
The Core Language Pack included with DNN includes language files which can be modified. Here's a list of the types of language files which can be edited using the Languages module.
- Actions: The names given to common actions such as clear cache, delete module, edit module.
- Strings: String resources are the names attributed Admin and Host pages, Banner types and Permission to Deploy modules.
- Error Messages: Messages which appear when an error occurs.
- Email Messages: Email messages are sent by DNN when users request password reminders, subscribe to a role, etc. They can also be message to editors or Administrators confirming actions such as deleting user accounts or sending newsletters.
- Text: Text language files.


interface TitlesCallback
Callback used by the calling user to get the result from successfully retrieving the titles from the provided urls
abstract fun onSuccessfulPageTitle(titles: List<String>): Unit
Callback called when titles were successfully retrieved |


Workflow showing how to partition a data.csv
file into multiple files given a map.csv
categorization file.
For example, the data file can contain sales and returns with columns SKU|SALES|RETURNS
, while the map file categorizes skus with SKU|CATEGORY
. The result of the test is a bunch of folders in dest_dir
, one for each CATEGORY
(partition) in the map, each containing a data.csv
file with the skus that belong to that partition.
main {
lb.PartitionCsv(
src_file = "partition/files/data.csv",
partition_file = "partition/files/map.csv",
dest_dir = "partition/files/%PARTITION_ID%",
delim = "|"
)
}


28 January 1998
Disease Outbreak Reported
Meningococcal meningitis group A has been confirmed in an outbreak in Tembo, Bandundu Region which is close to Lunda Norte Province in neighbouring Angola. Up to 25 January 114 cases, of which 32 were fatal (case fatality rate 28%), had been reported. The first case was reported on 2 January and coincided with the return of over 9,000 Congolese citizens from Angola. 13 cases (1 death) were reported in the second week of January, 35 cases (16 deaths) in the third week and 65 cases (14 deaths) in the fourth week. The weekly attack rates based on an estimated population of 46,000 in Tembo increased from 2.2 to 141.3 during the first four weeks of January. A team from the Ministry of Health, WHO and Médecins Sans Frontières has visited Tembo to assess the situation and plan control measures such as a vaccination campaign, training of health care staff, and public health education. Meningitis has also been reported in Kikwit and in Panzi health zones, in particular at Kingwangala and Kahemba. Apparently 80 cases of meningitis were also hospitalized across the border in Angola.


Hi guys, it feels great to finally get some time to write my first post for this year - parenting and my day job has kept me quite busy.
Migrations in the Node.js ecosystem is one of those things that still doesn't have an agreed upon go-to solution. Personally, I have been using Bookshelf.js as my ORM of choice when dealing with SQL databases. Through Bookshelk.js I got introduced to knex, which is an amazing SQL query builder that comes with migrations.  Node.js' module based system is perfect for that because you can store pieces of reusable code in npm
. I recently published a module called widget-knex-schema which can be used to easily create database tables through a simple JS/JSON object schema.
To demonstrate how widget-knex-schema
works, we're going to take code from a previous post, Building a simple API with Express and Bookshelf.js, and create it's migrations. We'll split the schema.js file to different files so that each table schema has it's own file and save them in the db/schemas
directory.
widget-knex-schema
at it's best is a knex
helper therefore we'll need knex
as a dependency. We'll also use sqlite
as our database.
npm i widget-knex-schema knex sqlite3
Let's not forget to install knex
globally: npm i knex -g
The project we're building on top of also had a few dependencies, let's install those:
npm i body-parser bookshelf express lodash --save
In the Building a simple API with Express and Bookshelf.js post we had 4 models: User, Post, Category, and Tag. This means we'll need to create 4 tables plus a mapping table for the many-to-many relationship between the posts and tags. Before we can create our migration files we need to initialise knex
and update the config settings:
knex init
Update the created knexfile.js file - we'll store all migration files in db/migrates
and all schema files in db/schemas
.
"use strict";
module.exports = {
development: {
client: 'sqlite3',
connection: {
filename: './db.sqlite'
},
useNullAsDefault: true,
migrations: {
tableName: 'knex_migrations',
directory: __dirname + '/db/migrations'
}
}
};
With knex
configured, we're ready to start creating our migrations. Firstly, let's create the users migration file.
knex migrate:make creating_users_table
Find the file in db/migrations
and use widget-knex-schema
to create the users table.
"use strict";
const migrate = require('widget-knex-schema');
const usersSchema = require('../schemas/users');
exports.up = function(knex, Promise) {
return migrate.createTable(knex, 'users', usersSchema, true);
};
exports.down = function(knex, Promise) {
return knex.schema.dropTableIfExists('users');
};
Next, let's create the categories migration file.
knex migrate:make creating_categories_table
"use strict";
const migrate = require('widget-knex-schema');
const categoriesSchema = require('../schemas/categories');
exports.up = function(knex, Promise) {
return migrate.createTable(knex, 'categories', categoriesSchema, true);
};
exports.down = function(knex, Promise) {
return knex.schema.dropTableIfExists('categories');
};
Then the tags migration file.
knex migrate:make creating_tags_table
"use strict";
const migrate = require('widget-knex-schema');
const tagsSchema = require('../schemas/tags');
exports.up = function(knex, Promise) {
return migrate.createTable(knex, 'tags', tagsSchema, true);
};
exports.down = function(knex, Promise) {
return knex.schema.dropTableIfExists('tags');
};
Then the posts migration file.
knex migrate:make creating_posts_table
"use strict";
const migrate = require('widget-knex-schema');
const postsSchema = require('../schemas/posts');
exports.up = function(knex, Promise) {
return migrate.createTable(knex, 'posts', postsSchema, true);
};
exports.down = function(knex, Promise) {
return knex.schema.dropTableIfExists('posts');
};
Lastly, create the posts_tags migration file.
knex migrate:make creating_posts_tags_table
"use strict";
const migrate = require('widget-knex-schema');
const postsTagsSchema = require('../schemas/posts_tags');
exports.up = function(knex, Promise) {
return migrate.createTable(knex, 'posts_tags', postsTagsSchema, true);
};
exports.down = function(knex, Promise) {
return knex.schema.dropTableIfExists('posts_tags');
};
The proof is the pudding - let's run our migrations.
knex migrate:latest
This is only the first version of widget-knex-schema
, I would appreciate some feedback and contributions. In future versions I would like to add more functionality to support column alterations.
All the code in this post can be found on Github: https://github.com/qawemlilo/handling_migrations.
That's all for now - happy coding!


Data sets for book "Basic Statistics and Data Analysis" by Larry J. Kitchens.
| Version: | 1.2.0 |
| Depends: | lattice, R (≥ 2.10) |
| Imports: | e1071 |
| Suggests: | ggplot2 (≥ 2.1.0), dplyr, tidyr |
| Published: | 2017-07-30 |
| Author: | Alan T. Arnholt [aut, cre], Ben Evans [aut] |
| Maintainer: | Alan T. Arnholt <arnholtat at appstate.edu> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | no |
| Materials: | README |
| CRAN checks: | BSDA results |
| Reference manual: | BSDA.pdf |
| Package source: | BSDA_1.2.0.tar.gz |
| Windows binaries: | r-devel: BSDA_1.2.0.zip, r-release: BSDA_1.2.0.zip, r-oldrel: BSDA_1.2.0.zip |
| OS X binaries: | r-release: BSDA_1.2.0.tgz, r-oldrel: BSDA_1.2.0.tgz |
| Old sources: | BSDA archive |
| Reverse imports: | bridger2, IIS, NPMOD, NSM3 |
| Reverse suggests: | CIplot, mice |
Please use the canonical form https://CRAN.R-project.org/package=BSDA to link to this page.


Step 1: Data download by the user¶
The information is usually captured by the user directly in a biblographical database as Scopus using a complex search string. The refinement of the search string is iterative and preliminary analysis of the keywords can help debug the search string. In this first part of the tutorial it is assumed that the search string is refined.
We recommend downloading the bibliographic information in three files to facilitate the loading of data in Python. The first file, named demo-citations.csv
, contains the fields showed in the following figure:
The second file, named demo-keywords.csv
, contains the information showed in the next figure.
Finally, the third file, demo-refs.csv
, contains the information about references cited by docuemnts selected in the search.
The selected fields maximize the potential of information for obtain insights of the data.


Glowell Prep School teachers, parents pray together
TEACHERS and parents of students of the Glowell Preparatory School in Portmore, St Catherine, met Thursday for the school's annual prayer breakfast.
The school's founder and principal Gloria Jack, said teachers and parents meet once a year, in November, to give thanks to Almighty God, through prayers.
“We salute and celebrate you, our parents. We celebrate you because you have been chosen by the Almighty God for his heritage because children are heritage of the Lord. Parenthood is a life-long journey; as long as you're alive you will be parenting,” said Jack. She added: “We live in an upside-down technological world where man thinks that he is god [so] we have to develop a spiritual relationship with God, as no one can deny the fact that the most important part of our day's activities is when meet together as a family to give God thanks. He has a direct line, a line that never goes busy, and a line that is always working. He is a person who we can always talk with because, regardless of what we may think, He is the Almighty.”
She urged the parents to bring up their children in a proper way, and not be guided by the world, reminding that the home is the first place where discipline should be taught.


/**
* Today is Magpie Festival,
* so I write some code to celebrate.

// So I keep waiting and I have confidence that you will.
boolean isHesitate = true;
while (isHesitate) {
i.waitFor(u);
// I think it is an important decision
// and you should think it over.
isHesitate = u.thinkOver();
}
// After a romantic wedding, we will live happily ever after.
i.marry(u);
i.liveHappilyWith(u);
* Today is Magpie Festival,
* so I write some code to celebrate.

// So I keep waiting and I have confidence that you will.
boolean isHesitate = true;
while (isHesitate) {
i.waitFor(u);
// I think it is an important decision
// and you should think it over.
isHesitate = u.thinkOver();
}
// After a romantic wedding, we will live happily ever after.
i.marry(u);
i.liveHappilyWith(u);
, I have fallen in love with you for
Love u forever and ever.


This demo shows how to use a {@link jidejs/ui/control/ListView}. ListView is a very powerful control and this example shows only a very limited set of its features.
require([ 'jidejs/base/ObservableList', 'jidejs/ui/control/ListView' ], function(ObservableList, ListView) { // create the initial data var people = new ObservableList([ 'John Doe', 'Santa Claus', 'Jane Doe', 'Michael Doe' ]); // create a ListView for the people var list = new ListView({ items: people // uncomment the following line to play with different settings // , classList: ['is-striped', 'has-border'] }); // select the first item in the list list.selectionModel.selectFirst(); // add the 'element' of the ListView to the DOM root.appendChild(list.element); });
{@link jidejs/ui/control/ListView} is a very powerful control that can be fully customized by changing the {@link jidejs/ui/control/Cell} used to render its items.


(.) climate information change survey beliefs scientific treatment scientists respondents group consensus effects {border-style global effect policy px;} #ffffff;} change. control questions follow-up treated Table public views scientists’ warming degree political baseline > (Column However, age age, caused errors experiment groups ideology. significant significantly specifications *** Fahrenheit Finally, University conducted degrees gender, high include informed knowledge low participants race, rate squared, Chg Prob Research Soft additional completed data education education, employment hard income, info level mean objective order providing px; respondent respondents’ state status, survey, var. willingness {font-family < **% ***% ./journal.pone..t Atmospheric Climate Dep. H.I.: Observations Policy Public R-squared S.I.: Sciences Significance Standard believe clustered controls did estimates font-size human levels: likely parentheses; sample screen skepticism temperature underway Change Science United affected answered answers conservatives decisions double; extent fact following immediate indicator information, long-run need probability received science short-run soft subjects support test (PDF) -month Click Clim Humans LINK Text Text. Underway activities beliefs, border-color border-width change: consent credibility does file. humans increase initial justify online participation provided question reject sent solid; survey. text vague warming. {font-style {font-weight (Chg (Columns (a) (b) Am't Average Change. Columns Department Hard Information Thus, accelerating action affects analysis bias bold cause characteristics consensus, conservative consistent courier; difference differences donate e-mail elicited em; equal evidence findings form gauge great ideological ideology, including information. issue know knowledgeable make p-val people percentage point pool possible preferences prior pt;} published questions. randomized report reported respondents. results skeptical strong study temperatures terms think winnings


| fill {tidyr} | R Documentation |
Fills missing values in selected columns using the next or previous entry. This is useful in the common output format where values are not repeated, and are only recorded when they change.
fill(data, ..., .direction = c("down", "up", "downup", "updown"))
data |
A data frame. |
... |
< |
.direction |
Direction in which to fill missing values. Currently either "down" (the default), "up", "downup" (i.e. first down and then up) or "updown" (first up and then down). |
Missing values are replaced in atomic vectors; NULL
s are replaced in lists.
# Value (year) is recorded only when it changes sales <- tibble::tribble( ~quarter, ~year, ~sales, "Q1", 2000, 66013, "Q2", NA, 69182, "Q3", NA, 53175, "Q4", NA, 21001, "Q1", 2001, 46036, "Q2", NA, 58842, "Q3", NA, 44568, "Q4", NA, 50197, "Q1", 2002, 39113, "Q2", NA, 41668, "Q3", NA, 30144, "Q4", NA, 52897, "Q1", 2004, 32129, "Q2", NA, 67686, "Q3", NA, 31768, "Q4", NA, 49094 ) # `fill()` defaults to replacing missing data from top to bottom sales %>% fill(year) # Value (pet_type) is missing above tidy_pets <- tibble::tribble( ~rank, ~pet_type, ~breed, 1L, NA, "Boston Terrier", 2L, NA, "Retrievers (Labrador)", 3L, NA, "Retrievers (Golden)", 4L, NA, "French Bulldogs", 5L, NA, "Bulldogs", 6L, "Dog", "Beagles", 1L, NA, "Persian", 2L, NA, "Maine Coon", 3L, NA, "Ragdoll", 4L, NA, "Exotic", 5L, NA, "Siamese", 6L, "Cat", "American Short" ) # For values that are missing above you can use `.direction = "up"` tidy_pets %>% fill(pet_type, .direction = "up") # Value (n_squirrels) is missing above and below within a group squirrels <- tibble::tribble( ~group, ~name, ~role, ~n_squirrels, 1, "Sam", "Observer", NA, 1, "Mara", "Scorekeeper", 8, 1, "Jesse", "Observer", NA, 1, "Tom", "Observer", NA, 2, "Mike", "Observer", NA, 2, "Rachael", "Observer", NA, 2, "Sydekea", "Scorekeeper", 14, 2, "Gabriela", "Observer", NA, 3, "Derrick", "Observer", NA, 3, "Kara", "Scorekeeper", 9, 3, "Emily", "Observer", NA, 3, "Danielle", "Observer", NA ) # The values are inconsistently missing by position within the group # Use .direction = "downup" to fill missing values in both directions squirrels %>% dplyr::group_by(group) %>% fill(n_squirrels, .direction = "downup") %>% dplyr::ungroup() # Using `.direction = "updown"` accomplishes the same goal in this example


Next: *read-base*, Previous: set-syntax-from-char, Up: Reader Dictionary
with-standard-io-syntax
{form}* ⇒ {result}*
forms—an implicit progn.
results—the values returned by the forms.
Within the dynamic extent of the body of forms, all reader/printer control variables, including any implementation-defined ones not specified by this standard, are bound to values that produce standard read/print behavior. The values for the variables specified by this standard are listed in Figure 23–1.
[Reviewer Note by Barrett: *print-pprint-dispatch* should probably be mentioned here, too.]
| Variable | Value |
|---|---|
| *package* | The CL-USER package |
| *print-array* | t |
| *print-base* | 10 |
| *print-case* | :upcase |
| *print-circle* | nil |
| *print-escape* | t |
| *print-gensym* | t |
| *print-length* | nil |
| *print-level* | nil |
| *print-lines* | nil |
| *print-miser-width* | nil |
| *print-pprint-dispatch* | The standard pprint dispatch table |
| *print-pretty* | nil |
| *print-radix* | nil |
| *print-readably* | t |
| *print-right-margin* | nil |
| *read-base* | 10 |
| *read-default-float-format* | single-float |
| *read-eval* | t |
| *read-suppress* | nil |
| *readtable* | The standard readtable |
(with-open-file (file pathname :direction :output) (with-standard-io-syntax (print data file))) ;;; ... Later, in another Lisp: (with-open-file (file pathname :direction :input) (with-standard-io-syntax (setq data (read file))))


---
title: Safari (iOS)
category: Mobile
order: 35
---
Did you mean OS X Safari instead?
Changing your search engine to DuckDuckGo (iOS 8)
1. Open the settings app.
2. Tap on Safari.
3. Tap on Search Engine.
4. Select DuckDuckGo.
A better way to stay private online.


M2 Is Bringing Toaplan's Back Catalogue To Modern Consoles
Arcade lovers, rejoice!
by Damien McFerranTiger Heli. Zero Wing. Hellfire. Truxton. Slap Fight. Fire Shark. If those names just sound like the ramblings of a deranged madman, then you'll probably want to navigate away from this page as soon as possible, but if at least one of them has you grinning with nostalgic glee, then the next bit of news is going to make your decade (or what's left of it, at least).
Emulation expert M2 has revealed that it has obtained the rights to resurrect the back catalogue of seminal Japanese game developer Toaplan. Founded in 1984, Toaplan was famous mainly for its amazing 2D shooters, but also released platformers like Wardner and Snow Bros. It closed its doors in 1994 after releasing the iconic bullet-hell title Batsugun, but several of its staffers would form Cave, a company which continued Toaplan's good work in the shmup genre.
The announcement came during the M2 Shmups Thanksgiving Festival in Japan, where M2 president Naoki Horii confirmed that the company had acquired the necessary permission to release (almost) all of Toaplan games onto "modern platforms" (titles like Mahjong Sisters and Enma Daio are believed to be outside of this deal). We're assuming "modern platforms" includes Switch, as well.
The full lineup and release schedule are yet to be confirmed, but does this news excite you personally, or could you literally care less about Toaplan and its output? Let us know with a comment.
[via siliconera.com]


20 comments
I updated a previous project with a SBT test case to throw an exception during test construction:
The output using SBT 0.12.2 in my machine:
ijuma% sbt test
[info] Loading project definition from /Users/ijuma/src/sbt-test-bug/project
[info] Set current project to root (in build file:/Users/ijuma/src/sbt-test-bug/)
[info] No tests to run for root/test:test
Exception in thread "Thread-1" java.io.EOFException
at java.io.ObjectInputStream$BlockDataInputStream.peekByte(ObjectInputStream.java:2572)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1315)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:369)
at sbt.React.react(ForkTests.scala:98)
at sbt.ForkTests$$anonfun$apply$2$Acceptor$2$.run(ForkTests.scala:66)
at java.lang.Thread.run(Thread.java:722)
[info] Passed: : Total 0, Failed 0, Errors 0, Passed 0, Skipped 0
[info] No tests to run for data/test:test
[success] Total time: 1 s, completed 27-Jan-2013 17:14:31
I seem to be getting this error with sbt 0.13.0.
Exception in thread "Thread-3" java.io.EOFException
at java.io.ObjectInputStream$BlockDataInputStream.peekByte(ObjectInputStream.java:2577)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1297)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:349)
at sbt.React.react(ForkTests.scala:110)
at sbt.ForkTests$$anonfun$mainTestTask$1$Acceptor$2$.run(ForkTests.scala:69)
at java.lang.Thread.run(Thread.java:695)
@taylorleese certainly it is a bug, but it is unlikely to have the same cause and warrants a separate issue. Unfortunately, I'd need a test case. sbt 0.13.1 might help pinpoint the problem with more logging, but I don't know if it will do anything at this point in execution. (0.13.1-RC1 had some issues so it wasn't announced- RC2 will be out this week.)
I'm seeing this as well on sbt 0.13.0
Exception in thread "Thread-18" java.io.EOFException
at java.io.ObjectInputStream$BlockDataInputStream.peekByte(ObjectInputStream.java:2598)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1318)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)
at sbt.React.react(ForkTests.scala:98)
at sbt.ForkTests$$anonfun$apply$2$Acceptor$2$.run(ForkTests.scala:66)
at java.lang.Thread.run(Thread.java:744)
Same on sbt 0.13.1-RC2:
Exception in thread "Thread-54" java.io.EOFException
at java.io.ObjectInputStream$BlockDataInputStream.peekByte(ObjectInputStream.java:2577)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1315)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:369)
at sbt.React.react(ForkTests.scala:116)
at sbt.ForkTests$$anonfun$mainTestTask$1$Acceptor$2$.run(ForkTests.scala:75)
at java.lang.Thread.run(Thread.java:722)
Unfortunatly it seems several test combinations given the blocking situation, I can restrict it more than https://github.com/playframework/playframework/blob/master/framework/src/anorm/src/test/scala/anorm/AnormSpec.scala .
If you comment out at least one test, sbt execution is ok, running all is blocked (sometime, but majority of time for me today).
playframework/framework# sbt
sbt> project Anorm
sbt> test
harrah reopened the issue
I don't see an EOFException, just a hang, which appears to be in the application/test code and not in sbt. The relevant stack traces from the remote jvm:
"specs2.DefaultExecutionStrategy1" prio=10 tid=0x00007fddf83e4000 nid=0xfbf in Object.wait() [0x00007fddf4de8000]
java.lang.Thread.State: RUNNABLE
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:188)
at anorm.H2Database$class.withConnection(H2Database.scala:11)
at anorm.AnormSpec$.withConnection(AnormSpec.scala:9)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$1.apply(AnormSpec.scala:11)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$1.apply(AnormSpec.scala:11)
at org.specs2.specification.ContextsInjection$$anon$1$$anonfun$asResult$1.apply(ContextsInjection.scala:11)
"specs2.DefaultExecutionStrategy2" prio=10 tid=0x00007fddf8363000 nid=0xfc0 waiting for monitor entry [0x00007fddf4ce7000]
java.lang.Thread.State: BLOCKED (on object monitor)
at java.sql.DriverManager.registerDriver(DriverManager.java:295)
- waiting to lock <0x000000077bd95720> (a java.lang.Class for java.sql.DriverManager)
at org.h2.Driver.load(Driver.java:160)
- locked <0x000000077bdb25f0> (a java.lang.Class for org.h2.Driver)
at org.h2.Driver.<clinit>(Driver.java:45)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:188)
at anorm.H2Database$class.withConnection(H2Database.scala:11)
at anorm.AnormSpec$.withConnection(AnormSpec.scala:9)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$6.apply(AnormSpec.scala:24)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$6.apply(AnormSpec.scala:24)
at org.specs2.specification.ContextsInjection$$anon$1$$anonfun$asResult$1.apply(ContextsInjection.scala:11)
"specs2.DefaultExecutionStrategy3" prio=10 tid=0x00007fddf83e8800 nid=0xfc1 in Object.wait() [0x00007fddf4be6000]
java.lang.Thread.State: RUNNABLE
at acolyte.Acolyte$.connection(Acolyte.scala:37)
at anorm.AnormTest$class.withQueryResult(AnormSpec.scala:65)
at anorm.AnormSpec$.withQueryResult(AnormSpec.scala:9)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$11$$anonfun$apply$12.apply(AnormSpec.scala:37)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$11$$anonfun$apply$12.apply(AnormSpec.scala:37)
at org.specs2.specification.ContextsInjection$$anon$1$$anonfun$asResult$1.apply(ContextsInjection.scala:11)
"specs2.DefaultExecutionStrategy4" prio=10 tid=0x00007fddf8342000 nid=0xfc2 in Object.wait() [0x00007fddf4ae4000]
java.lang.Thread.State: RUNNABLE
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at java.lang.reflect.Constructor.newInstance(Constructor.java:532)
at java.lang.Class.newInstance0(Class.java:374)
at java.lang.Class.newInstance(Class.java:327)
at java.util.ServiceLoader$LazyIterator.next(ServiceLoader.java:373)
at java.util.ServiceLoader$1.next(ServiceLoader.java:445)
at java.sql.DriverManager$2.run(DriverManager.java:537)
at java.security.AccessController.doPrivileged(Native Method)
at java.sql.DriverManager.loadInitialDrivers(DriverManager.java:517)
at java.sql.DriverManager.initialize(DriverManager.java:650)
at java.sql.DriverManager.registerDriver(DriverManager.java:296)
- locked <0x000000077bd95720> (a java.lang.Class for java.sql.DriverManager)
at acolyte.Driver.<clinit>(Driver.java:41)
at acolyte.Acolyte$.connection(Acolyte.scala:37)
at anorm.AnormTest$class.withQueryResult(AnormSpec.scala:65)
at anorm.AnormSpec$.withQueryResult(AnormSpec.scala:9)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$11$$anonfun$apply$16.apply(AnormSpec.scala:45)
at anorm.AnormSpec$$anonfun$1$$anonfun$apply$11$$anonfun$apply$16.apply(AnormSpec.scala:45)
at org.specs2.specification.ContextsInjection$$anon$1$$anonfun$asResult$1.apply(ContextsInjection.scala:11)
at org.specs2.specification.ContextsInjection$$anon$1$$anonfun$asResult$1.apply(ContextsInjection.scala:11)
If you forcibly kill sbt, yes, I see an EOFException, but that's not surprising- it is being forcibly shutdown in the middle of communicating with a remove jvm.
harrah closed the issue
We recently ran into a pretty severe issue where a ScalaTest test class was throwing a NPE during construction, which caused test execution to stop but for success to be reported. This meant that we were running 1/3 of our test suite instead of the full test suite and failures were not reported. Note that this was a multi-module build.
I can provide a simple test case if that helps.
The output was:


{% extends 'main/_base.html' %} {% load static %} {% block title %} About Us {% endblock %} {% block content %}
RoomScout.ca was started as a little side project to help get rid of a problem that I was facing. The problem I was facing was that I was managing bills for a house that I had with a spreadsheet, and it became tedious to add bills and then send a spreadsheet to my tenants every month. I also had an issue of getting a new tenant when my current one had left without notice.
I decided that I can start a project that would help solve my problems and also teach me a little about web development.
If there are any bugs or issues that you face, feel free to email me personally at<EMAIL_ADDRESS>I am happy to help and hope that this project can grow to help others that are looking for an easier way to manage roommates.


Admin
Professor
Add/update a professor
Delete a professor
Student
Add/update a student
Delete a student
Matching
Delete
Log Out


To engage, assist, and provide management and business consultancy services and other related services.
To assist and provide services for thesis preparation related to accounting; bookkeeping and taxation services
including one on one tutorial;
To assist and provide services on preparation of tour packages, itineraries and other related travel assistance;
To engage, manage and operate as photocopying, and printing services;
To assist and provide assistance in the requirements needed for driving lessons and other related services;
To engage and operate as real estate lessor(REL) including subleasing services without engaging on financial leasing.
To organize, conduct, coordinate and implement seminars, conferences and special events;
To operate as bayad center of bills for Globe, Smart, PLDT, BWD, Beneco, and other related statement of accounts.


Beta This is a test version of the layout of this page. Take the survey to help us improve it
Research and analysis
Summary of the findings of the TOP Foundation investigation into competitive school sport, conducted for Ofsted.
MS Word Document , 753KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 1.01MB , 31 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 1.08MB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 751KB , 26 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 442KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 723KB , 10 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 788KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 912KB , 26 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 448KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 665KB , 14 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 446KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 590KB , 11 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 160KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 531KB , 3 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 525KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 954KB , 32 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Word Document , 318KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 830KB , 42 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
In the spring of 2014 an investigation commissioned by Ofsted explored the school backgrounds, ethnicity and socioeconomic status of some of our best adult and age group international sport teams. The same investigation asked 29 National Governing Bodies of sport (NGBs) to report on their competitive school sport provision in 39 different sports. 26 (90%) NGBs agreed to take part and they reported on 35 sports.
This NGBs report is part of a wider investigation being undertaken by Ofsted into competitive school sport for Her Majesty’s Chief Inspector of Education, Children’s Services and Skills (HMCI), Sir Michael Wilshaw , which includes a supporting report with input from headteachers.
This report explores two main areas - the educational backgrounds of our best athletes, and the provision of 35 competitive school sports.


GitHub Practice Web Site
Cool, now Git is adding the closing tags for me!
Don't you think it's cool?


{% include head.html %}
{% include nav.html %} {% include header.html %} {% include about.html %} {% include profile.html %} {% include education.html %} {% include publications.html %} {% include conferences.html %} {% include coding.html %} {% comment %} {% include software.html %} {% endcomment % {% include experience.html %} {% include membership.html %} {% include cv.html %} {% include contact.html %} {% include scripts.html %} {% include footer.html %}