Using percentage
input property you can define the percentage of completion of the progress bar.
When percentage
input property is not provided on mz-progress
tag the progress bar will be shown as indeterminate.
Optionally, colors can be customized using backgroundClass
and/or progressClass
input properties but are not required.
Progress can be customized using the following properties on the mz-progress
element.


Enter your region, age and gender below:
Your Average insurance premium is EUR per month. This is an increase of 1% compared with last year's price.


Don't be a stranger, drop us a line! 💌
📝 Want to write for Alligator.io? We're always on the lookout for content collaborators. Just get in touch to introduce yourself! You can head over here for more details.
You can review our style guide here .
Unfortunately we can't answer individual code questions due to lack of time.
Your Name
Your Email
Message
Ok, send 💨


Before Change
// the specifiers dictionary, it should be sufficient to just check for
// the presence of any non-constant specifiers.
for spec in specifiers.itervalues():
if (any(Symbol(spec.name) in element for element in matrix) and
not getattr(spec, "constant", False)):
raise ValueError(("The coefficient matrix for the equations "
"contains "%s", which is not constant.") %
After Change
// the presence of any non-constant specifiers.
symbols = reduce(operator.add, (el.atoms() for el in matrix))
// Only check true symbols, not numbers
symbols = set([str(symbol) for symbol in symbols
if isinstance(symbol, Symbol)])
for symbol in symbols:


Login to Club Experience
To Continue To:
Email Address:
Password:
Login
Or:
Create an account
|
Reset your password


{% block edit_user_form %} {% from "_formhelpers.html" import render_field %}
NOTE: Changing your email address will log you out. You will need to verify the new email address and enter a new password.


MESSAGE TO SELLER
Item:
Title of the item
Price:
To:
From:
Message:
Enter your message here...
Send
Cancel


This package implements an interface to Oracle Data Mining (ODM). It provides an ideal environment for rapid development of demos and proof of concept data mining studies. It facilitates the prototyping of vertical applications and makes ODM and the RDBMS environment easily accessible to statisticians and data analysts familiar with R but not fluent in SQL or familiar with the database environment. It also facilitates the benchmarking and testing of ODM functionality including the production of summary statistics, performance metrics and graphics. It enables the scripting and control of production data mining methodologies from a high-level environment. Oracle Data Mining (ODM) is an option of Oracle Relational Database Management System (RDBMS) Enterprise Edition (EE). It contains several data mining and data analysis algorithms for classification, prediction, regression, clustering, associations, feature selection, anomaly detection, feature extraction, and specialized analytics. It provides means for the creation, management and operational deployment of data mining models inside the database environment. For more information consult the entry for "Oracle Data Mining" in Wikipedia (en.wikipedia.org).
| Version: | 1.1 |
| Depends: | R (≥ 2.10.1), RODBC |
| Suggests: | RODBC, mlbench, verification, PASWR, scatterplot3d |
| Published: | 2012-10-29 |
| Author: | Pablo Tamayo and Ari Mozes |
| Maintainer: | Pablo Tamayo <pablo.tamayo at oracle.com> |
| License: | LGPL-2 | LGPL-2.1 | LGPL-3 [expanded from: LGPL (≥ 2)] |
| URL: | http://www.r-project.org |
| NeedsCompilation: | no |
| CRAN checks: | RODM results |
| Reference manual: | RODM.pdf |
| Package source: | RODM_1.1.tar.gz |
| Windows binaries: | r-devel: RODM_1.1.zip, r-release: RODM_1.1.zip, r-oldrel: RODM_1.1.zip |
| OS X binaries: | r-release: RODM_1.1.tgz, r-oldrel: RODM_1.1.tgz |
| Old sources: | RODM archive |
Please use the canonical form https://CRAN.R-project.org/package=RODM to link to this page.


Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
The bulk of the text of this specification is also available in the WHATWG Web Applications 1.0 specification, under a license that permits reuse of the specification text.
This specification defines an API that allows Web application authors to spawn background workers running scripts in parallel to their main page. This allows for thread-like operation with message-passing as the coordination mechanism.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the most recently formally published revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
If you wish to make comments regarding this document, you can enter feedback using this form:
You can also e-mail feedback to<EMAIL_ADDRESS>(subscribe, archives), or<EMAIL_ADDRESS>(subscribe, archives). All feedback is welcome.
Implementors should be aware that this specification is not stable. Implementors who are not taking part in the discussions are likely to find the specification changing out from under them in incompatible ways. Vendors interested in implementing this specification before it eventually reaches the Candidate Recommendation stage should join the aforementioned mailing lists and take part in the discussions.
The latest stable version of the editor's draft of this specification is always available on the W3C CVS server and in the WHATWG Subversion repository. The latest editor's working copy (which may contain unfinished text in the process of being prepared) contains the latest draft text of this specification (amongst others). For more details, please see the WHATWG FAQ.
Notifications of changes to this specification are sent along with notifications of changes to related specifications using the following mechanisms:
svn checkout http://svn.whatwg.org/webapps/
The W3C Web Applications Working Group is the W3C working group responsible for this specification's progress along the W3C Recommendation track. This specification is the 19 May 2014 Editor's Draft.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This section is non-normative.
This specification defines an API for running scripts in the background independently of any user interface scripts.
This allows for long-running scripts that are not interrupted by scripts that respond to clicks or other user interactions, and allows long tasks to be executed without yielding to keep the page responsive.
Workers (as these background scripts are called herein) are relatively heavy-weight, and are not intended to be used in large numbers. For example, it would be inappropriate to launch one worker for each pixel of a four megapixel image. The examples below show some appropriate uses of workers.
Generally, workers are expected to be long-lived, have a high start-up performance cost, and a high per-instance memory cost.
This section is non-normative.
There are a variety of uses that workers can be put to. The following subsections show various examples of this use.
This section is non-normative.
The simplest use of workers is for performing a computationally expensive task without interrupting the user interface.
In this example, the main document spawns a worker to (naïvely) compute prime numbers, and progressively displays the most recently found prime number.
The main page is as follows:
<!DOCTYPE HTML>   <title>Worker example: One-core computation</title>
The highest prime number discovered so far is: <output id="result"></output>

The Worker()
constructor call creates a worker and returns a
Worker
object representing that worker, which is used to communicate with the worker.
That object's onmessage
event handler allows the
code to receive messages from the worker.
The worker itself is as follows:
var n = 1; search: while (true) { n += 1; for (var i = 2; i <= Math.sqrt(n); i += 1) if (n % i == 0) continue search; // found a prime! postMessage(n); }
The bulk of this code is simply an unoptimised search for a prime number. The postMessage()
method is used to send a
message back to the page when a prime is found.
This section is non-normative.
In this example, the main document uses two workers, one for fetching stock updates at regular intervals, and one for performing search queries that the user requests.
The main page is as follows:
<!DOCTYPE HTML>   <title>Worker example: Stock ticker</title>
<output id="symbol"></output> <output id="value"></output>

Search: <input type="text" autofocus oninput="search(this.value)">

(The data in this example is not real. Try searching for "Google" or "Apple".)

The two workers use a common library for performing the actual network calls. This library is as follows:
function get(url) { try { var xhr = new XMLHttpRequest(); xhr.open('GET', url, false); xhr.send(); return xhr.responseText; } catch (e) { return ''; // turn all errors into empty results } }
The stock updater worker is as follows:
importScripts('io.js'); var timer; var symbol; function update() { postMessage(symbol + ' ' + get('stock.cgi?' + symbol)); timer = setTimeout(update, 10000); } onmessage = function (event) { if (timer) clearTimeout(timer); symbol = event.data; update(); };
The search query worker is as follows:
importScripts('io.js'); onmessage = function (event) { postMessage(get('search.cgi?' + event.data)); };
This section is non-normative.
This section introduces shared workers using a Hello World example. Shared workers use slightly different APIs, since each worker can have multiple connections.
This first example shows how you connect to a worker and how a worker can send a message back to the page when it connects to it. Received messages are displayed in a log.
Here is the HTML page:
<!DOCTYPE HTML> <title>Shared workers: demo 1</title>
Log:

Here is the JavaScript worker:
onconnect = function(e) { var port = e.ports[0]; port.postMessage('Hello World!'); }
This second example extends the first one by changing two things: first, messages are received
using addEventListener()
instead of an event handler IDL attribute, and second, a message is sent to the
worker, causing the worker to send another message in return. Received messages are again
displayed in a log.
Here is the HTML page:
<!DOCTYPE HTML> <title>Shared workers: demo 2</title>
Log:

Here is the JavaScript worker:
onconnect = function(e) { var port = e.ports[0]; port.postMessage('Hello World!'); port.onmessage = function(e) { port.postMessage('pong'); // not e.ports[0].postMessage! // e.target.postMessage('pong'); would work also } }
Finally, the example is extended to show how two pages can connect to the same worker; in this
case, the second page is merely in an iframe
on the first page, but the same
principle would apply to an entirely separate page in a separate top-level browsing
context.
Here is the outer HTML page:
<!DOCTYPE HTML> <title>Shared workers: demo 3</title>
Log:

Here is the inner HTML page:
<!DOCTYPE HTML> <title>Shared workers: demo 3 inner frame</title>
Inner log:

Here is the JavaScript worker:
var count = 0; onconnect = function(e) { count += 1; var port = e.ports[0]; port.postMessage('Hello World! You are connection #' + count); port.onmessage = function(e) { port.postMessage('pong'); } }
This section is non-normative.
In this example, multiple windows (viewers) can be opened that are all viewing the same map. All the windows share the same map information, with a single worker coordinating all the viewers. Each viewer can move around independently, but if they set any data on the map, all the viewers are updated.
The main page isn't interesting, it merely provides a way to open the viewers:
<!DOCTYPE HTML>   <title>Workers example: Multiviewer</title>
<button type=button onclick="openViewer()">Open a new viewer</button>

Each viewer opens in a new window. You can have as many viewers as you like, they all view the same data.

The viewer is more involved:
<!DOCTYPE HTML>   <title>Workers example: Multiviewer viewer</title>
Viewer

Map

<canvas id="map" height=150 width=150></canvas>

 <button type=button onclick="worker.port.postMessage('mov left')">Left</button> <button type=button onclick="worker.port.postMessage('mov up')">Up</button> <button type=button onclick="worker.port.postMessage('mov down')">Down</button> <button type=button onclick="worker.port.postMessage('mov right')">Right</button> <button type=button onclick="worker.port.postMessage('set 0')">Set 0</button> <button type=button onclick="worker.port.postMessage('set 1')">Set 1</button>

Public Chat

 <form onsubmit="worker.port.postMessage('txt ' + message.value); message.value = ''; return false;">
 <input type="text" name="message" size="50"> <button>Post</button>
 </form>
Private Chat

There are several key things worth noting about the way the viewer is written.
Multiple listeners. Instead of a single message processing function, the code here attaches multiple event listeners, each one performing a quick check to see if it is relevant for the message. In this example it doesn't make much difference, but if multiple authors wanted to collaborate using a single port to communicate with a worker, it would allow for independent code instead of changes having to all be made to a single event handling function.
Registering event listeners in this way also allows you to unregister specific listeners when
you are done with them, as is done with the configure()
method in this
example.
Finally, the worker:
var nextName = 0; function getNextName() { // this could use more friendly names // but for now just return a number return nextName++; } var map = [ [0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 1, 0, 1, 1], [0, 1, 0, 1, 0, 0, 0], [0, 1, 0, 1, 0, 1, 1], [0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 1, 1, 1, 1], [1, 1, 0, 1, 1, 0, 1], ]; function wrapX(x) { if (x < 0) return wrapX(x + map[0].length); if (x >= map[0].length) return wrapX(x - map[0].length); return x; } function wrapY(y) { if (y < 0) return wrapY(y + map.length); if (y >= map[0].length) return wrapY(y - map.length); return y; } function wrap(val, min, max) { if (val < min) return val + (max-min)+1; if (val > max) return val - (max-min)-1; return val; } function sendMapData(viewer) { var data = ''; for (var y = viewer.y-1; y <= viewer.y+1; y += 1) { for (var x = viewer.x-1; x <= viewer.x+1; x += 1) { if (data != '') data += ','; data += map[wrap(y, 0, map[0].length-1)][wrap(x, 0, map.length-1)]; } } viewer.port.postMessage('map ' + data); } var viewers = {}; onconnect = function (event) { var name = getNextName(); event.ports[0]._data = { port: event.ports[0], name: name, x: 0, y: 0, }; viewers[name] = event.ports[0]._data; event.ports[0].postMessage('cfg ' + name); event.ports[0].onmessage = getMessage; sendMapData(event.ports[0]._data); }; function getMessage(event) { switch (event.data.substr(0, 4)) { case 'mov ': var direction = event.data.substr(4); var dx = 0; var dy = 0; switch (direction) { case 'up': dy = -1; break; case 'down': dy = 1; break; case 'left': dx = -1; break; case 'right': dx = 1; break; } event.target._data.x = wrapX(event.target._data.x + dx); event.target._data.y = wrapY(event.target._data.y + dy); sendMapData(event.target._data); break; case 'set ': var value = event.data.substr(4); map[event.target._data.y][event.target._data.x] = value; for (var viewer in viewers) sendMapData(viewers[viewer]); break; case 'txt ': var name = event.target._data.name; var message = event.data.substr(4); for (var viewer in viewers) viewers[viewer].port.postMessage('txt ' + name + ' ' + message); break; case 'msg ': var party1 = event.target._data; var party2 = viewers[event.data.substr(4).split(' ', 1)[0]]; if (party2) { var channel = new MessageChannel(); party1.port.postMessage('msg ' + party2.name, [channel.port1]); party2.port.postMessage('msg ' + party1.name, [channel.port2]); } break; } }
Connecting to multiple pages. The script uses the onconnect
event listener to listen for
multiple connections.
Direct channels. When the worker receives a "msg" message from one viewer naming another viewer, it sets up a direct connection between the two, so that the two viewers can communicate directly without the worker having to proxy all the messages.
This section is non-normative.
With multicore CPUs becoming prevalent, one way to obtain better performance is to split computationally expensive tasks amongst multiple workers. In this example, a computationally expensive task that is to be performed for every number from 1 to 10,000,000 is farmed out to ten subworkers.
The main page is as follows, it just reports the result:
<!DOCTYPE HTML>   <title>Worker example: Multicore computation</title>
Result: <output id="result"></output>

The worker itself is as follows:
// settings var num_workers = 10; var items_per_worker = 1000000; // start the workers var result = 0; var pending_workers = num_workers; for (var i = 0; i < num_workers; i += 1) { var worker = new Worker('core.js'); worker.postMessage(i * items_per_worker); worker.postMessage((i+1) * items_per_worker); worker.onmessage = storeResult; } // handle the results function storeResult(event) { result += 1*event.data; pending_workers -= 1; if (pending_workers <= 0) postMessage(result); // finished! }
It consists of a loop to start the subworkers, and then a handler that waits for all the subworkers to respond.
The subworkers are implemented as follows:
var start; onmessage = getStart; function getStart(event) { start = 1*event.data; onmessage = getEnd; } var end; function getEnd(event) { end = 1*event.data; onmessage = null; work(); } function work() { var result = 0; for (var i = start; i < end; i += 1) { // perform some complex calculation here result += 1; } postMessage(result); close(); }
They receive two numbers in two events, perform the computation for the range of numbers thus specified, and then report the result back to the parent.
This section is non-normative.
Creating a worker requires a URL to a JavaScript file. The Worker()
constructor is invoked with the URL to that file as its only
argument; a worker is then created and returned:
var worker = new Worker('helper.js');
This section is non-normative.
Dedicated workers use MessagePort
objects behind the scenes, and thus support all
the same features, such as sending structured data, transferring binary data, and transferring
other ports.
To receive messages from a dedicated worker, use the onmessage
event
handler IDL attribute on the Worker
object:
worker.onmessage = function (event) { ... };
You can also use the addEventListener()
method.
The implicit MessagePort
used by dedicated workers has its port
message queue implicitly enabled when it is created, so there is no equivalent to the
MessagePort
interface's start()
method on
the Worker
interface.
To send data to a worker, use the postMessage()
method. Structured data can be sent over this
communication channel. To send ArrayBuffer
objects efficiently (by transferring them
rather than cloning them), list them in an array in the second argument.
worker.postMessage({ operation: 'find-edges', input: buffer, // an ArrayBuffer object threshold: 0.6, }, [buffer]);
To receive a message inside the worker, the onmessage
event handler IDL attribute is used.
onmessage = function (event) { ... };
You can again also use the addEventListener()
method.
In either case, the data is provided in the event object's data
attribute.
 It supports the
structured data in the same manner.
postMessage(event.data.input, [event.data.input]); // transfer the buffer back
This section is non-normative.
Shared workers are identified by the URL of the script used to create it, optionally with an explicit name. The name allows multiple instances of a particular shared worker to be started.
Shared workers are scoped by origin. Two different sites using the same names will not collide. However, if a page tries to use the same shared worker name as another page on the same site, but with a different script URL, it will fail.
Creating shared workers is done using the SharedWorker()
constructor. This constructor takes the URL to the script to use for its first argument, and the
name of the worker, if any, as the second argument.
var worker = new SharedWorker('service.js');
Communicating with shared workers is done with explicit MessagePort
objects. The
object returned by the SharedWorker()
constructor holds a
reference to the port on its port
attribute.
worker.port.onmessage = function (event) { ... }; worker.port.postMessage('some message'); worker.port.postMessage({ foo: 'structured', bar: ['data', 'also', 'possible']});
Inside the shared worker, new clients of the worker are announced using the connect
event. The port for the new client is
given by the event object's source
attribute.
onconnect = function (event) { var newPort = event.source; // set up a listener newPort.onmessage = function (event) { ... }; // send a message back to the port newPort.postMessage('ready!'); // can also send structured data, of course };
All diagrams, examples, and notes in this specification are non-normative, as are all sections explicitly marked non-normative. Everything else in this specification is normative.
The key words "MUST", "MUST NOT", "REQUIRED", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in the normative parts of this document are to be interpreted as described in RFC2119. For readability, these words do not appear in all uppercase letters in this specification. [RFC2119]
Requirements phrased in the imperative as part of algorithms (such as "strip any leading space characters" or "return false and abort these steps") are to be interpreted with the meaning of the key word ("must", "should", "may", etc) used in introducing the algorithm.
Some conformance requirements are phrased as requirements on attributes, methods or objects. Such requirements are to be interpreted as requirements on user agents.
Conformance requirements phrased as algorithms or specific steps may be implemented in any manner, so long as the end result is equivalent. (In particular, the algorithms defined in this specification are intended to be easy to follow, and not intended to be performant.)
The only conformance class defined by this specification is user agents.
User agents may impose implementation-specific limits on otherwise unconstrained inputs, e.g. to prevent denial of service attacks, to guard against running out of memory, or to work around platform-specific limitations.
When support for a feature is disabled (e.g. as an emergency measure to mitigate a security problem, or to aid in development, or for performance reasons), user agents must act as if they had no support for the feature whatsoever, and as if the feature was not mentioned in this specification. For example, if a particular feature is accessed via an attribute in a Web IDL interface, the attribute itself would be omitted from the objects that implement that interface — leaving the attribute on the object but making it return null or throw an exception is insufficient.
This specification relies on several other underlying specifications.
Many fundamental concepts from HTML are used by this specification. [HTML]
The IDL blocks in this specification use the semantics of the WebIDL specification. [WEBIDL]
The construction "a Foo
object", where
Foo
is actually an interface, is sometimes
used instead of the more accurate "an object implementing the
interface Foo
".
The term DOM is used to refer to the API set made available to
scripts in Web applications, and does not necessarily imply the
existence of an actual Document
object or of any other
Node
objects as defined in the DOM specifications. [DOM]
An IDL attribute is said to be getting when its value is being retrieved (e.g. by author script), and is said to be setting when a new value is assigned to it.
The term "JavaScript" is used to refer to ECMA262, rather than the official term ECMAScript, since the term JavaScript is more widely known. [ECMA262]
There are two kinds of workers; dedicated workers, and shared workers. Dedicated workers, once created, are linked to their creator; but message ports can be used to communicate from a dedicated worker to multiple other browsing contexts or workers. Shared workers, on the other hand, are named, and once created any script running in the same origin can obtain a reference to that worker and communicate with it.
The global scope is the "inside" of a worker.
WorkerGlobalScope
common interface[Exposed=Worker] interface WorkerGlobalScope : EventTarget { readonly attribute WorkerGlobalScope self; readonly attribute WorkerLocation location; void close(); attribute OnErrorEventHandler onerror; attribute EventHandler onlanguagechange; attribute EventHandler onoffline; attribute EventHandler ononline; };
The self
attribute must return the
WorkerGlobalScope
object itself.
The location
attribute must
return the WorkerLocation
object created for the WorkerGlobalScope
object when the worker was created. It represents the absolute URL of the script that
was used to initialise the worker, after any redirects.
When a script invokes the close()
method on a WorkerGlobalScope
object, the user agent must run the following steps
(atomically):
Discard any tasks that have been added to the
WorkerGlobalScope
object's event loop's task
queues.
Set the worker's WorkerGlobalScope
object's closing flag to true. (This prevents any further
tasks from being queued.)
The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler IDL attributes,
by objects implementing the WorkerGlobalScope
interface:
| Event handler | Event handler event type |
|---|---|
onerror | error
|
onlanguagechange | languagechange
|
onoffline | offline
|
ononline | online
|
For data:
URLs, this is
the origin specified by the entry settings object when the constructor
was called. For other URLs, this is the origin of the value
of the absolute URL given in the worker's location
attribute.
DedicatedWorkerGlobalScope
interface[Global=Worker,DedicatedWorker] /*sealed*/ interface DedicatedWorkerGlobalScope : WorkerGlobalScope { void postMessage(any message, optional sequence<Transferable> transfer); attribute EventHandler onmessage; };
DedicatedWorkerGlobalScope
objects act as if they had an implicit
MessagePort
associated with them. This port is part of a channel that is set up when
the worker is created, but it is not exposed. This object must never be garbage collected before
the DedicatedWorkerGlobalScope
object.
All messages received by that port must immediately be retargeted at the
DedicatedWorkerGlobalScope
object.
The postMessage()
method on DedicatedWorkerGlobalScope
objects must act as if, when invoked, it
immediately invoked the method of the same name
on the port, with the same arguments, and returned the same return value.
The following are the event handlers (and their corresponding event handler event types) that must be supported, as event
handler IDL attributes, by objects implementing the DedicatedWorkerGlobalScope
interface:
| Event handler | Event handler event type |
|---|---|
onmessage | message
|
For the purposes of the application cache networking model, a dedicated worker is an extension of the cache host from which it was created.
SharedWorkerGlobalScope
interface[Global=Worker,SharedWorker] /*sealed*/ interface SharedWorkerGlobalScope : WorkerGlobalScope { readonly attribute DOMString name; readonly attribute ApplicationCache applicationCache; attribute EventHandler onconnect; };
Shared workers receive message ports through connect
events on their SharedWorkerGlobalScope
object for each
connection.
The name
attribute must return
the value it was assigned when the SharedWorkerGlobalScope
object was created by the
"run a worker" algorithm. Its value represents the name that can be used to obtain a
reference to the worker using the SharedWorker
constructor.
The following are the event handlers (and their corresponding event handler event types) that must be supported, as event
handler IDL attributes, by objects implementing the SharedWorkerGlobalScope
interface:
| Event handler | Event handler event type |
|---|---|
onconnect | connect
|
For the purposes of the application cache networking model, a shared worker is its own cache host. The run a worker algorithm takes care of associating the worker with an application cache.
The applicationCache
attribute returns the
ApplicationCache
object for the worker.
Each WorkerGlobalScope
object has a distinct event loop, separate
from those used by units of related
similar-origin browsing contexts. This event loop has no associated
browsing context, and its task queues only have
events, callbacks, and networking activity as tasks. These event loops are created by the run a worker algorithm.
Each WorkerGlobalScope
object also has a closing flag, which must initially be false, but which
can get set to true by the algorithms in the processing model section below.
Once the WorkerGlobalScope
's closing flag is set to true, the event
loop's task queues must discard any further tasks that would be added to them (tasks already on the queue are
unaffected except where otherwise specified). Effectively, once the closing flag is true, timers stop firing,
notifications for all pending asynchronous operations are dropped, etc.
Workers communicate with other workers and with browsing
contexts through message channels and their
MessagePort
objects.
Each WorkerGlobalScope
worker global scope has a list of
the worker's ports, which consists of all the MessagePort
objects that are
entangled with another port and that have one (but only one) port owned by worker
global scope. This list includes the implicit MessagePort
in the case of dedicated workers.
Each WorkerGlobalScope
also has a list of the worker's workers.
Initially this list is empty; it is populated when the worker creates or obtains further
workers.
Finally, each WorkerGlobalScope
also has a list of the worker's
Document
s. Initially this list is empty; it is populated when the worker is
created.
Whenever a Document
d is added to the worker's Document
s, the user agent must, for
each worker q in the list of the worker's workers whose list of
the worker's Document
s does not contain d, add d to q's WorkerGlobalScope
owner's list of the worker's
Document
s.
Whenever a Document
object is discarded,
it must be removed from the list of the worker's Document
s of each
worker whose list contains that Document
.
Given a settings object o when creating or obtaining a
worker, the list of relevant Document
objects to add depends on the type
of global object specified by o's. If o
specifies a global object that is a WorkerGlobalScope
object (i.e. if we
are creating a nested worker), then the relevant Document
s are the the worker's
Document
s of the global object specified by o. Otherwise, o specifies a global object that
is a Window
object, and the relevant Document
is just the
responsible document specified by o.
A worker is said to be a permissible worker if its list of the worker's
Document
s is not empty.
A worker is said to be an active needed worker if any of the Document
objects in the worker's Document
s are fully active.
A worker is said to be a protected worker if it is an active needed
worker and either it has outstanding timers, database transactions, or network connections,
or its list of the worker's ports is not empty, or its WorkerGlobalScope
is actually a SharedWorkerGlobalScope
object (i.e. the worker is a shared
worker).
A worker is said to be a suspendable worker if it is not an active needed worker but it is a permissible worker.
When a user agent is to run a worker for a script with URL url and a script settings object settings object, it must run the following steps:
Create a separate parallel execution environment (i.e. a separate thread or process or equivalent construct), and run the rest of these steps asynchronously in that context.
For the purposes of timing APIs, this is the official moment of creation of the worker.
Let worker global scope be the global object specified by settings object.
If worker global scope is actually a
SharedWorkerGlobalScope
object (i.e. the worker is a shared worker), and there are
any relevant application caches that are
identified by a manifest URL with the same origin as url and
that have url as one of their entries, not excluding entries marked
as foreign, then associate the worker global scope with the most
appropriate application cache of those that match.
Attempt to fetch the resource identified by url, from the origin specified by settings object, using the responsible document specified by settings object as the referrer source (not the specified API referrer source!), and with the synchronous flag set and the force same-origin flag set.
If the attempt fails, then for each Worker
or SharedWorker
object
associated with worker global scope, queue a task to
fire a simple event named error
at that object.
Abort these steps.
If the attempt succeeds, then let source be the result of running the UTF-8 decode algorithm on the script resource.
Let language be JavaScript.
As with script
elements, the MIME type of the script is ignored.
Unlike with script
elements, there is no way to override the type. It's always
assumed to be JavaScript.
In the newly created execution environment, create a JavaScript global
environment whose global object is worker global scope. If
worker global scope is a DedicatedWorkerGlobalScope
object,
then this is a dedicated worker environment. Otherwise, worker global
scope is a SharedWorkerGlobalScope
object, and this is a shared worker
environment. (In either case, by definition, it is a worker
environment.)
Let script be a new script.
Obtain the appropriate script execution environment for the scripting language language from settings object.
Parse/compile/initialise source using that script execution environment, as appropriate for language, and thus obtain a code entry-point. If the script was not compiled successfully, let the code entry-point be a no-op script, and act as if a corresponding uncaught script error had occurred.
Let script's settings object be settings object.
Closing orphan workers: Start monitoring the worker such that no sooner than it stops being a protected worker, and no later than it stops being a permissible worker, worker global scope's closing flag is set to true.
Suspending workers: Start monitoring the worker, such that whenever worker global scope's closing flag is false and the worker is a suspendable worker, the user agent suspends execution of script in that worker until such time as either the closing flag switches to true or the worker stops being a suspendable worker.
Jump to the script's code entry-point, and let that run until it either returns, fails to catch an exception, or gets prematurely aborted by the "kill a worker" or "terminate a worker" algorithms defined below.
If worker global scope is actually a
DedicatedWorkerGlobalScope
object (i.e. the worker is a dedicated worker), then
enable the port message queue of the worker's implicit port.
Event loop: Run the responsible event loop specified by settings object until it is destroyed.
The handling of events or the execution of callbacks by tasks run by the event loop might get prematurely aborted by the "kill a worker" or "terminate a worker" algorithms defined below.
The worker processing model remains on this step until the event loop is destroyed, which happens after the closing flag is set to true, as described in the event loop processing model.
Empty the worker global scope's list of active timers.
Disentangle all the ports in the list of the worker's ports.
Empty the worker's list of the worker's Document
s.
When a user agent is to kill a worker it must run the following steps in parallel with the worker's main loop (the "run a worker" processing model defined above):
Set the worker's WorkerGlobalScope
object's closing flag to true.
If there are any tasks queued in the
WorkerGlobalScope
object's event loop's task
queues, discard them without processing them.
Wait a user-agent-defined amount of time.
Abort the script currently running in the worker.
User agents may invoke the "kill a worker" processing model on a worker at any time, e.g. in response to user requests, in response to CPU quota management, or when a worker stops being an active needed worker if the worker continues executing even after its closing flag was set to true.
When a user agent is to terminate a worker it must run the following steps in parallel with the worker's main loop (the "run a worker" processing model defined above):
Set the worker's WorkerGlobalScope
object's closing flag to true.
If there are any tasks queued in the
WorkerGlobalScope
object's event loop's task
queues, discard them without processing them.
Abort the script currently running in the worker.
If the worker's WorkerGlobalScope
object is actually a
DedicatedWorkerGlobalScope
object (i.e. the worker is a dedicated worker), then
empty the port message queue of the port that the worker's implicit port is
entangled with.
The task source for the tasks mentioned above is the DOM manipulation task source.
Whenever an uncaught runtime script error occurs in one of the worker's scripts, if the error
did not occur while handling a previous script error, the user agent must report the
error for that script, with the position (line number
and column number) where the error occurred, using the WorkerGlobalScope
object as the target.
[HTML]
For shared workers, if the error is still not handled afterwards, the error may be reported to the user. [HTML]
For dedicated workers, if the error is still not
handled afterwards, the user
agent must queue a task to fire a trusted event that uses the ErrorEvent
interface, with the name error
, that doesn't bubble and is
cancelable, with its message
, filename
, lineno
, colno
,
attributes initialised appropriately,
and with the error
attribute initialised to null,
at the Worker
object associated with the
worker. If the event is not canceled, the user agent must act as if the uncaught runtime script
error had occurred in the global scope that the Worker
object is in, thus repeating
the entire runtime script error reporting process one level up.
If the implicit port connecting the worker to its Worker
object has been
disentangled (i.e. if the parent worker has been terminated), then the user agent must act as if
the Worker
object had no error
event handler and as
if that worker's onerror
attribute was
null, but must otherwise act as described above.
Thus, error reports propagate up to the chain of dedicated workers up to the
original Document
, even if some of the workers along this chain have been terminated
and garbage collected.
The task source for the task mentioned above is the DOM manipulation task source.
AbstractWorker
abstract interface[NoInterfaceObject, Exposed=Window,Worker]
interface AbstractWorker {
attribute EventHandler onerror;
};
The following are the event handlers (and their
corresponding event handler
event types) that must be supported, as event handler IDL attributes, by
objects implementing the AbstractWorker
interface:
| Event handler | Event handler event type |
|---|---|
onerror | error
|
When the user agent is required to set up a worker script settings object, given a worker global scope and a URL script address, it must run the following steps:
Let inherited responsible browsing context be the responsible browsing context specified by the incumbent settings object.
Let inherited responsible document be the responsible document specified by the incumbent settings object.
Let inherited origin be the origin specified by the incumbent settings object.
Let worker event loop be a newly created event loop.
Let settings object be a new script settings object whose algorithms are defined as follows:
When the script settings object is created, for each language supported by the user agent, create an appropriate execution environment as defined by the relevant specification.
When a script execution environment is needed, return the appropriate one from those created when the script settings object was created.
Currently, workers only support JavaScript, so only a JavaScript execution environment is actually needed here.
Return worker global scope.
Return inherited responsible browsing context.
Return inherited responsible document.
Return worker event loop.
Return script address.
Return UTF-8.
Return worker URL.
Return inherited origin.
Return settings object.
Worker
interface[Constructor(DOMString scriptURL), Exposed=Window,Worker] interface Worker : EventTarget { void terminate(); void postMessage(any message, optional sequence<Transferable> transfer); attribute EventHandler onmessage; }; Worker implements AbstractWorker;
The terminate()
method, when invoked, must
cause the "terminate a worker" algorithm to be run on the worker with which the object
is associated.
Worker
objects act as if they had an implicit MessagePort
associated
with them. This port is part of a channel that is set up when the worker is created, but it is not
exposed. This object must never be garbage collected before the Worker
object.
All messages received by that port must immediately be retargeted at the Worker
object.
The postMessage()
method on
Worker
objects must act as if, when invoked, it immediately invoked the method of the same name on the port, with the same
arguments, and returned the same return value.
The postMessage()
method's first argument can be structured data:
worker.postMessage({opcode: 'activate', device: 1938, parameters: [23, 102]});
The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler IDL attributes,
by objects implementing the Worker
interface:
| Event handler | Event handler event type |
|---|---|
onmessage | message
|
When the Worker(scriptURL)
constructor is invoked, the
user agent must run the following steps:
The user agent may throw a SecurityError
exception and abort these steps if
the request violates a policy decision (e.g. if the user agent is configured to not allow the
page to start dedicated workers).
Resolve the scriptURL argument relative to the API base URL specified by the entry settings object when the method was invoked.
If this fails, throw a SyntaxError
exception and abort these steps.
Let worker URL be the resulting absolute URL.
If the scheme component of worker
URL is not "data
", and the origin of worker URL is not the same as the
origin specified by the incumbent settings object, then throw a
SecurityError
exception and abort these steps.
For example, scripts can be external files with the same scheme, host, and port
as the original page, or data:
URLs,
or same-origin blob:
URLs. Thus, an https:
page couldn't
start workers using scripts with http:
URLs. [FILEAPI].
Create a new DedicatedWorkerGlobalScope
object. Let worker
global scope be this new object.
Set up a worker script settings object with worker global scope and worker URL, and let settings object be the result.
Create a new Worker
object, associated with worker global
scope. Let worker be this new object.
Create a new MessagePort
object whose owner is the incumbent settings object. Let this
be the outside port.
Associate the outside port with worker.
Create a new MessagePort
object whose owner is script settings. Let inside port be this new object.
Associate inside port with worker global scope.
Entangle outside port and inside port.
Return worker, and run the following steps asynchronously.
Enable outside port's port message queue.
Let docs be the list of relevant Document
objects
to add given the incumbent settings object.
Add to worker
global scope's list of the worker's Document
s the
Document
objects in docs.
If the global object specified by the incumbent settings object
is a WorkerGlobalScope
object (i.e. we are creating a nested worker), add worker global scope to the list of the worker's workers of the
WorkerGlobalScope
object that is the global object specified by the
incumbent settings object.
Run a worker for the script with URL worker URL and the script settings object settings object.
SharedWorker
interface[Constructor(DOMString scriptURL, optional DOMString name), Exposed=Window,Worker] interface SharedWorker : EventTarget { readonly attribute MessagePort port; }; SharedWorker implements AbstractWorker;
The port
attribute must return the value
it was assigned by the object's constructor. It represents the MessagePort
for
communicating with the shared worker.
When the SharedWorker(scriptURL, name)
constructor is invoked, the user agent must run the following
steps:
The user agent may throw a SecurityError
exception and abort these steps if
the request violates a policy decision (e.g. if the user agent is configured to not allow the
page to start shared workers).
Resolve the scriptURL argument.
If this fails, throw a SyntaxError
exception and abort these steps.

Let name be the value of the second argument, or the empty string if the second argument was omitted.
If the scheme component of parsed
scriptURL is not "data
", and the origin
of scriptURL is not the same as the
origin specified by the incumbent settings object, then throw a
SecurityError
exception and abort these steps.
Thus, scripts must either be external files with the same scheme, host, and port
as the original page, or data:
URLs.
For example, an https:
page couldn't start workers using scripts with
http:
URLs.
Let docs be the list of relevant Document
objects to
add given the incumbent settings object.
Execute the following substeps atomically:
Create a new SharedWorker
object, which will shortly be associated with a
SharedWorkerGlobalScope
object. Let this SharedWorker
object be worker.
Create a new MessagePort
object whose owner is the incumbent settings object. Let
this be the outside port.
Assign outside port to the port
attribute of worker.
Let worker global scope be null.
If name is not the empty string and there exists a
SharedWorkerGlobalScope
object whose closing flag is false, whose name
attribute is exactly equal to name, and that is the global object specified by a script
settings object that specifies as its origin the same origin
as the origin of scriptURL, then let worker
global scope be that SharedWorkerGlobalScope
object.
Otherwise, if name is the empty string and there exists a
SharedWorkerGlobalScope
object whose closing flag is false, whose name
attribute is the empty string, and whose location
attribute represents an absolute
URL that is exactly equal to scriptURL, then let worker global scope be that SharedWorkerGlobalScope
object.
If worker global scope is not null, but the user agent has been configured to disallow communication between the worker represented by the worker global scope and the scripts whose settings objects are the incumbent settings object, then set worker global scope to null.
For example, a user agent could have a development mode that isolates a particular top-level browsing context from all other pages, and scripts in that development mode could be blocked from connecting to shared workers running in the normal browser mode.
If worker global scope is not null, then run these steps:
If worker global scope's location
attribute represents an absolute
URL that is not exactly equal to scriptURL, then throw a
URLMismatchError
exception and abort all these steps.
Associate worker with worker global scope.
Let settings object be the script settings object whose global object is worker global scope.
Create a new MessagePort
object whose owner is settings object. Let this be
the inside port.
Entangle outside port and inside port.
Create a trusted event that uses the
MessageEvent
interface, with the name connect
, which does not bubble, is not
cancelable, has no default action, has a data
attribute whose value is initialised to the empty string, has a ports
attribute whose value is initialised to a read only array containing only the newly created port,
and has a source
attribute whose value is
initialised to the newly created port, and queue a task to dispatch the event at worker global
scope.
Add to worker global
scope's list of the worker's Document
s the
Document
objects in docs.
If the global object specified by the incumbent settings object
is a WorkerGlobalScope
object, add worker global scope to
the list of the worker's workers of the WorkerGlobalScope
object
that is the global object specified by the incumbent settings
object.
Return worker and abort all these steps.
Create a new SharedWorkerGlobalScope
object. Let worker
global scope be this new object.
Set up a worker script settings object with worker global scope and scriptURL, and let settings object be the result.
Associate worker with worker global scope.
Set the name
attribute of worker global scope to name.
Create a new MessagePort
object whose owner is settings object. Let inside port be this new object.
Entangle outside port and inside port.
Return worker and perform the remaining steps asynchronously.
Create a trusted event that uses the
MessageEvent
interface, with the name connect
, which does not bubble, is not
cancelable, has no default action, has a data
attribute whose value is initialised to the empty string, has a ports
attribute whose value is initialised to a read only array containing only the newly created port, and
has a source
attribute whose value is initialized
to the newly created port, and queue a task to dispatch the event at worker global
scope.
Add to worker global
scope's list of the worker's Document
s the
Document
objects in docs.
If the global object specified by the incumbent settings object is
a WorkerGlobalScope
object, add worker global scope to the
list of the worker's workers of the WorkerGlobalScope
object that is
the global object specified by the incumbent settings object.
Run a worker for the script with URL scriptURL and the script settings object settings object.
The task source for the tasks mentioned above is the DOM manipulation task source.
[Exposed=Worker] partial interface WorkerGlobalScope { void importScripts(DOMString... urls); readonly attribute WorkerNavigator navigator; }; WorkerGlobalScope implements WindowTimers; WorkerGlobalScope implements WindowBase64;
When a script invokes the importScripts(urls)
method on a WorkerGlobalScope
object, the user
agent must run the following steps:
If there are no arguments, return without doing anything. Abort these steps.
Let settings object be the incumbent settings object.
Resolve each argument.
If any fail, throw a SyntaxError
exception and abort these steps.
Attempt to fetch each resource identified by the resulting absolute URLs, from the origin specified by settings object, using the API referrer source specified by settings object, and with the synchronous flag set.
For each argument in turn, in the order given, starting with the first one, run these substeps:
Wait for the fetching attempt for the corresponding resource to complete.
If the fetching attempt failed, throw a NetworkError
exception and abort all
these steps.
If the attempt succeeds, then let source be the result of running the UTF-8 decode algorithm on the script resource.
Let language be JavaScript.
As with the worker's script, the script here is always assumed to be JavaScript, regardless of the MIME type.
Create a script using source as the script source, the URL from which source was obtained, language as the scripting language, and settings object as the script settings object.
If the script came from a resource whose URL does not have the same origin as the origin specified by the incumbent settings object, then pass the muted errors flag to the create a script algorithm as well.
Let the newly created script run until it either returns, fails to parse, fails to catch an exception, or gets prematurely aborted by the "kill a worker" or "terminate a worker" algorithms defined above.
If it failed to parse, then throw an ECMAScript SyntaxError
exception and abort all these steps. [ECMA262]
If an exception was thrown or if the script was prematurely aborted, then abort all these steps, letting the exception or aborting continue to be processed by the calling script.
If the "kill a worker" or "terminate a worker" algorithms abort the script then abort all these steps.
WorkerNavigator
objectThe navigator
attribute
of the WorkerGlobalScope
interface must return an instance of
the WorkerNavigator
interface, which represents the
identity and state of the user agent (the client):
[Exposed=Worker] interface WorkerNavigator {}; WorkerNavigator implements NavigatorID; WorkerNavigator implements NavigatorLanguage; WorkerNavigator implements NavigatorOnLine;
[Exposed=Worker]
interface WorkerLocation { };
WorkerLocation implements URLUtilsReadOnly;
A WorkerLocation
object represents an absolute URL set at its
creation.
The WorkerLocation
interface supports the URLUtilsReadOnly
interface. [URL]
When the object is created, the user agent must invoke the element's
URLUtilsReadOnly
interface's set the
input algorithm with the absolute URL that the WorkerLocation
object represents as the given value.
The element's URLUtilsReadOnly
interface's get the base algorithm must return null.
All references are normative unless marked "Non-normative".
Thanks to Aaron Boodman, Алексей Проскуряков (Alexey Proskuryakov), Anne van Kesteren, Ben Turner, Dmitry Titov, Drew Wilson, Jeremy Orlow, Jonas Sicking, Justin James, Kevin Hakanson, Maciej Stachowiak, Michael Nordman, Mike Smith, and Philip Taylor for their useful and substantial comments.
Huge thanks to the whole Gears team, who pioneered this technology and whose experience has been a huge influence on this specification.


Satisfying Rice Noodles with Tofu
Yields: 5
Preparation time: 30
Cooking time: 30
Ingredients
-
2 limesthumb sized ginger2 garlic cloves1.5 tbsp soy sauce1.5 tsp brown sugar1 tsp chili sauce (siriacha etc.,)8 oz brown rice noodles12 oz tofu extra firm1/3 cup cilantro coarsely chopped2 eggs1/3 cup peanuts5 scallions or one bunchoil for frying (coconut, avocado, peanut, etc.)3 cups chopped veggies (brocoli, carrots, etc.)
Directions
-
Chop tofu into cubes while heating up oil in a large frying pan or wok.Add tofu and a few splashes of soy sauce, flipping the sides of the tofu around to evenly cook.While tofu is cooking, chop your vegetables and start boiling a pot of water for your noodles.While vegetables are steaming, cook the rice noodles for 5 minutes. Make sure to strain them before they get too soft.In a small bowl, whisk your soy sauce, brown sugar, chili sauce, and lime juice.Remove veggies and refresh pan with a little more oil if necessary. While the pan is warming up again, chop your ginger and garlic. Saute.After the ginger and garlic are fragrant (about 5 minutes) add your rice noodles. Stir and saute for 1-2 minutes. Add your sauce. Stir until the noodles are fully coated.While noodles are cooking, chop your cilantro and scallions.Create a hole in the noodles and scramble your eggs in the hole. Once cooked, mix the eggs in with the noodles. Add in vegetables, tofu, scallions, cilantro, and peanuts.Garnish with extra cilantro and serve with soy and chili sauce.
Category: Dinner
inspired by Madeline from Madeline E. Gorchels


Edge Class
Constructor
Edge
-
session
-
source
-
target
-
description
Parameters:
-
session
Object -
source
String -
target
String -
description
Object
Item Index
Properties
contribution
String
When determining if an element is "in distress" or not, the contribution of all supporting elements is considered during an update.
This must result in a number to be considered valid and is passed the status of the "source" and "target" as 0: Functional, 1: Warning, 2: Exception, or 3: Deactivated .
created
Number
creater
String
description
String
Markdown style string describing the element.
fields
Object
id
String
modified
Number
modifier
String
name
String
page
String
Links exist in distinct pages that may or may not be part of the master page. This allows resources to be expressed in different manners and for those manners to inherit a page or not.
private
Boolean
When true, this link is considered limited to the set and not the master list.
removed
Boolean
When true, this edge is no longer used when calculating support/dependency trees or event propagation, but it will still appear in searches and show in exploratory graphs and searches.


| PGEO-Physical Geography |
| NR |
14076 |
PGEO |
1030 |
001 |
24M |
4.000 |
Physical Geography |
MWF |
09:10 am-10:05 am |
24 |
10 |
14 |
0 |
0 |
0 |
Patricia Jean Boda (P) |
01/17-05/04 |
DSB 207 |
Credit from 4-Year College |
| |
|
|
|
|
|
|
|
M |
12:40 pm-02:40 pm |
|
|
|
|
|
|
Patricia Jean Boda (P) |
01/17-05/04 |
DSB 207 |
Credit from 4-Year College |
| NR |
14431 |
PGEO |
3000 |
001 |
24M |
3.000 |
Maps and Mapping |
TR |
09:40 am-11:05 am |
24 |
8 |
16 |
0 |
0 |
0 |
Patricia Jean Boda (P) |
01/17-05/04 |
DSB 208 |
Credit from 4-Year College and Upper-Division Work |
| NR |
14429 |
PGEO |
4000 |
001 |
24M |
3.000 |
Climatology and Climate Change |
MWF |
03:00 pm-03:55 pm |
32 |
10 |
22 |
0 |
0 |
0 |
James A Henry (P) |
01/17-05/04 |
DSB 103 |
Credit from 4-Year College and Upper-Division Work |
| NR |
14430 |
PGEO |
4010 |
001 |
24M |
3.000 |
Biogeography |
TR |
11:20 am-12:45 pm |
32 |
10 |
22 |
0 |
0 |
0 |
Patricia Jean Boda (P) |
01/17-05/04 |
DSB 103 |
Credit from 4-Year College and Upper-Division Work |
| NR |
14078 |
PGEO |
4490 |
001 |
24M |
4.000 |
Remote Sensing |
MWF |
10:20 am-12:00 pm |
24 |
18 |
6 |
0 |
0 |
0 |
James A Henry (P) |
01/17-05/04 |
DSB 208 |
Credit from 4-Year College and Upper-Division Work |
| C |
14079 |
PGEO |
4510 |
001 |
24M |
4.000 |
Laboratory Problems in Remote Sensing |
|
TBA |
5 |
6 |
-1 |
0 |
0 |
0 |
James A Henry (P) |
01/17-05/04 |
TBA TBA |
Credit from 4-Year College and Upper-Division Work |
| NR |
14080 |
PGEO |
4530 |
001 |
24M |
3.000 |
Geographic Information Systems |
T |
11:20 am-01:20 pm |
12 |
8 |
4 |
32 |
21 |
11 |
Jeremy W Aber (P) |
01/17-05/04 |
DSB 208 |
Credit from 4-Year College and Upper-Division Work |
| |
|
|
|
|
|
|
|
T |
02:40 pm-04:05 pm |
|
|
|
|
|
|
Jeremy W Aber (P) |
01/17-05/04 |
DSB 101 |
Credit from 4-Year College and Upper-Division Work |
| C |
14081 |
PGEO |
4530 |
002 |
24M |
3.000 |
Geographic Information Systems |
T |
02:40 pm-04:05 pm |
12 |
12 |
0 |
32 |
21 |
11 |
Jeremy W Aber (P) |
01/17-05/04 |
DSB 101 |
Credit from 4-Year College and Upper-Division Work |
| |
|
|
|
|
|
|
|
R |
11:20 am-01:20 pm |
|
|
|
|
|
|
Jeremy W Aber (P) |
01/17-05/04 |
DSB 208 |
Credit from 4-Year College and Upper-Division Work |
| NR |
14082 |
PGEO |
4560 |
001 |
24M |
3.000 |
Intermediate Geographic Information Systems |
MW |
06:00 pm-07:25 pm |
24 |
8 |
16 |
30 |
12 |
18 |
Jeremy W Aber (P) |
01/17-05/04 |
DSB 208 |
Credit from 4-Year College and Upper-Division Work |
| NR |
14085 |
PGEO |
5530 |
002 |
24M |
4.000 |
Geographic Information Systems |
T |
02:40 pm-04:05 pm |
4 |
1 |
3 |
32 |
21 |
11 |
Jeremy W Aber (P) |
01/17-05/04 |
DSB 101 |
|
| |
|
|
|
|
|
|
|
R |
11:20 am-01:20 pm |
|
|
|
|
|
|
Jeremy W Aber (P) |
01/17-05/04 |
DSB 208 |
|
| NR |
14083 |
PGEO |
5560 |
001 |
24M |
3.000 |
Intermediate Geographic Information Systems |
MW |
06:00 pm-07:25 pm |
6 |
4 |
2 |
30 |
12 |
18 |
Jeremy W Aber (P) |
01/17-05/04 |
DSB 208 |
|
| NR |
16480 |
PGEO |
6050 |
001 |
24M |
3.000 |
Programming for Geospatial Database Applications |
R |
06:00 pm-09:00 pm |
24 |
13 |
11 |
0 |
0 |
0 |
Henrique Garcia Momm (P) |
01/17-05/04 |
DSB 208 |
|
| NR |
14631 |
PGEO |
6060 |
001 |
24M |
3.000 |
Advanced Topics in Geosciences |
|
TBA |
10 |
2 |
8 |
0 |
0 |
0 |
Henrique Garcia Momm (P) |
01/17-05/04 |
TBA TBA |
|
| NR |
17588 |
PGEO |
6060 |
003 |
24M |
3.000 |
Advanced Topics in Geosciences |
MWF |
08:00 am-08:55 am |
2 |
1 |
1 |
0 |
0 |
0 |
Henrique Garcia Momm (P) |
01/17-05/04 |
DSB 208 |
|
| C |
17625 |
PGEO |
6060 |
004 |
24M |
3.000 |
Advanced Topics in Geosciences |
W |
06:50 am-07:45 am |
1 |
1 |
0 |
0 |
0 |
0 |
Racha El Kadiri (P) |
01/17-05/04 |
DSB 208 |
|
| NR |
15863 |
PGEO |
6070 |
001 |
24M |
3.000 |
Quantitative Methods in Geosciences |
MW |
04:10 pm-05:35 pm |
10 |
8 |
2 |
0 |
0 |
0 |
Henrique Garcia Momm (P) |
01/17-05/04 |
DSB 208 |
|


Posts have a key automatically generated from their name, and support short and extended versions of the content.
You can sign in using the demo account to contribute to the blog.
Example of how to set up a page that displays multiple image galleries.
Demonstrates usage of single and multi image fields and their resizing methods.
You can sign in using the demo account to create and manage image galleries, and upload additional images
Simple contact form that validates input and logs enquiries to the database.
You can sign in using the demo account to view the submitted enquiries.
For an example of how to download a list in .csv format, see /routes/download/users.js.
It uses the excellent node-csv library.
Download users.csvKeystoneJS isn't opinionated about how you design or build the front-end of your site. Use jQuery, Angular, React.js with LESS, SASS or css-modules and any node.js template language.


When working with the CARDIAC, we found it useful to allocate places in memory where we would store data while we were working on it. We often refer to these as variables. It's important to note that the way we use variables in computing is a little different than the way they are used in Math. Often in Math we'll make a statement like y =2 x and then use y as being equal to twice x for the rest of the proof or calculation we're working on. But that's not the way they work in programming. The best way to think of variables in programming is as a box where you can put something or take something out, but where that something doesn't automatically change while it's in there.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/Unable.20to.20unfold.html ---
I'm trying to prove the prime field addition that I defined is correct, but somehow I can't unfold the equation...
https://gist.github.com/potsrevennil/0cbf2204a8a16daa6eab367f153be748#file-primefield-lean-L71
from your definitions it looks like the proof is just eq.symm (add_equiv _)
if you want to get at this by unfolding, you should dsimp [pf.add, (+)]
, although this might unfold too much
normally we would state a simp lemma expressing the definitional unfolding here, exactly because it's hard to get at unless you say it explicitly
what's dism's usage?
And why is that I can unfold eq in add_equiv but not of_int_add?
because of_int_add
does not have the form of_int ... = of_int ...
you have to unfold the addition on the lhs first, then you can unfold eq
dsimp
and unfold
are very similar, they are implemented as the same tactic behind the scenes with different configuration options
in this case it's just because dsimp
accepts operators like (+)
for simplifying and unfold
doesn't
oh yes I should unfold addition first!
But after unfold add, I still cannot unfold eq....
Anyway eq.symm (add_equiv _)
is really a nice solution, thanks a lot!
Last updated: Apr 24 2020 at 19:02 UTC


-
Method for 3D modelling based on structure from motion processing of sparse 2D images
Singh, Yash,
Toldo, Roberto,
Magri, Luca,
Fantoni, Simone,
and Fusiello, Andrea
2019
-
Critical Loci for two views reconstruction as quadratic transformations between images
Bertolini, Marina,
Magri, Luca,
and Turrini, Cristina
Journal of Mathematical Imaging and Vision
2019
-
Improving Automatic Reconstruction of Interior Walls from Point Cloud Data
Maset, Eleonora,
Magri, Luca,
and Fusiello, Andrea
In International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences
2019
-
Fitting Multiple Heterogeneous Models by Multi-Class Cascaded T-Linkage
Magri, Luca,
and Fusiello, Andrea
In Proceedings of the IEEE Conference on Computer Vision and
Pattern Recognition
2019
-
A Matrix Decomposition Perspective on Calibrated Photometric Stereo
Magri, Luca,
Toldo, Roberto,
Castellani, Umberto,
and Fusiello, Andrea
In Proceedings of the International Conference on Image
Analysis and Processing
2017
-
Bending the doming effect in structure from motion reconstructions through bundle adjustment
Magri, Luca,
and Toldo, Roberto
In The International Archives of Photogrammetry, Remote Sensing and Spatial Information Sciences
2017
-
Multiple structure recovery with T-linkage
Magri, Luca,
and Fusiello, Andrea
Journal of Visual Communication and Image Representation
2017
-
Multiple structure recovery via robust preference analysis
Magri, Luca,
and Fusiello, Andrea
Image and Vision Computing
2017
-
Multiple model fitting as a set coverage problem
Magri, Luca,
and Fusiello, Andrea
In Proceedings of the IEEE Conference on Computer Vision and
Pattern Recognition
2016
-
Multiple structure recovery via probabilistic biclustering
Denitto, Matteo,
Magri, Luca,
Farinelli, Alessandro,
Fusiello, Andrea,
and Bicego, Manuele
In Joint IAPR International Workshops on Statistical Techniques in Pattern Recognition and Structural and Syntactic Pattern Recognition
2016
-
Method for detecting a straight line in a digital image
Magri, Luca,
Rossi, Beatrice,
Tripathi, Subarna,
Fragneto, Pasqualina,
and Piccinelli, Emiliano Mario
2016
-
Robust Multiple Model Fitting with Preference Analysis and Low-rank Approximation
Magri, Luca,
and Fusiello, Andrea
In British Machine Vision Conference
2015
-
Scale estimation in multiple models fitting via Consensus Clustering
Magri, Luca,
and Fusiello, Andrea
In Proceedings of the International Conference on Computer Analysis of Images and Patterns
2015
-
Fitting Multiple Models via Density Analysis in Tanimoto Space
Magri, Luca,
and Fusiello, Andrea
In Proceedings of the International Conference on Image
Analysis and Processing
2015
-
J-DFA: A Novel Approach for Robust Differential Fault Analysis
Magri, Luca,
Mella, Silvia,
Fragneto, Pasqualina,
Melzani, Filippo,
and Rossi, Beatrice
In Workshop on Fault Diagnosis and Tolerance in Cryptography
2015


§206E-11 Construction contracts. The authority shall award construction contracts in conformity with the applicable provisions of chapter 103D. [L 1976, c 153, pt of §1; am L Sp 1993, c 8, §54]


Hello Devs! 😁
community.codehangar is a community that drives balance and diversity in the tech world by supporting women who create software technologies. Our goal is to increase visbility for ladies who code and connect female talent with great opportunities.
weVENTURE Orlando presents Orlando Women Who Code. More and more Orlando companies are seeking female developer talent to bring better products to market. Let’s explore how to fill the pipeline, connect current female talent to great opportunities & help our companies build cultures that attract female talent.
RegisterGirls Who Code programs work to inspire, educate, and equip girls with the computing skills to pursue 21st century opportunities. This summer girls in Orlando will have the opportunity to learn about computer science in a fun immersive way at the Melrose center in the Orange County Public Library downtown.
Learn MoreJoin the Code Hangar Slack group to connect with like minded code crafters in an environment where its okay to make mistakes and learning through breaking stuff is encouraged.


1.
2.
3.
OK!
"Consciously spending a few minutes each day focusing on some of the good things that happen can help us notice what goes right as well as wrong in our lives. Even on a bad day there are some good things that happen, however small." -Action For Happiness
This daily exercise has been recommended by Lifehacker, Action For Happiness, Lift, Live More Awesome, Happier Human, and Good.is. The goal of this site is to help spread the idea and give people an alternative to physically writing things down.
This is meant to be a reflection on what happened today. Once you leave or refresh this page, your information will not be saved. You won't be able to access what you've entered in the past, but you also don't have to worry about anyone discovering the intimate details of your life this way. Contact the creator of this site at<EMAIL_ADDRESS>I don't even know what a quail looks like.


How to Play:
- Enter a number in the field below.
- Your number will appear in a list at the bottom of the page.
There are a few exceptions to how your number will appear on the page:
- If you number is divisible by 3 it will become "ping"
- If your number is divisible by 5 it will become "pong"
- If your number is divisble by 3 and 5 it will become "pingpong"


Have your prerequisites ready, after following the install instructions for all of the prerequisites
When NodeJS is installed you have access to NPM as well, which is quite useful to install all your modules
Start with running npm init
. This will initialize your package.json
file which holds all the information for the packages included in your projects.
After filling out all the questions from the npm init
command you can start getting the packages you want.
Some modules need to be installed globally, do that by adding the -g
flag.
Use npm install PACKAGENAME
to install a package, if you want to save that to your package.json file (most of the times you want that) just add the --save
flag.
If the package is only needed during development, you add the --save-dev
flag.
Let's take an example to get started without going into to much detail, we want to use AngularJS in our project
npm install angular --save
node_modules/
folder and saves that instruction to your package.json file <script src="/node_modules/angular/angular.js"></script>
Wire it up with what you want basically: PHP, Java or use Javascript for the backend as well (which is what NodeJS is for).
You can automate a lot of things, build tools are here to do the heavy lifting for you or to automate tasks
Let us take Grunt as an example
npm install -g grunt-cli
npm install grunt --save-dev
gruntfile.js
file, this is where you define your tasks which you can then call with the grunt TASK
command depending how you set it upAll the build tools work in the same way, eventually it depends on personal preference or whatever you choose and stick to.
Yes you have more than project package managing, you also have front-end package managing, as if it wasn't confusing enough already, let's introduce Bower.
Bower is a package manager for things that are used on the front-end, so the things that might show up on the website / application itself or referenced to when you do view source
in your browser.
Examples are: Jquery, AngularJS, Font Awesome etc


book-a-lock results from a unique combination of Antwerp brains and skills, brought together by the Port of Antwerp Hackaton 2016. Together, SAP developers from Flexso and port experts from the University of Antwerp and AP Hogeschool built the future of the Port's inland vessel management.
Our solution for a better berth management? A mobile app for optimizing barge/ship routes through the port and docks, booking timeslots to pass through one or more locks, and finding dock parking spots close to your embarkment spot fully automatically.


Locomotives
Object ID
Name
Protocol
Address
Speedstep (max)
No. of Functions
Duration
{{LOCOMOTIVE_ROWS}}
Accessories
Coord
Object ID
Type
Name
Ecos Address
Ecos Address (ext.)
Port 1
Address 1
Inverse 1
Port 2
Address 2
Inverse 2
Protocol
Switch Count
Maintenance
{{ACCESSORY_ROWS}}
Sensors (S88)
Coord
Name
Address
{{SENSOR_ROWS}}


Dayo-Ajobiewe
Front-End Developer
I am Dayo-Ajobiewe Hope, front-end developer with a mastery of HTML, CSS, javaScript, jQuery, Bootstrap, SASS and React.
Projects
Markdown Previewer
Built using React.js, HTML, CSS and Bootstrap. This projects converts any text written in mardown in the comment section to plain HTML. Check it out on Codepen.
Random Quote Machine
Built using HTML, CSS, jQuery, Bootstrap and Font-awesome. This project displays a new random quote every time the new button is clicked. Check it out on Codepen.
Technical Documentation Page
This technical page documents information about javaScript array methods. Built using HTML, CSS and vanilla javaScript. Check it out on Codepen.
Javascript Calculator
This was one of my most challenging projects learning on freeCodeCamp. I had fun building this calculator and it taught me a lot about javaScript. Built using jQuery, HTML, CSS and Bootstrap. Check it out on Codepen.
Casa De Tickets
Built with HTML, CSS, Font-awesome to develop a product landing page for an online movie ticket vendor. Check it out on Codepen.
Survey Form
This form was built for conducting surveys. Built using Bootstrap, CSS and HTML. Check it out on Codepen.
Drum-pad Machine
Built using React.js, Bootstrap and CSS. This drumpad machine produces fun and amazing drum sounds for you to produce amazing beats easily and efficiently. Check it out on Codepen.
About Developer
I am a front-end web developer from Nigeria with a zeal for learning and building user-friendly websites and web-based applications. I was introduced to web-development by a friend and i must say it's been a very rewarding journey. I joined freeCodeCamp and started learning based on their curriculum while also taking advantage of other resources like w3schools.com mdn.com and treehouse.com. For my front-end development, i love to utilize vanilla javaScript and jQuery for amazing delivery. I am comfortable using the popular javaScript framework React for handling user interface. I employ bootstrap in most of my work because it's an amazing library and a very useful tool, i beautify my websites with CSS3 and SASS. Other than coding i enjoy seeing movies, reggeaton and i'm a loyal chelsea fan. You can reach me via my contacts below to discuss coding ideas, build software together or to rap about football.
Contact Me
Ekiti State, Nigeria
<EMAIL_ADDRESS>08166179988


There are dozens of different potato varieties.
They are usually described as early, second early and maincrop potatoes.


Game Dev 2021 For Ellis
by Kai Teshima
My Github
My Github index
T3A01-students-kai
T3A02-what-i-know-kai
T3A03-webpage-kai
T3A04-Resource-Links-by-Kai
T3A05-forms-kai
T3A06-CSS-by-kai
T3A07-code-kai
T3A08-Overview-kai
T3A09-Events-Kai
T3A10-inOut-Kai
T3A11-Variables-Kai
T3A12-Decisions-if-kai
T3A13-functions-Kai
T3A14-for-loop-Kai
T3A15-arrays-kai
T3A16-objects-kai
T3A17-bonus-class-kai
T4-A01-game-level1-kai
t4-A02-maze-kai
T4-A03-win-and-checkall-kAI
T4A04-WASD-Fred
T4A05-continuous-bounce-kai
T4A06-scoring-kai
T4A07-Random-auto-move-kai
T4A08-auto-background-easy-kai
T4A09-auto-background-better-kai
T4A10-continuous-gravity-kai
T4A11-console.log-kai
t4a12-canvas-kai
T4A13-rotate-kai
T4A14-image-drag-kai
T4A15-snake-kai
T4A16-bullet-kai
Ml Index
Level1
Level2
Level3


Two former Houston police officers arrested over a deadly drug raid
by Louis CasianoTwo former Houston police officers who allegedly provide false information that led to a deadly drug raid earlier this year have been arrested, authorities said Wednesday.
Gerald Goines and his partner, Steven Bryant, along with civilian Patricia Garcia, were taken into custody in connection with the Jan. 28 raid on a home that left two people dead and several officers wounded, the Justice Department said in a statement.
Rhogena Nicholas, 58, and Dennis Tuttle, 59, were killed in the raid on their home. Goines was shot during the chaos.
Goines, 55, is charged with seven counts, including making up an informant who he said purchased drugs from the home and lying in a search warrant affidavit. He later admitted to buying the drugs himself, authorities said.
Bryant, 46, is charged with falsifying records, including claiming he'd identified as heroin a substance that was bought at the home before the raid.
CHIEF: OFFICER LIED IN AN AFFIDAVIT BEFORE DEADLY HOUSTON RAID
Garcia, 53, is charged with giving false information when she called 911, claiming that the people inside the home were drug dealers and that they were using crack and heroin inside, federal prosecutors said. She also claimed that she could see her daughter inside the home, according to the DOJ.
Her call led police to the residence.
When officers entered the home, gunfire erupted, leading to the deaths of Tuttle and Nicholas and the wounding of five officers.
One officer was paralyzed.
During an investigation, police said they realized Goines had made up the informant when they couldn't find him.
PROBE OF CASES FROM HOUSTON OFFICERS IN DEADLY RAID EXPANDED
Houston Police Chief Art Acevedo maintained that the officers had a reason to be in the home.
“We cannot change what happened. We can’t go back in time. But we have an absolute duty to pursue the truth, pursue the facts,” he said at a Wednesday news conference.
Police found small amounts of marijuana and cocaine in the house, but no heroin. Family and friends of Tuttle and Nicolas claim the couple never sold drugs.
Both officers also face state charges. They were expected to appear in federal court on Wednesday.
The Harris County District Attorney's Office said it was "not uncommon" for federal and local authorities to pursue charges against defendants, The Houston Chronicle reported.
“We all want to flesh out all the facts, all the evidence,” said spokesman Dane Schiller, “and ensure that the truth is known.”
 Garcia faces a maximum five-year sentence.
Both officers were relieved of duty after the raid and retired.


--- title: JSXGraph Conference - October 2020 description: Coming soon... background_image: /uploads/2015/campus-luftbild.jpg sponsors: - label_image: /uploads/Sponsors/eu_flag_co_funded_pos_rgb_left.jpg title: Erasmus+ link: https://www.erasmusplus.de/ - label_image: /uploads/Sponsors/items_logo_blue.png title: ITEMS project link: https://itemspro.eu/ - label_image: /uploads/Sponsors/items_logo_red.gif title: ITEMS project link: https://itemspro.eu/ _options: label_image: width: 400 height: 400 image: width: 600 height: 1200 ---
Coming Soon...


Product code 254326
Size: 10 years
Qty: 1
order$1149.84
Delivery$12
TOTAL$1161.84
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.
It is a long established fact that a reader will be distracted by the readable content.


Browser Statistics
What is the trend in browser usage?
Browser Statistics and Trends
Statistics are important information.
From the statistics below (collected from W3Schools' log-files since 2002),
you can read the long term trends of browser usage.
We see that Google Chrome, Firefox, and Internet Explorer are the most used browsers today.
Browser Statistics
Click on the browser names to see detailed browser information:
| 2015 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
68.0 % |
6.3 % |
19.1 % |
3.7 % |
1.5 % |
| November |
67.4 % |
6.8 % |
19.2 % |
3.9 % |
1.5 % |
| October |
66.5 % |
6.9 % |
20.0 % |
3.8 % |
1.4 % |
| September |
65.9 % |
7.2 % |
20.6 % |
3.6 % |
1.4 % |
| August |
64.0 % |
6.6 % |
21.2 % |
4.5 % |
2.2 % |
| July |
63.3 % |
6.5 % |
21.6 % |
4.9 % |
2.5 % |
| June |
64.8 % |
7.1 % |
21.3 % |
3.8 % |
1.8 % |
| May |
64.9 % |
7.1 % |
21.5 % |
3.8 % |
1.6 % |
| April |
63.9 % |
8.0 % |
21.6 % |
3.8 % |
1.5 % |
| March |
63.7 % |
7.7 % |
22.1 % |
3.9 % |
1.5 % |
| February |
62.5 % |
8.0 % |
22.9 % |
3.9 % |
1.5 % |
| January |
61.9 % |
7.8 % |
23.4 % |
3.8 % |
1.6 % |
| 2014 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
61.6 % |
8.0 % |
23.6 % |
3.7 % |
1.6 % |
| November |
60.1 % |
9.8 % |
23.4 % |
3.7 % |
1.6 % |
| October |
60.4 % |
9.5 % |
23.4 % |
3.9 % |
1.6 % |
| September |
59.6 % |
9.9 % |
24.0 % |
3.6 % |
1.6 % |
| August |
60.1 % |
8.3 % |
24.7 % |
3.7 % |
1.8 % |
| July |
59.8 % |
8.5 % |
24.9 % |
3.5 % |
1.7 % |
| June |
59.3 % |
8.8 % |
25.1 % |
3.7 % |
1.8 % |
| May |
59.2 % |
8.9 % |
24.9 % |
3.8 % |
1.8 % |
| April |
58.4 % |
9.4 % |
25.0 % |
4.0 % |
1.8 % |
| March |
57.5 % |
9.7 % |
25.6 % |
3.9 % |
1.8 % |
| February |
56.4 % |
9.8 % |
26.4 % |
4.0 % |
1.9 % |
| January |
55.7 % |
10.2 % |
26.9 % |
3.9 % |
1.8 % |
| 2013 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
55.8 % |
9.0 % |
26.8 % |
3.8 % |
1.9 % |
| November |
54.8 % |
10.5 % |
26.8 % |
4.0 % |
1.8 % |
| October |
54.1 % |
11.7 % |
27.2 % |
3.8 % |
1.7 % |
| September |
53.2 % |
12.1 % |
27.8 % |
3.9 % |
1.7 % |
| August |
52.9 % |
11.8 % |
28.2 % |
3.9 % |
1.8 % |
| July |
52.8 % |
11.8 % |
28.9 % |
3.6 % |
1.6 % |
| June |
52.1 % |
12.0 % |
28.9 % |
3.9 % |
1.7 % |
| May |
52.9 % |
12.6 % |
27.7 % |
4.0 % |
1.6 % |
| April |
52.7 % |
12.7 % |
27.9 % |
4.0 % |
1.7 % |
| March |
51.7 % |
13.0 % |
28.5 % |
4.1 % |
1.8 % |
| February |
50.0 % |
13.5 % |
29.6 % |
4.1 % |
1.8 % |
| January |
48.4 % |
14.3 % |
30.2 % |
4.2 % |
1.9 % |
| 2012 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
46.9 % |
14.7 % |
31.1 % |
4.2 % |
2.1 % |
| November |
46.3 % |
15.1 % |
31.2 % |
4.4 % |
2.0 % |
| October |
44.9 % |
16.1 % |
31.8 % |
4.3 % |
2.0 % |
| September |
44.1 % |
16.4 % |
32.2 % |
4.2 % |
2.1 % |
| August |
43.7 % |
16.2 % |
32.8 % |
4.0 % |
2.2 % |
| July |
42.9 % |
16.3 % |
33.7 % |
3.9 % |
2.1 % |
| June |
41.7 % |
16.7 % |
34.4 % |
4.1 % |
2.2 % |
| May |
39.3 % |
18.1 % |
35.2 % |
4.3 % |
2.2 % |
| April |
38.3 % |
18.3 % |
35.8 % |
4.5 % |
2.3 % |
| March |
37.3 % |
18.9 % |
36.3 % |
4.4 % |
2.3 % |
| February |
36.3 % |
19.5 % |
37.1 % |
4.5 % |
2.3 % |
| January |
35.3 % |
20.1 % |
37.2 % |
4.3 % |
2.4 % |
| 2011 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
34.6 % |
20.2 % |
37.7 % |
4.2 % |
2.5 % |
| November |
33.4 % |
21.2 % |
38.1 % |
4.2 % |
2.4 % |
| October |
32.3 % |
21.7 % |
38.7 % |
4.2 % |
2.4 % |
| September |
30.5 % |
22.9 % |
39.7 % |
4.0 % |
2.2 % |
| August |
30.3 % |
22.4 % |
40.6 % |
3.8 % |
2.3 % |
| July |
29.4 % |
22.0 % |
42.0 % |
3.6 % |
2.4 % |
| June |
27.9 % |
23.2 % |
42.2 % |
3.7 % |
2.4 % |
| May |
25.9 % |
24.9 % |
42.4 % |
4.0 % |
2.4 % |
| April |
25.6 % |
24.3 % |
42.9 % |
4.1 % |
2.6 % |
| March |
25.0 % |
25.8 % |
42.2 % |
4.0 % |
2.5 % |
| February |
24.1 % |
26.5 % |
42.4 % |
4.1 % |
2.5 % |
| January |
23.8 % |
26.6 % |
42.8 % |
4.0 % |
2.5 % |
| 2010 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
22.4 % |
27.5 % |
43.5 % |
3.8 % |
2.2 % |
| November |
20.5 % |
28.6 % |
44.0 % |
4.0 % |
2.3 % |
| October |
19.2 % |
29.7 % |
44.1 % |
3.9 % |
2.2 % |
| September |
17.3 % |
31.1 % |
45.1 % |
3.7 % |
2.2 % |
| August |
17.0 % |
30.7 % |
45.8 % |
3.5 % |
2.3 % |
| July |
16.7 % |
30.4 % |
46.4 % |
3.4 % |
2.3 % |
| June |
15.9 % |
31.0 % |
46.6 % |
3.6 % |
2.1 % |
| May |
14.5 % |
32.2 % |
46.9 % |
3.5 % |
2.2 % |
| April |
13.6 % |
33.4 % |
46.4 % |
3.7 % |
2.2 % |
| March |
12.3 % |
34.9 % |
46.2 % |
3.7 % |
2.2 % |
| February |
11.6 % |
35.3 % |
46.5 % |
3.8 % |
2.1 % |
| January |
10.8 % |
36.2 % |
46.3 % |
3.7 % |
2.2 % |
| 2009 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
9.8 % |
37.2 % |
46.4 % |
3.6 % |
2.3 % |
| November |
8.5 % |
37.7 % |
47.0 % |
3.8 % |
2.3 % |
| October |
8.0 % |
37.5 % |
47.5 % |
3.8 % |
2.3 % |
| September |
7.1 % |
39.6 % |
46.6 % |
3.6 % |
2.2 % |
| August |
7.0 % |
39.3 % |
47.4 % |
3.3 % |
2.1 % |
| July |
6.5 % |
39.4 % |
47.9 % |
3.3 % |
2.1 % |
| June |
6.0 % |
40.7 % |
47.3 % |
3.1 % |
2.1 % |
| May |
5.5 % |
41.0 % |
47.7 % |
3.0 % |
2.2 % |
| April |
4.9 % |
42.1 % |
47.1 % |
3.0 % |
2.2 % |
| March |
4.2 % |
43.3 % |
46.5 % |
3.1 % |
2.3 % |
| February |
4.0 % |
43.6 % |
46.4 % |
3.0 % |
2.2 % |
| January |
3.9 % |
44.8 % |
45.5 % |
3.0 % |
2.3 % |
| 2008 |
Chrome |
IE |
Firefox |
Safari |
Opera |
| December |
3.6 % |
46.0 % |
44.4 % |
2.7 % |
2.4 % |
| November |
3.1 % |
47.0 % |
44.2 % |
2.7 % |
2.3 % |
| October |
3.0 % |
47.4 % |
44.0 % |
2.8 % |
2.2 % |
| September |
3.1 % |
49.0 % |
42.6 % |
2.7 % |
2.0 % |
| August |
|
51.0 % |
43.7 % |
2.6 % |
2.1 % |
| July |
|
52.4 % |
42.6 % |
2.5 % |
1.9 % |
| June |
|
54.2 % |
41.0 % |
2.6 % |
1.7 % |
| May |
|
54.4 % |
39.8 % |
2.4 % |
1.5 % |
| April |
|
54.8 % |
39.1 % |
2.2 % |
1.4 % |
| March |
|
53.9 % |
37.0 % |
2.1 % |
1.4 % |
| February |
|
54.7 % |
36.5 % |
2.0 % |
1.4 % |
| January |
|
54.7 % |
36.4 % |
1.9 % |
1.4 % |
| 2007 |
Mozilla |
IE |
Firefox |
Safari |
Opera |
| November |
1.2 % |
56.0 % |
36.3 % |
1.8 % |
1.6 % |
| September |
1.2 % |
57.2 % |
35.4 % |
1.6 % |
1.5 % |
| July |
1.4 % |
58.5 % |
34.5 % |
1.5 % |
1.9 % |
| May |
1.3 % |
58.9 % |
33.7 % |
1.5 % |
1.7 % |
| March |
1.3 % |
58.7 % |
31.8 % |
1.6 % |
1.6 % |
| January |
1.5 % |
58.6 % |
31.0 % |
1.7 % |
1.5 % |
| 2006 |
Mozilla |
IE |
Firefox |
Netscape |
Opera |
| November |
2.5 % |
60.6 % |
29.9 % |
0.2 % |
1.5 % |
| September |
2.3 % |
62.1 % |
27.3 % |
0.4 % |
1.6 % |
| July |
2.3 % |
62.4 % |
25.5 % |
0.4 % |
1.4 % |
| May |
2.3 % |
63.0 % |
25.7 % |
0.3 % |
1.5 % |
| March |
2.4 % |
64.7 % |
24.5 % |
0.5 % |
1.5 % |
| January |
3.1 % |
66.0 % |
25.0 % |
0.5 % |
1.6 % |
| 2005 |
Mozilla |
IE |
Firefox |
Netscape |
Opera |
| November |
2.8 % |
68.9 % |
23.6 % |
0.4 % |
1.5 % |
| September |
2.5 % |
75.5 % |
18.0 % |
0.4 % |
1.2 % |
| July |
2.6 % |
73.8 % |
19.8 % |
0.5 % |
1.2 % |
| May |
3.1 % |
71.6 % |
21.0 % |
0.7 % |
1.3 % |
| March |
3.3 % |
72.5 % |
18.9 % |
1.0 % |
1.9 % |
| January |
3.4 % |
74.5 % |
16.6 % |
1.1 % |
1.9 % |
| 2004 |
Mozilla |
IE |
Netscape |
Opera |
| November |
16.5 % |
76.2 % |
1.7 % |
1.6 % |
| September |
13.7 % |
79.0 % |
2.0 % |
1.7 % |
| July |
12.6 % |
80.4 % |
2.2 % |
1.6 % |
| May |
9.5 % |
81.9 % |
2.4 % |
1.6 % |
| March |
7.9 % |
82.8 % |
2.8 % |
1.4 % |
| January |
5.5 % |
84.7 % |
2.4 % |
1.5 % |
| 2003 |
Mozilla |
IE |
Netscape |
Opera |
| November |
7.2 % |
84.9 % |
2.6 % |
1.9 % |
| September |
6.2 % |
86.6 % |
2.7 % |
1.8 % |
| July |
5.7 % |
87.2 % |
2.7 % |
1.7 % |
| May |
4.6 % |
87.7 % |
3.3 % |
1.4 % |
| March |
4.2 % |
88.0 % |
3.4 % |
1.2 % |
| January |
4.0 % |
84.6 % |
4.0 % |
|
| 2002 |
AOL |
IE |
Netscape |
| November |
5.2 % |
83.4 % |
8.0 % |
| September |
4.5 % |
83.5 % |
8.0 % |
| July |
3.5 % |
84.5 % |
7.3 % |
| May |
2.8 % |
86.7 % |
7.3 % |
| March |
3.0 % |
86.1 % |
7.7 % |
| January |
2.8 % |
85.8 % |
7.9 % |
- IE = Microsoft Internet Explorer
- Firefox = Mozilla Firefox (identified as Mozilla before 2005)
- Chrome = Google Chrome
- Mozilla = The Mozilla Suite (Gecko, Netscape)
- Safari = Apple Safari (and Konqueror. Both identified as Mozilla before 2007)
- Opera = Opera (from 2011; Opera Mini is included here)
- Netscape = Netscape Navigator (identified as Mozilla after 2006)
- AOL = America Online (based on both Internet Explorer and Mozilla)
Statistics Can Be Misleading
You cannot - as a web developer - rely ONLY on statistics. Statistics can be misleading.
Note: W3Schools is a website for people with an interest for web technologies.
These people are more interested in using alternative browsers than the average
user. The average user tends to use the browser that comes
preinstalled with their computer, and do not seek out other browser alternatives.
Tip: Global averages may not be relevant to your web site. Different sites
attract different audiences. Some web sites attract professional developers
using professional hardware, while other sites attract hobbyists using old computers.
Anyway, our data, collected from W3Schools' log-files over many years, clearly shows the long
term trends.
Other Statistics
Operating system statistics
Screen resolution statistics
Quotes
"The pure and simple truth is rarely pure and never simple."


>
An authentic Italian pizza is perfection at 5 different levels – the base, the sauce, the cheese, the toppings and last but not the least – the pizza chef.
Prior to 2012, the record for World's Largest Pizza was held by Norwood Hypermarket in South Africa. In 2012, a group of chefs from NIPfood in Rome, Italy broke the record with a massive pizza with a surface area of 13,580.28 square feet. They even named the pizza Ottavia after the Octavian Augustus, a Roman emperor. Almost 20,000 pounds of flour and 10,000 pounds of mozzarella cheese went into Ottavia's production. Amazingly, the pizza was 100 percent gluten-free!


Template engines
{% include warning.html content=“The packages listed below may be
outdated, no longer maintained or even broken. Listing here does not
constitute an endorsement or recommendation from the Expressjs project
team. Use at your own risk.” %}
These template engines work “out-of-the-box” with Express:
-
Pug: Haml-inspired template engine (formerly Jade).
-
Haml.js: Haml implementation.
-
EJS: Embedded JavaScript template engine.
-
hbs: Adapter for Handlebars.js, an extension of Mustache.js template
engine.
-
Squirrelly: Blazing-fast template engine that supports partials, helpers, custom
tags, filters, and caching. Not white-space sensitive, works with any
language.
-
Eta: Super-fast lightweight embedded JS template engine. Supports custom
delimiters, async, whitespace control, partials, caching, plugins.
-
React: Renders React components on the server. It renders static markup and
does not support mounting those views on the client.
-
combyne.js: A template engine that hopefully works the way you’d expect.
-
Nunjucks: Inspired by jinja/twig.
-
marko: A fast and lightweight HTML-based templating engine that compiles
templates to CommonJS modules and supports streaming, async rendering
and custom tags. (Renders directly to the HTTP response stream).
-
whiskers: Small, fast, mustachioed.
-
Blade: HTML Template Compiler, inspired by Jade & Haml.
-
Haml-Coffee: Haml templates where you can write inline CoffeeScript.
-
express-hbs: Handlebars with layouts, partials and blocks for express 3 from Barc.
-
express-handlebars: A Handlebars view engine for Express which doesn’t suck.
-
express-views-dom: A DOM view engine for Express.
-
rivets-server: Render Rivets.js templates on the server.
-
LiquidJS: A simple, expressive and safe template engine.
-
express-tl: A template-literal engine implementation for Express.
-
Twing: First-class Twig engine for Node.js.
-
Sprightly: A very light-weight JS template engine (45 lines of code), that
consists of all the bare-bones features that you want to see in a
template engine.
The
Consolidate.js library
unifies the APIs of these template engines to a single Express-compatible
API.
Add your template engine here!
Edit the Markdown file
and add a link to your project, then submit a pull request (GitHub login
required). Follow the format of the above listings.


Some quick example text to build on the card title and make up the bulk of the card's content.
Sobre nós
Lorem ipsum dolor sit amet consectetur adipisicing elit. Nesciunt maiores officiis accusamus earum minus fuga
eum voluptatibus ad dolore libero, unde vel perferendis nisi nostrum, atque accusantium error exercitationem
quos eos nulla quam quas pariatur! Obcaecati voluptatem ipsum magnam totam.
Nossos projetos
Some quick example text to build on the card title and make up the bulk of the card's content.
Some quick example text to build on the card title and make up the bulk of the card's content.
Some quick example text to build on the card title and make up the bulk of the card's content.
Some quick example text to build on the card title and make up the bulk of the card's content.
Some quick example text to build on the card title and make up the bulk of the card's content.


Survey summary
Author: Klaudia Olejniczak
Presentation plan:
- General information about respondents
- Internet use
- Internet anxiety and Internet identifications
- Internet security
- Conclusions
- Q&A
General information about respondents
100 respondends
91 Poles
8 Ukrainians
1 German
Age
Gender
Internet Use
How often do people use Internet?
When do people use Internet?
ANSWER: Almost all the time
The most popular activities in the Internet
First generation of digital Natives
Second generation of digital Natives
Internet Anxiety and Internet ID
Anxiety versus Social Networks
How anxious do people feel about posting with their real name
How anxious do people feel about posting something controversial under their real name
Using real names in the Internet
Using real pictures in the Internet
Internet Security
Do people feel safe in the Internet?
Do people feel that they have enough knowleadge about the Internet to make this decisions
1. People(Mostly students) ale always connected to the Internet
2. People are quite anxious about posting, but they do it anyway.
3. People are confused about their knowledge of the Internet Security
1. Do you see any aspect of the topic that was not researched enough?
2. Do you think that the scale was understandable? Do you have suggestions how to improve it?
3. Do you think that some of the questions could be misunderstood?
References:
- Joiner, R., Gavin, J., Brosnan, M., Cromby, J., Gregory,
H., Guiller, J., Maras, P. and Moon, A. (2013). Comparing First and Second Generation Digital Natives’ Internet Use, Internet Anxiety, and Internet Identification. Cyberpsychology, Behavior, and Social Networking, 16 (7).
Retrieved from: https://www.ncbi.nlm.nih.gov/pubmed/23675995
- Olejniczak, K., Kuzhel, O., Kubicki, D. (Interviewers) and Citizens of Krakow (Interviewee). (2016). Survey [Survey transcript].
Retrieved from google survey site: https://docs.google.com/forms/d/1xlVDImukfItNIvdoJssWLDzTXl72TlEuQVZfVS-5FLU