SASL is used by protocols, such as the Lightweight Directory Access Protocol, version 3 (LDAP v3), and the Internet Message Access Protocol, version 4 (IMAP v4) to enable pluggable authentication. Instead of hardwiring an authentication method into the protocol, LDAP v3 and IMAP v4 use SASL to perform authentication, thus enabling authentication via various SASL mechanisms.
There are a number of standard SASL mechanisms defined by the Internet community for various levels of security and deployment scenarios. These range from no security (e.g., anonymous authentication) to high security (e.g., Kerberos authentication) and levels in between.
The Java SASL API also allows developers to use their own, custom SASL mechanisms. SASL mechanisms are installed by using the Java Cryptography Architecture (JCA).
When compared with JSSE and Java GSS, SASL is relatively lightweight and is popular among more recent protocols. It also has the advantage that several popular, lightweight (in terms infrastructure support) SASL mechanisms have been defined. Primary JSSE and Java GSS mechanisms, on the other hand, have relatively heavyweight mechanisms that require more elaborate infrastructures (Public Key Infrastructure and Kerberos, respectively).
SASL, JSSE, and Java GSS are often used together. For example, a common pattern is for an application to use JSSE for establishing a secure channel, and to use SASL for client, username/password-based authentication. There are also SASL mechanisms layered on top of GSS-API mechanisms; one popular example is a SASL GSS-API/Kerberos v5 mechanism that is used with LDAP.
Except when defining and building protocols from scratch, often the biggest factor determining which API to use is the protocol definition. For example, LDAP and IMAP are defined to use SASL, so software related to these protocols should use the Java SASL API. When building Kerberos applications and services, the API to use is Java GSS. When building applications and services that use SSL/TLS as their protocol, the API to use is JSSE. See the Java Security Documentation for further details about when to use JSSE versus Java GSS.
The Java SASL API is modeled according to this style of interaction and usage. It has interfaces, SaslClient and SaslServer, that represent client-side and server-side mechanisms, respectively. The application interacts with the mechanisms via byte arrays that represent the challenges and responses. The server-side mechanism iterates, issuing challenges and processing responses, until it is satisfied, while the client-side mechanism iterates, evaluating challenges and issuing responses, until the server is satisfied. The application that is using the mechanism drives each iteration. That is, it extracts the challenge or response from a protocol packet and supplies it to the mechanism, and then puts the response or challenge returned by the mechanism into a protocol packet and sends it to the peer.
The Sasl class is used for creating instances of SaslClient and SaslServer. Here is an example of how an application creates a SASL client mechanism using a list of possible SASL mechanisms.
String[] mechanisms = new String[]{"DIGEST-MD5", "PLAIN"}; SaslClient sc = Sasl.createSaslClient(mechanisms, authzid, protocol, serverName, props, callbackHandler);
Based on the availability of the mechanisms supported by the platform and other configuration information provided via the parameters, the Java SASL framework selects one of the listed mechanisms and return an instance of SaslClient.
The name of the selected mechanism is usually transmitted to the server via the application protocol. Upon receiving the mechanism name, the server creates a corresponding SaslServer object to process client-sent responses. Here is an example of how the server would create an instance of SaslServer.
SaslServer ss = Sasl.createSaslServer(mechanism, protocol, myName, props, callbackHandler);
Because the Java SASL API is a general framework, it must be able to accommodate many different types of mechanisms. Each mechanism needs to be initialized with input and may need input to make progress. The API provides three means by which an application gives input to a mechanism.
Mechanisms can use the callbacks defined in the javax.security.auth.callback package; these are generic callbacks useful for building applications that perform authentication. Mechanisms might also need SASL-specific callbacks, such as those for collecting realm and authorization information, or even (non-standardized) mechanism-specific callbacks. The application should be able to accommodate a variety of mechanisms. Consequently, its callback handler must be able to service all of the callbacks that the mechanisms might request. This is not possible in general for arbitrary mechanisms, but is usually feasible due to the limited number of mechanisms that are typically deployed and used.
// Get optional initial response byte[] response = (sc.hasInitialResponse() ? sc.evaluateChallenge(new byte[]) : null); String mechanism = sc.getMechanismName(); // Send selected mechanism name and optional initial response to server send(mechanism, response); // Read response msg = receive(); while (!sc.isComplete() && (msg.status == CONTINUE || msg.status == SUCCESS)) { // Evaluate server challenge response = sc.evaluateChallenge(msg.contents); if (msg.status == SUCCESS) { // done; server doesn't expect any more SASL data if (response != null) { throw new IOException( "Protocol error: attempting to send response after completion"); } break; } else { send(mechanism, response); msg = receive(); }
The client application iterates through each step of the authentication by using the mechanism (sc) to evaluate the challenge gotten from the server and to get a response to send back to the server. It continues this cycle until either the mechanism or application-level protocol indicates that the authentication has completed, or if the mechanism cannot evaluate a challenge. If the mechanism cannot evaluate the challenge, it throws an exception to indicate the error and terminates the authentication. Disagreement between the mechanism and protocol about the completion state must be treated as an error because it might indicate a compromise of the authentication exchange.
Here is an example of how a server might use SaslServer.
// Read request that contains mechanism name and optional initial response msg.receive(); // Obtain a SaslServer to perform authentication SaslServer ss = Sasl.createSaslServer(msg.mechanism, protocol, myName, props, callbackHandler); // Perform authentication steps until done while (!ss.isComplete()) { try { // Process response byte[] challenge = sc.evaluateResponse(msg.contents); if (ss.isComplete()) { send(mechanism, challenge, SUCCESS); } else { send(mechanism, challenge, CONTINUE); msg.receive(); } } catch (SaslException e) { send(ERROR); sc.dispose(); break; } }The server application iterates through each step of the authentication by giving the client's response to the mechanism (ss) to process. If the response is incorrect, the mechanism indicates the error by throwing a SaslException so that the server can report the error and terminate the authentication. If the response is correct, the mechanism returns challenge data to be sent to the client and indicates whether the authentication is complete. Note that challenge data can accompany a "success" indication. This might be used, for example, to tell the client to finalize some negotiated state.
When a security layer has been negotiated, all subsequent communication with the peer must take place using the security layer. To determine whether a security layer has been negotiated, get the negotiated quality-of-protection (QOP) from the mechanism. Here is an example of how to determine whether a security layer has been negotiated.
String qop = (String) sc.getNegotiatedProperty(Sasl.QOP); boolean hasSecurityLayer = (qop != null && (qop.equals("auth-int") || qop.equals("auth-conf")));
A security layer has been negotiated if the Sasl.QOP property indicates that either integrity and/or confidentiality has been negotiated.
To communicate with the peer using the negotiated layer, the application first uses the wrap method to encode the data to be sent to the peer to produce a "wrapped" buffer. It then transfers a length field representing the number of octets in the wrapped buffer followed by the contents of the wrapped buffer to the peer. The peer receiving the stream of octets passes the buffer (without the length field) to unwrap to obtain the decoded bytes sent by the peer. Details of this protocol are described in RFC 2222. Here is an example of how a client application sends and receives application data using a security layer.
// Send outgoing application data to peer byte[] outgoing = ...; byte[] netOut = sc.wrap(outgoing, 0, outgoing.length); send(netOut.length, netOut); // send to peer // Receive incoming application data from peer byte[] netIn = receive(); // read length and ensuing bytes from peer byte[] incoming = sc.unwrap(netIn, 0, netIn.length);
security.provider.7=com.sun.security.sasl.Providerin the Java Security Properties file ($JAVA_HOME/lib/security/java.security).
To add or remove a SASL provider, you add or remove the corresponding line in the Security Properties file. For example, if you want to add a SASL provider and have its mechanisms be chosen over the same ones implemented by the SunSASL provider, then you would add a line to the Security Properties file with a lower number.
security.provider.7=com.example.MyProvider security.provider.8=com.sun.security.sasl.Provider
Alternatively, you can programmatically add your own provider using the java.security.Security class. For example, the following sample code registers the com.example.MyProvider to the list of available SASL security providers.
Security.addProvider(new com.example.MyProvider());When an application requests a SASL mechanism by supplying one or more mechanism names, the SASL framework looks for registered SASL providers that support that mechanism by going through, in order, the list of registered providers. The providers must then determine whether the requested mechanism matches the selection policy properties and if so, return an implementation for the mechanism.
The selection policy properties specify the security aspects of a mechanism, such as its susceptibility to certain attacks. These are characteristics of the mechanism (definition), rather than its implementation so all providers should come to the same conclusion about a particular mechanism. For example, the PLAIN mechanism is susceptible to plaintext attacks regardless of how it is implemented. If no selection policy properties are supplied, there are no restrictions on the selected mechanism. Using these properties, an application can ensure that it does not use unsuitable mechanisms that might be deployed in the execution environment. For example, an application might use the following sample code if it does not want to allow the use of mechanisms susceptible to plaintext attacks.
Map props = new HashMap(); props.add(Sasl.POLICY_NOPLAINTEXT, "true"); SaslClient sc = Sasl.createSaslClient(mechanisms, authzid, protocol, serverName, props, callbackHandler);See the Sasl class for descriptions of the selection policy properties.
| Client Mechanism Name | Parameters/Input | Callbacks | Configuration Properties | Selection Policy |
|---|---|---|---|---|
| CRAM-MD5 | authorization id (as default username) |
NameCallback PasswordCallback |
Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT |
|
| DIGEST-MD5 | authorization id protocol id server name |
NameCallback PasswordCallback RealmCallback RealmChoiceCallback |
Sasl.QOP Sasl.STRENGTH Sasl.MAX_BUFFER Sasl.SERVER_AUTH "javax.security.sasl.sendmaxbuffer" "com.sun.security.sasl.digest.cipher" |
Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT |
| EXTERNAL | authorization id external channel |
Sasl.POLICY_NOPLAINTEXT Sasl.POLICY_NOACTIVE Sasl.POLICY_NODICTIONARY |
||
| GSSAPI | JAAS Subject authorization id protocol id server name |
Sasl.QOP Sasl.MAX_BUFFER Sasl.SERVER_AUTH "javax.security.sasl.sendmaxbuffer" |
Sasl.POLICY_NOACTIVE Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT |
|
| PLAIN | authorization id |
NameCallback PasswordCallback |
Sasl.POLICY_NOANONYMOUS |
An application that uses these mechanisms from the SunSASL provider must supply the required parameters, callbacks and properties. The properties have reasonable defaults and only need to be set if the application wants to override the defaults. Most of the parameters, callbacks, and properties are described in the API documentation. The following sections describe mechanism-specific behaviors and parameters not already covered by the API documentation.
The Cram-MD5 client mechanism uses the authorization id
parameter, if supplied, as the default username in the
NameCallback
to solicit the application/end-user for the
authentication id. The authorization id is otherwise not used by
the Cram-MD5 mechanism; only the authentication id is exchanged
with the server.
The Digest-MD5 mechanism is used for digest authentication and optional establishment of a security layer. It specifies the following ciphers for use with the security layer: Triple DES, DES and RC4 (128, 56, and 40 bits). The Digest-MD5 mechanism can support only ciphers that are available on the platform. For example, if the platform does not support the RC4 ciphers, then the Digest-MD5 mechanism will not use those ciphers.
The Sasl.STRENGTH property supports "high", "medium", and "low" settings; its default is "high,medium,low". The ciphers are mapped to the strength settings as follows.
| Strength | Cipher | Cipher Id |
|---|---|---|
| high | Triple DES RC4 128 bits |
3des rc4 |
| medium | DES RC4 56 bits |
des rc4-56 |
| low | RC4 40 bits | rc4-40 |
When there is more than one choice for a particular strength, the cipher selected depends on the availability of the ciphers in the underlying platform. To explicitly name the cipher to use, set the "com.sun.security.sasl.digest.cipher" property to the corresponding cipher id. Note that this property setting must be compatible with Sasl.STRENGTH and the ciphers available in the underlying platform. For example, Sasl.STRENGTH being set to "low" and "com.sun.security.sasl.digest.cipher" being set to "3des" are incompatible. The "com.sun.security.sasl.digest.cipher" property has no default.
The "javax.security.sasl.sendmaxbuffer" property specifies (the string representation of) the maximum send buffer size in bytes. The default is 65536. The actual maximum number of bytes will be the minimum of this number and the peer's maximum receive buffer size.
Subject
to contain the client's Kerberos credentials or that the
credentials could be obtained by implicitly logging in to Kerberos.
To obtain the client's Kerberos credentials, use the Java Authentication and
Authorization Service (JAAS) to log in using the Kerberos login
module. See the Java GSS-API
and JAAS Tutorials for Use with Kerberos for details and
examples. After using JAAS authentication to obtain the Kerberos
credentials, you put the code that uses the SASL GSSAPI mechanism
within
doAs or
doAsPrivileged.
LoginContext lc = new LoginContext("JaasSample", new TextCallbackHandler()); lc.login(); lc.getSubject().doAs(new SaslAction()); class SaslAction implements java.security.PrivilegedAction { public class run() { ... String[] mechanisms = new String[]{"GSSAPI"}; SaslClient sc = Sasl.createSaslClient(mechanisms, authzid, protocol, serverName, props, callbackHandler); ... } }To obtain Kerberos credentials without doing explicit JAAS programming, see the Java GSS-API and JAAS Tutorials for Use with Kerberos. When using this approach, there is no need to wrap the code within doAs or doAsPrivileged.
The "javax.security.sasl.sendmaxbuffer" property specifies (the string representation of) the maximum send buffer size in bytes. The default is 65536. The actual maximum number of bytes will be the minimum of this number and the peer's maximum receive buffer size.
| Server Mechanism Name | Parameters/Input | Callbacks | Configuration Properties | Selection Policy |
|---|---|---|---|---|
| CRAM-MD5 | server name | AuthorizeCallback NameCallback PasswordCallback |
Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT |
|
| DIGEST-MD5 | protocol id server name |
AuthorizeCallback NameCallback PasswordCallback RealmCallback |
Sasl.QOP Sasl.STRENGTH Sasl.MAX_BUFFER "javax.security.sasl.sendmaxbuffer" "com.sun.security.sasl.digest.realm" "com.sun.security.sasl.digest.utf8" |
Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT |
| GSSAPI | JAAS Subject protocol id server name |
AuthorizeCallback | Sasl.QOP Sasl.MAX_BUFFER "javax.security.sasl.sendmaxbuffer" |
Sasl.POLICY_NOACTIVE Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT |
An application that uses these mechanisms from the SunSASL provider must supply the required parameters, callbacks and properties. The properties have reasonable defaults and only need to be set if the application wants to override the defaults.
All users of server mechanisms must have a callback handler that deals with the AuthorizeCallback. This is used by the mechanisms to determine whether the authenticated user is allowed to act on behalf of the requested authorization id, and also to obtain the canonicalized name of the authorized user (if canonicalization is applicable).
Most of the parameters, callbacks, and properties are described in the API documentation. The following sections describe mechanism-specific behaviors and parameters not already covered by the API documentation.
The "javax.security.sasl.sendmaxbuffer" property is described in the Digest-MD5 client section.
The "com.sun.security.sasl.digest.realm" property is used to specify a list of space-separated realm names that the server supports. The list is sent to the client as part of the challenge. If this property has not been set, the default realm is the server's name (supplied as a parameter).
The "com.sun.security.sasl.digest.utf8" property is used to specify the character encoding to use. "true" means to use UTF-8 encoding; "false" means to use ISO Latin 1 (ISO-8859-1). The default is "true".
javax.security.sasl.level=FINEST handlers=java.util.logging.ConsoleHandler java.util.logging.ConsoleHandler.level=FINEST
The table below shows the mechanisms and the logging output that they generate.
| Mechanism | Logging Level | Information Logged |
|---|---|---|
| CRAM-MD5 | FINE | Configuration properties; challenge/response messages |
| DIGEST-MD5 | INFO | Message discarded due to encoding problem (e.g., unmatched MACs, incorrect padding) |
| DIGEST-MD5 | FINE | Configuration properties; challenge/response messages |
| DIGEST-MD5 | FINER | More detailed information about challenge/response messages |
| DIGEST-MD5 | FINEST | Buffers exchanged at the security layer |
| GSSAPI | FINE | Configuration properties; challenge/response messages |
| GSSAPI | FINER | More detailed information about challenge/response messages |
| GSSAPI | FINEST | Buffers exchanged at the security layer |
The first step involves providing an implementation for the SASL mechanism. To implement a client mechanism, you need to implement the methods declared in the SaslClient interface. Similarly, for a server mechanism, you need to implement the methods declared in the SaslServer interface. For the purposes of this discussion, suppose you are developing an implementation for the client mechanism "SAMPLE-MECH", implemented by the class, com.example.SampleMechClient. You must decide what input are needed by the mechanism and how the implementation is going to collect them. For example, if the mechanism is username/password-based, then the implementation would likely need to collect that information via the callback handler parameter.
The next step involves providing a factory class that will create instances of com.example.SampleMechClient. The factory needs to determine the characteristics of the mechanism that it supports (as described by the Sasl.POLICY_* properties) so that it can return an instance of the mechanism when the API user requests it using compatible policy properties. The factory may also check for validity of the parameters before creating the mechanism. For the purposes of this discussion, suppose the factory class is named com.example.MySampleClientFactory. Although our sample factory is responsible for only one mechanism, a single factory can be responsible for any number of mechanisms.
The final step involves creating a JCA provider. The steps for creating a JCA provider is described in detail in the document, How to Implement a Provider for the Java Cryptography Architecture. SASL client factories are registered using property names of the form
SaslClientFactory.mechName
while SASL server factories are registered using property names of the formSaslServerFactory.mechName
mechName is the SASL mechanism's name. This is what's returned by SaslClient.getMechanismName() and SaslServer.getMechanismName(). Continuing with our example, here is how the provider would register the "SAMPLE-MECH" mechanism.
put("SaslClientFactory.SAMPLE-MECH", "com.example.MySampleClientFactory");
A single SASL provider might be responsible for many mechanisms. Therefore, it might have many invocations of put to register the relevant factories. The completed SASL provider can then be made available to applications using the instructions given previously.


In previous chapter you learned about Node class. Though Node is the most important class in LimeJS you almost never create instances of Node itself. You will create Sprites. Sprite is a rectangular display object that can have visual appearance. The appearance can be added with ’setFill(fill)’ method. All of the functionality of the Node class can still be used on sprites and other shapes that inherit from it. This includes adding children sprites.
#!JavaScript
var redsquare = new lime.Sprite().setSize(50,50).
setFill('#c00').setAnchorPoint(0,0);
layer.appendChild(redsquare);
Circle shape makes it easy to create circles or ellipses. All methods are the same as for Sprite. Note that you don't define radius for a circle but just set it's width and height.
#! Radius is the same corner radius property that you will find in any drawing application.
#!JavaScript
var shape = new lime.RoundedRect().setSize(100,40).
setRadius(10);
Label is a shape what can have textual content inside. Text can be defined with ’setText(str)’ method. You can also set various font properties of a label and alignment of its text. If you don't set fixed size for the label one is calculated automatically based on the length of the text and size of the font.
#!JavaScript
var lbl = new lime.Label().setText('Your Score: 10').setFontFamily('Verdana').
setFontColor('#c00').setFontSize(26).setFontWeight('bold').setSize(150,30);
Polygons are most abstract shapes you can create with LimeJS. You need to define the points that make up the polygon, all the rest is done for you. You can not change the anchorPoint and size properties of a polygon caused this are also taken from the point values. This flexible way allows you to create almost anything but realize that less points will mean better performance.
#!JavaScript
var triangle = new lime.Polygon().
addPoints(0,-1, .5,.5, -.5,.5);
Simply creating shapes will not show anything on the screen, it will only set up connections between them. To add some visual appearance you have to set shape's fill property with ’setFill(fill)’ method. The property passed in to setFill can be object that implements lime.fill.Fill or for some simpler fills you can just pass in the values that will be parsed through ’lime.fill.Fill.parse()’ function to automatically create the fills.
Color is the simplest fill you can add to your shape to have it appear in single solid color. You can pass in the values in many different forms: as a hex string, rgb(a) string or raw rgb(a) values.
#!JavaScript
shape.setFill(100,0,0); //dark red
shape.setFill(0,0,0,.5); // 50% transparent gray
shape.setFill('#ffffff'); //white
shape.setFill('rgb(100,0,0)'); //same dark red as first
Once you have created your Color fill object you can transform its value with some built in functions. More specifically you can change color's brightness with method ’addBrightness(factor)’ and saturation with ’addSaturation(factor)’. The factor must be in -1 to +1 range.
#!JavaScript
var green = new lime.fill.Color(0,100,0); // neutral green
var darker_green = green.addBrightness(-.2);
var intensive_green = green.addSaturation(.3);
As it's name says Image fill simply allows you to set external image file as background of a shape. Image is scaled to fit the elements size.
#!JavaScript
sprite.setFill('assets/image.png');
Currently only supported gradient is lime.fill.LinearGradient that allows to create a background transform between colors on a single direction. Radial gradients are not supported at the moment. The angle of the gradient can be defined with method ’setDirection(x0,y0,x1,y1)’ where P(x0,y0) and P(x1,y1) define start and end positions inside 1x1 square. Colors can be defined with method ’addColorStop(offset,var_args)’ where offset must be in 0-1 range.
#!JavaScript
var gradient = new lime.fill.LinearGradient().
setDirection(0,0,1,1). // 45' angle
addColorStop(0,100,0,0,1). // start from red color
addColorStop(1,0,0,100,.5); // end with transparent blue
sprite.setFill(gradient);
Adding mask to a shape means that you only show some specific area of your element. In LimeJS masking is done similarly as in Flash - you create two objects and set one as a mask for the other. This means that only the intersection part is shown and all other parts are clipped away from original element. Only rectangular masks are supported at the moment. After the masks are set you can still modify all the properties of both elements.
#!JavaScript
var mask = new lime.Sprite().setSize(100,100).setPosition(100,100);
parent.addChild(mask);
var image = new lime.Sprite().setSize(300,200).setFill('assets/myimage.png');
parent.addChild(image);
image.setMask(mask);


VIS Author Profiles (VAP) describes publication records of authors from the visualization community in the form of interactive reports that combine automatically generated text and visualizations. The profiles are based on data from DBLP, the Visualization Publication Data Collection, and KeyVis. VAP uses a subset of the DBLP dataset, containing 127,871 publications until 16 July 2018. And our system produce profile pages of 5,087 authors working in the visualization community. VAP is a prototype and might contain occassional bugs or performance issues. If you encounter any problem or have a suggestion, please feel free to contact us.
Ready to explore?
Type an author's name in the search box or start with a random author's profile.
Publication
Shahid Latif and Fabian Beck: VIS Author Profiles: Interactive Descriptions of Publication Records Combining Text and Visualization. IEEE VIS 2018 [Preprint]
Contact Us
Shahid Latif and
Fabian Beck
{shahid.latif, fabian.beck} (at) paluno.uni-due.de
University of Duisburg-Essen, Germany


Anim-x Anchor Example
Bae 5
By
Yung Bae
Stellae
By
ev.exi
Virtual world
By
Fibre
Virtual world
By
Fibre
Play now


Most of us like to play games in one form of the other, some are part of the glorious pc master race, some prefer video game consoles and some of us likes portability hence go for handheld devices. Whatever it is, have we ever wondered which video games are the greatest of them all? If you have, then come along as we count down to the most popular games of all time.

| Rank | Title | Platform | |
|---|---|---|---|
| 15. | Diablo 3 | Microsoft Windows, OS X, PlayStation 3, Xbox 360, PlayStation 4, Xbox One, Nintendo Switch | |
| 14. | Super Mario Bros. | NES Super Nintendo, Game Boy Colour | |
| 13. | Super Smash Brothers | Nintendo 64, iQue Player, GameCube, Wii, Nintendo 3DS, Wii U, Nintendo Switch | |
| 12. | Pokemon franchise | Game Boy, Game Boy Color, Game Boy Advance, Nintendo DS, Nintendo 3DS, Nintendo Switch | |
| 11. | The Legend of Zelda | Nintendo Entertainment System, Super Nintendo Entertainment System, Game Boy, Nintendo 64, Game Boy Color, Game Boy Advance, GameCube, Wii, Nintendo DS, Nintendo 3DS, Wii U, Nintendo Switch | |
| 10. | Metal Gear Solid | PlayStation, Microsoft Windows | |
| 9. | Halo | Xbox, Microsoft Windows, OS X, Xbox 360, Windows Phone, iOS, Xbox One, Arcade | |
| 8. | Final Fantasy | Arcade, MSX, Android, BlackBerry OS, iOS, Mobile phone, Windows Phone, NES, SNES, GC, GBA, Wii, DS, 3DS, Switch, Ouya, PS1, PS2, PS3, PS4, PSP, PS Vita, Microsoft Windows, Xbox 360, Xbox One, WonderSwan | |
| 7. | Call of Duty | Microsoft Windows, OS X, Nintendo DS, GameCube, Nokia N-Gage, PlayStation 2, PlayStation 3, PlayStation 4, PlayStation Portable, PlayStation Vita, Wii, Wii U, Xbox, Xbox 360, Xbox One, iOS, Android, BlackBerry, J2ME | |
| 6. | Angry Bird | iOS, Android, Symbian^3, Nintendo 3DS (AB Trilogy), PlayStation Store (PSP/PS3/PSVita/AB Trilogy), Xbox 360/Xbox One (AB Trilogy), Google Plus, Google Chrome (Chrome Web Store), BlackBerry Tablet OS, Facebook(Flash), Mac OS X, Wii (AB Trilogy), Wii U (AB Trilogy), HTML5, BlackBerry 10[2] | |
| 5. | Skyrim | Microsoft Windows, PlayStation 3, Xbox 360, PlayStation 4, Xbox One, Nintendo Switch | |
| 4. | Grand Theft Auto | Android, Dreamcast, Fire OS, Game Boy Advance, Game Boy Color, iOS, macOS, Microsoft Windows, MS-DOS, Nintendo DS, PlayStation, PlayStation 2, PlayStation 3, PlayStation 4, PlayStation Portable, Windows Phone, Xbox, Xbox 360, Xbox One | |
| 3. | World of Warcraft | Microsoft Windows, macOS | |
| 2. | Counter-Strike | Microsoft Windows, OS X, Linux, PlayStation 3, Xbox, Xbox 360 | |
| 1. | Minecraft | Windows, macOS, Linux | |
| Most widely available game: | Final Fantasy |


{{ areTheyPlaying }}
{{ day }}
{{ wittyPhrase }}
It takes so long to load a webpage. Get a
Slack notification
instead.


In the previous sections, we talked about circuits, how they work, how we build them and how we represent them on a schematic diagram. We even built our first circuit using a battery, a resistor, and LED and some wires.
When it comes to building circuits in real life, connecting wires and components together like we did above – either twisting the wires together or soldering them together – is certainly one way to do it. While sometimes it makes sense to build circuits by twisting wires together or soldering, the problem is that these modifying these types of circuits can be very difficult and cumbersome.
In most cases, you’ll want to build temporary circuits that are easy to modify – this lets you “play around” with the circuit and work out the kinks in your design; then, once you have a temporary circuit that is working exactly the way you want, you can use the design as the basis for your permanent circuit.
One of the most common ways of building a temporary circuit involves the use of a “breadboard,” which you may also hear referred to as a “proto-board.” The name breadboard stems from the fact that early electronics hobbyists would often use the large wooden boards designed for rolling out and cutting bread dough to house their temporary circuits.
The breadboards used
to build electronics are often called “solderless” breadboards,
which can help avoid confusion when talking to your pastry chef
friends. ☺
Breadboards come in many shapes and sizes, but the fundamental components of the breadboard will remain the same:
We’ll get to the purpose of each of these parts in a moment, but the key to a breadboard’s usefulness is how the various areas are electrically connected. Those connections are illustrated here:
As you can see, each of the two rails consists of two long row of connections (a red row in each rail and a blue row in each rail). There are spaces between the groups of holes in the rail, but the entire row is still electrically connected as indicated. Also note that the two red rows are not connected and the two blue rows are not connected – they are denoted in the same color only because they serve the same purpose.
In the center of the board, each row of five connect strips are electrically connected together. While I only highlighted a few rows of connect strips, in actuality, every row of five is a connected strip. It’s important to note that there is no electrical connection across the notch – there’s good reason for this which we’ll get to in a bit.
If you recall from our previous on basic electrical circuits, in order to have a closed circuit, electricity must be able to flow from power, through the circuit, to ground. A breadboard makes it easy to wire a circuit in this fashion – the rails contain the start of the circuit (power) and the end of the circuit (ground), while the connect strips provide space for your components and the connections between those components.
In a previous project (Project #2), we built the following circuit using a battery, an LED, a resistor, and some wires:
Lighting an LED Diagram
We’re now going to build that same circuit again, but this time using the breadboard on our RaspberrySTEM. Note that all future projects will use the breadboard as well…
Let’s look back at our example schematic from our first circuit:
Lighting an LED Schematic
To implement that design on our breadboard, we would follow the schematic from power to ground, inserting each component along the way. Let’s look at this step-by-step:
Provide power and ground to the breadboard.
The first step is to provide power and ground to the breadboard. This is done by wiring the (+) terminal of the 3V battery to one of the holes in the red row along the rail. This will provide power to the entire red row, as all the holes in that row are connected.
Next, wire the (-) terminal of the 3V battery to one of the holes in the blue row along the rail. This will provide ground to the entire blue row, as all holes in that row are connected.
Here’s what the breadboard should look like at this point (with the corresponding portion of the schematic):
Lighting an LED Partial Schematic
Lighting an LED Partial Diagram
Bring power to one of the connect strips on the breadboard.
Next, we will connect power from the red rail to one of the connect strips on the breadboard (the connect strips are where we’ll be creating the heart of the circuit). We do this by running a wire from the power row (the red row along the rail) to any connect strip, and firmly planting the ends of the wire into their respective holes. Remember, it doesn’t matter which hole you choose in the power row, as the entire row is connected. And it doesn’t matter which connect strip you choose or which hole of the connect strip you choose.
Here’s what the breadboard should look like at this point (with the corresponding portion of the schematic):
Lighting an LED Partial Schematic
Lighting an LED Partial Diagram
Connect the resistor.
The next step is to connect the resistor to the breadboard. We do this by inserting one end of the resistor into the same connect strip as the wire. We then insert the other end of the resistor into a different connect strip. Because all five holes in the connect strip are connected, there is now continuity all the way from the power source (the battery) to the first connect strip, through the resistor, and to the second connect strip.
Here’s what the breadboard should look like at this point (with the corresponding portion of the schematic):
Lighting an LED Partial Schematic
Lighting an LED Partial Diagram
Provide continuity from the resistor to new connect strip.
We now place a wire from the same connect strip as the resistor to a new connect strip. This new connect strip is where we will connect the first lead of our LED.
Here’s what the breadboard should look like at this point (with the corresponding portion of the schematic):
Lighting an LED Partial Schematic
Lighting an LED Partial Diagram
Connect the LED.
Now that we have continuity from the resistor to a new connect strip, it’s time to insert the next component – the LED. We insert one end of the LED anywhere in the connect strip we just wired. And we insert the other end of the LED into a new connect strip.
Note that LEDs must be oriented the correct way for electricity to flow through them, so ensure that the long side of the LED is the side inserted into second connect strip.
Here’s what the breadboard should look like at this point (with the corresponding portion of the schematic):
Lighting an LED Partial Schematic
Lighting an LED Partial Diagram
Complete the circuit.
We now have continuity all the way from power, through the resistor and to the LED – it’s now time to complete the circuit by attaching the LED to ground. We do this by attaching the second leg of the LED to the blue row along the rail (the ground row). Because the second leg of the LED is embedded in a connect strip, we can accomplish this by connecting any part of that connect strip to any hole in the blue row using a wire.
Now that the circuit is completed, electricity should be flowing, and your LED should be lit!
Here’s what the final breadboard layout should look like:
Lighting an LED Schematic
Lighting an LED Diagram


{% include "includes/navbar.html" %} {% block body %} {% endblock %} {% include "includes/footer.html" %}


protected suspend fun execute(param: String?): Boolean
Execute with DEFAULT_TIMEOUT a call to this param (the url) and return true if a success call.


§486-87 Penalties. Any person guilty of committing any of the prohibited acts or omitting any of the required acts of this part shall be guilty of a misdemeanor. [L 1988, c 156, pt of §3; am L 1993, c 54, §4]


A simple calendar plugin for the awesome Bootstrap framework
Here is a basic use-case of this plugin. It adds notes to any date on the calendar. Currently, this example saves data in the localStorage.
By adding the following markup, you will get the calendar rendered like the one shown above. It internally leverages Bootstrap's Carousel plugin for the layout & transitions with a default template. However, you can configure it to some other template based on your needs.


My GPG public key is right here.
twitter @aerth___
telegram @aerth
keybase @aerth
Most of my software is released with GPLv3 or MIT license and open to contribution.
open source projects
I have a couple (old) docker automatic builds going on. You can see them at Docker Hub.
docker pull aerth/php:latest
docker pull aerth/boltcms:latest
docker pull aerth/adminer:latest
docker pull aerth/mysql:latest


SHE'S ALL THAT (Miramax - 1999) Cast: Freddie Prinze Jr., Rachael Leigh Cook, Matthew Lillard, Paul Walker, Jodi Lyn O'Keefe Screenplay by R. Lee Fleming Jr. Produced by Peter Abrams, Robert L. Levy and Richard N. Gladstein Directed by Robert Iscove Running time: 91 minutes
Note: Some may consider portions of the following text to be spoilers. Be forewarned.
-------------------------------------------------------------
The recent trend emerging from studio films arriving on the marketplace -- the repackaging of familiar, proven story material in a teen-friendly context -- is indicative of the degree to which this lucrative demographic is coveted. Amy Heckerling's contemporary revision of Jane Austen's "Emma" provided one of 1995's most clever and buoyant pictures in the unexpected hit CLUELESS, and the recent Robert Rodriguez film THE FACULTY is simply a mishmash of THE INVASION OF THE BODY SNATCHERS, THE THING, and teenagers, but in the imminent future, the trickle of teen updates to date becomes a river: on the horizon include such fare as CRUEL INTENTIONS ("Les Liaisons Dangereuses" plus Buffy), TEN THINGS I HATE ABOUT YOU ("The Taming Of The Shrew" in high school), and the U.S. release of STRIKE! (spunky teen starlets meet "Lysistrata", to woeful effect).
Yet another example of teen-oriented revisionism run rampant is the relentlessly conventional SHE'S ALL THAT, re-teaming THE HOUSE OF YES castmates Freddie Prinze Jr. and Rachael Leigh Cook in an update of the Pygmalion tale squarely aimed at the teen crowd. Put to film most memorably in MY FAIR LADY, this formula is hardly unpredictable -- man aims to transform "ugly duckling" to princess, with unexpected peripheral effects -- but what's disappointing here is the lack of any sort of effective fresh spin; after transplanting the fable into a trendy Southern California milieu, R. Lee Fleming Jr.'s screenplay slips into auto-pilot.
That's especially crippling in this picture, far moreso than the scoffable inability of horn-rimmed glasses, a bad wig, a paint-splattered ensemble, and a tendency of tumbling to the ground to mask Ms. Cook's appeal while in wallflower mode -- after all, similar efforts to render the radiant Audrey Hepburn as gawky were also spectacularly unsuccessful. It's crucial that a tale with such an obvious preordained conclusion should sustain interest along its familiar route, yet every twist and turn in the tedious plot unfolds like clockwork while punchlines and comic gags thud with unforgivable regularity. Although the film ramps up a notch during its final half-hour, it's mostly due to the performances of its leads that the picture broaches tolerability.
A few necessary amendments have been implemented onto the formula in order to make the story more palatable to contemporary attitudes. Today's audiences would have be challenged to find empathy for the passive, demure heroines which populate these tales; consequently, frumpy social outcast Laney (Cook) is no shrinking violet: she's much tougher, sharper and more self-assured -- not only does she refuse to swoon at the sudden attention from hotshot Zack (Prinze Jr.), she outright rejects his advances and freely fires acid zingers in his direction. Far from being a reclamation project, the picture takes on the perspective that she's the film's strongest and most complete character from the outset.  And there is the matter of that wonderfully tacky falafel hat she gets to wear at her part-time job.)
Otherwise, there's a numbing lack of innovation evident in this film. Racking up the clichis, the typical centerpiece makeover scene makes its inevitable appearance, with the "not improved, just different" Laney descending down the staircase accompanied by a sweet love song on the background as Zack gapes upwards agog (though I liked that the filmmakers undercut the moment with some humour). It should be noted that Zack's moment of epiphany is a curious variant -- a time-honoured staple of these sorts of pictures is the magical reaction shot of the guy finally recognizing the beauty buried beneath the glasses and the bad hair; it's usually a fleeting moment which occurs when she removes her ungainly spectacles, but it occurs here when Laney slips out of her overalls to reveal her swimsuit-clad figure.
While it may be futile to point out logical faults in what's essentially a contemporary fairytale, the film is so rife with holes that it would be overly charitable to neglect them altogether. Zack is depicted as such a sensitive, kind-hearted soul that his initial pairing with such a cartoonishly one-dimensional villainess as Taylor (Jodi Lyn O'Keefe) defies credibility (save, that is, for her physical attributes). Frankly, he's such a flat-out nice guy that it becomes difficult to swallow someone so thoroughly genial could rocket up the cutthroat high school social ladder to the point where he lords over the student body, enforcing law and order with nary a bit of intimidation and having the soccer team at his beck and call.
These are minor quibbles relative to Laney's behavioural inconsistency, leaping from incredulous (and warranted) suspicion of Zack's advances to reluctant acceptance of his courtship with little cohesion bridging the two positions. (It feels like scenes are missing.) And the velocity of perennial outcast Laney's acceptance into the In Crowd should give hope for social misfits everywhere.
While the picture's focus is largely upon the budding romance between our class-mismatched couple, it indulges in occasional comic diversions (most of which crash and burn) and some brief flights of fancy, catapulting fully into the realm of full-fledged fantasy at the prom, where the seniors break out into an extended choreographed dance sequence. It's a moment that's both energetic and fun to watch.
Although SHE'S ALL THAT's plodding consistent vision is smartly softened by the genuine sincerity and affection with which it treats its love story, the roster of caricatures which serve as supporting characters is a drawback. Among the peripheral players, which include a reunion of THE MIGHTY's Elden Henson and Kieran Culkin (as part of Laney's Outcast Brigade) and Anna Paquin (who turns in a bizarre interpretation of a teenager), only rubber-faced Matthew Lillard makes much of an impression as the comically narcissistic Brock. (Not only does he sport a tattoo of himself on his bicep, it's also labelled "Me", lest any confusion arise.) Brock's the sort of character who, on stage, would carry around a mirror to gaze adoringly at himself; appropriately, in the film he'd rather approvingly ogle his televised visage than cuddle with Taylor.
The film's strength undoubtedly lies with the screen presence of its charismatic leads. Mr. Prinze Jr. gives an easygoing, affable performance; his wide, disarming smile suggests that the hurtful cruelty inherent in the plot will be dulled. Meanwhile, Ms. Cook continues to demonstrate her adeptness in front of the camera, navigating both her character's sullen and softer sides with ease. (She, along with Monica Keena, were the only bright spots in STRIKE!) Although her tiny, delicate frame and photogenic face is obscured by garish clothing and unsightly accessories for half the movie (and her first scene calls on her to hock up a loogie, natch), she's an instantly charming performer. They deserved a better movie than this.
[ ** (out of four stars) | Alternate Rating: C- ]
- Alex Fung, January 31, 1999 email<EMAIL_ADDRESS>web : http://www.ncf.carleton.ca/~aw220/
-- Alex Fung<EMAIL_ADDRESS>| http://www.ncf.carleton.ca/~aw220/ "Somebody asked me what I learned from Michael Bay. And I said, 'nothing.'" - Billy Bob Thornton
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


I love adventure stories. I can’t wait to read the Lord of the Rings series with my kids someday. I’m excited to look at Tolkein’s maps and talk about whether Frodo, Sam, and the Fellowship should have taken a different route.
As a teacher, I ask myself the same questions every day. Did I make the best decision in the path that I’m choosing? Should I be the one leading the group? Should I backtrack and try a different direction? It’s part of teaching. It’s part of life.
We need to help our students navigate a non-linear activity (learning) within a system that demands linear thinking (standards, testing). Roadblocks and challenges aside, how do we set the path? How often do we have to make corrections? How far back to we jump? I think there are some major areas in our classroom landscape that will help us move forward.
1. Home – Home is comfortable. In the LOTR series, home is the Shire. It represents quiet, comfort, and safety. Our students enter our classes each year with a home mindset. They’re comfortable in what they know. As the teacher, we have to coax them out of their own comfort zone and into something unknown. From here, students are relying on our wisdom and leadership for the path.
2. Sage Forest – It’s easy to jump on stage and being spewing everything we know. We don’t have to answer to anyone, and our pupils dutifully follow along. We have total control and our word is taken as truth. Unfortunately, this limits the exposure our students get to the larger world, save for the window that we provide. It is isolated, and while our kids can learn, it often isn’t meaningful. Think Yoda on Dagobah. Luke could do a lot of fancy tricks when he was alone, but Darth Vader handed it* to him when he tried to put his learning into practice.
3. Plain Crossway – This region isn’t uneventful, but it isn’t terribly exciting, either. The travellers and the the leader can discuss the appropriate path, but ultimately, it doesn’t matter which direction you go. This can be a good thing, but oftentimes leaves the traveller feeling unsatisfied. In other words, the teacher isn’t acting as a sage, but isn’t really providing enrichment or growth on the basics. Instead, they’re focusing on making it alive to the other side rather than building a new trail together.
4. Digital Highlands – Navigating the peaks and valleys of the digital learning space takes a person who is confident, wise, and willing to take risks when they can’t see around the next corner. Digital learning is an important piece of the learning space, but it cannot be the only learning space for our students. We have to allow for forays, but we can’t get sucked into the bottom of the digital sphere, never to emerge again.
One space isn’t more meaningful than another. The meaning in each space comes in how they’re combined with the other; the journey isn’t defined by one stop along the way, it’s the trip as a whole that brings meaning. I know we all love Twitter and apps, but let’s try to remember that we have to vary our focus and settings to have a good story to tell.
Leave a comment


‘Damaso’ review: Monster of a film
There are definitely a lot of ideas in 'Damaso'
by Oggs CruzSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


You are: {{ user }}. I can't seem to find you on our mailing list, which means I don't think you should have access to this interface.
If this is wrong, please contact the quartermaster.


THE GREAT SSI QUEST
Welcome to the SAFBC
Register Delegate
Complete Quest
Give the module a second to load after clicking the button...


List of all Traces of i2geo.net
This is the list of all traces.Find the list of traces at each value-space: topics, licenses, and softwares plain?, print?
| Title | Main topic: | # | License | Author | Geometry system | Langue de la construction | Country | Educational level | Other themes | URL |
|---|


Enter an algebraic expression that represents the operation the tool should compute. Here are some hints:


the and virus influenza with oncolytic viruses cell for viral tumor cells protein that are {background cancer which The been death from through immune margin This Virol. {border-style apoptosis have infection factor immunogenic px;} #ffffff;} RNA activation can this was may shown signaling human induction potent clinical novel wild-type development has induced not Influenza also effects growth infected might replication their viruses. Med. PKR armed attenuated checkpoint its therapeutic virus. within against anti-cancer attenuation immunogenicity into malignant melanoma necroptosis phase release should tissue transgene al. al.Influenza delNS deleted deletion disease enhance induce leading more murine nuclear other preclinical px; responses stimulation various were {font-family IFN IL- Immunol. RIPK activity apoptotic due expression font-size highly host inhibitors innate lung necrosis promising receptor strategy vaccine (Fig. Biol. Cancer Death NEP Oncolytic Sci. These able agent apoptosis. but combined dependent double; during effect gene immuno-stimulatory including induces infections inhibition inhibitor interferon laherparepvec lead leads order pathway patients proteins reading site study such transgenes truncated type use virus-induced Acad. Gen. NS-deletion Natl RIG-I Ther. Thus, al.Oncolytic associated avian background based border-color border-width both cells. cellsJ. cellular cleavage cytotoxic efficacy enhanced enhances expressing frame further future generated increased kinase known like major mediated metastatic mice microenvironment models necessary necroptosis. pancreatic phenotype potential present response results solid; specific strategies subsequent than viruses, {font-style {font-weight Another Cell Commons Creative Drug Engl. Fig. However, Immunother. NF-κB Rev. There activated after anti-viral appears biology bold cause cells, complete courier; cytokine deletions dendritic different domains double-stranded effect. effectiveness em; express expressed field first form how indicated infection. initiation interleukin- level live measles multiple necroptotic nonstructural optimize partial pathogenic promotes proven pt;} recombinant replication-deficient safe safety same seasonal seems showed since stage strong strongly studies swine system targeted targeting they truncation trypsin tumors used vaccination variety virotherapy well while


WELCOME TO WORLDNAME!
RULES: CUSTOM
Show More Info
PVP: DISABLED
SEED: 1231231
more rules...
 You may be muted or banned for any reason, and the in-game chat may be monitored.
TheBlockheads.net
Blockheads Forums


Keynote of the decade: behind the scenes, an Infinispan perspective
JBoss World 2011's much talked about keynote ended with a big bang - a live demo that many thought we were insane to even try and pull off - and has sparked off a lot of interest, many claiming JBoss has got its mojo back. One of the things people keep asking is, what actually went on? How did we build such a demo? How can we do the same?
Firstly, if you did not attend the keynote or did not watch it online, I recommend that you stop reading this now, and go and watch the keynote. A recording is available online (the demo starts at about minute 35).
Ok, now that you’ve been primed, lets talk about the role Infinispan played in that demo. The demo involved reading mass volumes of real-time data off a Twitter stream, and storing these tweets in an Infinispan grid. This primary grid (known as Grid-A), and ran off 3 large rack-mount servers. The Infinispan nodes were standalone, bootstrapped off a simple Main class, and formed a cluster, running in asynchronous distributed mode with 2 data owners.
Andrew Sacamano did an excellent job of building an HTML 5-based webapp to visualise what goes on in such a grid, making use of cache listeners pushing events to browsers and browsers rendering the "spinning spheres" using HTML 5’s canvas tag. So now we could visualise data and data movement within a grid of Infinispan nodes.
As Twitter data started to populate the grid, we fired up a second grid (Grid-B) consisting of 8 nodes. Again, these nodes were configured using asynchronous distribution and 2 data owners, but this time these nodes were running on very small and cheap plugtop computers. These plugtops - GuruPlugs - are constrained devices with 512MB of RAM, a 1GHz ARM processor.
Yes, your iPhone has more grunt :-) And yes, these sub-iPhone devices were running a real data grid!
The purpose of this was to demonstrate the extremely low footprint and overhead Infinispan imposes on your hardware (we even had to run the zero assembly port of OpenJDK, an interpreted-mode JVM, since the processor only had a 16-bit bus!). We also had a server running JBossAS running Andrew’s cool visualisation webapp rendering the contents of Grid-B, so people could "see" the data in both grids.
We then fired up Drools to have it mine the contents of Grid-A and send it to Grid-B applying some rules to select the interesting tweets, namely the ones having the hashtag #JBW. With this in place, we then invited the audience to participate - by tweeting with hashtag #JBW, as well as the hashtag of your favourite JBoss project - e.g., #infinispan :-) People were allowed to vote for more than one project, and the most prolific tweeter was to win a prize. This started a frenzy of tweeting, and was reflected in the two grid visualisations.
Not only Infinispan is very quick here: needless to say, Drools was sending the tweets from Grid-A to Grid-B using HornetQ, the fastest JMS implementation on the planet.
Jay Balunas of Richfaces built a TwitterStream app with live updates of these tweets for various devices, including iPhones, iPads, Android phones and tablets, and of course, desktop web browsers, grabbing data off Grid-B. Christian Sadilek and Mike Brock from the Errai team also built a tag-cloud application visualising popular tags as a tag cloud, again off Grid-B, making use of Errai to push events to the browser.
After simulating Mark Proctor to try cheating the system with a script, we could recover the correct votes: clear Grid-B, update the Drools rules to have it discard the cheat tweets, and have a cleaned up stream of tweets flow to Grid-B.
All applications, including Drools and the visualizations, where using a JPA interface to store or load the tweets: it was powered by an early preview of HibernateOGM, which aims to abstract any NoSQL store as a JPA persistence store while still providing some level of consistency. As HibernateOGM is not feature complete, it was using Hibernate Search to provide query capabilities via a Lucene index, and using the Infinispan integration of Hibernate Search to distribute the index on Infinispan.
We then demonstrated failover, as we invited the winner to come up on stage to choose and brutally un-plug one of the plugtops of his choice from Grid-B - this plugtop became his prize. Important to note, the webapps running off the grid did not risk to lose any data, Drools pulling stuff off Grid-A onto Grid-B was still able to continue running, the Lucene index could continually be updated and queried by the remaining nodes.
From an Infinispan perspective, what did this demo make use of?
-
Data distribution, numOwners = 2
-
Async network communication via JGroups
-
JTA integration with JBossTS
-
Cache listeners to notify applications of changes in data and topology
-
The Infinispan Lucene Directory distributing the Lucene index on the grid
So a fairly simple setup, using simple embeddable components, cheap hardware, to build a fairly complex application with excellent failover and scalability properties.
So we where depending on wi-fi connectivity, internet access, a live tweet stream, technology previews and people’s cooperation!
To make things more interesting, the day before the demo one of the servers died; hardware failure: didn’t survive the trip. A second server, meant to serve the UI webapps, started reporting failures on all network interfaces just before starting the demo: it could not figure out hardware addresses of cluster peers, and we had no time to replace him: its backup was already dead. Interesting enough we could tap in some advanced parameters of the JGroups configuration to workaround this issue.
Nothing was pre-recorded! Actually the backup plan was to have Mark Little dancing a tip-tap; next year we will try to stretch our demo even more so you might see that dance!
So here you can see the recording of the event: http://www.jboss.org/jbw2011keynote or listen to the behind the scenes podcast.
After the demo, we did hear of a large commercial application using Infinispan and Drools in precisely this manner - except instead of Twitter, the large data stream was flight seat pricing, changing dynamically and constantly, and eventually rendered to web pages of various travel sites - oh, and they weren’t running on plugtops in case you were thinking ;) So, the example isn’t completely artificial.
How do you use Infinispan? We’d love for you to share stories with us.
Cheers
Manik and Sanne


Image Tools¶
AG_image_tools Package¶
drizzle Module¶
- AG_image_tools.drizzle.drizzle(tstomap, ts, mapshape, weights=1, weightmap=None)[source]¶
Drizzle a timestream onto a map. Returns the map of the weighted average per pixel of the input timestream. (note that this works for any 1D array with a same-size mapping to an image; I’ve written it with timestreams in mind though)
- tstomap - mapping from timestream -> map. len(tstomap) = len(ts)
- Both tstomap and ts should be one-dimensional, but they’ll be raveled if you don’t do it yourself
- weights - needs to have the same dimensions as ts or be scalar
- (default=1)
- mapshape - [nx,ny] simple 2D map specification. Make sure your map
- includes all points mapped to
You can specify a weightmap to increase efficiency instead of computing it
radialprofile Module¶
- AG_image_tools.radialprofile.azimuthalAverage(image, center=None, stddev=False, returnradii=False, return_nr=False, binsize=0.5, weights=None, steps=False, interpnan=False, left=None, right=None, mask=None)[source]¶
Calculate the azimuthally averaged radial profile.
image - The 2D image center - The [x,y] pixel coordinates used as the center. The default is
None, which then uses the center of the image (including fractional pixels).stddev - if specified, return the azimuthal standard deviation instead of the average returnradii - if specified, return (radii_array,radial_profile) return_nr - if specified, return number of pixels per radius and radius binsize - size of the averaging bin. Can lead to strange results if
non-binsize factors are used to specify the center and the binsize is too large- weights - can do a weighted average instead of a simple average if this keyword parameter
- is set. weights.shape must = image.shape. weighted stddev is undefined, so don’t set weights and stddev.
- steps - if specified, will return a double-length bin array and radial
- profile so you can plot a step-form radial profile (which more accurately represents what’s going on)
- interpnan - Interpolate over NAN values, i.e. bins where there is no data?
- left,right - passed to interpnan; they set the extrapolated values
- mask - can supply a mask (boolean array same size as image with True for OK and False for not)
- to average over only select data.
If a bin contains NO DATA, it will have a NAN value because of the divide-by-sum-of-weights component. I think this is a useful way to denote lack of data, but users let me know if an alternative is prefered...
- AG_image_tools.radialprofile.azimuthalAverageBins(image, azbins, symmetric=None, center=None, **kwargs)[source]¶
Compute the azimuthal average over a limited range of angles kwargs are passed to azimuthalAverage
- AG_image_tools.radialprofile.radialAverage(image, center=None, stddev=False, returnAz=False, return_naz=False, binsize=1.0, weights=None, steps=False, interpnan=False, left=None, right=None, mask=None, symmetric=None)[source]¶
Calculate the radially averaged azimuthal profile. (this code has not been optimized; it could be speed boosted by ~20x)
image - The 2D image center - The [x,y] pixel coordinates used as the center. The default is
None, which then uses the center of the image (including fractional pixels).stddev - if specified, return the radial standard deviation instead of the average returnAz - if specified, return (azimuthArray,azimuthal_profile) return_naz - if specified, return number of pixels per azimuth and azimuth binsize - size of the averaging bin. Can lead to strange results if
non-binsize factors are used to specify the center and the binsize is too large- weights - can do a weighted average instead of a simple average if this keyword parameter
- is set. weights.shape must = image.shape. weighted stddev is undefined, so don’t set weights and stddev.
- steps - if specified, will return a double-length bin array and azimuthal
- profile so you can plot a step-form azimuthal profile (which more accurately represents what’s going on)
- interpnan - Interpolate over NAN values, i.e. bins where there is no data?
- left,right - passed to interpnan; they set the extrapolated values
- mask - can supply a mask (boolean array same size as image with True for OK and False for not)
- to average over only select data.
If a bin contains NO DATA, it will have a NAN value because of the divide-by-sum-of-weights component. I think this is a useful way to denote lack of data, but users let me know if an alternative is prefered...


THE FRENCH CONNECTION A film review by Blake French Copyright 2001 filmcritic.com
The French Connection puts the majority of contemporary action movies to shame.  Unlike many modern-day thrillers, this film is an exciting, taut, and realistic portrayal of urban police life, but it does not fill its running time with gratuitous violence, nonstop profanity, and copious amounts of sex. Character motivation and story drive the film forward--not a needless excess of violent, antisocial behavior. It's a standout cinematic achievement that won five Academy Awards including Best Picture, Best Director, Best Actor (Gene Hackman), Best Film Editing, and Best Writing.
Ernest Tidyman's story follows the adventures of two New York narcotics cops, "Popeye" Doyle (Hackman), and his partner, Russo (Roy Scheider). They track a lead about a large drug delivery that develops into a plan that could entirely destroy the marijuana trade between Paris and New York.
The movie contains convincing, memorable action sequences. In an unexpected, timely scene, Doyle walks down the street when suddenly a sniper hiding on top of his apartment opens fire. The sniper misses and hits an innocent bystander. Doyle finds cover behind a tree. More pedestrians rush to care for the injured victim. Doyle tells them to run. This sequence convinces us that the threat of the sniper is real, which leads us to one of the most thrilling chase scenes in film history.
Most modern action scenes involve massive gunfire from both the good and the bad. It's almost as if the bullets have read the screenplay, hitting their targets only at the plot's discretion. The French Connection gives us convincing situations without the plot contrivances and predictable shoot-outs. The story flows smoothly because everything that happens is character driven.
Recent action movies contain special effects that make The French Connection look like child's play. Nowadays, a film can contain enormous explosions, amazing car chases and crashes, impressive computer generated images, and enough gunfire to impress the Army. But it's not the special effects that make The French Connection a true classic, it's the quality of the performances, the enticing direction by William Friedkin, the brilliant editing, and the intensity and selectivity of the action sequences. Today's filmmakers can throw almost anything into their movies, but there's one thing that they often forget that The French Connection hits right on the nose: action itself doesn't drive a story forward, character does. In today's world, that's almost a novelty.

Visit filmcritic.com on the Web at http://www.filmcritic.com
========== X-RAMR-ID: 28793 X-Language: en X-RT-ReviewID: 236408 X-RT-TitleID: 1007875 X-RT-SourceID: 178 X-RT-AuthorID: 3648 X-RT-RatingText: 5/5
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


4. Logical & bitwise instructions¶
4.1. Document conventions¶
Notation: Rd, Rn
denote ARM registers R0-R7 except in the case of the
special instructions where R0-R15 may be used. Rn<a-b>
denotes an ARM register
whose contents must lie in range a <= contents <= b
. In the case of instructions
with two register arguments, it is permissible for them to be identical. For example
the following will zero R0 (Python R0 ^= R0
) regardless of its initial contents.
eor(r0, r0)
These instructions affect the condition flags except where stated.
4.2. Logical instructions¶
and_(Rd, Rn)
Rd &= Rn
orr(Rd, Rn)
Rd |= Rn
eor(Rd, Rn)
Rd ^= Rn
mvn(Rd, Rn)
Rd = Rn ^ 0xffffffff
i.e. Rd = 1’s complement of Rnbic(Rd, Rn)
Rd &= ~Rn
bit clear Rd using mask in Rn
Note the use of “and_” instead of “and”, because “and” is a reserved keyword in Python.
4.3. Shift and rotation instructions¶
lsl(Rd, Rn<0-31>)
Rd <<= Rn
lsr(Rd, Rn<1-32>)
Rd = (Rd & 0xffffffff) >> Rn
Logical shift rightasr(Rd, Rn<1-32>)
Rd >>= Rn
arithmetic shift rightror(Rd, Rn<1-31>)
Rd = rotate_right(Rd, Rn)
Rd is rotated right Rn bits.
A rotation by (for example) three bits works as follows. If Rd initially
contains bits b31 b30..b0
after rotation it will contain b2 b1 b0 b31 b30..b3
4.4. Special instructions¶
Condition codes are unaffected by these instructions.
clz(Rd, Rn)
Rd = count_leading_zeros(Rn)
count_leading_zeros(Rn) returns the number of binary zero bits before the first binary one bit in Rn.
rbit(Rd, Rn)
Rd = bit_reverse(Rn)
bit_reverse(Rn) returns the bit-reversed contents of Rn. If Rn contains bits b31 b30..b0
Rd will be set
to b0 b1 b2..b31
Trailing zeros may be counted by performing a bit reverse prior to executing clz.


Berrettini signs off with victory over Thiem
by Martyn HermanLONDON (Reuters) - Matteo Berrettini became the first Italian to win a match in ATP Finals history as he signed off with a 7-6(3) 6-3 defeat of off-color Dominic Thiem at the O2 Arena on Thursday.
The afternoon tussle was a little flat as Thiem had already sealed a place in the semi-finals after group wins against Roger Federer and Novak Djokovic, while Berrettini could not progress.
But the powerful 23-year-old Berrettini, making his debut at the tournament, produced some eye-catching tennis to make sure he heads home with a morale-boosting win.
The 200 ranking points and $215,000 for the group stage win capped a stunning year for Berrettini who was outside the top 50 in January but will end the season ranked eighth.
The only other Italians to qualify for the elite season-ender were Corrado Barazzutti in 1978 and Adriano Panatta in 1975 and neither managed to win a match.
Berrettini served for the first set at 5-4 after breaking the Thiem serve to love in the previous game, but a netted volley handed back the break.
The Italian dominated the tiebreak and grew in confidence in the second set as Thiem, suffering with a cold, failed to repeat the dazzling form he displayed when beating Djokovic in a three-set thriller on Tuesday.
A running backhand pass gave him a break for 4-2 in the second set and he closed out the win in dominant fashion.
Despite losing on Thursday, Thiem has won the group and will be joined in the semi-finals by either Djokovic or Federer who clash for the 49th time in an evening blockbuster.


JavaScript30 // Neumorphism Drum Kit
A
claspan
S
hithat
D
kick
F
openhat
G
boom
H
ride
J
snare
K
tom
L
tink
designed by
yish


public class DecodeOptions
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
int |
CallbackWaitTimeout
Deprecated.
Timeout setting decWaitForDecode will wait before checking callback (WinCE Only)
|
int |
DecAttemptLimit
Amount of time decoder will spend on each image
|
int |
DecodeMode
Deprecated.
Decoding modes
|
int |
LinearRange
Deprecated.
Size of the window used in the Advanced Linear decoding mode
|
int |
MultiReadCount
Maximum number of barcodes to read in a single image
|
int |
PrintWeight
Deprecated.
Relative contrast
|
int |
SearchLimit
Deprecated.
Amount of time decoder will spend searching for a barcode
|
int |
VideoReverse
Video reverse (linear only)
|
| Constructor and Description |
|---|
DecodeOptions()
Data structure that is used to retrieve attributes of last acquired image
|
public int PrintWeight
public int DecodeMode
public int LinearRange
public int VideoReverse
public int DecAttemptLimit
public int SearchLimit
public int CallbackWaitTimeout
public int MultiReadCount


At the University of Virginia, he is a Research Professor at the Biocomplexity Institute. His current interests include Multicloud Hybrid Cloud Computing Analytics Services, MLCommons Benchmarking of Deep Learning Applications, Workflow Management for Benchmarking of DeepLearning Algorithms, and Student Research Project Supervision. He initiated the Cloudmesh project which hybrid multicloud toolkit to enable cloud computing across various Cloud and Container IaaS such as OpenStack, AWS, Azure, docker, docker swarm, and Kubernetes.
He received a Masters Degree in 1990 from the University of Bonn, Germany, and a Ph.D. in 1996 from Syracuse University in computer science. He held a position at Argonne National Laboratory from Nov. 1996 – Aug. 2009, where he was last a scientist and a fellow of the Computation Institute at the University of Chicago. During his last two years at ANL he was on sabbatical and an Associate Professor and the Director of an institution at Rochester Institute of Technology, focusing on Cyberinfrastructure.
At Indiana University he was an Assistant Director in the Digital Science Center (DSC) in the School of Informatics and Computing at Indiana University.
Past academic appointments include Adjunct Professor in the Intelligent Systems Engineering Department at Indiana University, Adjunct Professor positions at the Computer Science Department at Indiana University, Associate Professor at Rochester Institute of Technology, Adjunct Professor at the University of North Texas. He has also taught voluntarily at Illinois Institute of Technology.
He provided leadership to interface with the San Diego Supercomputing Center on virtual clusters for XSEDE comet. He was the co-PI on developing a scientific impact metric for the longest-running high-performance computing infrastructure funded by NSF spanning XSEDE, reaching as far back as TerraGrid. Previously, he was the architect of FutureGrid, one of the first successful clouds in US academia. He was previously involved in Grid computing since the term was coined. Before that, he initiated and led the Java Commodity Grid Kit which provided the basis for hundreds of Grid-related projects, including the Globus Toolkit.
To contact him, please send mail to<EMAIL_ADDRESS>PhD in Computer Science, 1996
Syracuse University
MS Computer Science (Diplom), 1989
University of Bonn
BSc in Computer Science
University of Bonn
Responsibilities include:
Responsibilities include:
Responsibilities include:
On popular demand, I have added here some open source project ideas for semester-long projects suitable at various Universities. For larger and other projects, please contact me. This list is created for undergraduate and graduate classes, emphasizing holistic research experiences combining theory, practice, and management skills. The list is only a small sample and is influenced by the classes and their Professors that have contacted me with project ideas for these classes.
The pronunciation of my lastname is as follows:
fon La-Chef-Ski
von La-Chef-Ski
The coat of arms changes over time dependent on various factors. Here are some variations of the coat of arms.
Often I am asked where my name comes from. If you like to know more,
please check out the information about the name von Laszewski
.
However, please note that the information refers to the early use of the
name. It is related to a teutonic knight called Zelberschwecht
. At one
point in history they took on the name of the town Laszewo
where they
used to live.
To find out more, about the family trees of Laszewski’s please visit:
29 Nov 2022


Copyright 2009-2013 Tracy Flynn. All rights reserved. Licensed under the Apache License, Version 2.0.
AppConfig is designed to provide painless configuration for multiple runtime environments based on a model similar to the Ruby-on-Rails 'development/production/test' approach with all the appropriate defaulting and overriding of settings.
It is particularly targeted at the problem of configuring components and applications 'from the outside' without needing to modify the packaged artifact.
If certain conventions are observed, it can also independently manage configurations for multiple AppConfig-enabled components within a single application.
It is based on Apache Commons Configuration.
Suppose the settings for a component or a program that's been built with AppConfig support need to be changed.
mkdir ~/local_appconfig
Put environment-specific settings into the configuration directory in files with the naming patterns:
Where 'environment' is one of 'development','production' or 'test'. The contents of the properties files follow Java Property file syntax. The contents of the logback-xxx.xml files follow logback syntax (See Logback Home).
Override whatever settings need to be changed in the appropriate file.
e.g. Change development database connection settings for your machine in 'database-development.properties'
Either
export com.verymuchme.appconfig.externalConfigurationDirectory=~/local_appconfig
or
java -Dcom.verymuchme.appconfig.externalConfigurationDirectory=~/local_appconfig ...
Enable this setting when running multiple web applications in the same container. This causes the servlet context to be appended to the external configuration directory. This provides a separate configuration directory per web application.
Either
export com.verymuchme.appconfig.externalConfigurationDirectory.useContextPathAsSuffix=true
Or
java -Dcom.verymuchme.appconfig.externalConfigurationDirectory.useContextPathAsSuffix=true \
-Dcom.verymuchme.appconfig.externalConfigurationDirectory=~/local_appconfig ...
Note that the application must have been built so that the contextPath is passed to AppConfig as an option at application initialization time using the setting 'application.contextPath'.
Either
export com.verymuchme.appconfig.runTimeEnvironment=production
or
java -Dcom.verymuchme.appconfig.externalConfigurationDirectory=~/local_appconfig \
-Dcom.verymuchme.appconfig.runTimeEnvironment=production ...
By default, AppConfig assumes you're running in 'development' mode.
When you run the program, your modified settings will be picked up automatically, will override the default settings and be used to configure the program.
Not currently up to date
You can generate a fully functional demo by using the following Maven archetype and instructions:
mvn archetype:generate -DarchetypeRepository=https://github.com/tflynn/mvn-repo-public/raw/master/releases -DarchetypeGroupId=com.verymuchme.archetypes -DarchetypeArtifactId=basic_jar -DarchetypeVersion=1.2 -DgroupId=com.example.demo -DartifactId=basic_jar -DartifactVersion=1.0-SNAPSHOT
cd basic_jar
mvn clean package
java -cp ./target/basic_jar-1.0-SNAPSHOT-jar-with-dependencies.jar com.example.demo.App
Examine the following files to understand how the application is being configured:
./src/main/java/com/example/demo/App.java
./src/main/java/com/example/demo/ConfigurationLoader.java
./src/main/resources/com/example/demo/application-defaults.properties
./src/main/resources/com/example/demo/application-development.properties
./src/main/resources/com/example/demo/application-test.properties
./src/main/resources/com/example/demo/database-defaults.properties
./src/main/resources/com/example/demo/logback-defaults.xml
./src/main/resources/com/example/demo/logback-development.xml
./src/main/resources/com/example/demo/logback-test.xml
AppConfig is designed to provide painless configuration for multiple runtime environments based on a model similar to the Ruby-on-Rails 'development/production/test' approach with all the appropriate defaulting and overriding of settings.
It is particularly targeted at the problem of configuring components and applications 'from the outside' without needing to modify the packaged artifact.
It is based on Apache Commons Configuration.
AppConfig appConfig = new AppConfig();
appConfig.setApplicationPropertiesPackageName("your base package name");
appConfig.setExternalConfigurationDirectory("configuration directory name");
HashMap<String,Object> configurationOptions = new HashMap<String,Object>();
configurationOptions.put("application.contextPath",servletContext.getContextPath()); // Web app only
appConfig.setOptions(configurationOptions);
appConfig.configure();
(See error handling information below)
Configuration files should be stored at the root of your package.
Do NOT place them at the root your source tree. If you do, unpredictable things will happen when you try to load configuations in a project containing multiple AppConfig-enabled components.
Example:
AppConfig itself is a Maven-based package with a base package of 'com.verymuchme.appconfig'. So, configuration files would be placed in:
./src/main/resources/com/verymuchme/appconfig
The following files will be automatically loaded in the order shown.
application-development.properties (optional)
database-development.properties (optional)
application-defaults.properties
database-defaults.properties
logback-development.xml (optional)
logback-defaults.xml (optional)
For each file, the search order is the following:
Following the Apache Commons Configuration convention, if the same key found in multiple files, the value from the first file found and loaded wins. So, in this case, 'development' trumps 'defaults' - just the desired behavior.
In general, if a file is shown, it must be present in one of the locations or an exception will be thrown. It may be empty. 'Optional' indicates that the file can be absent.
Configuration configuration = appConfig.getConfiguration();
// See AppConfig javadocs or Apache Commons Configuration API docs for more information
// http://commons.apache.org/configuration/apidocs/index.html
String configurationValue = configuration.getString("some property name");
The default logging configuration support assumes logback (See Logback Home). Note that the 'LogbackFactory' class is a convenience class provided by the AppConfig package. It mirrors the syntax of 'slf4j.LoggerFactory'.
In code, all you need is something similar to:
import ch.qos.logback.classic.LogbackFactory;
import ch.qos.logback.classic.Logger;
…
public class SomeClass {
…
private static final Logger logger = LogbackFactory.getLogger(SomeClass.class);
…
public void someMethod() {
…
logger.debug("Some significant message");
…
}
…
}
And in the POM file - or in an equivalent dependency management tool
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.2</version>
</dependency>
<!-- LogBack -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
<version>1.0.9</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.0.9</version>
</dependency>
Note that the 'slf4j' and 'logback' dependencies are managed by the 'AppConfig' dependency (see below).
Both the logging and configuration implementations can be changed.
Because AppConfig follows its own configuration model, it can be configured from the outside, and doesn't require a rebuild of the package to add new support.
To change logging support:
To change configuration support:
Application or component configuration normally happens at point where the artifact starts. It's also usually the case that a problem with the configuration is serious if not fatal.
That assumption led to two simple decisions.
So, a try/catch is needed around the AppConfig initialization (as shown below) if the code wants to detect configuration errors and exit gracefully.
try {
AppConfig appConfig = new AppConfig();
appConfig.setApplicationPropertiesPackageName("your base package name");
appConfig.setExternalConfigurationDirectory("configuration directory name");
appConfig.configure();
}
catch (AppConfigException ace) {
try {
logger.error("App failed to configure properly. Exiting abnormally",ace);
System.exit(1); // Exit with error code
}
catch (Exception ee) {
// Can't be sure that logging was configured successfully if app configuration failed
System.out.println("App failed to configure properly. Logging apparently not configured. Exiting abnormally");
System.out.println(e.getMessage());
e.printStackTrace(System.out);
System.exit(2); // Exit with error code
}
}
Most AppConfig internal behaviors can be overriden with appropriate feature switches.
The value of a particular feature switch is determined hierarchically, with the first value found for a particular setting being used. The searcn order in which the switch settings are examined is:
The setting name is the same in all cases.
The following internal settings are available:
#
# Internal defaults for all settings that can be overridden
#
# Property values are specified with a slightly extended property syntax
#
# "true" / "false" are recognized as boolean values
# "null" is recognized as the null value
# a comma delimited list of values is recognized as an array of string values
#
# File name for internal default properties - only specify a value to override the default 'internal-defaults.properties'
com.verymuchme.appconfig.internalDefaultPropertiesFileName = null
# Include the Apache Commons Configuration definition file to include the "<system/>" element as the first definition
com.verymuchme.appconfig.systemPropertiesOverride = false
# Allowed run time environment names
com.verymuchme.appconfig.permittedRunTimeEnvironments = development,production,test
# Current run time environment name
com.verymuchme.appconfig.runTimeEnvironment = development
# Default run time environment name
com.verymuchme.appconfig.defaultRunTimeEnvironment = development
# External configuration directory
com.verymuchme.appconfig.externalConfigurationDirectory = null
# Default prefix for application configuration files
com.verymuchme.appconfig.applicationConfigurationPrefix = application
# Default prefix for database configuration files
com.verymuchme.appconfig.database.ConfigurationPrefix = database
# Require a default database configuration file
com.verymuchme.appconfig.database.defaultConfigurationEnabled = true
# Default prefix for a logback configuration file
com.verymuchme.appconfig.logging.ConfigurationPrefix = logback
# Require a default logback configuration file
com.verymuchme.appconfig.logback.defaultConfigurationEnabled = true
# Default suffix for all configuration files
com.verymuchme.appconfig.configurationNameSuffix = properties
# Default suffix for logging configuration files
com.verymuchme.appconfig.loggingConfigurationNameSuffix = xml
# Default prefix for default configuration files
com.verymuchme.appconfig.defaultConfigurationName = defaults
# Default name for Freemarker configuration template
com.verymuchme.appconfig.configurationTemplateName = configuration-xml.ftl
# Base class for Freemarker to use to find template
com.verymuchme.appconfig.freemarker.baseClassName = null
# Default AppConfig logging level for bootstrap logging
com.verymuchme.appconfig.boostrapLogging.logLevel = ERROR
# Default AppConfig logging level for internal logging
com.verymuchme.appconfig.logging.logLevel = ERROR
# Name of AppConfig internal logback configuration file
com.verymuchme.appconfig.logging.internalConfigurationFileName = logback-internal.xml
# Default value of application properties package name
application.propertiesPackageName = null
# Default value of application properties package directory
application.propertiesPackageDir = null
# Default LoggingHelper class name
com.verymuchme.appconfig.loggingHelper.className = com.verymuchme.appconfig.LoggingHelperLogback
# Default ConfigurationBuilder class name
com.verymuchme.appconfig.configurationBuilder.className = com.verymuchme.appconfig.ConfigurationBuilderCommonsConfiguration
# Context class for loading logging properties. If null, configuration files loaded relative to
# internal logging configuration
application.logging.contextClass = null
# For Spring Apps, application context
application.applicationContext = null
# If there is more than one AppConfig-enabled web application running in the same container,
# each application needs to be configured separately.
#
# Enable this setting to cause the servlet context to be appended to the external configuration directory.
# This provides a separate configuration directory per web application.
#
# The contextPath must be passed to AppConfig as an option at application initialization time
# using the setting 'application.contextPath'
#
com.verymuchme.appconfig.externalConfigurationDirectory.useContextPathAsSuffix = false
# For web applications, the contextPath at application initialization time - ServletContext.getContextPath()
application.contextPath = null
Apache Commons Configuration uses the concept of a configuration definition file. At its heart, all AppConfig is doing is generating a customized configuration definition file and passing it to Apache Commons Configuration to load application and database properties.
If the default template in AppConfig isn't suitable, it can be changed by setting the internal setting 'com.verymuchme.appconfig.configurationTemplateName' to point to another template. The template is a Freemarker template. Have a look at the AppConfig source before making a change to see what settings are passed to the template.
Note that, because of loading issues, logging configuration is handled separately.
Settings internal to AppConfig itself (the list above) can be accessed from the application configuration object. For instance, to get the current runtime environment:
configuration.getString("com.verymuchme.appconfig.runTimeEnvironment");
AppConfig uses github to manage sources and Javadocs.
<repository>
<id>mvn-repo-releases</id>
<url>https://github.com/tflynn/mvn-repo-public/raw/master/releases</url>
</repository>
<repository>
<id>mvn-repo-snapshots</id>
<url>https://github.com/tflynn/mvn-repo-public/raw/master/snapshots</url>
</repository>
<!-- AppConfig -->
<!-- Contains dependencies for Logback logging support 1.0.9 -->
<!-- Contains dependency for slf4j-api 1.7.2 -->
<dependency>
<groupId>com.verymuchme.appconfig</groupId>
<artifactId>app_config</artifactId>
<version>4.0.1</version>
</dependency>


ADFIRWMC - 4. The Value of Unstructured Analysis
I find performing unstructured analysis upfront to be critical part of my work flow because it tells me massive amount of contextual data upfront and it focuses the structured analysis I need to accomplish.
When I say unstructed analysis, I am referring mostly to searching through the strings inside of the artifacts I have collected for keyword matches. Where do these keywords come from? Unless you are on a complete witch hunt, which unfortunately happens, there is a set of circumstances that led you to investigate this system. It could be an alert from weird proxy traffic or an antivirus hit on a file found in a User’s Temp folder.
Whatever it is, these events typically have fun details that you can search for. (90% of the time it ends up being some part of a file path or part of a URL.) Let’s look at a little bit of science before we get into DFIRness of it all. This topic can get hopeless deep and veer of course quickly so I am only covering the meat and potatoes.
Tools Used
Strings
A string is a data type used in programming, such as an integer and floating point unit, but is used to represent text rather than numbers. Most of the words you read on a computer are stored as a string on disk or in memory. For instance, by visiting this site, your browser has probably stored a cached version of this page to a temp folder somewhere in your profile. On top of that, your browser also needs this page’s content in its process memory in order to render it. Strings get thrown all over the place by doing even the most mundane tasks. Knowing the significance of where strings are found can make your life a lot easier.
ASCII
- Stands for American Standard Code for Information Interchange but you will never need to know that.
- Even though ASCII predates epoch and maybe even time itself, it is the basis for most modern character-encoding schemes.
- Ascii is a code for representing English characters as numbers, with each letter assigned a number from 0 to 127
- Not all ASCII characters are visible text.
- Some are used to control how text is displayed like 0x0A New Line or 0x09 Tab.
- Some are strictly for commands like Escape 0x1B or Delete 0x7F.
- Reference: https://www.asciitable.com/
Example:
Example displayed:
Fun ASCII DFIR stuff you might find:
- Browser History, Cookies, etc. are stored in ASCII in Chrome, FireFox (Probably others too.)
- File Paths in Shortcuts
- Antivirus Logs
Unicode
- Like ASCII but bigger
- Unicode is a standard which defines the internal text coding system in almost all operating systems used in computers at present.
- Version 1 started out with 65536 code points, commonly encoded in 16 bits or 2 bytes.
- The current version is 6.3, using 110,187 of the available 1.1 million code points.
Example:
Example Displayed:
Fun Unicode DFIR stuff you might find:
- Names of Files and Folders in $MFT, $LogFile, $UsnJrnl
- Stuff in Windows Event Logs
- Stuff in Windows Registry Keys
- File Paths in Recycle Bin metadata files
- File Paths in Shortcuts
- Sticky Notes left on the Desktop
- Literally almost anything with text.
Why Do You Care?
Imagine you are a salty beat cop 4 days from retirement. Just do it. No, really.
You get a call on a tip line saying an elaborate bank heist could have been committed. The caller says the they normally use a specific kind of fake id, knock out the guards with a tranq gun, put a bunch of money in a blue bag, and fly off the roof of the bank in a fancy helicopter. While not perfect, unstructured analysis can provide the following details immediately:
- Has there been a fake ID in the bank?
- No? The crooks either haven’t struck or got lost on the way. It happens.
- Yes? The crooks have been here!
- Has there been a tranq gun in the bank?
- No? The guards must have spotted the fake ID and disabled the crooks before they got the gun out. NICE!
- Yes?  The guards may or may not have had to deal with tranq darts. Gettting serious now…

- No? Guards took out the crooks or the crooks were looking for Rubles instead of Dollars and just left.
- Yes? Well then we can assume that the guards are subdued and the crooks are running around in the bank unchecked.
- Has anyone seen a fancy helicopter recently?
- No? Helicopter might have been ceased or ran out of gas. Happens all the time.
- Yes? Well…you have been successfully robbed. Time to start dusting for prints…
Real World Example
Here is an interesting “crook” I found on Hybrid Analysis. This sample has been linked to APT33 and drops the TURNEDUP backdoor. For funsies, I 7zipped it up, named it “Paul_resume.7z” and sent it to myself in an email to simulate how these things go down.
High level things we can look for from this sample as discovered from our detection team and/or OSINT:
- Filenames
- stikynote.exe, codexgigas_f09bb42e6c39a9714ed8a4d4191cf19e40d1919b.exe, Paul_resume.7z
- URLs
- googlmail.net
THIS IS A JOB FOR POWERSHELL!!!
start-process C:\Tools\strings.exe -ArgumentList "-nobanner -accepteula -s 2018-03-18-10-16-4\*" -RedirectStandardOutput ..\strings.txt
gc .\strings.txt| Where-Object { $_ -imatch "Paul_resume|codexgigas|stikynote" } | sort | unique
###Example:
This output speaks so much about what has transpired on this machine that I don’t need to wait for structured analysis to make a containment decision. Here are the highlights that I can see in roughly 30 secs:
- The $MFT, $LogFile, and $USNJrnl:$J show evidence of the download attempt, successful download of the zip file, unzipping, and execution:
- Download Attempt:
C:\Scripts\2018-03-18-10-16-4\c\$Extend\$USNJrnl$J: <<Paul_Resume.7z.2hvceui.partial
- The suffix .parital is affixed to files that are in the process of being downloaded by IE and Edge.
- Successful Download:
C:\Scripts\2018-03-18-10-16-4\c\$Extend\$USNJrnl$J: <Paul_Resume.7z
- Here we see just the Paul_Resume.7z meaning it finished downloading
- Unzipping
C:\Scripts\2018-03-18-10-16-4\c\$Extend\$USNJrnl$J: $<Paul_Resume.7z.lnk
- I don’t know the exact filepath of this Shortcut file but the majority of shortcuts are created for recently accessed files.
C:\Scripts\2018-03-18-10-16-4\c\$Extend\$USNJrnl$J: r<codexgigas_f09bb42e6c39a9714ed8a4d4191cf19e40d1919b-1.exe
- Since this is the file inside the 7z file, we can see that it was successfully unzipped.
C:\Scripts\2018-03-18-10-16-4\c\Users\Username\NTUSER.DAT: C:\Users\Username\Desktop\Paul_Resume\codexgigas_f09bb42e6c39a9714ed8a4d4191cf19e40d1919b-1.exe
- This line from the NTUSER.DAT file of from the Username profile clearly shows this was extracted to the users desktop. What stored this string in the user’s registry? Right now…it doesn’t matter. We are not parsing anything. Only triaging.
- Execution:
C:\Scripts\2018-03-18-10-16-4\c\$Extend\$USNJrnl$J: R<CODEXGIGAS_F09BB42E6C39A9714E-F57CC974.pf
- Files ending in .pf are typically associated with Windows Prefetch. This is a file that is autmagically generated when you run an execuatable to make a Windows machine more efficient. This is strong evidence of execution. We will dig into Prefetch later in this course.
- This machine does not have StikyNotes install from Microsoft so references to StikyNote.exe, StikyNote.tmp, and STIKYNOTE.EXE-EC3D9C6B.pf seen in $UsnJrnl:$J, $LogFile, and $MFT tell us that the TURNEDUP backdoor was successfully ran on this machine.
- Download Attempt:
- Persistence:
- This was less science and more eductated guesswork but it is rare to see a complete file path in a registry value unless it is going to be used to execute something Windows wouldn’t naturally know where to find ergo… persistence. A quick peek with Eric Zimmerman’s Registry Explorer revealed my hunch was right.
Registry file: C:\Scripts\2018-03-18-10-16-4\c\Users\Username\NTUSER.DAT Key: Software\Microsoft\Windows\CurrentVersion\Run Last write: 2018-03-18 17:03:14 Value: RESTART_STICKY_NOTESS (RegSz) Data: C:\Users\Username\AppData\Local\Temp\StikyNote.exe
- Good ol’ HKCU\Software\Microsoft\Windows\CurrentVersion\Run is one of the easiest methods of making sure an executable starts when a user logs in. Makes for a good IoC to test the rest of your environment against.
We have found all the evidence we need to determine that this machine needs to be removed from the network and further analysis needs be taken to determine what took place after infection. While fairly typical, this example does not represent all malware or reasons you might need to DFIR a system so your milage may vary BUT I found performing this step first almost always helps eliminate or focus structured analysis.
Still not a believer? I wrote up a similar case a while ago that saved my buns before the holidays.