Play the Five-Note Sequence from Close Encounters of the Third Kind
Inspiration
The sounds on my Simon soundwall are based on the the famous five-notes sequence from Close Encounters of the Third Kind, a 1977 American science fiction film.
Stunning galaxy pictures are provided by The Hubble Space Telescope, launched in 1990 into a low-Earth orbit 569 km above the ground.
Did you know that Chromesthesia (or sound-to-color synesthesia) is a neurological phenomenon in which heard sounds automatically and involuntarily evoke an experience of color?


the with and patients {background margin {border-style SARS-CoV- px;} #ffffff;} cardiovascular had heart ACE for infection severe that coronavirus myocardial respiratory are COVID- acute cardiac damage have injury px; were {font-family Therefore, during font-size more novel pneumonia symptoms underlying COVID-, COVID-. CVD SARS-CoV associated can caused double; has infected might should syndrome system treatment which who The Wuhan, also border-color border-width levels solid; these treated {font-style {font-weight ICU bold cause courier; disease em; from given history hypertension increased likely mechanisms metabolism outbreak pt;} than virus was


Brett Zamir
on 2012-07-04 16:56:02
@Anonymous: Our function is returning what PHP also returns in your example. The PHP function is based on the byte value of the string--i.e., concatening the hex value of each character byte one byte at a time instead of treating the input string characters as individual bits.
Ours is also, though based on the value of each UTF-16 character as used by JavaScript (internally--as opposed to the character encoding of the page which can (and should) be UTF-8) rather than trying to treat JavaScript strings as UTF-8 multiple byte values as PHP treats them.
If you need the latter behavior, that can be achieved by:
function bin2hex (s) {
return encodeURIComponent(s+'').replace(/%/g, '').toLowerCase();
}
If you want your functionality in the PHP way (and thus php.js way), you can use:
dechex(bindec('10100101'))
which will give "a5" lower case (as in PHP).
Rafa?
on 2012-06-29 23:38:44
@ntoniazzi: thanks for the improvement. It's now on git (https://github.com/kvz/phpjs/commit/fe540ca0f15a4127204ba7615f64fcaafb33c81f). If you want to have something else than your nick (ntoniazzi) in the "credit" section, please contact me.
ntoniazzi
on 2012-06-29 16:50:11
This one is about 50% faster :
function bin2hex(s) {
var i, m, o = "", n;
for (i = 0, m = s.length; i< m; i++) {
n = s.charCodeAt(i).toString(16)
o += n.length < 2 ? "0" + n : n;
}
return o;
}
Anonymous
on 2012-05-13 17:05:03
Sorry but this not work for convert binaries numbers to hexadecimal numbers. WTF! Try convert "10100101"... your function return "3130313030313031" (but the correct answer is "A5").
Brett Zamir
on 2010-04-13 04:35:24
Hello Max! Actually, the character referred to on that page is in fact a control character, not the character that it shows. It appears that they may be rendered at that site with that appearance because Windows-1252 does define the character at that code point as in fact being that Latin ligature: http://en.wikipedia.org/wiki/Windows-1252#Codepage_layout . If you consult http://www.unicode.org/charts/PDF/U0080.pdf , you can confirm that the character is not supposed to be rendered the way it is on the page you have cited, while you can see at http://www.unicode.org/charts/PDF/U0100.pdf that U+152 is the one it is showing.
However, if you go to their "browser test page", even though you can't see the character in Firefox, if you copy the hidden character there (minus the surrounding spaces and tabs) and use it in the bin2hex function, you'll see that it returns '8c'.
So the behavior of the function is correct. FYI, if you're using Firefox, my extension at https://addons.mozilla.org/en-US/firefox/addon/5235 will let you find the definitions of characters similar to that site and some of the other information it contains, with characters rendered as is, or also available with a transcluded image from the Unicode site itself so you can see how it is supposed to look. And if you are seeking for the real characters, you can use the extension to search by character name, e.g., to search for "oe", you'll turn up U+152 in the chart view.
Also, FYI, many people confuse Windows-1252 with Latin-1 (ISO-8859-1) to such an extent that even browsers do so, and now the HTML5 draft is purposely defining Latin-1 to map to Windows-1252: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#character-encodings-0 ! To avoid the confusion and get all kinds of other benefits, always use Unicode...
Max
on 2010-04-12 23:47:06
Hi all !
I think there is a bug with some characters in the bin2hex function.
For example, with this char : "Œ" i have the hex : "152"
and it should be "008c" ?
http://www.fileformat.info/info/unicode/char/008c/index.htm
"152" is not an hexadecimal code ?
And it's the same problem with these letters : Š š Ž ž Œ œ Ÿ
Thanks !
Kevin van Zonneveld
on 2008-11-25 17:03:51
@ Linuxworld: Thanks a lot for your thorough contribution!
Linuxworld
on 2008-11-22 19:07:49
Hum, lacks a-f range in the previous snippet,
Hope this time is the good one.
function bin2hex(s){
// http://kevin.vanzonneveld.net
// + original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
// + bugfixed by: Onno Marsman
// + bugfixed by: Linuxworld (v2)
// * example 1: bin2hex('Kev');
// * returns 1: '4b6576'
var v,i, f = 0, a = [];
s += '';
f = s.length;
for(i = 0; i<f; i++){
a[i] = s.charCodeAt(i).toString(16).replace(/^([\da-f])$/,"0$1");
}
return a.join('');
}
Linuxworld
on 2008-11-22 16:55:51
Sorry for the previous duplicates, here is the optimized version (ie shorter, with no more str_repeat dependency):
function bin2hex(s){
// http://kevin.vanzonneveld.net
// + original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
// + bugfixed by: Onno Marsman
// + bugfixed by: Linuxworld (v2)
// * example 1: bin2hex('Kev');
// * returns 1: '4b6576'
var v,i, f = 0, a = [];
s += '';
f = s.length;
for(i = 0; i<f; i++){
a[i] = s.charCodeAt(i).toString(16).replace(/^(\d)$/,"0$1");
}
return a.join('');
}
Now, alert(bin2hex(String.fromCharCode(0x00))) gives 00 which is the expected result.
Linuxworld
on 2008-11-18 16:34:54
Hello Kevin,
First, nice job and big thanks for sharing this kind of stuff: JS and PHP worth to be closer thanks to equivalents.
Before fixing your bin2hex function that were not working in my case, I have used one of http://www.paulschou.com/tools/xlate/ that works fine on php side but translated with your js equivalents gave a string with NaN and zeroes..
Your version of bin2hex is buggy and returns a shorter string length due to missing prepending zeroes for low bytes (ie those of value < 0x10). Note that an user has provided a patched version of ord that seems to take this into acccount and with this one, Paul schou's bin2hex equivalent may work on the js side.
Here is the patched and commented version, Enjoy. Linuxworld
/**
*@name bin2hex
*@brief Convert binary data into hexadecimal representation
*@version 2.0
*@requires str_repeat
*@note
* V1.0 - original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
* V1.1 - bugfixed by: Onno Marsman
* V2.0 (18.11.2008) 2 digits for low bytes fix by Linuxworld
*@see http://kevin.vanzonneveld.net/techblog/article/javascript_equivalent_for_phps_bin2hex/
*@internal Similar to recursive ord or encodeuri without %. Be warned encodeuri or encodeuricomponent
* are buggy on both JS/PHP sides. An attempt to reproduce encodeUri was made here http://www.captain.at/howto-php-urlencode-javascript-decodeURIComponent.php but its encoding/decoding
*table is incomplete and thus not as much reliable than bin2hex.
* For all escaping stuff to retrieve hex values: http://xkr.us/articles/javascript/encode-compare/
*@example
* example 1: bin2hex('Kev');
* returns 1: '4b6576'
*@param String s a binary string (ie one given after base64_decode call for sample)
*@return String the hexadecimal representation of the given string.
**/
function bin2hex(s){
var v,i, f = 0, a = [];
s += '';
f = s.length;
for(i = 0; i<f; i++){
v= s.charCodeAt(i).toString(16);
a[i] =str_repeat("0", 2-v.toString().length)+v; //ensures 2 digit code for bytes!
}
return a.join('');
}
Linuxworld
on 2008-11-18 16:34:10
Hello Kevin,
First, nice job and big thanks for sharing this kind of stuff: JS and PHP worth to be closer thanks to equivalents.
Before fixing your bin2hex function that were not working in my case, I have used one of http://www.paulschou.com/tools/xlate/ that works fine on php side but translated with your js equivalents gave a string with NaN and zeroes..
Your version of bin2hex is buggy and returns a shorter string length due to missing prepending zeroes for low bytes (ie those of value < 0x10). Note that an user has provided a patched version of ord that seems to take this into acccount and with this one, Paul schou's bin2hex equivalent may work on the js side.
Here is the patched and commented version, Enjoy. Linuxworld
/**
*@name bin2hex
*@brief Convert binary data into hexadecimal representation
*@version 2.0
*@requires str_repeat
*@note
* V1.0 - original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
* V1.1 - bugfixed by: Onno Marsman
* V2.0 (18.11.2008) 2 digits for low bytes fix by Linuxworld
*@see http://kevin.vanzonneveld.net/techblog/article/javascript_equivalent_for_phps_bin2hex/
*@internal Similar to recursive ord or encodeuri without %. Be warned encodeuri or encodeuricomponent
* are buggy on both JS/PHP sides. An attempt to reproduce encodeUri was made here http://www.captain.at/howto-php-urlencode-javascript-decodeURIComponent.php but its encoding/decoding
*table is incomplete and thus not as much reliable than bin2hex.
* For all escaping stuff to retrieve hex values: http://xkr.us/articles/javascript/encode-compare/
*@example
* example 1: bin2hex('Kev');
* returns 1: '4b6576'
*@param String s a binary string (ie one given after base64_decode call for sample)
*@return String the hexadecimal representation of the given string.
**/
function bin2hex(s){
var v,i, f = 0, a = [];
s += '';
f = s.length;
for(i = 0; i<f; i++){
v= s.charCodeAt(i).toString(16);
a[i] =str_repeat("0", 2-v.toString().length)+v; //ensures 2 digit code for bytes!
}
return a.join('');
}
Greg Copenhaver
on 2008-05-09 17:40:19
I attempted to use your bin2hex() function, but had a problem with it in my situation (Javascript LM hashes - http://gcopenhaver.com/node/94). Some characters in the string that I was passing to were 0x0f and lower, and this function does not include the first '0' for any of those, causing problems if it's not at the beginning of the string. Here's a function from http://tero.co.uk/des/code.php that will include the '0' if a byte is 0x0f or less. In my use, I removed the '0x' prefix that was set in this function. This is the code as copied from the des.js file. I don't know anything about the licensing of this code.
function stringToHex (s) {
var r = "0x";
var hexes = new Array ("0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f");
for (var i=0; i<s.length; i++) {r += hexes [s.charCodeAt(i) >> 4] + hexes [s.charCodeAt(i) & 0xf];}
return r;
}


retract/[1,2]
retract/1 – removes a clause from the database
retract/2 – removes a clause specified by a database reference
erase/1 – removes a clause from the database
FORMS
retract(Clause)
retract(Clause,DBRef)
erase(DBRef)
DESCRIPTION
When Clause is bound to an atom or a structured term, the current module is searched for
a clause that will unify with Clause. When a matching clause is found in the database, Clause is unified with the structure corresponding to the clause. The clause is then
removed from the database.
retract/2 additionally unifies DBRef with the database reference of the clause.
erase/1 removes the clause associated with DBRef from the database. Note that erase(DBRef) should never be called following retract(Clause,DBRef) since at that point DBRef is no longer a valid database reference.
retract/1 and retract/2 will repeatedly generate and remove clauses upon backtracking. :/2 can be used to specify which module should be searched.
EXAMPLES
The following example shows how retract/1 and retract/2 can be used to get rid of all the comic book heroes that live in our modules.
First we create all the heroes by consulting user. Then we get rid of hero(spiderman) by using a simple call to retract/1:
?- [user].
Consulting user.
hero(spiderman).
hero(superman).
hero(batman).
module girls.
hero(superwoman).
endmod.
^D user consulted.
yes.
?- retract(hero(spiderman)).
yes.
In the next example, we show what heroes are left by using the listing/1 procedure. After that, we remove hero(superman)with a retract/2 call. The old database reference to the man of steel is instantiated to Ref.
?- listing(hero/1).
% user:hero/1
hero(superman).
hero(batman).
% girls:hero/1
hero(superwoman).
yes.
?- retract(hero(superman),Ref).
Ref = ’$dbref’(5208,15,2384,1)
yes.
In this next example, we use clause/3 to find the database reference of hero(batman). After this, we use the database reference in a retract/2 call to remove hero(batman) from the database. Note that the Clause argument for retract/2 is uninstantiated in this call. The clause that was removed is instantiated
to Clause, after the call to retract/2 has succeeded.
?- clause(hero(batman),Body,Ref).
Body = true
Ref = ’$dbref’(5052,15,2384,2)
yes.
?- retract(Clause,’$dbref’(5052,15,2384,2)).
Clause = hero(batman)
yes.
In the following example, we list the heroes left in the database. Only hero(superwoman) is left, but she’s in a different module. However, using the Mod:Goal construct, we can remove her too:
?- listing(hero/1).
% girls:hero/1
hero(superwoman).
yes.
?- girls:retract(hero(X)).
X = superwoman
yes.
?- listing(hero/1).
yes.
As the last call to listing/1 shows, there are no more heroes left in the database.
SEE ALSO
clause/1,
[Bowen 91, 7.3], [Clocksin 81, 6.4], [Bratko 86, 7.4], [Sterling 86, 12.2].


Take medium sized or larger square sheet, flip white side up. Fold from corner to corner.
Take medium sized or larger square sheet, flip white side up. Fold from corner to corner.
Crease along diagonal making sure it's lined up. Turn 90 degrees, and repeat.
Fold triangle at crease into 1/4 sized triangle
Crease the fold.
Open flap from step 4. Press the corner down to meet the other corner.
Crease the fold, resulting in a square section. There should be an outward facing crease diagonally from corner to corner.
Flip over so the square is now the base.
Repeat step 5 and 6.
Open triangle up and fold in half diagonally on the crease. The square should fold naturally with the crease and the color should be on the inside.
Repeat steps 5 and 6 once more on this side.
There should now be four flaps, two on top and two on bottom. Take on of those flapsand stand it upright.
In a similar fashion to steps 5 and 6, open the flap and press down. This should result in a triangle from the top to the end of the color.
Grab the left side flap from the piece you just made. Starting at the point nearest you, fold the outside flap to line up with the center line.
Repeat step 13, making sure the two folds line up with the middle as well as possible.
Open those two flaps up, and create a crease from the corners of the creases you just made. this will serve as a guide in the next step.
This is one of the more difficult techniques to get right at first so keep trying it until it looks right. Lift the center crease at the base of the colored triangle. Using the crease vertex you just drew with your finger, flip the bottom flap up. Be sure the two side flaps come with evenly so that when you push it down, they line up evenly.
Fold top of flap down over the finger drawn crease.
Repeat steps 12 through 17 on the 3 remaining flaps.
After all sides are complete, it should look like this. Now lay it down flat on the table, with the solid end on the bottom and the flat side facing up.
Fold from the bottom point matching the outside edge with the inside middle crease.
Repeat step 20 for the opposite flap. Repeate for all four sides.
Hold with the creased flaps in your hand and grab the top portion of that side.
Crease the flap over towards the bottom. Repeate for all four sides.
Open flower up and grab a pedal of the Lily. Roll over finger or pencil to give it a realistic droop.


depd
Deprecate all the things
With great modules comes great responsibility; mark things deprecated!
Install
This module is installed directly using npm
:
$ npm install depd
This module can also be bundled with systems like Browserify or webpack, though by default this module will alter it’s API to no longer display or track deprecations.
API
var deprecate = require('depd')('my-module')
This library allows you to display deprecation messages to your users. This library goes above and beyond with deprecation warnings by introspection of the call stack (but only the bits that it is interested in).
Instead of just warning on the first invocation of a deprecated function and never again, this module will warn on the first invocation of a deprecated function per unique call site, making it ideal to alert users of all deprecated uses across the code base, rather than just whatever happens to execute first.
The deprecation warnings from this module also include the file and line information for the call into the module that the deprecated function was in.
NOTE this library has a similar interface to the debug
module, and
this module uses the calling file to get the boundary for the call stacks,
so you should always create a new deprecate
object in each file and not
within some central file.
depd(namespace)
Create a new deprecate function that uses the given namespace name in the messages and will display the call site prior to the stack entering the file this function was called from. It is highly suggested you use the name of your module as the namespace.
deprecate(message)
Call this function from deprecated code to display a deprecation message. This message will appear once per unique caller site. Caller site is the first call site in the stack in a different file from the caller of this function.
If the message is omitted, a message is generated for you based on the site
of the deprecate()
call and will display the name of the function called,
similar to the name displayed in a stack trace.
deprecate.function(fn, message)
Call this function to wrap a given function in a deprecation message on any call to the function. An optional message can be supplied to provide a custom message.
deprecate.property(obj, prop, message)
Call this function to wrap a given property on object in a deprecation message on any accessing or setting of the property. An optional message can be supplied to provide a custom message.
The method must be called on the object where the property belongs (not inherited from the prototype).
If the property is a data descriptor, it will be converted to an accessor descriptor in order to display the deprecation message.
process.on(‘deprecation’, fn)
This module will allow easy capturing of deprecation errors by emitting the
errors as the type “deprecation” on the global process
. If there are no
listeners for this type, the errors are written to STDERR as normal, but if
there are any listeners, nothing will be written to STDERR and instead only
emitted. From there, you can write the errors in a different format or to a
logging source.
The error represents the deprecation and is emitted only once with the same rules as writing to STDERR. The error has the following properties:
message
- This is the message given by the libraryname
- This is always'DeprecationError'
namespace
- This is the namespace the deprecation came fromstack
- This is the stack of the call to the deprecated thing
Example error.stack
output:
DeprecationError: my-cool-module deprecated oldfunction
at Object.<anonymous> ([eval]-wrapper:6:22)
at Module._compile (module.js:456:26)
at evalScript (node.js:532:25)
at startup (node.js:80:7)
at node.js:902:3
process.env.NO_DEPRECATION
As a user of modules that are deprecated, the environment variable NO_DEPRECATION
is provided as a quick solution to silencing deprecation warnings from being
output. The format of this is similar to that of DEBUG
:
$ NO_DEPRECATION=my-module,othermod node app.js
This will suppress deprecations from being output for “my-module” and “othermod”.
The value is a list of comma-separated namespaces. To suppress every warning
across all namespaces, use the value *
for a namespace.
Providing the argument --no-deprecation
to the node
executable will suppress
all deprecations (only available in Node.js 0.8 or higher).
NOTE This will not suppress the deperecations given to any “deprecation” event listeners, just the output to STDERR.
process.env.TRACE_DEPRECATION
As a user of modules that are deprecated, the environment variable TRACE_DEPRECATION
is provided as a solution to getting more detailed location information in deprecation
warnings by including the entire stack trace. The format of this is the same as
NO_DEPRECATION
:
$ TRACE_DEPRECATION=my-module,othermod node app.js
This will include stack traces for deprecations being output for “my-module” and
“othermod”. The value is a list of comma-separated namespaces. To trace every
warning across all namespaces, use the value *
for a namespace.
Providing the argument --trace-deprecation
to the node
executable will trace
all deprecations (only available in Node.js 0.8 or higher).
NOTE This will not trace the deperecations silenced by NO_DEPRECATION
.
Display
When a user calls a function in your library that you mark deprecated, they
will see the following written to STDERR (in the given colors, similar colors
and layout to the debug
module):
bright cyan bright yellow
| | reset cyan
| | | |
▼ ▼ ▼ ▼
my-cool-module deprecated oldfunction [eval]-wrapper:6:22
▲ ▲ ▲ ▲
| | | |
namespace | | location of mycoolmod.oldfunction() call
| deprecation message
the word "deprecated"
If the user redirects their STDERR to a file or somewhere that does not support
colors, they see (similar layout to the debug
module):
Sun, 15 Jun 2014 05:21:37 GMT my-cool-module deprecated oldfunction at [eval]-wrapper:6:22
▲ ▲ ▲ ▲ ▲
| | | | |
timestamp of message namespace | | location of mycoolmod.oldfunction() call
| deprecation message
the word "deprecated"
Examples
Deprecating all calls to a function
This will display a deprecated message about “oldfunction” being deprecated from “my-module” on STDERR.
var deprecate = require('depd')('my-cool-module')
// message automatically derived from function name
// Object.oldfunction
exports.oldfunction = deprecate.function(function oldfunction () {
// all calls to function are deprecated
})
// specific message
exports.oldfunction = deprecate.function(function () {
// all calls to function are deprecated
}, 'oldfunction')
Conditionally deprecating a function call
This will display a deprecated message about “weirdfunction” being deprecated from “my-module” on STDERR when called with less than 2 arguments.
var deprecate = require('depd')('my-cool-module')
exports.weirdfunction = function () {
if (arguments.length < 2) {
// calls with 0 or 1 args are deprecated
deprecate('weirdfunction args < 2')
}
}
When calling deprecate
as a function, the warning is counted per call site
within your own module, so you can display different deprecations depending
on different situations and the users will still get all the warnings:
var deprecate = require('depd')('my-cool-module')
exports.weirdfunction = function () {
if (arguments.length < 2) {
// calls with 0 or 1 args are deprecated
deprecate('weirdfunction args < 2')
} else if (typeof arguments[0] !== 'string') {
// calls with non-string first argument are deprecated
deprecate('weirdfunction non-string first arg')
}
}
Deprecating property access
This will display a deprecated message about “oldprop” being deprecated from “my-module” on STDERR when accessed. A deprecation will be displayed when setting the value and when getting the value.
var deprecate = require('depd')('my-cool-module')
exports.oldprop = 'something'
// message automatically derives from property name
deprecate.property(exports, 'oldprop')
// explicit message
deprecate.property(exports, 'oldprop', 'oldprop >= 0.10')


This will not only help to find errors between separate modules, it will also generate better code, since the compiler must not assume that a variable sized parameter list is in place and must not pass the argument count to the called function. This will lead to shorter and faster code.
Variable declarations in nested blocks are usually a good thing. But with cc65, there is a drawback: Since the compiler generates code in one pass, it must create the variables on the stack each time the block is entered and destroy them when the block is left. This causes a speed penalty and larger code.
The compiler needs hints from you about the code to generate. It will try to optimize the generated code, but follow the outline you gave in your C program. So for example, when accessing indexed data structures, get a pointer to the element and use this pointer instead of calculating the index again and again. If you want to have your loops unrolled, or loop invariant code moved outside the loop, you have to do that yourself.
While long support is necessary for some things, it's really, really slow on the 6502. Remember that any long variable will use 4 bytes of memory, and any operation works on double the data compared to an int.
The 6502 CPU has no opcodes to handle signed values greater than 8 bit. So sign extension, test of signedness etc. has to be done with extra code. As a consequence, the code to handle signed operations is usually a bit larger and slower than the same code for unsigned types.
While in arithmetic operations, chars are immidiately promoted to ints, they are passed as chars in parameter lists and are accessed as chars in variables. The code generated is usually not much smaller, but it is faster, since accessing chars is faster. For several operations, the generated code may be better if intermediate results that are known not to be larger than 8 bit are casted to chars.
You should especially use unsigned chars for loop control variables if the loop is known not to execute more than 255 times.
When indexing into an array, the compiler has to calculate the byte offset into the array, which is the index multiplied by the size of one element. When doing the multiplication, the compiler will do a strength reduction, that is, replace the multiplication by a shift if possible. For the values 2, 4 and 8, there are even more specialized subroutines available. So, array access is fastest when using one of these sizes.
Since cc65 is not building an explicit expression tree when parsing an expression, constant subexpressions may not be detected and optimized properly if you don't help. Look at this example:
#define OFFS 4
int i;
i = i + OFFS + 3;
The expression is parsed from left to right, that means, the compiler sees 'i', and puts it contents into the secondary register. Next is OFFS, which is constant. The compiler emits code to add a constant to the secondary register. Same thing again for the constant 3. So the code produced contains a fetch of 'i', two additions of constants, and a store (into 'i'). Unfortunately, the compiler does not see, that "OFFS + 3" is a constant for itself, since it does its evaluation from left to right. There are some ways to help the compiler to recognize expression like this:
The compiler is not always smart enough to figure out, if the rvalue of an increment is used or not. So it has to save and restore that value when producing code for the postincrement and postdecrement operators, even if this value is never used. To avoid the additional overhead, use the preincrement and predecrement operators if you don't need the resulting value. That means, use
...
++i;
...
instead of
...
i++;
...
The compiler produces optimized code, if the value of a pointer is a constant. So, to access direct memory locations, use
#define VDC_STATUS 0xD601
*(char*)VDC_STATUS = 0x01;
That will be translated to
lda #$01
sta $D601
The constant value detection works also for struct pointers and arrays, if the subscript is a constant. So
#define VDC ((unsigned char*)0xD600)
#define STATUS 0x01
VDC[STATUS] = 0x01;
will also work.
If you first load the constant into a variable and use that variable to access an absolute memory location, the generated code will be much slower, since the compiler does not know anything about the contents of the variable.
Initialization of local variables when declaring them gives shorter and faster code. So, use
int i = 1;
instead of
int i;
i = 1;
But beware: To maximize your savings, don't mix uninitialized and initialized variables. Create one block of initialized variables and one of uniniitalized ones. The reason for this is, that the compiler will sum up the space needed for uninitialized variables as long as possible, and then allocate the space once for all these variables. If you mix uninitialized and initialized variables, you force the compiler to allocate space for the uninitialized variables each time, it parses an initialized one. So do this:
int i, j;
int a = 3;
int b = 0;
instead of
int i;
int a = 3;
int j;
int b = 0;
The latter will work, but will create larger and slower code.
When addressing an array via a pointer, don't use the plus and dereference operators, but the array operator. This will generate better code in some common cases.
Don't use
char* a;
char b, c;
char b = *(a + c);
Use
char* a;
char b, c;
char b = a[c];
instead.
Register variables may give faster and shorter code, but they do also have an overhead. Register variables are actually zero page locations, so using them saves roughly one cycle per access. The calling routine may also use register variables, so the old values have to be saved on function entry and restored on exit. Saving an d restoring has an overhead of about 70 cycles per 2 byte variable. It is easy to see, that - apart from the additional code that is needed to save and restore the values - you need to make heavy use of a variable to justify the overhead.
As a general rule: Use register variables only for pointers that are dereferenced several times in your function, or for heavily used induction variables in a loop (with several 100 accesses).
When declaring register variables, try to keep them together, because this will allow the compiler to save and restore the old values in one chunk, and not in several.
And remember: Register variables must be enabled with -r
or -Or
.
The language rules for constant numeric values specify that decimal constants without a type suffix that are not in integer range must be of type long int or unsigned long int. So a simple constant like 40000 is of type long int! This is often unexpected and may cause an expression to be evaluated with 32 bits. While in many cases the compiler takes care about it, in some places it can't. So be careful when you get a warning like
test.c(7): Warning: Constant is long
Use the U
, L
or UL
suffixes to tell the compiler the desired
type of a numeric constant.
Since cc65 has the "wrong" calling order, the location of the fixed parameters in a variadic function (a function with a variable parameter list) depends on the number and size of variable arguments passed. Since this number and size is unknown at compile time, the compiler will generate code to calculate the location on the stack when needed.
Because of this additional code, accessing the fixed parameters in a variadic function is much more expensive than access to parameters in a "normal" function. Unfortunately, this additional code is also invisible to the programmer, so it is easy to forget.
As a rule of thumb, if you access such a parameter more than once, you should think about copying it into a normal variable and using this variable instead.


Datacite/ORCID search & claim tool
Tool for searching for works in the DataCite metadata catalogue and adding them to an ORCID profile. Based on the code for CrossRef Metadata Search.
Status: in production at http://datacite.labs.orcid-eu.org
Code: https://github.com/ORCID-EU-Labs/cr-search
ISNI2ORCID
Tool for searching the ISNI registry by name and adding one or more ISNIs to ORCID profile as as external identifiers.
Status: in beta testing at http://isni2orcid.labs.orcid-eu.org
Code: https://github.com/gthorisson/isni2orcid
ORCID Feed
ORCID works as machine-readable feeds in RSS, JSON and other formats.
Status: in beta testing at http://feed.labs.orcid-eu.org
Code: https://github.com/ORCID-EU-Labs/orcid-feed
All current Labs projects are being undertaken as part of the ODIN project - ORCID and DataCite Interoperability Network.


RepresentationGraph
Namespace: Legivel
Nested types and modules
| Type | Description |
| EmptyDocumentResult |
Empty Result Info (possible candidate to discard) |
| ErrorResult |
Yaml Error Result Info |
| EventNodeKind | |
| GlobalTag |
Defines a Global Tag, its properties and functions. |
| LocalTag |
Defines a Local Tag, its properties and functions. |
| LocalTagsFuncs |
Local Tags should use these functions when appropriate |
| Node |
The main/root structure of a Yaml Node |
| NodeData<'T> |
Contains the actual data of a node, used for all types, Map, Seq, Scalar |
| NodeKind |
A Node may be of Maping, Sequence or Scalar type |
| ParseEvents | |
| ParseInfo |
Registers parsing information per Node, related to the source document |
| ParseMessageAtLine |
Contains a warning or error message |
| ParsedDocumentResult |
Fully parsed document result info |
| Representation |
Representation of the parsed document |
| TagFunctions |
Each Global Tag must implement the functions in this type |
| TagKind |
A Tag can be Local, Global, Unrecognized or Non Specific |
| TagReport |
Statistics of problematic tags used in the source yaml |
| TagShorthand |
Mapping of tag shorthands, with the TAG directive |
| Unrecognized |
Statistics for unrecognized tags |
| Module | Description |
| ParseEvents |


SpectrogramJS
Visualize sounds using a spectrogram - right in your browser!
See how to use SpectrogramJS


This page describes a simple, valid format to use in your HTML document heads. The head of an HTML document is not displayed in your web browser when the page loads; it contains metadata, or information about the page, such as a page title, links to stylesheets, or keyword data. The document head is different from a header, which is introductory content on a page: usually elements such as a logo, a first-level heading, and often the main navigation for the site.
For a full explanation of HTML document heads and metadata, please read "What's in the head? Metadata in HTML" at MDN Web Docs.
The document head section of your HTML file must include at least the following:
<!DOCTYPE html> <html lang="en-US"> <head> <title> Your page title goes here. </title> </head> <body>
After your final paragraph or othe content element tag is closed, be sure to close your body and html tags:
</body> </html>


new ACollector()
An array based collector
- Source:
Extends
Members
-
length :number
-
Get the size of the collection
Type:
- number
- Inherited From:
- Source:
Methods
-
add(item)
-
Adds to the top of the collection
Parameters:
Name Type Description item
* The item to add to the collection. Only one item at a time can be added
- Source:
-
all(qu) → {boolean}
-
Returns true if all items match the query. Aliases as
every
Parameters:
Name Type Description qu
object The query to execute
- Inherited From:
- Source:
Returns:
- Type
- boolean
-
any(qu) → {boolean}
-
Returns true if any of the items match the query. Aliases as
all
Parameters:
Name Type Description qu
object The query to execute
- Inherited From:
- Source:
Returns:
- Type
- boolean
-
append(item)
-
Add to the bottom of the list
Parameters:
Name Type Description item
* The item to add to the collection. Only one item at a time can be added
- Source:
-
at(args)
-
Creates an array of elements from the specified indexes, or keys, of the collection. Indexes may be specified as individual arguments or as arrays of indexes
Parameters:
Name Type Description args
indexes The indexes to use
- Source:
-
compact()
-
Modifies the collection with all falsey values of array removed. The values false, null, 0, "", undefined and NaN are all falsey.
- Source:
-
countBy(query, iterator, thisobj) → {object}
-
Creates an object composed of keys returned from running each element of the collection through the given callback. The corresponding value of each key is the number of times the key was returned by the callback.
Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate. If you pass in a query, only the items that match the query are iterated over.
iterator
function thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
Returns:
- Type
- object
-
each(query, iterator, thisobj)
-
Iterate over each item in the collection, or a subset that matches a query. This supports two signatures:
.each(query, function)
and.each(function)
. If you pass in a query, only the items that match the query are iterated over.Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate
iterator
function Function to execute against each item in the collection
thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
-
every(qu) → {boolean}
-
Returns true if all items match the query. Aliases as
all
Parameters:
Name Type Description qu
object The query to execute
- Inherited From:
- Source:
Returns:
- Type
- boolean
-
find(qu) → {array}
-
Find all records that match a query
Parameters:
Name Type Description qu
object The query to execute.
- Inherited From:
- Source:
Returns:
The results
- Type
- array
-
findKeys(qu) → {array}
-
Find all records that match a query and returns the keys for those items. This is similar to module:document/probe.find but instead of returning records, returns the keys. If
obj
is an object it will return the hash key. If 'obj' is an array, it will return the indexParameters:
Name Type Description qu
object The query to execute.
- Inherited From:
- Source:
Returns:
- Type
- array
-
findOne(qu) → {object}
-
Returns the first record that matches the query. Aliased as
seek
.Parameters:
Name Type Description qu
object The query to execute.
- Inherited From:
- Source:
Returns:
- Type
- object
-
findOneKey(qu) → {object}
-
Returns the first record that matches the query and returns its key or index depending on whether
obj
is an object or array respectively. Aliased asseekKey
.Parameters:
Name Type Description qu
object The query to execute.
- Inherited From:
- Source:
Returns:
- Type
- object
-
flatten(query, iterator,, thisobj) → {number}
-
Flattens a nested array (the nesting can be to any depth). If isShallow is truthy, array will only be flattened a single level. If callback is passed, each element of array is passed through a callback before flattening.
Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate . If you pass in a query, only the items that match the query are iterated over.
iterator,
function thisobj
object <optional>
The value of
this
- Source:
Returns:
- Type
- number
-
groupBy(query, iterator, thisobj) → {object}
-
Creates an object composed of keys returned from running each element of the collection through the callback. The corresponding value of each key is an array of elements passed to callback that returned the key. The callback is invoked with three arguments: (value, index|key, collection).
Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate . If you pass in a query, only the items that match the query are iterated over.
iterator
function thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
Returns:
- Type
- object
-
index(key) → {*}
-
Gets an items by its index
Parameters:
Name Type Description key
number The index to get
- Source:
Returns:
- Type
- *
-
map(query, iterator, thisobj)
-
Maps the contents to an array by iterating over it and transforming it. You supply the iterator. Supports two signatures:
.map(query, function)
and.map(function)
. If you pass in a query, only the items that match the query are iterated over.Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate
iterator
function Function to execute against each item in the collection
thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
-
max(query, iterator, thisobj) → {number}
-
Retrieves the maximum value of an array. If callback is passed, it will be executed for each value in the array to generate the criterion by which the value is ranked.
Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate . If you pass in a query, only the items that match the query are iterated over.
iterator
function thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
Returns:
- Type
- number
-
min(query, iterator, thisobj) → {number}
-
Retrieves the minimum value of an array. If callback is passed, it will be executed for each value in the array to generate the criterion by which the value is ranked.
Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate . If you pass in a query, only the items that match the query are iterated over.
iterator
function thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
Returns:
- Type
- number
-
pluck(query, property) → {*}
-
Reduce the collection to a single value. Supports two signatures:
.pluck(query, function)
and.pluck(function)
Parameters:
Name Type Argument Description query
object <optional>
The query to evaluate. If you pass in a query, only the items that match the query are iterated over.
property
string The property that will be 'plucked' from the contents of the collection
- Inherited From:
- Source:
Returns:
- Type
- *
-
push(item)
-
Add an item to the top of the list. This is identical to
add
, but is provided for stack semanticsParameters:
Name Type Description item
* The item to add to the collection. Only one item at a time can be added
- Source:
-
reduce(query, iterator, accumulator, thisobj) → {*}
-
Reduces a collection to a value which is the accumulated result of running each element in the collection through the callback, where each successive callback execution consumes the return value of the previous execution. If accumulator is not passed, the first element of the collection will be used as the initial accumulator value. are iterated over.
Parameters:
Name Type Argument Description query
object <optional>
A query to evaluate
iterator
function The function that will be executed in each item in the collection
accumulator
* <optional>
Initial value of the accumulator.
thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
Returns:
- Type
- *
-
remove(qu) → {object|array}
-
Remove all items in the object/array that match the query
Parameters:
Name Type Description qu
object The query to execute. See module:document/probe.queryOperators for the operators you can use.
- Inherited From:
- Source:
Returns:
The array or object as appropriate without the records.
- Type
- object | array
-
shuffle() → {array}
-
Creates an array of shuffled array values, using a version of the Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
- Inherited From:
- Source:
Returns:
- Type
- array
-
some(qu) → {boolean}
-
Returns true if any of the items match the query. Aliases as
any
Parameters:
Name Type Description qu
object The query to execute
- Inherited From:
- Source:
Returns:
- Type
- boolean
-
sortBy(query, iterator, thisobj) → {array}
-
Returns a sorted copy of the collection.
Parameters:
Name Type Argument Description query
object <optional>
The query to evaluate. If you pass in a query, only the items that match the query are iterated over.
iterator
function thisobj
object <optional>
The value of
this
- Inherited From:
- Source:
Returns:
- Type
- array
-
toArray() → {array}
-
Returns the collection as an array. If it is already an array, it just returns that.
- Inherited From:
- Source:
Returns:
- Type
- array
-
toJSON() → {Object|array}
-
Supports conversion to a JSON string or for passing over the wire
- Inherited From:
- Source:
Returns:
- Type
- Object | array
-
unique(qu) → {array}
-
Returns the set of unique records that match a query
Parameters:
Name Type Description qu
object The query to execute.
- Inherited From:
- Source:
Returns:
- Type
- array
-
update(qu, setDocument)
-
Updates all records in obj that match the query. See module:document/probe.updateOperators for the operators that are supported.
Parameters:
Name Type Description qu
object The query which will be used to identify the records to updated
setDocument
object The update operator. See module:document/probe.updateOperators
- Inherited From:
- Source:


JavaScript & CSS Scaffolding
Introduction
While Laravel does not dictate which JavaScript or CSS pre-processors you use, it does provide a basic starting point using Bootstrap and Vue that will be helpful for many applications. By default, Laravel uses NPM to install both of these frontend packages.
CSS
Laravel Mix provides a clean, expressive API over compiling SASS or Less, which are extensions of plain CSS that add variables, mixins, and other powerful features that make working with CSS much more enjoyable.html. In this document, we will briefly discuss CSS compilation in general; however, you should consult the full Laravel Mix documentation for more information on compiling SASS or Less.
JavaScript
Laravel does not require you to use a specific JavaScript framework or library to build your applications. In fact, you don't have to use JavaScript at all. However, Laravel does include some basic scaffolding to make it easier to get started writing modern JavaScript using the Vue library. Vue provides an expressive API for building robust JavaScript applications using components. As with CSS, we may use Laravel Mix to easily compile JavaScript components into a single, browser-ready JavaScript file.
Removing The Frontend Scaffolding
If you would like to remove the frontend scaffolding from your application, you may use the preset
Artisan command. This command, when combined with the none
option, will remove the Bootstrap and Vue scaffolding from your application, leaving only a blank SASS file and a few common JavaScript utility libraries:
php artisan preset none
Writing CSS
Laravel's package.json
file includes the bootstrap
package to help you get started prototyping your application's frontend using Bootstrap. However, feel free to add or remove packages from the package.json
file as needed for your own application. You are not required to use the Bootstrap framework to build your Laravel application - it is provided as a good starting point for those who choose to use it.
Before compiling your CSS, install your project's frontend dependencies using the Node package manager (NPM):
npm install
Once the dependencies have been installed using npm install
, you can compile your SASS files to plain CSS using Laravel Mix. The npm run dev
command will process the instructions in your webpack.mix.js
file. Typically, your compiled CSS will be placed in the public/css
directory:
npm run dev
The default webpack.mix.js
included with Laravel will compile the resources/sass/app.scss
SASS file. This app.scss
file imports a file of SASS variables and loads Bootstrap, which provides a good starting point for most applications. Feel free to customize the app.scss
file however you wish or even use an entirely different pre-processor by configuring Laravel Mix.
Writing JavaScript
All of the JavaScript dependencies required by your application can be found in the package.json
file in the project's root directory. This file is similar to a composer.json
file except it specifies JavaScript dependencies instead of PHP dependencies. You can install these dependencies using the Node package manager (NPM):
npm install
{tip} By default, the Laravel
package.json
file includes a few packages such asvue
andaxios
to help you get started building your JavaScript application. Feel free to add or remove from thepackage.json
file as needed for your own application.
Once the packages are installed, you can use the npm run dev
command to compile your assets. Webpack is a module bundler for modern JavaScript applications. When you run the npm run dev
command, Webpack will execute the instructions in your webpack.mix.js
file:
npm run dev
By default, the Laravel webpack.mix.js
file compiles your SASS and the resources/js/app.js
file. Within the app.js
file you may register your Vue components or, if you prefer a different framework, configure your own JavaScript application. Your compiled JavaScript will typically be placed in the public/js
directory.
{tip} The
app.js
file will load theresources/js/bootstrap.js
file which bootstraps and configures Vue, Axios, jQuery, and all other JavaScript dependencies. If you have additional JavaScript dependencies to configure, you may do so in this file.
Writing Vue Components
By default, fresh Laravel applications contain an ExampleComponent.vue
Vue component located in the resources/js/components
directory. The ExampleComponent.vue
file is an example of a single file Vue component which defines its JavaScript and HTML template in the same file. Single file components provide a very convenient approach to building JavaScript driven applications. The example component is registered in your app.js
file:
Vue.component(
'example-component',
require('./components/ExampleComponent.vue')
);
To use the component in your application, you may drop it into one of your HTML templates. For example, after running the make:auth
Artisan command to scaffold your application's authentication and registration screens, you could drop the component into the home.blade.php
Blade template:
@extends('layouts.app')
@section('content')
<example-component></example-component>
@endsection
{tip} Remember, you should run the
npm run dev
command each time you change a Vue component. Or, you may run thenpm run watch
command to monitor and automatically recompile your components each time they are modified.
If you are interested in learning more about writing Vue components, you should read the Vue documentation, which provides a thorough, easy-to-read overview of the entire Vue framework.
Using React
If you prefer to use React to build your JavaScript application, Laravel makes it a cinch to swap the Vue scaffolding with React scaffolding. On any fresh Laravel application, you may use the preset
command with the react
option:
php artisan preset react
This single command will remove the Vue scaffolding and replace it with React scaffolding, including an example component.


AI (2001)
The tone of Steven Spielberg's AI is uneven because of his collaboration with the late director Stanley Kubrick – but a mediocre work from either of these masters is still superior to fare offered by most other filmmakers.
Apparently Mr. Kubrick had been developing the project for years, and requested Mr. Spielberg to take it over. Based on a short story by Brian Aldiss, as well as the screen story by Ian Watson, AI is the first screenplay written by Speilberg since his CLOSE ENCOUNTERS OF THE THIRD KIND. The piece opens with a speech by Dr. Hobby (William Hurt) to his colleagues, a proclamation that even more human-like robots should be developed and marketed by his company. Switch to the home of one of the company's employees, Henry Swinton (Sam Robards) and his wife Monica (Frances O'Connor), whose son Martin is in cryogenic suspension because of a disease beyond current science. Dr. Hobby and the company place a prototype of a robot designed to mimic a human child – David, played by Haley Joel Osment, with the Swintons. For several sequences we are treated to mildly creepy scenes, but the real rub begins when Monica commences the ritualistic activation of David's special programming – he is designed to love the one on whom he imprints, and even more intensely, to seek love from him or her.
What engaging questions Spielberg is raising here. First (and I heard this idea recently on a radio interview unrelated to the movie), why should humans strive to create machines in their own images? Why not make them functional in the ways an auto manufacturer engineers a welding robot, without legs or a minutely mimetic face? Just because we might at some time have the technology to make a completely plausible copy of a human, does that mean we should? Most importantly – and this idea hearkens back to many other films, such as WESTWORLD or the less well-known ZPG (ZERO POPULATION GROWTH) – should we interact with these super toys just as we interact with other humans – as objects and sources of passion and love? Can a `mecha' (the mechanistic versus the organic, or `orga,' by the way) assume the full role of homo sapien?
The grist of the film is the social hierarchy you would expect from Stanley Kubrick. The `mechas' are the quite literally disposable underclass, the target of the hatred of the `orgas,' and a marginalized and easily persecuted subculture. In some of the most gripping scenes, the robots are rounded up and finally held in a cage. Reminding us of ancient Christians awaiting slaughter by lions, the various generations of personified machines are destroyed by different perverse methods, the center of a spectacle known as the `Flesh Fair.' After some very powerful scenes in the upset lives of the Swinton family, David is discarded, and falls in with another mecha on the run, Gigolo Joe (Jude Law), a love-slave robot framed for murder. In this central section of the film, David and Joe become both fugitives and adventurers, as David pursues his quest of finding the Blue Fairy, the character with whom he has become obsessed since hearing that she turned Pinocchio into a real boy; David reasons, of course, that after he becomes human, his mother would love him more than ever, and accept him back into her life.
Haley Joel Osment pulls off his robot act extremely well. His David is supposed to be seamless in his movements – and that's probably not hard to act out. But Osment excels with the emotional infancy that David must suffer through. He's a boy of eleven or so and suddenly must bond closely with his `Mommy,' a woman whom he called Monica just seconds before his activation. What a young age to be capable of such consistently strong performances!
Spielberg certainly deserves credit for surrounding his main player with such capable supporting actors. The parents, Robards and O'Connor, turn in fine performances, and Jude Law is strangely accurate in his portrayal of this empathetic yet egotistical automaton. There's a certain likable cheesiness about his personality, especially when he cocks his head and early twentieth-century romantic tunes come from his body. A great make-up job too.
The special effects are wonderful, as one would expect from a science fiction film with Steven Spielberg at the helm. Animatronic effects are done by the master himself, Stan Winston. I especially like the little bear named Teddy, voiced by the veteran of many animated outings, Jack Angel. He is at once gruff and cute.
I have heard that AI differs from anything Spielberg has done so far. I would agree, though many scenes inevitably evoke memories of portions of his work. There's the confusion of Shanghai streets in EMPIRE OF THE SUN; there are the intimate familial relationships (and the moon) from ET; there are several images straight from CLOSE ENCOUNTERS. It is when the story returns to David's quest for the Fairy – and for the all-important mother love – that the momentum slows. It is fair to say that the third and final act is effective enough, though it does not seem to realize its parentage. What comes before it is not exactly adequate foreshadowing for a brutally realistic Kubrickian climax; nor is it the comfy Spielbergian rising action. Nevertheless, the film takes big risks, and even though they are not all successful, we come away with amazement and thoughts to keep us busy for several hours and conversations.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


--- layout: default permalink: /404.html edition: "2017" nav: "oscamp2017" image: "2017/default.jpg" --- {% include hero.html %} {% include not-found.html %}


The regression discontinuity (RD) design is a popular quasi-experimental design for causal inference and policy evaluation. The 'rdpower' package provides tools to perform power and sample size calculations in RD designs: rdpower() calculates the power of an RD design and rdsampsi() calculates the required sample size to achieve a desired power. See Cattaneo, Titiunik and Vazquez-Bare (2018) <https://sites.google.com/site/rdpackages/rdpower/Cattaneo-Titiunik-VazquezBare_2018_Stata.pdf> for further methodological details.
| Version: | 0.3 |
| Imports: | rdrobust |
| Published: | 2018-08-21 |
| Author: | Matias D. Cattaneo, Rocio Titiunik, Gonzalo Vazquez-Bare |
| Maintainer: | Gonzalo Vazquez-Bare <gvazquez at umich.edu> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| In views: | Econometrics |
| CRAN checks: | rdpower results |
| Reference manual: | rdpower.pdf |
| Package source: | rdpower_0.3.tar.gz |
| Windows binaries: | r-devel: rdpower_0.3.zip, r-release: rdpower_0.3.zip, r-oldrel: rdpower_0.3.zip |
| OS X binaries: | r-release: rdpower_0.3.tgz, r-oldrel: rdpower_0.3.tgz |
| Old sources: | rdpower archive |
Please use the canonical form https://CRAN.R-project.org/package=rdpower to link to this page.


[[HEAD_CONTENTS]]
Community
Community Overview
The world of HubSpot.
App Marketplace
Discover and install additions to the HubSpot software.
Search Grader
Simple tool to determine how a given website i...
Analyze
Analyze Overview
See how you're doing. Identify opportunities.
Blog Analytics
Uncover which articles spark the most attention.
Reach
You may speak but who's listening? Track your online following.
Competitors
Compare your marketing metrics to others.
Sources
See how different traffic sources drive visits, leads, and customers to your site.
Visits By Page
Split your incoming traffic to see the pages that get the most views.
Convert
Convert Overview
Convert traffic into customers through a marketing funnel.
Prospects
Identify the companies and geographic locations your visitors come from.
Landing Pages
Build specialized pages that convert prospects into leads.
Leads
Identify and manage high-quality leads for your sales team.
List Manager
Create lists of your leads so you can send targeted communications.
Lead Nurturing
Automate emails to convert leads into customers.
Promote
Promote Overview
Spread the gospel. Amplify your online presence.
Social Media
Discuss and interact with others to increase your company's visibility.
Email Manager
Send emails to your leads database.
Optimize
Optimize Overview
Showcase your site to search engines. Optimized pages drive qualified traffic.
Keyword Grader
Research which keywords are best for you. You need traffic, ranking and relevance.
Page Grader
Let HubSpot check each page of your site for possible SEO improvements.
Link Grader
Review who's linking to you. Weigh how much SEO mojo is behind each link.
Create
Create Overview
Grow your footprint. Give the search engines a reason to crawl. Content is king.
Blog
Write articles that will generate more inbound links and leads for your business.
Website Pages
Manage and edit your pages on HubSpot.
Landing Pages
Build specialized pages that convert prospects into leads.
Call-to-Actions
Create Call-to-Action buttons, embed them on your web pages, and determine which buttons drive the most leads.
Your Website
Go to http://cosmicelevators.com
Dashboard
Logoff
Settings
Help Center
UI
Profile
Debug
Host
Marketplace
App Help
[[BODY_CONTENTS]]
[[BOTTOM_BODY_CONTENTS]]


BusMall
Go to Shopping Cart
Ordering Page
Select Item to Add to Cart:
Item:
Quantity:
Input Personal Info Here:
Name:
Street:
City:
State:
Zip Code:
Phone Number:
Card Number:
Add To Cart


Include Markdown files inside of Markdown files
Press is great!
This Markdown can be shared across lots of files.


Enables the use of time calculations within DateTime itself
- advance
- ago
- at_beginning_of_day
- at_midnight
- beginning_of_day
- change
- compare_with_coercion
- end_of_day
- future?
- getutc
- in
- midnight
- past?
- seconds_since_midnight
- since
- utc
- utc?
- utc_offset
Uses Date to provide precise Time calculations for years, months, and days. The options parameter takes a hash with any of these keys: :years, :months, :weeks, :days, :hours, :minutes, :seconds.
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 63 63: def advance(options) 64: d = to_date.advance(options) 65: datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day) 66: seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600 67: seconds_to_advance == 0 ? datetime_advanced_by_date : datetime_advanced_by_date.since(seconds_to_advance) 68: end
Returns a new DateTime representing the time a number of seconds ago Do not use this method in combination with x.months, use months_ago instead!
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 72 72: def ago(seconds) 73: self.since(-seconds) 74: end
Alias for beginning_of_day
Alias for beginning_of_day
Returns a new DateTime representing the start of the day (0:00)
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 84 84: def beginning_of_day 85: change(:hour => 0) 86: end
Returns a new DateTime where one or more of the elements have been changed according to the options parameter. The time options (hour, minute, sec) reset cascadingly, so if only the hour is passed, then minute and sec is set to 0. If the hour and minute is passed, then sec is set to 0.
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 46 46: def change(options) 47: ::DateTime.civil( 48: options[:year] || self.year, 49: options[:month] || self.month, 50: options[:day] || self.day, 51: options[:hour] || self.hour, 52: options[:min] || (options[:hour] ? 0 : self.min), 53: options[:sec] || ((options[:hour] || options[:min]) ? 0 : self.sec), 54: options[:offset] || self.offset, 55: options[:start] || self.start 56: ) 57: end
Layers additional behavior on DateTime#<=> so that Time and ActiveSupport::TimeWithZone instances can be compared with a DateTime
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 118 118: def compare_with_coercion(other) 119: other = other.comparable_time if other.respond_to?(:comparable_time) 120: other = other.to_datetime unless other.acts_like?(:date) 121: compare_without_coercion(other) 122: end
Returns a new DateTime representing the end of the day (23:59:59)
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 92 92: def end_of_day 93: change(:hour => 23, :min => 59, :sec => 59) 94: end
Tells whether the DateTime object‘s datetime lies in the future
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 34 34: def future? 35: self > ::DateTime.current 36: end
Alias for utc
Alias for since
Alias for beginning_of_day
Tells whether the DateTime object‘s datetime lies in the past
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 29 29: def past? 30: self < ::DateTime.current 31: end
Seconds since midnight: DateTime.now.seconds_since_midnight
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 39 39: def seconds_since_midnight 40: self.sec + (self.min * 60) + (self.hour * 3600) 41: end
Returns a new DateTime representing the time a number of seconds since the instance time Do not use this method in combination with x.months, use months_since instead!
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 78 78: def since(seconds) 79: self + Rational(seconds.round, 86400) 80: end
Adjusts DateTime to UTC by adding its offset value; offset is set to 0
Example:
DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)) # => Mon, 21 Feb 2005 10:11:12 -0600 DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 +0000
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 102 102: def utc 103: new_offset(0) 104: end
Returns true if offset == 0
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 108 108: def utc? 109: offset == 0 110: end
Returns the offset value in seconds
[ show source ]
# File vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 113 113: def utc_offset 114: (offset * 86400).to_i 115: end


+++ title = "Baños" lat = -1.397228 lon = -78.421311 +++
Located a few hours south of Quito — in Ecuador's central Andean highlands — Baños is the adventure capital of Ecuador, as well as 100% backpacker's central. You can do everything here, from downhill mountain-biking to rapid river-rafting, and from waterfall canyoning to snow-capped mountain-peak climbing. Also a charming town, surrounded by some really beautiful jungle-covered mountains, and filled with great places to stay and to eat. I spent some time here in Baños, relaxing a bit, but mainly doing a lot of crazy activities.
{{< galleryphoto "2007-08-06-09-00-00--main-square-of-banos.jpg" >}}


Chasing Tails is a not for profit organization that aims to rescue, rehabilitate and rehome abandoned cats and dogs. With the mission to make the world a better place for all abandoned pets, the Center offers veterinary care, adoption services and care advice for cats and dogs. Our pets are adorable and have their own unique personalities, which are sure to delight anyone looking to bring a pet into their lives. Explore our site to learn more about the pets in our shelter or sign up for our mailing list to attend one of our Meet the Pets events!
Animals Rescued: 15
Squirrels Chased: 213
Pet Videos Published: 45
These are a few causes and organisations that are working towards imporving the lives of animals. Chasing Tails supports these endeavours and strives to work in line with them!


KwikOZ
Personal Feed
Public Feed
Link
Public Feed
APRIL 29, 2021
USERNAME
APRIL 29, 2021
USERNAME
APRIL 29, 2021
USERNAME
APRIL 29, 2021
USERNAME
APRIL 29, 2021
USERNAME


In this quickstart, we will use zc.async to make a small web application that is a Python Package Index (PyPI, http://pypi.python.org/) helper portal. We’ll call it “My PyPI,” to be cute.
My PyPI will let you subscribe to changes of specific packages, rather than the entire package index; and will let you associate external web pages with packages for you and others to see and search on.
We’ll make a number of “toy app” decisions to keep the story quick, but it should be a good example for how to leverage zc.async.
Also for simplicity, we’ll assume that we are making several instances on the same machine, such as you might do with a few processors at your disposal. To get the true advantage of high availability in production, you’d want at least two boxes, with a deployment of a ZEO server (or equivalent, for RelStorage), some kind of redundancy for your database (ZRS, or slony for RelStorage plus PostgreSQL) and instructions for each box on how to connect to the ZEO primary.
This quickstart is more complex than the Quickstart with virtualenv. I suggest you read that through before this one.
This quickstart instead uses the following somewhat “heavier” technologies.
zc.buildout is a way of producing repeatable software build-outs, for development and conceivably for deployment. It is written in Python, but is not Python-specific, and it has found use as a make replacement for many projects.
Grok is a web framework emerging from “Zope 3” technologies. From their website:
Grok is a web application framework for Python developers. It is aimed at both beginners and very experienced web developers. Grok has an emphasis on agile development. Grok is easy and powerful.
This guide, then, takes a somewhat slower definition of “quick” for its “quickstart”, in exchange for more guidance and care with a view towards production-readiness.
As of this writing, Grok requires Python 2.4. Moreover, for more repeatable installations, many developers strongly recommend using a “clean”, non-system Python, to reduce the probability of unnecessary or spurious problems (in your software or in your system!). Therefore, consider building your own Python 2.4 for your development.
We’ll also expect that your Python has easy_install. If it doesn’t, you can just download ez_setup.py and then run it with your local, development Python (e.g., ~/opt/py/bin/python ez_setup.py). This will install the easy_install command for your development Python in the same bin directory as your Python (e.g., ~/opt/py/bin/easy_install).
Grok has a pleasantly convenient way to start a project. It is called grokproject. Use your local Python’s easy_install to install it. For instance, I might type ~/opt/py/bin/easy_install grokproject.
After it runs, it should have installed the grokproject command in the same bin directory as your local Python (e.g., ~/opt/py/bin/grokproject).
Now we will use grokproject to make a skeleton of our package. Let’s call the project “mypypi”.  Then use the newly installed grokproject command to create
XXX


--- layout: post status: publish published: true title: AWS ELB upgrade - Layer 7 Load Balancing author: display_name: neil login: neil email<EMAIL_ADDRESS>url: '' author_login: neil author_email<EMAIL_ADDRESS>wordpress_id: 82 wordpress_url: https://www.millardtechnicalservices.co.uk/?p=82 date: '2016-08-12 13:26:23 +0000' date_gmt: '2016-08-12 12:26:23 +0000' categories: - Infrastructure tags: [] comments: [] ---
AWS have announced Application (level 7 on the osi model) Load Balancing.
I've been using HA Proxy to achieve this for a while now.
What does this mean to us?
You can now load balance and direct traffic to a 'target group' of servers. This means you can use on ELB for a website whilst using multiple server groups for each microservice. For instance anything with /api in the url can get directed at a different group to those with /backend in the url. In current setups we are using subdomains to do this, api.webdomain.com and backend.webdomain.com.
Having Application Load Balancers will allow us to simplify and reduce the number of ELBs needed, thus saving money.
This and more features can be found on amazon's blog. https://aws.amazon.com/blogs/aws/new-aws-application-load-balancer/


Christian
Boulanger is a Berlin-based social scientist, part-time coder,
and open source enthusiast (JavaScript/NodeJS/PHP). For his personal
needs, he developed
Bibliograph
, an online bibliographic data manager, which has been based on Qooxdoo
since 2005, and is used by Humboldt-Universität zu
Berlin's Law Faculty since 2011.


These terms and conditions of use (Terms) explain how you may use this website and any of its content (Site). These Terms apply between The Virtual Training Team Limited (we, us or our) and you, the person accessing or using the Site ( you or your ).
You should read these Terms carefully before using the Site. By using the Site or otherwise indicating your consent, you agree to be bound by these Terms. If you do not agree with any of these Terms, you should stop using the Site immediately.
These Terms apply to any parts of the Site, its functionality and content provided to you free of charge for information purposes only.
If you order any services from us through the Site or any other medium, separate terms and conditions will apply.
If you would like these Terms in another format (for example: audio, large print, braille), please contact us using the contact details set out below.
We are The Virtual Training Team Limited (trading as Virtual Training Team), a company registered in England and Wales under company registration number 10565643. Our registered office is at Church Lane Farmhouse Church Lane, Brandon, Grantham, Lincolnshire, England, NG32 2AP.
If you have any questions about the Site, please contact us.
The Site is for your use only.
You agree that you are solely responsible for all costs and expenses you may incur in relation to your use of the Site.
We make no promise that the Site is appropriate or available for use in locations outside of the UK. If you choose to access the Site from locations outside the UK, you acknowledge you do so at your own initiative and are responsible for compliance with local laws where they apply.
As a condition of your use of the Site, you agree not to:
misuse or attack our Site by knowingly introducing viruses, trojans, worms, logic bombs or any other material which is malicious or technologically harmful (such as by way of a denial-of-service attack), or
attempt to gain unauthorised access to our Site, the server on which our Site is stored or any server, computer or database connected to our Site.
We may prevent or suspend your access to the Site if you do not comply with these Terms or any applicable law.
We will use reasonable efforts to identify and remove any content that is inappropriate, defamatory, infringes intellectual property rights or is otherwise in breach of these Terms when we are notified, but we cannot be responsible if you have failed to provide us with the relevant information.
If you believe that any content which is distributed or published by the Site is inappropriate, defamatory or infringing on intellectual property rights, you should contact us immediately using the contact details at the top of this page.
Your privacy and personal information are important to us. Any personal information that you provide to us will be dealt with in line with our Privacy & Cookies Policy, which explains what personal information we collect from you, how and why we collect, store, use and share such information, your rights in relation to your personal information and how to contact us and supervisory authorities in the event you have a query or complaint about the use of your personal information.
The intellectual property rights in the Site and in any text, images, video, audio or other multimedia content, software or other information or material submitted to or accessible from the Site (Content) are owned by us and our licensors.
We and our licensors reserve all our intellectual property rights (including, but not limited to, all copyright, trade marks, domain names, design rights, database rights, patents and all other intellectual property rights of any kind) whether registered or unregistered anywhere in the world. This means, for example, that we remain owners of them and are free to use them as we see fit.
Nothing in these Terms grants you any legal rights in the Site or the Content other than as necessary for you to access it. You agree not to adjust, try to circumvent or delete any notices contained on the Site or the Content (including any intellectual property notices) and in particular, in any digital rights or other security technology embedded or contained within the Site or the Content.
Trade marks: “Virtual Training Team” is our unregistered trade mark and is protected under the common law doctrines of “passing off” and “unfair competition”. Other trade marks and trade names may also be used on the Site or in the Content. Use by you of any trade marks on the Site or in the Content is strictly prohibited unless you have our prior written permission.
While we try to make sure that the Site is secure, we do not actively monitor or check whether information supplied to us through the Site is confidential, commercially sensitive or valuable.
Other than any personal information which will be dealt with in accordance with our Privacy Policy, we do not guarantee that information supplied to us through the Site will be kept confidential and we may use it on an unrestricted and free-of-charge basis as we reasonably see fit.
We try to make sure that the Site is accurate, up-to-date and free from bugs, but we cannot promise that it will be. Furthermore, we cannot promise that the Site will be fit or suitable for any purpose. Any reliance that you may place on the information on the Site is at your own risk.
We may suspend or terminate access or operation of the Site at any time as we see fit.
Any Content is provided for your general information purposes only and to inform you about us and our products and news, features, services and other websites that may be of interest, but has not been tailored to your specific requirements or circumstances. It does not constitute technical, financial or legal advice or any other type of advice and should not be relied on for any purposes. You should always use your own independent judgment when using our Site and its Content.
While we try to make sure that the Site is available for your use, we do not promise that the Site will be available at all times or that your use of the Site will be uninterrupted.
The Site may contain hyperlinks or references to third party advertising and websites other than the Site. Any such hyperlinks or references are provided for your convenience only. We have no control over third party advertising or websites and accept no legal responsibility for any content, material or information contained in them. The display of any hyperlink and reference to any third-party advertising or website does not mean that we endorse that third party’s website, products or services. Your use of a third-party site may be governed by the terms and conditions of that third-party site and is at your own risk.
Except for any legal responsibility that we cannot exclude in law (such as for death or personal injury) or arising under applicable laws relating to the protection of your personal information, we are not legally responsible for any:
losses that were not foreseeable to you and us when these Terms were formed;
losses that were not caused by any breach on our part;
business losses; and
losses to non-consumers.
We are not liable to you if we fail to comply with these Terms because of circumstances beyond our reasonable control, including, but not limited to, strikes, lock-outs or other industrial disputes; breakdown of systems or network access; or flood, fire, explosion or accident.
No one other than a party to these Terms has any right to enforce any of these Terms.
No changes to these Terms are valid or have any effect unless agreed by us in writing or made in accordance with this clause 14.
We reserve the right to vary these Terms from time to time. Our updated Terms will be displayed on the Site and by continuing to use and access the Site following such changes, you agree to be bound by any variation made by us. It is your responsibility to check these Terms from time to time to verify such variations.
We will try to resolve any disputes with you quickly and efficiently. If you are unhappy with us, please contact us as soon as possible.
If a dispute cannot be resolved using our complaint handling procedure or you are unhappy with the outcome, you may want to use alternative dispute resolution (ADR). ADR is a process for resolving disputes between you and us that does not involve going to court.
If you do not wish to use ADR, you can still bring court proceedings.
Relevant United Kingdom law will apply to these Terms. If you want to take court proceedings, the relevant courts of the United Kingdom will have non-exclusive jurisdiction in relation to these Terms.


Self Reproducing Coins As Universal Turing Machine
Transcript By: Bryan Bishop
Tags: Research, Smart contracts, Scalability
Category: Conference
Self-reproducing coins as universal turing machine
Dmitry Meshkov, Alexander Chepurnoy and Vasily Kharin (Ergo Platform)
paper: https://arxiv.org/abs/1806.10116
Introduction
This is joint work with my colleagues. I am Alexander Chepurnoy. We work for Ergo Platform. Vasily is an external member. This talk is about turing completeness in the blockchain. This talk will be pretty high-level. This talk is based on already-published paper, which was presented at the CBT conference. Because of copyright agreements with Springer, you will not find the latest version on arxiv.
The general question of scalability is how can we do more with less until we can do everything with nothing? We can already do smart contracts in bitcoin. But we want to do more. How can we do more without spending much effort? There’s some research in the community about aggregated signatures. This is another direction I’d like to propose, which is how to have more complex contracts without sacrificng much.
Questions
Can we achieve Turing completeness without jump (or equivalent) opcodes? Do we need a general purpose programming language? Can we do it in the utxo model we have in bitcoin? And if we can do turing complete computations on the blockchain, then how practical is that?
Outline
I will talk about turing completeness in blockchain environments, then scripting language pre-requesities, and so on.
Turing completeness
The question is, what is turing completeness in the first place? Turing complete system is a system which can emulate a universal Turing machine. It’s a system that can run any algorithm or any computation. We have many turing complete models. If you have a program in a Turing complete system like a random access machine which is about a modern personal computers, alright so, if we are switching to another Turing complete system like building circles or a system to you consider later.. so you don’t have explosive growth or exponential growth in your program length, so you have some reasonable overhead switching from one Turing complete system to another.
Blockchain requires constant block validation time. It needs to be basically constant. There’s some very strictly limited propagation time, and validation time has to be limited and has to be very restricted.
A popular belief is that for turing completeness on the blockchain, you need a general purpose language like with jump instructions, loops or recursion.
But imagine a version of ethereum where there is a gas limit per block and all the state changes are reversed after transaction script execution (and payment amount is not dependent on the program) then this new ethereum version is not turing complete.
Bitcoin: boxes, registers, scripting
I’m going to show how to make a bitcoin-like turing complete system, called bitcoin plus. In bitcoin, we have a notion of outputs and unspent outputs usually… let’s switch to a more general term, a transaction is spending some boxes or some coins. A transaction is creating new boxes. In addition to monetary value and a spending condition or restriction condition, we allow for some number of arbitrary typed general purpose data sets. Let’s assume that there is a register mandatory, r0, which is called monetary value… r1 is guarding script, r2 is general purpose, and r9 is general purpose too. So now we have some data in the coins.
The scripting language needs to be able to do basic arithmetic operations like bitcoin script already does. We need if-then-else clauses. We need cryptographic primitives like bitcoin. Array declaration (predefined size) and access operations. And context data- such as height, self, inputs, and outputs. Unlike bitcoin, we are going to add some context data. When we’re validating a transaction, there is some context. In bitcoin, we can ask for amount of time, we can access current blockheight or blocktime. In addition to height, there’s “self” in our proposal.
Rule 110 cellular automata
One of the most simple turing-complete systems is rule 110 by Stephen Wolfram. It’s the simplest one-dimensional cellular automata. It was proven 15 years ago that this rule 110 is turing complete.
- “Universality in elementary cellular automata” https://git.io/vj6ew
Use transaction chaining to share memory between the transactions. https://git.io/vj6rX This can be done with constant block validation time, with a relatively minimal scripting language. We’re not doing much, but this allows for running arbitrary computations on the blockchain.
Is this practical?
For even simple computations, rule 110 string could be billions and billions of bits… so it doesn’t give you much, since you can’t run large programs like that on the blockchain. And the programs can’t run in any reasonable time. What I think is important to show is that this correspondence, this possible correspondence, to be set between input and output, the possibility to set conditions on outputs, dependent on input state, and also possibility to get it over the program itself… so we can, many, practical things, such as demurrage currency, crowdfunding, authenticated states, decentralized exchanges, oracles that authenticate the UTXO state, and so on.
https://github.com/ergoplatform/ergo/blob/master/papers/yellow


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Class Summary | |
|---|---|
| AbstractConstantSwitch | |
| AbstractExprSwitch | |
| AbstractJimpleValueSwitch | |
| AbstractRefSwitch | |
| AbstractStmtSwitch | |
| ArithmeticConstant | |
| ClassConstant | |
| Constant | |
| DoubleConstant | |
| FloatConstant | |
| GroupIntPair | |
| IntConstant | |
| JasminClass | Methods for producing Jasmin code from Jimple. |
| Jimple | The Jimple class contains all the constructors for the components of the Jimple grammar for the Jimple body. |
| JimpleBody | Implementation of the Body class for the Jimple IR. |
| JimpleMethodSource | |
| JimpleToBafContext | |
| LocalStmtPair | |
| LongConstant | |
| NaiveSideEffectTester | Provides naive side effect information. |
| NullConstant | |
| NumericConstant | |
| ParameterRef | ParameterRef objects are used by Body
objects to refer to the parameter slots on method entry. |
| PlaceholderStmt | |
| PointerStmtSwitch | |
| ReachingTypeDumper | Dumps the reaching types of each local variable to a file in a format that can be easily compared with results of other analyses, such as VTA. |
| RealConstant | |
| StaticFieldRef | |
| StmtBody | Abstract base class for Body's on Stmts (Jimple and Grimp). |
| StringConstant | |
| ThisRef |
| Exception Summary | |
|---|---|
| NoSuchLocalException |
Public classes for the Jimple intermediate representation. Jimple is 3-address code, and is the representation of choice for Java analyses.
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Zim mental health nurse who threatened wife with axe avoids UK jail
A Zimbabwean mental health nurse in the UK who threatened his wife with an axe has escaped an immediate jail term.
by Chad Nugent | BraintreeandWithamTimes |Tanyaradzwa Mhangami had sent his partner threatening messages while on a night shift before he arrived home and they continued to row while sitting in her car.
The 39-year-old continued to be aggressive towards her, told her not to mess with him and even referenced a case he had heard in the news where a man had killed his spouse.
Related Articles
Jun 6, 2019 28,686 200
Bogus nurse ‘kills’ patient in Mutare
Jan 17, 2015 216 2
Nurse banned in UK over fake Zim O’Levels
Oct 11, 2014 1,926 32
Nurse loses cellphone to bogus patient
Oct 14, 2013 187 0
They both went inside their home in Clay Pitts, Braintree, and Mhangami armed himself with an axe and chillingly asked his wife ‘you don’t want me to use this on you, do you?’
Fearing for her life, she left the house and called the police.
Mhangami was spotted in an upstairs window with the axe and then appeared at the back of the house wearing just his boxer shorts and told officers to get out of the garden.
He was then spotted with a six-inch knife and refused to put it down when directed to by the police.
Officers then decided to ram their way into the home and tasered Mhangami when he refused to drop the knife.
When he recovered from being stunned Mhangami was aggressive towards officers, kicking out them at the home and when they went to Colchester Hospital where he also spat at one constable.
Chelmsford Crown Court heard Mhangami had no previous convictions and had taken too much of his anti-depressant medication at the time of the incident in August and his own mental health situation had reached a crisis point.
He plans to report himself to the Nursing and Midwifery Council.
Judge Christopher Morgan handed him a two year jail sentence suspended for two years after he admitted affray and three assaults on emergency workers.
He said: “During this incident two weapons were produced.
“This is a situation which clearly could have escalated further than it did and when police arrived at the premises you had to be Tasered.
“It is unforgivable to spit and last out at police in the way that you did.
“Be under no illusion if you commit any similar offences where you produce weapons you will got to prison for a significant period of time.”
Mhangami must also attend 30 rehabilitation days in the next two years, undertake the Building Better Relationships programme and do 120 hours of unpaid work.
He is also banned from going back to the address for a year.


Chemical Weathering
Chemical weathering is caused by rain water reacting with the mineral grains in rocks to form new minerals (clays) and soluble salts. These reactions occur particularly when the water is slightly acidic.
These chemical processes need water, and occur more rapidly at higher temperature, so warm, damp climates are best. Chemical weathering (especially hydrolysis and oxidation) is the first stage in the production of soils.
Solution - removal of rock in solution by acidic rainwater. In particular, limestone is weathered by rainwater containing dissolved CO2, (this process is sometimes called carbonation).
Hydrolysis - the breakdown of rock by acidic water to produce clay and soluble salts.
Oxidation - the breakdown of rock by oxygen and water, often giving iron-rich rocks a rusty-coloured weathered surface.
Where does it occur?
These chemical processes need water, and occur more rapidly at higher temperature, so warm, damp climates are best. Chemical weathering (especially hydrolysis and oxidation) is the first stage in the production of soils.How does it occur?
There are different types of chemical weathering, the most important are:Solution - removal of rock in solution by acidic rainwater. In particular, limestone is weathered by rainwater containing dissolved CO2, (this process is sometimes called carbonation).
Hydrolysis - the breakdown of rock by acidic water to produce clay and soluble salts.
Oxidation - the breakdown of rock by oxygen and water, often giving iron-rich rocks a rusty-coloured weathered surface.
Solution
Malham Cove, Yorkshire
Find out more on 'Solution'.Hydrolysis
Anglesey, N. Wales
Find out more on 'Hydrolysis'.