So as I’ve mentioned before, my day job involves a rather large web content management system by these guys, and it runs on a fairly common (for enterprise-level stuff) hybrid of native code, J2EE, XML and Perl. Add to that the resources that make the website itself shiny like stylesheets and javascripts, and there’s no possible way you could come up with a consistent method of documenting all that code, right? Right?
Wrong. One of my colleagues (Hi Alex!) passed this link around earlier in the week:
Natural Docs is (as they put it) “an open-source, extensible, multi-language documentation generator. You document your code in a natural syntax that reads like plain English. Natural Docs then scans your code and builds high-quality HTML documentation from it.”
Boom. Right there. If it supported Objective C, I would be utterly, totally sold on using this in everything I do.
 Sure, I can spell. I have pretty decent grammar (most of the time). Generally I don’t misplace my punctuation (Hello everyone younger than me, I’m looking at you!). And when push comes to shove, my documentation doesn’t suck when I actually write it - but actually sitting down and spending time writing it in the first place? Puhleeease (Yes, I can see all you corporate IT managers shaking your heads up the back there. Deal with it, programmers like to program, not cover your arses). By the way, I’m talking about serious post-code documentation here - anyone who’s ever worked on anything larger than “Hello, world!” will tell you how important specifications are to the success of any software project - I don’t believe Natural Docs have quite perfected the whole “suck the idea out of you and your client’s heads and document it for you” module just yet.
I may just have to look into what’s involved in adding Objective C support to Natural Docs, because this could be the beginning of a beautiful friendship!


== Threat Capability Analysis ==
Once a threat community has been identified, the capabilities of said community must also be analyzed in order to build an accurate threat model that reflects the actual probability of such a community/agent to successfully act upon the organization and compromise it.
This analysis requires both a technical analysis as well as an opportunity analysis (where applicable).


ProcessGroup
| Kind of class: | public class |
|---|---|
| Package: | |
| Inherits from: |
|
| Known subclasses: | |
| Version: | 02/09/10 |
| Author: | Aaron Clinger |
| Classpath: | org.casalib.process.ProcessGroup |
| File last modified: | Friday, 20 May 2011, 00:59:45 |
► View source▼ Hide source
/* CASA Lib for ActionScript 3.0 Copyright (c) 2011, Aaron Clinger & Contributors of CASA Lib All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Neither the name of the CASA Lib nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package org.casalib.process { import org.casalib.events.ProcessEvent; import org.casalib.process.Process; import org.casalib.util.ArrayUtil; /** Manages and threads {@link Process processes}. @author Aaron Clinger @version 02/09/10 @examplepackage { import fl.motion.easing.Linear; import org.casalib.display.CasaMovieClip; import org.casalib.display.CasaSprite; import org.casalib.events.ProcessEvent; import org.casalib.process.ProcessGroup; import org.casalib.transitions.PropertyTween; public class MyExample extends CasaMovieClip { protected var _processGroup:ProcessGroup; public function MyExample() { super(); this._processGroup = new ProcessGroup(); this._processGroup.addEventListener(ProcessEvent.COMPLETE, this._onProcessComplete); var i:int = -1; var box:CasaSprite; while (++i < 10) { box = new CasaSprite(); box.y = 30 * i; box.graphics.beginFill(0xFF00FF); box.graphics.drawRect(0, 0, 25, 25); box.graphics.endFill(); this.addChild(box); this._processGroup.addProcess(new PropertyTween(box, 'x', Linear.easeNone, 500, 1)); } this._processGroup.start(); } protected function _onProcessComplete(e:ProcessEvent):void { this._processGroup.destroyProcesses(); this._processGroup.destroy(); trace("Done!"); } } }
*/ public class ProcessGroup extends Process { public static var NORM_THREADS:uint = 1; /**< The default amount of threads for all ProcessGroup instances. */ public static const MAX_THREADS:uint = uint.MAX_VALUE; /**< The maximum amount of threads for a ProcessGroup instance. Use this value if you wish to disable threading. */ protected var _threads:uint; protected var _processes:Array; protected var _autoStart:Boolean; /** Creates a new ProcessGroup. */ public function ProcessGroup() { super(); this.threads = ProcessGroup.NORM_THREADS; this._processes = new Array(); } override public function start():void { super.start(); this._checkThreads(); } override public function stop():void { this._isRunning = false; var l:uint = this._processes.length; while (l--) { if (this._processes[l].running) { this._processes[l].stop(); return; } } super.stop(); } /** Instructs the ProcessGroup to {@link #start} automatically if it contains an incomplete {@link Process} or if an incomplete is {@link Process#addProcess added}. */ public function get autoStart():Boolean { return this._autoStart; } public function set autoStart(autoStart:Boolean):void { this._autoStart = autoStart; if (!this.completed && !this.running) this.start(); } /** Adds a process to be threaded and run by the ProcessGroup. @param process: The process to be added and run by the group. @usageNote You can add a different instance of ProcessGroup to another ProcessGroup. @throwsError
if you try add the same Process to itself. */ public function addProcess(process:Process):void { if (process == this) throw new Error('You cannot add the same Process to itself.'); this.removeProcess(process); this._addProcessListeners(process); this._hasCompleted = process.completed; if (this._processes.length == 0) { this._processes.push(process); } else { var i:int = -1; var l:int = this._processes.length - 1; var hasAdded:Boolean; var p:Process; while (++i < this._processes.length) { p = this._processes[i]; if (!p.completed) { this._hasCompleted = false; if (hasAdded) break; } if (!hasAdded) { if (process.priority > p.priority) { this._processes.splice(i, 0, process); hasAdded = true; } else if (i == l) { this._processes.push(process); hasAdded = true; } if (hasAdded && !this._hasCompleted) break; } } } if (this.autoStart && !this.completed) { if (this.running) this._checkThreads(); else this.start(); } } /** Removes a process from the ProcessGroup. @param process: The process to be removed. */ public function removeProcess(process:Process):void { this._removeProcessListeners(process); this._hasCompleted = true; var l:uint = this._processes.length; while (l--) { if (this._processes[l] == process) this._processes.splice(l, 1); else if (!this._processes[l].completed) this._hasCompleted = false; } } /** Determines if this ProcessGroup contains a specific process. @param process: The process to search for. @param recursive: If any child of this ProcessGroup is also a ProcessGroup search its childrentrue
, or only search this ProcessGroup's childrenfalse
. @return Returnstrue
if the ProcessGroup contains the process; otherwisefalse
. */ public function hasProcess(process:Process, recursive:Boolean = true):Boolean { const processFound:Boolean = this._processes.indexOf(process) > -1; if (!recursive) return processFound; if (processFound) return true; var l:uint = this._processes.length; var p:Process; var g:ProcessGroup; while (l--) { p = this._processes[l]; if (p is ProcessGroup) { g = p as ProcessGroup; if (g.hasProcess(process, true)) return true; } } return false; } /** The processes that compose the group. */ public function get processes():Array { return this._processes.concat(); } /** The processes that are neither complete or running. */ public function get queuedProcesses():Array { return ArrayUtil.getItemsByKey(this.incompletedProcesses, 'running', false); } /** The processes that are currently running. */ public function get runningProcesses():Array { return ArrayUtil.getItemsByKey(this.processes, 'running', true); } /** The processes that have not completed. */ public function get incompletedProcesses():Array { return ArrayUtil.getItemsByKey(this.processes, 'completed', false); } /** The processes that have completed. */ public function get completedProcesses():Array { return ArrayUtil.getItemsByKey(this.processes, 'completed', true); } /** The number of simultaneous processes to run at once. */ public function get threads():uint { return this._threads; } public function set threads(threadAmount:uint):void { this._threads = threadAmount; } /** Calls {@link Process#destroy destroy} on all processes in the group and removes them from the ProcessGroup. @param recursive: If any child of this ProcessGroup is also a ProcessGroup destroy its childrentrue
, or only destroy this ProcessGroup's childrenfalse
. */ public function destroyProcesses(recursive:Boolean = true):void { this.stop(); var l:uint = this._processes.length; if (recursive) { var p:Process; var g:ProcessGroup; while (l--) { p = this._processes[l]; if (p is ProcessGroup) { g = p as ProcessGroup; g.destroyProcesses(true); } else p.destroy(); } } else while (l--) this._processes[l].destroy(); this._processes = new Array(); } override public function destroy():void { var l:uint = this._processes.length; while (l--) this._removeProcessListeners(this._processes[l]); this._processes = new Array(); super.destroy(); } protected function _checkThreads():void { var t:uint = this.threads; var i:int = -1; var p:Process; while (++i < this._processes.length) { if (t == 0) return; p = this._processes[i]; if (p.running) t--; else if (!p.completed && this.running) { p.start(); t--; } } if (t == this.threads && this.running) this._complete(); } protected function _onProcessStopped(e:ProcessEvent):void { this._checkThreads(); } protected function _onProcessCompleted(e:ProcessEvent):void { this._checkThreads(); } protected function _addProcessListeners(process:Process):void { process.addEventListener(ProcessEvent.STOP, this._onProcessStopped, false, 0, true); process.addEventListener(ProcessEvent.COMPLETE, this._onProcessCompleted, false, 0, true); } protected function _removeProcessListeners(process:Process):void { process.removeEventListener(ProcessEvent.STOP, this._onProcessStopped); process.removeEventListener(ProcessEvent.COMPLETE, this._onProcessCompleted); } } }
Manages and threads processes.
Example
-
package { import fl.motion.easing.Linear; import org.casalib.display.CasaMovieClip; import org.casalib.display.CasaSprite; import org.casalib.events.ProcessEvent; import org.casalib.process.ProcessGroup; import org.casalib.transitions.PropertyTween; public class MyExample extends CasaMovieClip { protected var _processGroup:ProcessGroup; public function MyExample() { super(); this._processGroup = new ProcessGroup(); this._processGroup.addEventListener(ProcessEvent.COMPLETE, this._onProcessComplete); var i:int = -1; var box:CasaSprite; while (++i < 10) { box = new CasaSprite(); box.y = 30 * i; box.graphics.beginFill(0xFF00FF); box.graphics.drawRect(0, 0, 25, 25); box.graphics.endFill(); this.addChild(box); this._processGroup.addProcess(new PropertyTween(box, 'x', Linear.easeNone, 500, 1)); } this._processGroup.start(); } protected function _onProcessComplete(e:ProcessEvent):void { this._processGroup.destroyProcesses(); this._processGroup.destroy(); trace("Done!"); } } }
Summary
Constructor
-
ProcessGroup
()
- Creates a new ProcessGroup.
Constants
-
MAX_THREADS
: uint
- The maximum amount of threads for a ProcessGroup instance.
Class properties
-
NORM_THREADS
: uint
- The default amount of threads for all ProcessGroup instances.
Class properties inherited from Process
Instance properties
-
autoStart
: Boolean
- Instructs the ProcessGroup to start automatically if it contains an incomplete Process or if an incomplete is added.
-
processes
: Array
- The processes that compose the group.
-
queuedProcesses
: Array
- The processes that are neither complete or running.
-
runningProcesses
: Array
- The processes that are currently running.
-
incompletedProcesses
: Array
- The processes that have not completed.
-
completedProcesses
: Array
- The processes that have completed.
-
threads
: uint
- The number of simultaneous processes to run at once.
Instance methods
-
start
() : void
- stop () : void
- addProcess (process:Process) : void
- Adds a process to be threaded and run by the ProcessGroup.
- removeProcess (process:Process) : void
- Removes a process from the ProcessGroup.
- hasProcess (process:Process, recursive:Boolean = true) : Boolean
- Determines if this ProcessGroup contains a specific process.
- destroyProcesses (recursive:Boolean = true) : void
- Calls destroy on all processes in the group and removes them from the ProcessGroup.
- destroy () : void
- Instance methods inherited from RemovableEventDispatcher
- addProcess (process:Process) : void
Constructor
ProcessGroup
function ProcessGroup()Creates a new ProcessGroup.
Constants
MAX_THREADS
static const MAX_THREADS:uint = uint.MAX_VALUEThe maximum amount of threads for a ProcessGroup instance. Use this value if you wish to disable threading.
Class properties
NORM_THREADS
static NORM_THREADS:uint = 1(read,write)The default amount of threads for all ProcessGroup instances.
Instance properties
autoStart
autoStart:Boolean(read,write)completedProcesses
completedProcesses:Array(read)The processes that have completed.
incompletedProcesses
incompletedProcesses:Array(read)The processes that have not completed.
processes
processes:Array(read)The processes that compose the group.
queuedProcesses
queuedProcesses:Array(read)The processes that are neither complete or running.
runningProcesses
runningProcesses:Array(read)The processes that are currently running.
threads
threads:uint(read,write)The number of simultaneous processes to run at once.
Instance methods
addProcess
function addProcess(process:Process) : voidAdds a process to be threaded and run by the ProcessGroup.
destroy
override function destroy() : void→Removes any event listeners and stops all internal processes to help allow for prompt garbage collection. Always call before deleting last object pointer.OverridesdestroyProcesses
function destroyProcesses(recursive:Boolean = true) : voidCalls destroy on all processes in the group and removes them from the ProcessGroup.
Parametersrecursive:If any child of this ProcessGroup is also a ProcessGroup destroy its childrentrue
, or only destroy this ProcessGroup's childrenfalse
.hasProcess
function hasProcess(process:Process, recursive:Boolean = true) : BooleanDetermines if this ProcessGroup contains a specific process.
Parametersprocess :The process to search for.recursive:If any child of this ProcessGroup is also a ProcessGroup search its childrentrue
, or only search this ProcessGroup's childrenfalse
.Returns-
Returns
true
if the ProcessGroup contains the process; otherwisefalse
.
removeProcess
function removeProcess(process:Process) : voidRemoves a process from the ProcessGroup.
Parametersprocess:The process to be removed.- stop () : void


Pair programming is concept of having two individuals working on the same code or coding project with one as the driver, and one as the navigator. Pair programming emphasises the concept of pair programming and collaboration.
Pair programming is important for several reasons when it comes to DBC. First and foremost getting a second set of eyes and a new brain to look over what you are working on. It also gets you into the practice of working with others when collaborting on programs or projects.
The driver is the main person that is doing the actual typing at that particular moment and examining the current line of code being input. The navigator


Summary
-
What is a vulnerability/CVE?
-
What's happening on a server?
-
Immutable Infrastructure
-
The consequences
-
Conclusion
Annexes:
-
Overview of GNU/Linux distributions
-
The new Stack by Google
-
Immutable application
What is a vulnerability?
Intersection of:
-
The presence of a flaw.
-
The possibility for a attacker to access it.
-
The possibility for a attacker to exploit it.
What is a CVE?
Common Vulnerability Exposure
Writing code is hard
"The design of Linux and BSD is secure. The implementation is not."
Why Rust? by Redox-OS
Documented vulnerabilities per year provided by SRCCLR
So, I need to upgrade my servers everyday...
What's happening on a server?
-
Backup
-
Updates
-
Certifications
-
Process
-
Provisionning
-
Security
-
Hardware Maintenance
What's happening on a server?
All the servers are generating a infinite number of state
Immutable infrastructure
Two states:
-
Functionnal
-
Not functionnal
App fail? OS update? Rebalance hardware allocation?
Redeploy new instance
Service uptime
!=
Server uptime
Conclusion
"There are two types of companies: those who have been hacked, and those who don’t yet know they have been hacked"
-
Security is hard
-
Handling CVE is hard
-
Automation and immutable infrastructure are the key
Do you have any questions?
Overview of GNU/Linux distributions
Source-based distribution
Advantages:
-
Light
-
Hackability
-
Upstream-friendly
The new Stack by Google
-
Applications Ops
-
Cluster Ops
-
Kernel/OS Ops
-
Hardware Ops
Immutable applications


Search from Glyphicon.
24px
asterisk
plus
euro
minus
cloud
envelope
pencil
glass
music
search
heart
star
star-empty
user
film
th-large
th
th-list
ok
remove
zoom-in
zoom-out
off
signal
cog
trash
home
file
time
road
download-alt
download
upload
inbox
play-circle
repeat
refresh
list-alt
lock
flag
headphones
volume-off
volume-down
volume-up
qrcode
barcode
tag
tags
book
bookmark
print
camera
font
bold
italic
text-height
text-width
align-left
align-center
align-right
align-justify
list
indent-left
indent-right
facetime-video
picture
map-marker
adjust
tint
edit
share
check
move
step-backward
fast-backward
backward
play
pause
stop
forward
fast-forward
step-forward
eject
chevron-left
chevron-right
plus-sign
minus-sign
remove-sign
ok-sign
question-sign
info-sign
screenshot
remove-circle
ok-circle
ban-circle
arrow-left
arrow-right
arrow-up
arrow-down
share-alt
resize-full
resize-small
exclamation-sign
gift
leaf
fire
eye-open
eye-close
warning-sign
plane
calendar
random
comment
magnet
chevron-up
chevron-down
retweet
shopping-cart
folder-close
folder-open
resize-vertical
resize-horizontal
hdd
bullhorn
bell
certificate
thumbs-up
thumbs-down
hand-right
hand-left
hand-up
hand-down
circle-arrow-right
circle-arrow-left
circle-arrow-up
circle-arrow-down
globe
wrench
tasks
filter
briefcase
fullscreen
dashboard
paperclip
heart-empty
link
phone
pushpin
usd
gbp
sort
sort-by-alphabet
sort-by-alphabet-alt
sort-by-order
sort-by-order-alt
sort-by-attributes
sort-by-attributes-alt
unchecked
expand
collapse-down
collapse-up
log-in
flash
log-out
new-window
record
save
open
saved
import
export
send
floppy-disk
floppy-saved
floppy-remove
floppy-save
floppy-open
credit-card
transfer
cutlery
header
compressed
earphone
phone-alt
tower
stats
sd-video
hd-video
subtitles
sound-stereo
sound-dolby
sound-5-1
sound-6-1
sound-7-1
copyright-mark
registration-mark
cloud-download
cloud-upload
tree-conifer
tree-deciduous


Treemenu
Classic treeview I
Classic treeview II
Treeview with methods and events
Treeview with custom content
Treeview like vscode/monaco style
Treeview json
Treeview json (dynamic loading)


Mold is a very light-weight (200 lines of JavaScript) client-side JavaScript-based templating library. It compiles ('bakes') plain-text templates to functions that map JavaScript values to strings (the filling in of the template) and provides an interface for directly inserting the result of such functions into documents ('casting' the molds).
The majority of Mold's operators are concerned with plain text,
but a few of them are HTML-specific, in that they refer to the
nodes created by the template. Some magic is involved in this (see
section 'Implementation'), but Mold.cast
encapsulates that
magic.
In a typical use scenario, the web application somehow gets template strings from the server (it could directly fetch text files, or the strings might be in script files), compiles them once, and then uses the resulting 'molds' to build up parts of the document.
Mold consists of only a single (small) script file: mold.js
. The library is licenced
under a zlib-style license. For those
wanting to work on it, the git
repository can be gotten from
http://marijnhaverbeke.nl/git/mold
. The code is also
on github.
I am not doing numbered releases, since the userbase is still small. The library interface can be considered stable, though.
You are welcome to mail me (Marijn Haverbeke) with any questions or problems you have.
A template to build a simple multiple choice widget, for example, might look like this (refer to the explanation below if something confuses you):

Choose one:
 <?do var odd = false;?>
 <?label choiceList?> <?for choice $arg?>
 <?event click handleChoice(choice);?> <?if typeof choice == "string"?> <?text choice?> <?else?> <?html choice.render()?> <?/if?>
 <?/for?>

This loops over an array of choices, building up a
representation of each choice, with a special case for choices
that are simple strings. Note that choice.render
can
also be a mold function. Templates can easily be composed like
this.
To use Mold, you include mold.js
in your document, which
creates a Mold
object that is the interface to the
library.
The Mold.bake
function, which takes a
single string as an argument, is used to transform a template
string into a mold. A mold is a function that takes a single
argument (or none, if your template does not use any parameter
data) and returns a string.
Mold uses XML processing instruction syntax for template
operators. This means '<?
' and
'?>
' are used around all instructions, as in PHP.
Contrary to PHP, though, Mold uses several different processing
instructions which serve different roles. After the
'<?
', an instruction name should follow (see
below). In cases where you don't want to use angle brackets
(inside attributes in a valid XML document, for example),
'[?
' and '?]
' can be used as
equivalents.
(Note that the scanner used by Mold is rather simplistic. If
you have a string or regular expression containing
'?>
' inside your instruction, you should use
'?\>
' instead, to prevent it from being recognised
as the end of the instruction.)
The following instructions are recognised:
text
(or t
)$arg
throughout), and inserted as text ― meaning any HTML
special character in it will be escaped.html
(or h
)text
, but the result of the
expression is not escaped, so HTML tags can be inserted.do
(or d
)do
)
without producing output. Can be useful for defining local
variables (any variables defined in such a block will be visible
to instructions coming after it.)if
/if
, elif
, or else
) will
not be evaluated/expanded.elif
if
or other elif
that did not fire, evaluates the expression it is given, and
only expands the block following it if this produces a true
value.else
if
s and
elif
s. The block following else
is
expanded only if none of the previous conditions fired./if
if
/elif
/else
instructions.for
<?for x [expr]?>
loops over the array
created by the given expression. <?for key, value in
[expr]?>
loops over an object. The value
variable in the second form can be omitted when not needed. The
template fragment in the loop will be repeated once for every
element in the collection, with the named variables bound to the
relevant values (bound by function call, not reassigned, so they
can be closed over). The variable $i
, inside the
loop body, refers to the current index, starting at 0./for
for
block.event
<
' and
'>
' of an HTML tag. The tag it applies to is
determined as follows (the same applies for the instructions
after this): When it sits before all non-text nodes in the
enclosing node, it applies to the enclosing node. Otherwise, it
applies to the first non-text node before it. Directly after the
word event
, an event type should be given (without
'on
', so something like 'click
' or
'submit
'). After that the handler body follows,
which may refer to the $event
variable to get the
event object. Mold supports one non-standard event,
enter
, which will fire for keypress
events with a key-code of 13.run
(or r
)do
, except that the
$node
variable refers to the nearest HTML node.
Having access to this node means that it has to be run 'out of
line', after the template has been expanded, so variables
defined in this instruction are not visible to the rest of the
template code. Variables defined during template expansion, on
the other hand, are visible in this block.label
(or l
)event
) HTML node. It takes a name as argument,
which will become a property in the object that Mold.cast
(see below) returns,
pointing to the node. When a label occurs inside a loop, the
property will refer to an array of nodes. (Note that nested
loops will still produce a single, flat array.)It should be noted that, while Mold.bake
does some error checking,
it is still rather easy to pass nonsense parameters to
instructions. This can result in rather hard to debug run-time
failures (see 'Implementation'), but
could, if you really want to, be used to make the library do
things it is not designed for ― you could create your own
PHP-style loops, for example, with two do
instructions, one opening the loop and one closing it.
To build HTML from a compiled template, the
Mold.cast
function is used. It takes three arguments
(node, mold, arg)
, and replaces the content of
node
with the result of applying mold
to
arg
. The last argument can be left off for molds that
do not require data. If there were any labels defined in the mold
used (or molds called from that mold), the value returned by
Mold.cast
will be an object containing links to the
labeled nodes.
As an alternative, there is also
Mold.castAppend
, which takes the same arguments as cast
, but appends the new nodes to
the target node, instead of replacing its content.
It is possible to define custom instructions with
Mold.define
, which accepts a string (the instruction
name) and a mold-like function (takes one argument, returns a
string) and defines a new instruction that takes an (optional)
expression as its argument and expands to the result of calling
the given function with the value of this expression. This is
basically a way to define pleasant shortcuts for things like
<?html myTemplate("something")?>
.
There are a few more properties of the Mold
object
that can be useful. The most important one is
Mold.attachEvent
. By default, Mold uses a very
simplistic event handler framework, which leaves most of the
browser incompatibilities intact (it only chooses between
addEventListener
and attachEvent
, and
makes sure the event object arrives properly). Most JavaScript
libraries provide a nicer wrapper, which can be wired into Mold by
setting Mold.attachEvent
to a function of three
arguments: (node, eventName, func)
, where
eventName
is the type of event (without
'on
' prefix), and func
is a function of
one argument (the event object).
When using Prototype, for example, you might do this:
Mold.attachEvent = Event.observe;
There is also Mold.escapeHTML
, which HTML-escapes
the characters '<>"&
'. This is not
directly needed for using Mold, but since it was defined
internally anyway, and might come in useful, it is exported.
What Mold.bake
does is
decompose the template into instructions and pieces of plain text,
and then build a (textual) JavaScript function from these pieces,
and use eval
to turn it into a real function. This
way, loops and conditionals are straightforwardly borrowed from
the underlying interpreter, and a lot of work must only be done
once.
The event
, run
, and
label
instructions need information about the nodes
in the resulting DOM tree. Rather than implement some kind of HTML
parser, Mold delays their execution until after the text has been
parsed by the browser. At expansion time their code is stored in a
(numbered) function, which closes over the variables that are
active in the template. At the place where they occur, a dummy tag
(I used empty var
tags with a special class) in
inserted. Then, after using innerHTML
to transform
the text into a DOM tree, Mold.cast
searches for such tags,
removes them, and runs the code on the relevant nodes. (If you
directly call mold functions that use these instructions, you will
see the dummy tags.)
Whether a system like this ― intricately connected to
the dodgy innerHTML
property ― is the most
ideal is debatable. My initial intention was to use XHTML
templates with a bunch of special tags, a kind of XSLT for
JavaScript/JSON data, and use DOM manipulation for all the
transformations. But, while innerHTML
is implemented
pretty well in most browsers, stuff like cloneNode
and transforming XML trees to HTML is slightly flaky in a lot of
them (and extremely flaky in one particular browser...
you guess which).


Login to https://dev-portal.onshape.com/oauthApps to register your application and get a client_id and client_secret. Ensure you select "OAuth 2 authorization with a callback URL".
Set the "Authorization callback URL" to: {{siteUrl}}_oauth/onshape
Complete the rest of the form as required, along with the captcha and press submit.
Record the client_id and client_secret in the "Client Id" and "Client Secret" fields of this form and press submit to save the configuration


Unity
Workshop on Unity
You will learn to build a game using unity. You will be provided Mentored Session by various Unity Experts.
You Will need to bring Your own Laptop with unity installed inorder to save time.
- Event will be from morning 9 Am to 3 Pm.
- You Must have Unity installed in your laptop.
- You will need to have your laptop charged.
Download Unity
Click to Download Unity-----------------------------------------------------------------------------------
CodeJam
This will be Two rounds happening on both the days.
Round 1
This will be pen and paper round. You will be given set of MCQ's which you will need to solve with the given time constraints.- Event will be held on 19 March (10:15 Am - 12:15 Pm)
- You will need to carry your id card.
Round 2
This will be Competitive Round. You will have to solve the problem on hackerrank.
- Event will be held on 20 March (09:15 Am - 12:15 Pm)
- The Contest will held for two hours.
-----------------------------------------------------------------------------------
CSGO
This will be Two rounds happening on both the days.
Round 1 & Round 2
- Event will be held on 19 March (12:15 Pm - 03:00 Pm)
- Student must bring their own laptops.
- CsGo should be installed in the respective laptops prior to the event.
- Participants should come max 5 in a team.
- Required Steam Account
-----------------------------------------------------------------------------------
Keyboard Arranging
This will be single round event happening on day1.
- Event will be held on 19 March (11:15 AM-12:15 PM)
- You Must be 10 minutes before at the venue.
- Participants should come max 3 in a team.
- Each team will be given a single keyboard which they need to be arranged.
-----------------------------------------------------------------------------------
Web Designing
This will be single round event happening on day1.
Event will be held on 20 March (08:30 AM-12:15 PM)
Themes
- Three platforms to work on
- WordPress.
- WIX.
- Adobe DreamWeaver.
- Html, css, bootstrap, php, javascript.
- Any Sort of Informal Presentation is not allowed caught,if it will lead to disqualification.
- Perks : Get a chance to get selected as a web designer for any future events.
-----------------------------------------------------------------------------------
GamiCon Quiz
This will be single round event happening on day1.
- Event will be held on 19 March (01:15 PM-03:00 PM)
- You can not use any gadgets or chits, if caught will lead to disqualification.
- You are not allowed to discuss the answers.
-----------------------------------------------------------------------------------
Gaming Club
Desc......


References and Resolve
One of the most important and tricky parts in implementing a custom language PSI is resolving references.
Resolving references gives users the ability to navigate from a PSI element usage (accessing a variable, calling a method and so on) to the declaration of that element (the variable’s definition, a method declaration and so on).
This feature is needed in order to support the Go to Declaration
action invoked by Ctrl-B and Ctrl-Click, and it is a prerequisite for implementing the Find Usages
action, the Rename
refactoring and code completion.
All PSI elements which work as references (for which the Go to Declaration
action applies) need to implement the
PsiElement.getReference()
method and to return a
PsiReference
implementation from that method.
The
PsiReference
interface can be implemented by the same class as
PsiElement,
or by a different class. An element can also contain multiple references (for example, a string literal can contain multiple substrings which are valid full-qualified class names), in which case it can implement
PsiElement.getReferences()
and return the references as an array.
The main method of the
PsiReference
interface is resolve()
, which returns the element to which the reference points, or null
if it was not possible to resolve the reference to a valid element (for example, should it point to an undefined class).
A counterpart to this method is isReferenceTo()
, which checks if the reference resolves to the specified element.
The latter method can be implemented by calling resolve()
and comparing the result with the passed PSI element, but additional optimizations are possible (for example, performing the tree walk only if the element text is equal to the text of the reference).
Example: Reference to a ResourceBundle in the Properties language plugin
There’s a set of interfaces which can be used as a base for implementing resolve support, namely the PsiScopeProcessor interface and the PsiElement.processDeclarations() method. These interfaces have a number of extra complexities which are not necessary for most custom languages (like support for substituting Java generics types), but they are required if the custom language can have references to Java code. If Java interoperability is not required, the plugin can forgo the standard interfaces and provide its own, different implementation of resolve.
The implementation of resolve based on the standard helper classes contains of the following components:
-
A class implementing the PsiScopeProcessor interface which gathers the possible declarations for the reference and stops the resolve process when it has successfully completed. The main method which needs to be implemented is
execute()
, which is called to process every declaration encountered during the resolve, and returnstrue
if the resolve needs to be continued orfalse
if the declaration has been found. The methodsgetHint()
andhandleEvent()
are used for internal optimizations and can be left empty in the PsiScopeProcessor implementations for custom languages. -
A function which walks the PSI tree up from the reference location until the resolve has successfully completed or until the end of the resolve scope has been reached. If the target of the reference is located in a different file, the file can be located, for example, using FilenameIndex.getFilesByName() (if the file name is known) or by iterating through all custom language files in the project (
iterateContent()
in the FileIndex interface obtained from ProjectRootManager.getFileIndex() ). -
The individual PSI elements, on which the
processDeclarations()
method is called during the PSI tree walk. If a PSI element is a declaration, it passes itself to theexecute()
method of the PsiScopeProcessor passed to it. Also, if necessary according to the language scoping rules, a PSI element can pass the PsiScopeProcessor to its child elements.
An extension of the
PsiReference
interface, which allows a reference to resolve to multiple targets, is the
PsiPolyVariantReference
interface.
The targets to which the reference resolves are returned from the multiResolve()
method.
The Go to Declaration
action for such references allows the user to choose a navigation target.
The implementation of multiResolve()
can be also based on
PsiScopeProcessor,
and can collect all valid targets for the reference instead of stopping when the first valid target is found.
The Quick Definition Lookup
action is based on the same mechanism as Go to Declaration
, so it becomes automatically available for all references that can be resolved by the language plugin.


The Appendix Archives
This is an archive of The Appendix, a journal of narrative and experimental history. Between 2012 and 2015, we published eight quarterly issues in two volumes, as well almost one hundred articles to our blog, featuring the work of 168 historians, writers, and artists with an eye for the strange and a suspicion of both jargon and traditional narratives.
We started with the end and finished in motion.
We published stories of the birth of fire; Chinese ghost tales told in reverse; ancient Andean echo chambers, lost Soviet amusement parks, brave men and women, running from enslavement, or boxing their way to freedom; and as many balloon stories as your patience would bear.
Thank you for reading. And thanks to Hannah Carney, J.R. Jones, Andrea Kinnison, Amy Kohout, Shannon Nagy, Marissa Nicosia, Lydia Pyne, and Michael Schmidt for their editorial dedication and to all of our countributors for their scholarship and creativity.
The Appendix co-founders,
Benjamin Breen,
Felipe Fernandes Cruz,
Christopher Heaney,
and Brian Jones


Whetstone
Create dynamic interfaces to interact with JavaScript source code.
Find out more on GitHub.
/*
* This demo uses Whetstone to retrieve values
* from the source and make them available for
* editing
*
* Have fun!
*/
let x = 3
x = 5
let message = "yay!"
for (var i = 0; i < 10; i++) {
console.log(message)
}


align-self takes the same arguments as align-items but applies to single child.
5-1. Parent is set to align-self : flex-start; but square 2 has align-self : flex-end;


We're sorry but L4D2 Stats Plugin doesn't work properly without JavaScript enabled. Please enable it to continue.


---
# Basics
subject: Today's slate of games
description: Upcoming college football games on ESPN+
# Button Section
button_1_copy: see full schedule
button_1_link: https://tinyurl.com/y6tqpnow
button_2_copy: stream now
button_2_link: https://tinyurl.com/yy8jshxs
---
Big 12 Now on ESPN+
McNeese vs Oklahoma State
SAT 9/7, 7:00 PM/ET
The Oklahoma State Cowboys take on McNeese in their home opener tonight in Stillwater. Streaming live exclusively on Big 12 Now on ESPN+.
{{> buttons}}
Week 2 Schedule Highlights
Coastal Carolina vs Kansas
SAT 9/7, 7:00 PM/ET
Charlotte vs Appalachian State
SAT 9/7, 3:30 PM/ET
North Dakota vsNorth Dakota State
SAT 9/7, 3:30 PM/ET
Western Kentucky vsFlorida International
SAT 9/7, 3:30 PM/ET
ESPN+ Exclusive
Episode 5: The First Test
Coach Miles and the Jayhawks prepare for their first game together as they host Indiana State. Kansas’ newly designated starting quarterback gets put to the test late in the fourth quarter with the game on the line. Streaming exclusively on Big 12 Now on ESPN+.


PatientHeartRate module¶
-
class
PatientHeartRate.
PatientInfo
(patient)¶ Bases:
object
-
calc_beats
()¶ - Calculates mean beats per min (heart rate),
- num_beats and beat times attributes
Parameters: self – instance of PatientInfo
Raises: - UnknownError – if peak detection fails
- ValueError – if no beats detected
-
calc_duration
()¶ Calculates time of ECG measurement
Parameters: self – instance of PatientInfo Returns duration: duration of strip (s)
-
calc_volt_ex
()¶ Determines maximum and minimum of voltage data (excluding nan)
Parameters: self – instance of PatientInfo Returns voltage_extremes: tuple of min and max voltages
-
check_interp
()¶ - Checks ECG data for missing time and voltages values,
- interpolates if needed, saves back to self
Parameters: self – instance of PatientInfo
-
check_volt_range
()¶ Checks voltage data to ensure values do not exceed 300 mV
Parameters: self – instance of PatientInfo Raises: ValueError – if any ECG voltage in data is greater or equal to 300 mV
-
write_json
()¶ Write .json file containing attributes of ecg data
Parameters: self – instance of PatientInfo Raises: UnknownError – if writing .json file fails”
-


Q-R
←O-P
S-T →
Cheeselibrary.com - A website devoted to cheese education Copyright © 2015 Regional Tastes Ltd.


RG Build Strike Gundam
HG Moon Gundam
RG Unicorn Gundam
HG 00 Sky "Higher Than Sky"
HG AGE-2 Magnum SV
HG Harute Gundam
RG Freedom Gundam
HG Vidar
Click to go back!


To collaborate with talented engineers, and to develop products that I am passionate about.
Fluent in Python, Java, programmatic testing, Redis, Git, Flask, and SQLAlchemy. Once fluent in Objective-C and C++. Conversational in HTML, CSS, Sass, jQuery, Javascript, and CoffeeScript.


qiskit.wrapper._wrapper module¶
Helper module for simplified QISKit usage.
Members¶
Functions¶
available_backends |
Return names of backends that are available in the SDK, optionally filtering them based on their capabilities. |
compile |
Compile a list of circuits into a qobj. |
execute |
Executes a set of circuits. |
get_backend |
Return an instance of a Backend object from its name identifier. |
least_busy |
Return the least busy available backend for those that have a pending_jobs in their status. |
load_qasm_file |
Construct a quantum circuit from a qasm representation (file). |
load_qasm_string |
Construct a quantum circuit from a qasm representation (string). |
local_backends |
Return the available local backends. |
register |
Authenticate against an online backend provider. |
registered_providers |
Return the currently registered providers. |
remote_backends |
Return the available remote backends. |
unregister |
Removes a provider from list of registered providers. |
Reference¶
-
qiskit.wrapper._wrapper.
available_backends
(filters=None, compact=True)[source]¶ Return names of backends that are available in the SDK, optionally filtering them based on their capabilities.
Note
In order for this function to return online backends, a connection with an online backend provider needs to be established by calling the register() function.
Note
If two or more providers have backends with the same name, those names will be shown only once. To disambiguate and choose a backend from a specific provider, get the backend from that specific provider.
Example:
p1 = register(token1) p2 = register(token2) execute(circuit, p1.get_backend('ibmq_5_tenerife')) execute(circuit, p2.get_backend('ibmq_5_tenerife'))
Parameters: - filters (dict or callable) – filtering conditions.
- compact (bool) – group backend names based on compact group names.
Returns: the names of the available backends.
Return type: list[str]
-
qiskit.wrapper._wrapper.
compile
(circuits, backend, config=None, basis_gates=None, coupling_map=None, initial_layout=None, shots=1024, max_credits=10, seed=None, qobj_id=None, hpc=None, skip_transpiler=False)[source]¶ Compile a list of circuits into a qobj.
Parameters: - circuits (QuantumCircuit or list[QuantumCircuit]) – circuits to compile
- backend (BaseBackend or str) – a backend to compile for
- config (dict) – dictionary of parameters (e.g. noise) used by runner
- basis_gates (str) – comma-separated basis gate set to compile to
- coupling_map (list) – coupling map (perhaps custom) to target in mapping
- initial_layout (list) – initial layout of qubits in mapping
- shots (int) – number of repetitions of each circuit, for sampling
- max_credits (int) – maximum credits to use
- seed (int) – random seed for simulators
- qobj_id (int) – identifier for the generated qobj
- hpc (dict) – HPC simulator parameters
- skip_transpiler (bool) – If True, bypass most of the compilation process and creates a qobj with minimal check nor translation
Returns: the qobj to be run on the backends
Return type: obj
-
qiskit.wrapper._wrapper.
execute
(circuits, backend, config=None, basis_gates=None, coupling_map=None, initial_layout=None, shots=1024, max_credits=10, seed=None, qobj_id=None, hpc=None, skip_transpiler=False)[source]¶ Executes a set of circuits.
Parameters: - circuits (QuantumCircuit or list[QuantumCircuit]) – circuits to execute
- backend (BaseBackend or str) – a backend to execute the circuits on
- config (dict) – dictionary of parameters (e.g. noise) used by runner
- basis_gates (str) – comma-separated basis gate set to compile to
- coupling_map (list) – coupling map (perhaps custom) to target in mapping
- initial_layout (list) – initial layout of qubits in mapping
- shots (int) – number of repetitions of each circuit, for sampling
- max_credits (int) – maximum credits to use
- seed (int) – random seed for simulators
- qobj_id (int) – identifier for the generated qobj
- hpc (dict) – HPC simulator parameters
- skip_transpiler (bool) – skip most of the compile steps and produce qobj directly
Returns: returns job instance derived from BaseJob
Return type:
-
qiskit.wrapper._wrapper.
get_backend
(name)[source]¶ Return an instance of a Backend object from its name identifier.
Parameters: name (str) – unique name of the backend. Returns: a Backend instance. Return type: BaseBackend
-
qiskit.wrapper._wrapper.
least_busy
(names)[source]¶ Return the least busy available backend for those that have a pending_jobs in their status. Backends such as local backends that do not have this are not considered.
Parameters: names (list[str]) – backend names to choose from (e.g. output of available_backends()
)Returns: the name of the least busy backend Return type: str Raises: QISKitError
– if passing a list of backend names that is either empty or none have attributepending_jobs
-
qiskit.wrapper._wrapper.
load_qasm_file
(qasm_file, name=None, basis_gates='id, u0, u1, u2, u3, x, y, z, h, s, sdg, t, tdg, rx, ry, rz, cx, cy, cz, ch, crz, cu1, cu3, swap, ccx, cswap')[source]¶ Construct a quantum circuit from a qasm representation (file).
Parameters: - qasm_file (str) – a string for the filename including its location.
- name (str or None) – the name of the quantum circuit after loading qasm text into it. If no name is give the name is of the text file.
- basis_gates (str) – basis gates for the quantum circuit.
Returns: circuit constructed from qasm.
Return type: Raises: QISKitError
– if the file cannot be read.
-
qiskit.wrapper._wrapper.
load_qasm_string
(qasm_string, name=None, basis_gates='id, u0, u1, u2, u3, x, y, z, h, s, sdg, t, tdg, rx, ry, rz, cx, cy, cz, ch, crz, cu1, cu3, swap, ccx, cswap')[source]¶ Construct a quantum circuit from a qasm representation (string).
Parameters: - qasm_string (str) – a string of qasm, or a filename containing qasm.
- basis_gates (str) – basis gates for the quantum circuit.
- name (str or None) – the name of the quantum circuit after loading qasm text into it. If no name given, assign automatically.
Returns: circuit constructed from qasm.
Return type: Raises: QISKitError
– if the string is not valid QASM
-
qiskit.wrapper._wrapper.
local_backends
(compact=True)[source]¶ Return the available local backends.
Parameters: - compact (bool) – only report alias names. this is usually shorter, any several
- usually share the same alias. (backends) –
Returns: the names of the available remote backends.
Return type: list[str]
-
qiskit.wrapper._wrapper.
register
(*args, provider_class=<class 'qiskit.backends.ibmq.ibmqprovider.IBMQProvider'>, **kwargs)[source]¶ Authenticate against an online backend provider. This is a factory method that returns the provider that gets registered.
Parameters: - args (tuple) – positional arguments passed to provider class initialization
- provider_class (BaseProvider) – provider class
- kwargs (dict) –
keyword arguments passed to provider class initialization. For the IBMQProvider default this can include things such as:
- token (str): The token used to register on the online backend such
- as the quantum experience.
- url (str): The url used for online backend such as the quantum
- experience.
- hub (str): The hub used for online backend.
- group (str): The group used for online backend.
- project (str): The project used for online backend.
- proxies (dict): Proxy configuration for the API, as a dict with
- ’urls’ and credential keys.
- verify (bool): If False, ignores SSL certificates errors.
Returns: the provider instance that was just registered.
Return type: Raises: QISKitError
– if the provider could not be registered- (e.g. due to conflict)
-
qiskit.wrapper._wrapper.
remote_backends
(compact=True)[source]¶ Return the available remote backends.
Parameters: - compact (bool) – only report alias names. this is usually shorter, any several
- usually share the same alias. (backends) –
Returns: the names of the available remote backends.
Return type: list[str]
-
qiskit.wrapper._wrapper.
unregister
(provider)[source]¶ Removes a provider from list of registered providers.
Note
If backend names from provider1 and provider2 were clashing, unregister(provider1) removes the clash and makes the backends from provider2 available.
Parameters: provider (BaseProvider) – the provider instance to unregister Raises: QISKitError
– if the provider instance is not registered


Viezh Robert
Warsaw, Poland
4.5
“Wow... I am very happy to use this VPN, it turned out to be more than my expectations and so far there have been no problems. LaslesVPN always the best”.
Yessica Christy
Shanxi, China
4.5
“I like it because I like to travel far and still can connect with high speed.”.
Kim Young Jou
Seoul, South Korea
4.5
“This is very unusual for my business that currently requires a virtual private network that has high security.”.
Let's subscribe with us and find the fun.


La Famiglia Pizzeria
We make the best pizza in the world!
Don't believe us? Order online and we'll prove it to you.
Order online
Choose a size!
Small pizza (32cm)
Medium pizza (42cm)
Large pizza (50cm)
Select your toppings:
Mushrooms
Cheese
Olives
Ham
Calculate cost!
You selected our
pizza, with:
Your price is: $


Are you sure you want to delete the network {{networkDetailsCtrl.network.networkName}}?
{{networkDetailsCtrl.network.networkName}}


$1200 $812.50
Package of VR googles and games This discount is only limited to schools. Ask your district to contact us for the promo code. Promo code is required for purchase.
4.2 average based on 186 reviews.


- .NET 4.0
- Duplicate Lines Bug fixed
Download for new fixed release:
https://github.com/zarunbal/LogExpert/releases
Project Description
Windows tail program and log file analyzer.
Official external web site: http://www.log-expert.de/
Future plans/open issues:
Future plans/ideas for LogExpert
FAQ/Info for most reported problems:
FAQ
3rd Party Columnizers: Columnizers
Screencast: A screencast made by Latish Sehgal: Click here
Info about version branches


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use INode | |
|---|---|
| synoptic.algorithms.bisim | Provides for implementations of a coarsening and an refinement algorithm. |
| synoptic.algorithms.graph | Provides for algorithms on graphs. |
| synoptic.gui | Provides a simple GUI. |
| synoptic.invariants | Provides implementation of invariants, and a specialized invariant set (TemporalInvariantSet ). |
| synoptic.invariants.fsmcheck | |
| synoptic.invariants.ltlchecker | |
| synoptic.model | Provides basic data structures, such as graphs, transitions, and events. |
| synoptic.model.export | |
| synoptic.model.interfaces | |
| synoptic.tests | |
| synoptic.tests.units |
| Uses of INode in synoptic.algorithms.bisim |
|---|
| Methods in synoptic.algorithms.bisim with type parameters of type INode | ||
|---|---|---|
static
|
KTails.kEquals(NodeType n1,
NodeType n2,
int k,
boolean subsumption)
We perform k-tails comparison on the message graph to the given depth k. |
|
private static
|
KTails.kEqualsWithoutSubsumption(NodeType n1,
NodeType n2,
int k,
java.util.LinkedHashMap<NodeType,NodeType> allVisitedMatches)
Without subsumption the children sets of both nodes must match each other exactly -- there needs to be a 1-1 correspondence that holds recursively. |
|
private static
|
KTails.kEqualsWithSubsumption(NodeType n1,
NodeType n2,
int k)
With subsumption its okay for some transitions of n1 to be unmatched with any transitions in n2, but all of n2 transitions must be matched to some transition in n1. |
| Uses of INode in synoptic.algorithms.graph |
|---|
| Classes in synoptic.algorithms.graph with type parameters of type INode | |
|---|---|
class |
StronglyConnectedComponents<NodeType extends INode<NodeType>>
An implementation of tarjans algorithm for finding the SCC of a graph. |
class |
TopologicalSort<NodeType extends INode<NodeType>>
Topological sort. |
class |
TransitiveClosure<NodeType extends INode<NodeType>>
Computes the transitive closure. |
| Methods in synoptic.algorithms.graph with type parameters of type INode | ||
|---|---|---|
static
|
TopologicalSort.getSourceNodes(IGraph<T> graph)
|
| Uses of INode in synoptic.gui |
|---|
| Fields in synoptic.gui with type parameters of type INode | |
|---|---|
(package private) edu.uci.ics.jung.graph.DirectedGraph<INode<Partition>,ITransition<Partition>> |
JungGui.jGraph
The visual representation of pGraph, displayed by the Applet. |
(package private) edu.uci.ics.jung.algorithms.layout.Layout<INode<Partition>,ITransition<Partition>> |
JungGui.layout
The layout used to display the graph. |
(package private) edu.uci.ics.jung.visualization.VisualizationViewer<INode<Partition>,ITransition<Partition>> |
JungGui.vizViewer
the visual component and renderer for the graph |
| Methods in synoptic.gui that return types with arguments of type INode | |
|---|---|
edu.uci.ics.jung.graph.DirectedGraph<INode<Partition>,ITransition<Partition>> |
JungGui.getJGraph()
|
| Methods in synoptic.gui with parameters of type INode | |
|---|---|
protected void |
GuiVertex.paintShapeForVertex(edu.uci.ics.jung.visualization.RenderContext<INode<Partition>,ITransition<Partition>> rc,
INode<Partition> v,
java.awt.Shape shape)
|
void |
GuiVertex.paintVertex(edu.uci.ics.jung.visualization.RenderContext<INode<Partition>,ITransition<Partition>> rc,
edu.uci.ics.jung.algorithms.layout.Layout<INode<Partition>,ITransition<Partition>> layout,
INode<Partition> v)
|
| Method parameters in synoptic.gui with type arguments of type INode | |
|---|---|
protected void |
GuiVertex.paintShapeForVertex(edu.uci.ics.jung.visualization.RenderContext<INode<Partition>,ITransition<Partition>> rc,
INode<Partition> v,
java.awt.Shape shape)
|
void |
GuiVertex.paintVertex(edu.uci.ics.jung.visualization.RenderContext<INode<Partition>,ITransition<Partition>> rc,
edu.uci.ics.jung.algorithms.layout.Layout<INode<Partition>,ITransition<Partition>> layout,
INode<Partition> v)
|
void |
GuiVertex.paintVertex(edu.uci.ics.jung.visualization.RenderContext<INode<Partition>,ITransition<Partition>> rc,
edu.uci.ics.jung.algorithms.layout.Layout<INode<Partition>,ITransition<Partition>> layout,
INode<Partition> v)
|
protected boolean |
GuiVertex.vertexHit(edu.uci.ics.jung.visualization.RenderContext<INode<Partition>,ITransition<Partition>> rc,
java.awt.Shape s)
|
| Constructor parameters in synoptic.gui with type arguments of type INode | |
|---|---|
ModalMousePlugin(edu.uci.ics.jung.visualization.RenderContext<INode<Partition>,ITransition<Partition>> rc)
|
| Uses of INode in synoptic.invariants |
|---|
| Classes in synoptic.invariants with type parameters of type INode | |
|---|---|
class |
AllRelationsTransitiveClosure<NodeType extends INode<NodeType>>
Code taken from: http://www.cs.princeton.edu/courses/archive/fall05/cos226/lectures /digraph.pdf |
| Methods in synoptic.invariants with type parameters of type INode | ||
|---|---|---|
|
TemporalInvariantSet.getAllCounterExamples(IGraph<T> graph)
Returns a list of paths, each of which violates an invariant maintained by this invariant set (i.e. |
|
static
|
TemporalInvariantSet.getCounterExample(ITemporalInvariant inv,
IGraph<T> g)
Returns a path that violates a specific invariant in a graph. |
|
|
TemporalInvariantSet.getFirstCounterExample(IGraph<T> g)
Returns the first counter-example encountered in the graph g. |
|
private static
|
TemporalInvariantSet.printStats(IGraph<T> g,
TemporalInvariantSet overapproximatedInvariantsSet,
int overapproximatedInvariantsSetSize)
|
|
|
NeverFollowedInvariant.shorten(java.util.List<T> trace)
Returns a sub-trace of the input violating trace that looks like ...'first' ... |
|
|
ITemporalInvariant.shorten(java.util.List<T> path)
Shorten a counter-example for this invariant. |
|
|
AlwaysPrecedesInvariant.shorten(java.util.List<T> trace)
Returns a sub-trace of the violating trace that looks like ...'second' where 'first' APby 'second' is this invariant and where 'first' does _not_ appear in the returned sub-trace at all. |
|
|
AlwaysFollowedInvariant.shorten(java.util.List<T> trace)
Unlike the other types of invariants' counter-example paths, an AFby counter-example path cannot be trivially shortened because it must include the entire path to the TERMINAL node. |
| Uses of INode in synoptic.invariants.fsmcheck |
|---|
| Classes in synoptic.invariants.fsmcheck with type parameters of type INode | |
|---|---|
class |
AFbyInvFsms<T extends INode<T>>
FSM for a set of invariants of the form "A always followed by B". |
class |
AFbyTracingSet<T extends INode<T>>
Represents a "A always followed by B" synoptic.invariants to simulate, recording the shortest historical path to reach a particular state. |
class |
APInvFsms<T extends INode<T>>
FSM for a set of invariants of the form "A always precedes B". |
class |
APTracingSet<T extends INode<T>>
Represents a set of "A always precedes B" synoptic.invariants to simulate, recording the shortest historical path to reach a particular state. |
class |
FsmStateSet<T extends INode<T>>
Abstract class to provide functionality for simulating nondeterministic finite state machines, utilizing BitSets as a method for evaluating the transitions of many instances in parallel. |
class |
NFbyInvFsms<T extends INode<T>>
FSM for a set of invariants of the form "A never followed by B". |
class |
NFbyTracingSet<T extends INode<T>>
Represents a set of "A never followed by B" synoptic.invariants to simulate, recording the shortest historical path to reach a particular state. |
class |
TracingStateSet<T extends INode<T>>
Abstract NFA state set which keeps the shortest path justifying a given state being inhabited. |
| Fields in synoptic.invariants.fsmcheck declared as INode | |
|---|---|
(package private) T |
TracingStateSet.HistoryNode.node
|
| Methods in synoptic.invariants.fsmcheck with type parameters of type INode | ||
|---|---|---|
static
|
FsmModelChecker.getCounterExample(BinaryInvariant invariant,
IGraph<T> graph)
Runs invariant-checking finite state machines over the synoptic.model graph, while keeping history paths which justify any particular state. |
|
static
|
FsmModelChecker.runBitSetChecker(java.lang.Iterable<BinaryInvariant> invariants,
IGraph<T> graph)
Use the BitSet checker to evaluate, and return which synoptic.invariants failed. |
|
static
|
FsmModelChecker.runChecker(IStateSet<T,S> initial,
IGraph<T> graph,
boolean earlyExit)
Given an initial StateSet, and graph to check, this yields the fixpoint states eventually reached. |
|
protected static
|
FsmModelChecker.whichFail(FsmStateSet<T> initial,
IGraph<T> graph)
|
| Uses of INode in synoptic.invariants.ltlchecker |
|---|
| Classes in synoptic.invariants.ltlchecker with type parameters of type INode | |
|---|---|
class |
GraphLTLChecker<T extends INode<T>>
|
| Uses of INode in synoptic.model |
|---|
| Classes in synoptic.model with type parameters of type INode | |
|---|---|
class |
Graph<NodeType extends INode<NodeType>>
A graph implementation that provides a merge operation to merge another graph into it. |
| Classes in synoptic.model that implement INode | |
|---|---|
class |
LogEvent
The event class. |
class |
Partition
Implements a partition in a partition graph. |
| Fields in synoptic.model declared as INode | |
|---|---|
private NodeType |
Graph.dummyInitialNode
The node which has transitions to all the initial nodes in the graph. |
private NodeType |
Graph.dummyTerminalNode
Every terminal node maintains a transition to this special node to indicate that the source node is a terminal. |
| Uses of INode in synoptic.model.export |
|---|
| Methods in synoptic.model.export with type parameters of type INode | ||
|---|---|---|
|
GraphVizExporter.export(java.io.File dotFile,
IGraph<T> newHead)
|
|
|
GraphVizExporter.export(IGraph<T> g)
|
|
private
|
GraphVizExporter.export(java.io.Writer writer,
IGraph<T> graph,
boolean fast)
|
|
private
|
GraphVizExporter.export(java.io.Writer writer,
IGraph<T> graph,
boolean fast,
boolean isInitialGraph)
|
|
|
GraphVizExporter.exportAsDotAndPng(java.lang.String fileName,
IGraph<T> g)
|
|
|
GraphVizExporter.exportAsDotAndPngFast(java.lang.String fileName,
IGraph<T> pg)
|
|
|
GraphVizExporter.exportAsDotAndPngFast(java.lang.String fileName,
IGraph<T> pg,
boolean isInitialGraph)
|
|
private
|
GraphVizExporter.exportGraphCanonically(java.io.Writer writer,
IGraph<T> graph,
boolean isInitialGraph)
Exports a graph in a dot format using the writer. |
|
private
|
GraphVizExporter.exportRelationNodes(java.io.Writer writer,
IGraph<T> graph,
java.lang.String relation,
java.util.LinkedList<WeightedTransition<T>> allTransitions,
java.util.LinkedHashMap<T,java.lang.Integer> nodeToInt,
int nodeCnt)
Exports all the nodes in the graph for a particular relation, using output stream writer. |
|
private
|
GraphVizExporter.nodeDotAttributes(T node,
boolean initial,
boolean terminal,
java.lang.String color)
|
|
static
|
GraphVizExporter.quickExport(java.lang.String fileName,
IGraph<T> g)
|
| Uses of INode in synoptic.model.interfaces |
|---|
| Classes in synoptic.model.interfaces with type parameters of type INode | |
|---|---|
interface |
IGraph<NodeType extends INode<NodeType>>
This is the interface all graphs have to provide. |
| Uses of INode in synoptic.tests |
|---|
| Methods in synoptic.tests with type parameters of type INode | ||
|---|---|---|
protected static
|
SynopticTest.exportTestGraph(IGraph<T> g,
int index)
Exports a graph to a png file. |
|
protected static
|
SynopticTest.exportTestGraph(IGraph<T> g,
java.lang.String title)
Exports a graph to a png file. |
| Uses of INode in synoptic.tests.units |
|---|
| Methods in synoptic.tests.units with type parameters of type INode | ||
|---|---|---|
private
|
PartitionGraphTests.getNodeByName(IGraph<T> g,
java.lang.String nodeName)
|
|
private static
|
ModelCheckersTests.testCExamplePath(IGraph<T> g,
ITemporalInvariant inv,
boolean cExampleExists,
java.util.List<T> expectedPath)
Test that the graph g generates or not (depending on the value of cExampleExists) a counter-example for invariant inv, which is exactly the expectedPath through the graph g. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Artemis is an Oberon-07 module collection. My hope is to encourage continued use and development of the Oberon-07 language and encourage convergence towards compatibility in implementations of Oberon-07 compilers. My focus in this project is using Oberon-07 on POSIX systems.
This project started as a re-imagining of the efforts that began at the Oakwood Hotel in the 1992. As at Oakwood I hope to encourage convergence to help code become more portable. Unlike Oakwood my focus is only on Oberon-07 and systems implemented in Oberon-07 or providing an Oberon-07 compiler. That is the scope of Artemis project for now.
Initial development is being done in a POSIX environment and relies on Karl Landström’s OBNC compiler. As time permits I am attempting to port the changes to other Oberon-07 implementations including Mike Spivey’s Obc-3 and Oleg N. Cher’s OfrontPlus compiler.
Artemis draws inspiration from Wirth and Reed’s Project Oberon 2013, Joseph Templ’s Ofront with V4. It also draws inspiration from the discussions and community on the Oberon List.
A big thank you goes to all the inspiring people who contributed to Oberon and Oberon Systems over the years particularly where their source code is publicly available or through published articles, presentations or books about the language and system. All have help me study the path Prof. Wirth and Prof. Gutkneckt pioneered all those many years ago.
The directories named for their compilers will implement modules providing a common definition but specifically written to that compiler. This typically will be modules that rely on an underlying C library or behavior. The plan is for commonly defined modules targeting a specific compiler to use the “art” prefix. This will give room to the compiler developer to either adopt or create their own compatible implementations. E.g. current I’ve implemented a Unix and Clock modules for the OBNC and Oxford compilers. These will be renamed artUnix and artClock. Likewise the implementations of extArgs, extEnv I made for the Oxford compiler will be renamed artArgs and artEnv so that it is clear these are not the original OBNC modules extensions written by Karl.
The root repository directory is for modules that are portable between POSIX Oberon-07 compiler implementations and portable to an Oberon-07 based Oberon System. Where I’ve provided non-canonical implementations I plan to use the “art” prefix in the module name.
The obncdocs directory contains documentation of the module definitions for the common modules in the root directory.
The obnc directory contains modules that target specific features of the OBNC compiler. This is primarily integration with C based libraries and services. These aren’t portable between compilers but should work across POSIX systems where OBNC is available.
The oxford directory contains modules that target the Oxford Oberon Compiler, aka Obc-3. This is primarily integration with C based libraries and services. These aren’t portable between compilers but should work across POSIX systems where Obc-3 is available.
The ofrontplus directory contains modules that target the OfrontPlus compiler. This is primarily integration with C based libraries. These modules are not portable between compilers but should work across POSIX systems where OfrontPlus is available.
Any modules which are not canonical to Artemis or are specific to a compiler implementation must be prefixed with “art”. This will allow for better re-use in other projects (e.g. OfrontPlus) and avoids name collisions.
Chars is a module for working with CHAR and ARRAY OF CHAR. It is inspired by the Oakwood Strings module. It goes beyond the Oakwood minimum. It can function as a drop in replacement for the Oakwood Strings module.
DStrings provides a dynamic string implementation for Oberon-07. The procedures signatures are often compatible with the Chars module. It leverages the Rider concept borrowed from Files and Texts in the Oberon System.
Tests is a minimal test library used to implement module tests in Artemis. It tries to honor the advice of “simple but no simpler”.
Obn2 is a module provides compatibility for some built-in Oberon-2 procedures that were dropped in the evolution to Oberon-07.
Path is a module for working with POSIX style paths and file extensions. It does not directly interact with the OS. It does provided a means of working with path strings in a uniform way. By default it assumes the paths are delimited with the ‘/’ character and ‘.’ for file extensions. This is configurable by the Path module’s SetDelimiter()
and SetExtDelimiter()
procedures.
The following modules are not portable to Project Oberon are implemented specifically for a targeted compiler.
artUnix provides access to some Unix/C facilities.
Exit(exitCode : INTEGER);
will cause a program to exist with the given POSIX exit code.
KernelName(dest : ARRAY OF CHAR)
uses the POSIX command uname
to populate dest
with the name of the host OS kernel if known
Architecture(dest : ARRAY OF CHAR)
uses the POSIX command uname
to populate the dest
with the name of the host architectures, e.g. x86_64, armv7.
artClock provides an abstraction layer working with the system clock. The implementation uses the C clock_gettime()
and clock_settime()
.
artArgs provides an OBNC compatible Args module
artEnv provides an OBNC compatible Env module
artConvert provides an OBNC compatible Convert module
artUnix provides access to some Unix/C facilities.
Exit(exitCode : INTEGER);
will cause a program to exist with the given POSIX exit code.
KernelName(dest : ARRAY OF CHAR)
uses the POSIX command uname
to populate dest
with the name of the host OS kernel if known
Architecture(dest : ARRAY OF CHAR)
uses the POSIX command uname
to populate the dest
with the name of the host architectures, e.g. x86_64, armv7.
artClock is an abstraction layer for working with the system clock. It uses the C clock_gettime()
and clock_settime()
.
NOTE: These modules are in the planning stages and hopefully included in the next release of Artemis.
artArgs provides an OBNC compatible Args module
artEnv provides an OBNC compatible Env module
artConvert provides an OBNC compatible Convert module
artUnix provides access to some Unix/C facilities.
Exit(exitCode : INTEGER);
will cause a program to exist with the given POSIX exit code.
KernelName(dest : ARRAY OF CHAR)
uses the POSIX command uname
to populate dest
with the name of the host OS kernel if known
Architecture(dest : ARRAY OF CHAR)
uses the POSIX command uname
to populate the dest
with the name of the host architectures, e.g. x86_64, armv7.
artClock is an abstraction layer for working with the system clock. It uses the C clock_gettime()
and clock_settime()
.
Artemis is made up of two categories of Oberon-07 modules. Modules in the root should be portable across POSIX Oberon-07 compilers and portable to Oberon Systems with an Oberon-07 compiler (e.g. on Project Oberon 2013). A second category are modules written for specific POSIX based Oberon-07 compilers.
In the POSIX environment Oberon-07 compilers have not converged (2021-09-21). This is true for Oakwood module implementations and and particularly true for how C code is integrated. The later is the important divergence as integration with legacy C libraries and services is likely to be required for some time into the future.
Both non-portable and portable modules can be used together in a project. This requires knowing the compiler you’re using and targeting it’s way of managing where to find modules.
An example is using Tests.Mod for the clocktest implementations in both obnc and oxford directories. With OBNC you need to set some environment variables to let the compiler known where to search for modules. Here’s what you can do to compile this implementation of clocktest in the obnc directory.
export OBNC_IMPORT_PATH=".:../"
obnc -o clocktest ClockTest.obn
With Obc-3 you can just provide the full path to the module you want to include. Compiling the implementation of clocktest in the oxford directory looks like —
obc -07 -o clocktest Clock.m ../Tests.m extEnv.m ClockTest.m
NOTE (2021-06-16): Not sure why yet but I found it necessary to rename Tests.Mod to Tests.m to get compilation with obc. It might be because the other files I am compiling use the ‘.m’ extension. Need to check with Mike.
FIXME: Document handling of imports and compiling OfrontPlus compiler.


java.lang.Runtime.exec() Payload Workarounds
Occasionally there are times when command execution payloads via Runtime.getRuntime().exec()
fail. This can happen when using web shells, deserialization exploits, or through other vectors.
Sometimes this is because redirection and pipe characters are used in a way that doesn't make sense in the context of the process that's being launched. For example, executing ls > dir_listing
in a shell should output a listing of the current directory into a file called dir_listing
. But in the context of the exec()
function, that command would instead be interpreted to fetch the listings of the >
and dir_listing
directories.
Other times, arguments with spaces within them are broken by the StringTokenizer class which splits command strings by spaces. Something like ls "My Directory"
would then be interpreted as ls '"My' 'Directory"'
.
With the help of Base64 encoding, the converter below can help reduce these issues. It can make pipes and redirects great again through calls to Bash or PowerShell and it also ensures that there aren't spaces within arguments.
Input type:


Lamborghini Lambo V12 Vision GT a real-life hypercar waiting to happen
A one-seat Terzo Millennio with a Sian powertrain and a giant wing
by Jonathon RamseyDuring the World Finals of the 2019 FIA-Certified Gran Turismo Championships held over the weekend in Monaco, Mazda showed a sketch of the RX-Vision GT3 concept coming to Gran Turismo Sport next year. Lamborghini went further, not only revealing artwork of its future playable concept, the Lambo V12 Vision GT, but also parking a full-scale model of the concept on the gaming floor. Yes, Lamborghini Lambo V12 is a quixotic kind of name that takes us back to Ferrari LaFerrari, however, everything else about the jet-fighter-inspired single-seater has us looking to the future. Instead of the Roboracer, Formula E should put together a one-make series with these.
Designed by Lamborghini Centro Stile, the Lambo V12 is a cockpit with outrigger wheels, every one of the minimal surfaces designed to purposefully shunt air around the car to the Y-shaped rear wing. The hexagonal windows extending below the shoulder line are inspired by Marcello Gandini's 1968 Marzal concept. The shoulder defines the base of a rear-hinged canopy that extends to the Lambo V12's leading edge; according to the sketch, when the canopy is raised, even the pedal box is visible as it sits above the beltline. The primary controls are on the steering wheel, all information projected in the heads-up display. Behind the pilot, the 808-horsepoewer hybrid V12 powertrain from the limited-edition Sián FKP 37.
Chief designer Mitja Borkert told Top Gear the math shows the Lambo V12 weighs 819 kilograms, which would rather nicely deliver a one-to-one power-to-weight ratio — in metric horsepower and pixels, at least. Even better for gamers, the car will apparently provide "intelligent, context-sensitive advice from one of the factory drivers." Even better for those driving on real roads — and who can afford such things — Borkert said he could see the holographic display a real-world item within the next decade.
The Lambo V12 will appear in-game come spring 2020 after the design team makes its final revisions. We hope there are night races so the streaker can show off its light signatures. And we hope Lamborghini makes a run of 63 track-only examples, because they'll sell at any price.


As part of my dissertation, I have conducted fieldwork in several archives in Russia. A reflection on my archival experience was published in the Fall 2019 Comparative Politics Newsletter.
I built a dataset of mayors for all Russian city districts (gorodskie okruga)
for the period of 2011-2018. This dataset tracks the timeline of the city charters' changes and
includes information about changes in the mayors' selection rule for every city,
provides basic information of mayors' candidacies and tracks the switches of those candidacies
for every city.
If you have questions about this dataset, please email me.
My primary programming languages are Python and R. I wrote Python scraping codes to extract municipal-level budget data and some R codes to build maps of Russian cities. These codes are available on my github page. I also wrote Python codes to parse Russian public procurement data. These codes are available upon request.
Here is a list of my personal inspirations and recommendations; all created by women in science and industry.


pub const Header = packed struct {
magic: u16,
version: u8,
flags: u8,
hdr_len: u32,
/// All offsets are in bytes relative to the end of this header
func_info_off: u32,
func_info_len: u32,
line_info_off: u32,
line_info_len: u32,
};
pub const InfoSec = packed struct {
sec_name_off: u32,
num_info: u32,
// TODO: communicate that there is data here
//data: [0]u8,
};


{{site.user_description_short}}
{{site.user_description}}
Assess, build or update your application pipeline. Integrate with a variety of tooling and platforms.
Build bespoke applications and integrations of systems. Backend systems, APIs, tooling.
Operational assessment, team architecture, planning & delivery. One off or ongoing.


×
Share these birds
Description
Share this URL with your friends:
This Session
oiseaux de même
Brian Belet
and
Bill Walker
Find bird sightings
within
15km
30km
of
Paris
Asa Wright Nature Center
Cape May Bird Observatory
in the last
7 days
14 days
28 days
Bird
@
location
Rate
1x
Pan
Reverse
Recorded by
recordist
at
location
Bird
@
location
Rate
1x
Pan
Reverse
Recorded by
recordist
at
location
Bird
@
location
Rate
1x
Pan
Reverse
Recorded by
recordist
at
location
Bird
@
location
Rate
1x
Pan
Reverse
Recorded by
recordist
at
location
source code on github
Share
Tweet


Committee of judges to examine insurance compensation levels in Ireland
by Stephen McNeiceA personal injuries committee made up of judges has been selected to examine insurance compensation levels in Ireland.
The announcement was made this morning by Chief Justice Frank Clarke at an insurance fraud conference in Dublin.
It comes amid ongoing criticism over the level of compensation payouts in Ireland.
Mr Justice Clarke said the committee will get to work straight away, despite not being formally established by law.
He explained: "One of the issues that they will have to consider is bench-marking Irish damages by reference to other comparable countries - not just the UK, but other countries as well.
"If they were to wait until they are formally established before commencing that process, that would take time.
"But there's no reason why the process of putting in place that research cannot start straight away."
Concerns have been raised in recent years about the levels of compensation and damages awarded here, as well as the cost of insurance.
Small and medium businesses have previously highlighted the difficulty of obtaining public liability insurance due to the spiralling costs.
Michael D'Arcy, the Minister of State with responsibility for insurance, has previously suggested high insurance payouts are fostering a "litigious nature" among Irish people.


--- layout: archive permalink: /archive/ title: "Posts by Month" author_profile: true --- {% assign postsByMonth = site.posts | group_by_exp:"post", "post.date | date: '%b %Y'" %} {% for month in postsByMonth %}


Before Change
state = (1, 0)
rewards = [0.0] * 100
for n in xrange(10000):
action = agent.get_action(state=state)
if action == 0:
state = (1, 0)
reward = 0.0
terminal = False
After Change
network_builder = layered_network_builder([{"type": "dense", "num_outputs": 16}, {"type": "linear", "num_outputs": 2}])
agent = DQNAgent(config=config, network_builder=network_builder)
runner = Runner(agent=agent, environment=environment)
def episode_finished(r):
return r.episode < 100 or not all(x >= 1.0 for x in r.episode_rewards[-100:])
runner.run(episodes=10000, episode_finished=episode_finished)
self.assertTrue(runner.episode < 10000)


Home
Home
Portfolio
About Me
Having trouble with Designs?
Well, solve your problems with my services!
Small Business Owner?
Get more customers
More publicity
Establish an identity to further the prospect of your business


This web application is for determining your Akan Name simply by taking in your birthday credentials and your gender then it calculates the week you were born and the exact day . Afterwhich it generates your Akan Name which you will see after submitting your credentials. Akan Names are from the Ghanian culture in which children are given first name as a 'day name' which corresponds to the day in the week they were born.


This week at Dev Bootcamp we switched from Ruby to Javascript. Which was a little bit discouraging because we were just getting good at Ruby and then we had to switch to something totally new. Even still when I am looking at the challenges I am thinking in my head how to do them in Ruby. However, as I have started to learn more and more Javascript I have begun to see that the languages although very different in syntax are not that different in how they can be used. This of course is with my base knowledge of these things and it very well might be that once I know the inns and outs of the languages I will see that they are very different. One thing that they both can do in a way is create a class/object and create instances of that. Ruby is built for this more it seems since you can so easily put together a class with different methods inside it, however in javascript you have to create a function to construct these new objects. But they both accomplish the same task. Objects in Javascript resemble Hashes' in Ruby, you assign a name to a value. That value can be either be a string, boolean, number or unlike a Ruby hash a function. In Javascript you use the keyword this instead of the @@ like in a ruby class, below I will give a simple examples of both a Ruby class and Javascript object constructor.
Javascript
function car(model) {
this.model = model;
this.paint = function() {
prompt( "what color is your car" )
}
}
bwm = new car("bwm")
bwm.paint // -> prompts
Ruby
class Car
def inilize name
@name = name
end
def paint(color)
@color = color
end
end


Menu
Home
Fundraiser
Meeting Tracker
Check Request
Student Organnization
Student Organization - Check Request Form
Request for payment to:
Amount to be paid:
Reason for request:
Individual requesting check:
Organization to be charged:
Indicate what date this check is needed:
2nd signature for approval:
Today's Date:
Comments:
Reset Form
Submit


%- include ../partials/scripts.html %>
<%- include ../partials/navbar.html %>
Post A Service
Latest Services
<%- include ../partials/footer.html %>


BC Explorer
Back
Home
connect
disconnect
Services
Device_ID:
Is connected:
Get Device Information!
Get RSSI!
Create Pair!
Remove Pair!
ServiceIndex:
ServiceUUID: