---
layout: page
---
I lead an AI applied research and engineering organization at Meta Reality Labs responsible for developing computer vision, machine perception and speech/NLU technologies for augmented reality glasses. This involves working with a large cross functional team of engineers and product managers to enable the AI use cases in our products. Our work cuts across the full ML stack - algorithms, model architecture, model optimization, deployment and SW/HW co-design. My research interests include all aspects of buiding efficient AI solutions.
I received a Ph.D. in Computer Engineering from Carnegie Mellon University in 2004. I have held the
positions of Visiting Scholar (2011 – 2014) and Visiting Faculty (2016 – 2017) at Stanford University.
I have authored 100+ research publications and am an inventor on 45+ US and international patents (granted and pending). I
received the ACM-SIGDA Technical Leadership Award in 2009 and was invited to the 2017 National Academy of
Engineering’s Frontiers of Engineering Symposium. I am a senior member of IEEE.
Contact me
vchandra@alumni.cmu.edu


Luvit 2.5.6 Documentation
Table of Contents
Require#
Luvit's custom require system with relative requires and sane search paths.
This allows us to have the convenience of having node style require statements to include libraries.
Luvit's custom require system with relative requires and sane search paths.
This allows us to have the convenience of having node style require statements to include libraries.


Our app is available on any mobile device! Download now to get started!
How It works
List your items
Receive and Accept a rental Request
Meet the Renter and hand over the item
Meet the Renter at the end of the rental period to recollect it
Earn Money!
Lookup an item
Request it, wait for the Owner to accept
Pay Rental Fees
Meet the Owner to collect it
Meet the Owner to return it when done
Do you have a lot of “junk” sitting in your garage, and don’t know what to do with it?
If you have items sitting collecting dust in your garage, list them on our App and start earning some cash by lending them. An additional source of income is always welcome and a plus! .


Configure Google
In order to call Google API's, you need to register as a developer and create client credentials. Here are some instructions for these steps.
The first thing you'll need to do is Create a Project on Google to obtain client credentials. Click "Create project" and enter your desired project name.
Then click on your newly created project from the listing on the dashboard, and under the Credentials section, create a new "OAuth2 2.0 client ID".
Google will ask you to configure your consent screen, to add your logo and other information displayed to the user to authorize Google to release information.
Fill out the form...
Now you're ready to create the credentials. Enter "Authorized JavaScript
origins". It should be the uri of your Gluu Server--for example
https://idp.example.com
.
Google will display the client-id and the according secret ... ignore it. Instead, download the JSON file which you are going to upload into your Gluu Server, next.
Move this file to the location /opt/tomcat/conf/google.json
. The JSON
file will look something like this example (no... these data are not
valid credentials!):
{
"web": {
"client_id": "7a64e55f-724d4e8c91823d5f1f18a0b2.apps.googleusercontent.com",
"auth_uri": "https:\/\/accounts.google.com\/o\/oauth2\/auth",
"token_uri": "https:\/\/accounts.google.com\/o\/oauth2\/token",
"auth_provider_x509_cert_url": "https:\/\/www.googleapis.com\/oauth2\/v1\/certs",
"client_secret": "bb76a2c99be94e35b874",
"javascript_origins": [
"https:\/\/brookie.gluu.info"
]
}
}
The last step is to enable Google+ API's:
- Navigate back to the Google API console
- Select project and enter project name
- Open new project "API & auth -> API" menu item in configuration navigation tree
- Click "Google+ API"
- Click "Enable API" button
Configure Gluu Server
Login to oxTrust, and navigate to "Configure Custom Scripts".
At the bottom of the page, click on the link to "Add custom script configuration".
In the main body of the "Custom Script" section, paste the code from github.
You'll also need to add some custom properties:
- gplus_client_secrets_file:
/opt/tomcat/conf/google.json
- gplus_deployment_type: enroll
- gplus_remote_attributes_list: email, given_name, family_name, and locale
-
gplus_local_attributes_list: uid, mail, givenName, sn, cn, preferredLanguage
-
gplus_client_secrets_file - It is a mandatory property that holds the path to the application configuration file downloaded from Google console for application. An example is
/etc/certs/gplus_client_secrets.json
. These are the single steps needed to get it: a) Log into:https://console.developers.google.com/project
b) Click "Create project" and enter project name c) Open new project "API & auth -> Credentials" menu item in configuration navigation tree d) Click "Add credential" with type "OAuth 2.0 client ID" e) Select "Web application" application type f) Enter "Authorized JavaScript origins". It should be CE server DNS name, for examplehttps://gluu.info
. g) Click "Create" and Click "OK" in next dialog h) Click "Download JSON" in order to downloadgplus_client_secrets.json
file. Also it is mandatory to enable Google+ API: a) Log intohttps://console.developers.google.com/project
b) Select project and enter project name c) Open new project "API & auth -> API" menu item in configuration navigation tree d) Click "Google+ API" e) Click "Enable API" button -
gplus_deployment_type - Specify the deployment mode. It is an optional property. If this property isn't specified the script tries to find the user in the local LDAP by 'subject_identifier' claim specified in id_token. If this property has a 'map' value the script allows to map 'subject_identifier' to the local user account. If this property has an 'enroll' value the script adds a new user to the local LDAP with status 'active'. In order to map the IDP attributes to the local attributes it uses properties from both gplus_remote_attributes_list and gplus_local_attributes_list. The allowed values are map and enroll.
-
gplus_remote_attributes_list - Comma-separated list of attribute names (user claims) that Google+ returns which map to local attributes in the
gplus_local_attributes_list
property. It is mandatory only ifgplus_deployment_type
is set to 'enroll'. -
gplus_local_attributes_list - Comma-separated list of Gluu Server LDAP attribute names that are mapped to Google user claims from the
gplus_remote_attributes_list
property. It is mandatory only ifgplus_deployment_type
is set to 'enroll'. -
extension_module - Optional property to specify the full path of an external module that implements two methods:
# This is called when the authentication script initializes
def init(conf_attr):
# Code here
return True/False
# This is called after authentication
def postLogin(conf_attr, user):
# Code here
return True # or return False
- gplus_client_configuration_attribute - Optional property to
specify the client entry attribute name which can override
gplus_client_secrets_file file
content. It can be used in cases when all clients should use a separategplus_client_secrets.json
configuration.
Testing
One simple way to test the configuration is to use oxTrust. In the "Configure Authentication" dropdown menu, select "Google" (or whatever you entered as the "Name" of the custom authentication script--as the default authentication method.
After you login and logout, you should be presented with a new login form that has the Google login button:
After clicking the Google login button, you are presented for authorization--Google needs to make sure its ok to release attributes to the Gluu Server:
If the script doesn't work, and you locked yourself out of oxTrust,
don't worry! You can create an LDIF file, for example revert.ldif
, to
set back the default authentication method, like this:
dn: inum=@!1E3B.F133.14FA.5062!0002!4B66.CF9C,ou=appliances,o=gluu
changetype: modify
replace: oxAuthenticationMode
oxAuthenticationMode: internal
oxAuthenticationMode corresponds to the 'Name' of the customer
authentication script in oxTrust. Use internal
to revert to the
default LDAP authentication. You'll have to change the inum
with the
inum
of your installation. You can find it using ldapsearch like this:
/opt/opendj/bin/ldapsearch -h localhost -p 1389 -D "cn=directory manager" -j ~/.pw -b "ou=appliances,o=gluu" -s one "objectclass=*" inum
~/.pw
is a file with your Directory Manager password. If you don't
remember it, try to find it using grep
:
grep ldapPass= /install/community-edition-setup/setup.properties.last
Once your LDIF looks ok, then use ldapmodify
to revert back to
password authentication:
/opt/opendj/bin/ldapmodify -h localhost -p 1389 -D "cn=directory manager" -j ~/.pw -f revert.ldif
If things go wrong, it can leave the sessions in your browser in a bad state. If things get really weird, remove the cookies in your browser for the hostname of your Gluu Server.


Difficulty
Easy
Medium
Hard
👩💻 Speed Typer 👨💻
Time left:
10
s
Score:
0
Type the following:
Time ran out
Your final score is
0
Reload


Bridge Plugins
Bridge plugins are custom bridge implementations that can be used by an ego vehicle to send and receive sensor data.
Bridge plugins must be built by the simulator and the resultant bundle named bridge_XXX
must be placed in the AssetBundles/Bridges
folder. If running the binary, this folder is included in the downloaded .zip file.
If running in Unity Editor (Developer Mode), the sensor will be built into the folder directly. This must be done before running the simulator (running the executable or pressing Play
in the Editor).
Building bridge plugins to a bundle is done as below:
1. Open Simulator -> Build...
menu item
2. Select bridge plugins in "Bridges" section of build window
3. Build plugins with "Build" button
To make a bridge plugin, create folder in Assets/External/Bridges
, for example Assets/External/Bridge/CustomBridge
.
Inside this folder you must place all the scripts that will be used by simulator to build C# managed assembly.
Implementation#
A bridge plugin must provide two separate classes inheriting the following interfaces:
1) IBridgeFactory
2) IBridgeInstance
Factory class is used to provide meta-information about bridge and a few factory methods. It will be created only once.
Instance class represents the actual bridge implementation that is able to send and/or receive data. It will be created once for every vehicle where it is used.
Bridge Factory#
public interface IBridgeFactory
{
IBridgeInstance CreateInstance();
void Register(IBridgePlugin plugin);
void RegPublisher<DataType, BridgeType>(IBridgePlugin plugin, Func<DataType, BridgeType> converter);
void RegSubscriber<DataType, BridgeType>(IBridgePlugin plugin, Func<BridgeType, DataType> converter);
}
This interface requires the class to expose four public methods:
1) CreateInstance
- called to create new bridge instance. Typically this method simply returns new object of class
that implements IBridgeInstance interface.
2) Register
- called by simulator allow factory register supported functionality with plugin interface. See the section below on plugin registration.
3) RegPublisher
and RegSubscriber
- called by custom sensors to register custom data types for publisher or subscriber functionality. Factory can use this method itself to register its supported data types for simulator built-in sensors.
Classes inheriting from this interface must have BridgeName
attribute applied to inform name that will be
used to identify this bridge. For example:
[BridgeName("MyCustomBridge")]
public class MyCustomBridgeFactory : IBridgeFactory
{
...
}
Bridge Instance#
public interface IBridgeInstance
{
Status Status { get; }
void Connect(string connection);
void Disconnect();
}
This interface requires the class to expose three public methods:
1) Status
- getter that will be called by simulator to query status of bridge. For example, sensors will be sending data only if Status is set to Connected
state.
1) Connect
- called when simulator wants to initate new connection. Connection string is passed unmodified from web interface where it can be set to anything. It is responsibility of bridge implementation to validate then accept or reject this string.
2) Disconnect
- called when simulator wants to close connection. Typically called upon unloading vehicle from scene.
Bridge Plugin Registration#
Upon creating a bridge factory, the simulator will call Register
method to allow factory and pass plugin instance that factory should use to register available data types and publishers/subscribers. This information is not static as custom sensor plugins may want to register their custom types with one or multiple bridge factories.
Simulator provides many different data types, for example ImageData
or PointCloudData
that represents specific instances of data published or subscribed by sensors. Factory must inform plugin about which types it supports.
This is performed by calling AddType<DataType>(string bridgeTypeName)
on plugin instance. DataType
is one of the data types simulator supports. bridgeTypeName
is an arbitrary string used to show name of this data type in UI.
For each subscriber or publisher bridge factory should call AddSubscriberCreator<DataType>
or AddPublisherCreator<DataType>
on plugin instance. These methods should provide delegate that can be used to create subscriber or publisher instances for each sensor that wants to use specific data type.
void AddSubscriberCreator<DataType>(SubscriberCreator<DataType> subscriber);
void AddPublisherCreator<DataType>(PublisherCreator<DataType> publisher);
See IBridgePlugin.cs
source code for more information on delegate arguments and return values.
Typically, the bridge will call AddType
+ AddSubscriberCreator
from RegSubscriber
method, and AddType
+ AddPublisherCreator
from RegPublisher
method. This should be done for all default simulator data types simulator supports.
Additionally, custom sensor plugins may choose to call your bridge RegPublisher
and RegSubscriber
methods to add custom data types they which to publish or subscribe. Please refer to ComfortSensor
and LaneFollowingSensor
sensor plugins for examples of this functionality.
Examples#
Open-source examples are available:
Logging Bridge - simple bridge that logs all published data to a .txt file.
You can also refer to the existing ROS, ROS2 and CyberRT bridges in the main simulator repository for examples on how to make a fully featured bridge.


Codehaus XFire
DocumentationQuicklinksDevelopers
Sponsors |
This page is for brainstorming how REST support should work in XFire (or possibly a new project if xfire ends up being too heavy weight). Dan's First TakeCreating a Servicepublic class CustomerService { @RestMethod(methods={HttpMethod.GET}) Customer getCustomer(String id); @RestMethod(methods={HttpMethod.DELETE}) void deleteCustomer(String id); @RestMethod(methods={HttpMethod.POST}) @WebResult(name="customerId") String addCustomer(Customer customer); @RestMethod(method={HttpMethod.PUT}) void updateCustomer(Customer customer); } public enum HttpMethod { DELETE, GET, PUT, POST } Mapping data to method parametersThe information to invoke our service could come from a number of places:
Mapping the Operations to URIsThis could be done in the interface a couple different ways. At the class level: @RestService(uri="/customer/") public class CustomerService { ... } At the method level public class CustomerService { @RestMethod(methods={HttpMethod.GET}, uri="/customer") Customer getCustomer(String id); ... } At the service registration level: CustomerService customerService = ...; ServiceRegistry registry = ...; registry.register("/internal-customers", customerService); registry.register("/external-customers", anotherCustomerService); Questions
|


CLIENTS
We would like to dedicate this page to honor our roots which are interwoven with those clients who have helped us to achieve our goals by supporting our vision for innovative projects, trusting our character and encouraging our professional efforts from the very beginning. Likewise, we honor and thank our current clientele who continue to help us to maintain a successful professional practice.
We also honor our charter staff whose dedicated team efforts allowed us to establish a foundation that withstands over half a century later.
We thank our current staff as we continue working together daily to achieve our never-ending promise of providing the highest level of professional service possible.
Connect With Us
contact us today for more info<PHONE_NUMBER>


GEOG*2420
The Earth From Space
Colour Theory and Digital Imagery
John Lindsay
Fall 2015
Readings
JR Jensen Chapter 4, pp. 104-106
The additive colour model (RGB)
(source: unknown)
RGB colour and digital images
- The additive colour model is commonly used to display digital imagery.
RGB colour and digital images
(source: Jensen, 2007)
RGB colour and digital images
(source: Lindsay, 2013)
RGB colour and digital images
(source: unknown)
RGB colour and digital images
(source: Lindsay, 2013)
Additive colour model (RGB)
(source: unknown)
Additive colour model (RGB)
(source: Lindsay, 2013)
Digital Colour-composite images
(source: Lindsay, 2013)
Multispectral satellite data bands
(source: USGS, 2015)
Multispectral satellite data bands
Common Landsat 8 band combinations
(source: Butler, 2013)
Multispectral satellite data bands
(source: USGS, 2015)
Natural colour (Landsat-8 RGB-432)
(source: Lindsay, 2013)
False-colour Infrared (Landsat-8 RGB-543)
(source: Lindsay, 2013)
False-colour (Landsat-8 RGB-753)
(source: Lindsay, 2013)
Subtractive colour model (CMYK)
Subtractive colour model (CMYK)
(source: Jensen, 2007)
Subtractive colour model (CMYK)
(source: http://www.aoe.com.au/filters.html)
Subtractive colour model (CMYK)
(source: Lindsay, 2013)


Many three.js applications render their 3D objects directly to the screen. Sometimes, however, you want to apply one or more graphical effects like Depth-Of-Field, Bloom, Film Grain or various types of Anti-aliasing. Post-processing is a widely used approach to implement such effects. First, the scene is rendered to a render target which represents a buffer in the video card's memory. In the next step one or more post-processing passes apply filters and effects to the image buffer before it is eventually rendered to the screen.
three.js provides a complete post-processing solution via [page:EffectComposer] to implement such a workflow.
The first step in the process is to import all necessary files from the examples directory. The guide assumes you are using the official [link:https://www.npmjs.com/package/three npm package] of three.js. For our basic demo in this guide we need the following files.
import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
import { GlitchPass } from 'three/addons/postprocessing/GlitchPass.js';
import { OutputPass } from 'three/addons/postprocessing/OutputPass.js';
After all files are successfully imported, we can create our composer by passing in an instance of [page:WebGLRenderer].
const composer = new EffectComposer( renderer );
When using a composer, it's necessary to change the application's animation loop. Instead of calling the render method of [page:WebGLRenderer], we now use the respective counterpart of [page:EffectComposer].
function animate() {
requestAnimationFrame( animate );
composer.render();
}
Our composer is now ready so it's possible to configure the chain of post-processing passes. These passes are responsible for creating the final visual output of the application. They are processed in order of their addition/insertion. In our example, the instance of `RenderPass` is executed first, then the instance of `GlitchPass` and finally `OutputPass`. The last enabled pass in the chain is automatically rendered to the screen. The setup of the passes looks like so:
const renderPass = new RenderPass( scene, camera );
composer.addPass( renderPass );
const glitchPass = new GlitchPass();
composer.addPass( glitchPass );
const outputPass = new OutputPass();
composer.addPass( outputPass );
`RenderPass` is normally placed at the beginning of the chain in order to provide the rendered scene as an input for the next post-processing step. In our case, `GlitchPass` is going to use these image data to apply a wild glitch effect. `OutputPass` is usually the last pass in the chain which performs sRGB color space conversion and optional tone mapping. Check out this [link:https://threejs.org/examples/webgl_postprocessing_glitch live example] to see it in action.
You can use a wide range of pre-defined post-processing passes provided by the engine. They are located in the [link:https://github.com/mrdoob/three.js/tree/dev/examples/jsm/postprocessing postprocessing] directory.
Sometimes you want to write a custom post-processing shader and include it into the chain of post-processing passes. For this scenario, you can utilize `ShaderPass`. After importing the file and your custom shader, you can use the following code to setup the pass.
import { ShaderPass } from 'three/addons/postprocessing/ShaderPass.js';
import { LuminosityShader } from 'three/addons/shaders/LuminosityShader.js';
// later in your init routine
const luminosityPass = new ShaderPass( LuminosityShader );
composer.addPass( luminosityPass );
The repository provides a file called [link:https://github.com/mrdoob/three.js/blob/master/examples/jsm/shaders/CopyShader.js CopyShader] which is a good starting code for your own custom shader. `CopyShader` just copies the image contents of the [page:EffectComposer]'s read buffer to its write buffer without applying any effects.


Visual Studio 2017 Professional Download For Pc Free
Visual Studio 2017 Professional Download For Pc Free
Download And Install Visual Studio 2017 Free Youtube
Microsoft Visual Studio Enterprise 2017 Download License Microsoft Sk Mychoicesoftware Com
Visual Studio 2017 Professional Download For Pc Free
Install Visual Studio Microsoft Docs
Visual Studio 2017 のダウンロードとインストール 開発メモ Webkaru
Install Visual Studio Microsoft Docs
Install Visual Studio Microsoft Docs
Install Visual Studio Microsoft Docs
Microsoft Corp Mob Visual Studio Professional 2017 License Download Ms Office Works
Visual Studio 2017 Release Candidate Visual Studio Blog
Microsoft Visual Studio All Versions Iso Download
What S New In Visual Studio 2019 Download For Free Visual Studio
Visual Studio 2017 Professional Download For Pc Free
Visual Studio Community 2017のダウンロードとインストール C言語入門 Cppdrive
Visual Studio 2017 15 0 Release Notes Microsoft Docs
How To Download Visual Studio Community Edition 2017 Not 2019 Stack Overflow
Visual Studio 2017 Download Techspot
C Game Development Workload In Visual Studio 2017 C Team Blog
How To Get Free Windows 7 Pro Product Key Download Activated Visual Studio Professional 2017 Key Download The Latest Release Notes Visual Studio Professional 2017 Product Key Sale New Features New Installation Experience
Microsoft Visual Studio 2017 Professional Open License Trusted Tech Team
How To Download And Install Visual Studio For C
Visual Studio 2019 Ide Programming Software For Windows
1
Visual Studio 2017 15 0 Release Notes Microsoft Docs
Microsoft Visual Studio Enterprise 2017 Download License Microsoft Sk Mychoicesoftware Com
Install Visual Studio Microsoft Docs
Visual Studio 2017 のダウンロードとインストール 開発メモ Webkaru
Visual Studio 2015 Professional Key Crack Withoutbrain Powered By Doodlekit
Download Latest Version Of Visual Studio 2017
How To Download And Install Visual Studio For C
Amazon Com Visual Studio Professional 2017 Retail Media


{% extends 'structure.html' %} {% block title %} Admin Dashboard {% endblock title %} {% block main %}
This is the admin dashboard.


--- layout: page title: Hi, I'm Shiwen Wu subtitle: Master student in Data Science use-site-title: true ---
My name is Shiwen Wu, currently a 2nd-year Master student in Data Science at Peking University, advised by Prof. Bin Cui. My research interests are recommender systems and multi-document summarization.


I am an aspiring front-end web developer, interested in uncovering web-based and digital solutions. I feel strongly in free, clear, and open communications, and that digital design and successful web development can provide the most direct route
to a relationship between user and product.
My first career as a public art project manager has provided me with a background of delivering organized and timely results, and working with projects diverse in scale, concept, and setting.
I am a strong collaborator and comfortable with a no-glory-given, behind-the scenes producer role. I’m most interested in pursuing team-based opportunities and projects.
Committed to ongoing education, I have supplemented my BA/MA
degrees with a full-stack bootcamp at Academy Pittsburgh, and most recently a front-end focused bootcamp with Moms Can: Code. I hope to work with future teammates who understand the value of knowledge-sharing and continued learning.
I am a non-media artist focused on new-media expression. Using time-based constructs, I use found digital objects and footage to create new narratives.
Here is some more information about this product that is only revealed once clicked on.
2019
Co-designed with Stephanie McInelly. This was a bootcamp assignment to create a fake html newsletter using pair programming processes. The goal of the assigment was to learn how to create an HTML email with css inline,
and to learn how to work with a collaborator to pair-program.
The concept of this newsletter was all food-scented candle-related news, an nonsensical response to somber headlines and newsletters.
2019
Bootcamp project taking another group's pair-programmed html email newsletter and redesigning it. The goal of this assignment was to learn how to parse through other's code to make updates/changes.
Authentic Grace
2019
Pair Programmed with Stephanie McInelly. This project was a ootcamp excercise to design an MVP for a small brick-and-morter store seeking to expand into online sales. Built homepage, product section,
and product feature pages.
Here is some more information about this product that is only revealed once clicked on.
Here is some more information about this product that is only revealed once clicked on.
Here is some more information about this product that is only revealed once clicked on.
Here is some more information about this product that is only revealed once clicked on.


{% csrf_token %}
{{ rgf.first_name }}
First Name
{{ rgf.last_name }}
Last Name
{{ rgf.username }}
Username
{{ rgf.email }}
Email Address
{{ rgf.password1 }}
Password
{{ rgf.password2 }}
Confirm Password
Register
{{ rgf.errors }}
This page is protected by Google reCAPTCHA to ensure you're not a bot.
Learn more.


Apocalypse Now A film by Francis Coppola Starring: Martin Sheen, Marlon Brando, Robert Duvall, Dennis Hopper, and = Larry Fishburne
It is with hesitance that I call "Apocalypse Now" a masterpiece. Certainly, it had the pedigree to be one of the greatest films ever made, with a director known for producing masterpieces with ease, and some of the finest actors of the 1970's. The plot, an adaptation of Joseph Conrad's "Heart of Darkness", was set in Vietnam, and the timing of the film was supposed to be brilliant, coming on the heels of the end of the war.
"Apocalypse" certainly has its moments, some of which are the finest in film history. The plot is fairly simple. Captain Willard (Sheen), is a troubled soldier who came back to Hanoi for a 2nd tour of duty. His mission is simple: take a boat up to Cambodian territory, and destroy the command of renegade Colonel Kurtz (Brando) "with extreme prejudice". Along the way, Willard runs into a series of adventures, including one with Lt. Col. Kilgore (Duvall), and a strange encounter with Playboy bunnies. Willard' s four person crew finally make it to Kurtz' compound, where he discovers Kurtz has set himself up as a god among the natives. Willard's experiences with Kurtz take up the last half-hour, with a confrontation and eventual ending.
The movie is visually breathtaking. The battle scenes are exquisitely done, and the score is brilliant, setting a murky mood of darkness that is first-rate. The collage of disturbing images that Coppola presents is at times both astonishing and sickening. The vast amount of detail poured into every war scene is stunning, and there are many episodes that are deeply powerful which resonate through the entire movie. The journey to Kurtz' camp is quite a ride, with psychosis setting in on almost every character. The most interesting one is Kilgore, the Lt. Col. who cares more about the surf than about the mission. It is at times revolting, psychotic, and incredible, and it is one hell of a movie. The scenes are bold, inventive, and powerful, and the acting is stunning, especially be Sheen, Duvall, and Fishburne. The narration is exquisite, as is the mystery of Kurtz. Coppola sets about a hallucinatory ride through Vietnam, kind of like "Saving Private Ryan" on LSD. The film is jarring in its implications, and psychotic in its execution.
The problems come when the film slows down. One of the major scenes in the film, where the boat arrives at the final Army checkpoint before they start their search for Kurtz, is a colossal mess. The dialogue is confusing, the lighting is atrocious, and the scene drags on for 10 terrible minutes of film. The true problems happen after the crew does come into the Kurtz compound. The film slows down to a drag. Sheen seems forever captured by a madman, played by Brando is a lazy performance that is not deserving of the accolades it received. Brando is in the film for no more than 15 minutes, but is bathed in shadows the entire time, making the last half hour of the film visually pathetic. The scenes are poorly done, the dialogue is muffled, and the whole mess is utterly confusing beyond all belief. Sheen seems to adore this man, but why the viewers are never told. The entire journey is supposed to be a prelude for a stunning entrance of this god-like Kurtz, but the scenes fall way short of expectations. Granted, it has its moments, which are brutally horrific, but the general feeling is one of confusion. Brando mumbles his lines in a incoherent stir, and my feeling was that this could never be a great man, this could never be a man who inspires hundreds to follow him, so why do they do it? There are moments of brilliance, but the visual confusion dilutes the power of the scene. There are too many questions left unanswered with the character of Kurtz to have a satisfying ending.
The finest scene at the end is Sheen's escape, and his entrace into the temple. His rise out of the water, with the smoke coming off of his slicked head, is a brilliant 30 seconds of film. Yet, you cannot shake the feeling that there is so much more this film could have done. The psychotic ride is unforgettable at times, and indeed the film on the whole is very good. It is a stunningly flawed expression of film, for it addresses major issues, such as man's mental stamina during bouts of war. But one still cannot shake the feeling that this film could have so much more powerful, had the character of Kurtz been more explored, and had Sheen truly succumbed to the fate that the viewer thought he was destined for. There is too much good material in here not to be called a masterpiece, but it could have been so much more rewarding.
RATING: ***1/2 out of ****
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


{% extends "layout.html" %}
{% block content %}
Manage User
UserId
User Name
Phone Number
User Active
User Access Type
Change Password
New Password
Confirm Password


RecordVs
Rank your favorite records, two at a time.
{{record1.title}}
{{record1.artist}}
{{record2.title}}
{{record2.artist}}
How It Works
1. We'll use your Last.fm account to find your favorite records.
2. Play by choosing your favorite of two random records from your collection.
3. Our algorithms will build your charts based on every choice you make. The more you play, the more accurate your charts will be.
4. Your charts are public, share them around!


Buss Mall
Bus-mall project
click 25 times to know the details for each pic .
give your number that you want to vote?
Results


|
My Project
|
#include <sock.h>
Public Attributes | |
| struct nn_fsm | fsm |
| int | state |
| struct nn_sockbase * | sockbase |
| struct nn_socktype * | socktype |
| int | flags |
| struct nn_ctx | ctx |
| struct nn_efd | sndfd |
| struct nn_efd | rcvfd |
| struct nn_sem | termsem |
| struct nn_clock | clock |
| struct nn_list | eps |
| struct nn_list | sdeps |
| int | eid |
| int | linger |
| int | sndbuf |
| int | rcvbuf |
| int | rcvmaxsize |
| int | sndtimeo |
| int | rcvtimeo |
| int | reconnect_ivl |
| int | reconnect_ivl_max |
| struct nn_ep_options | ep_template |
| struct nn_optset * | optsets [NN_MAX_TRANSPORT] |
| struct { | |
| uint64_t established_connections | |
| uint64_t accepted_connections | |
| uint64_t dropped_connections | |
| uint64_t broken_connections | |
| uint64_t connect_errors | |
| uint64_t bind_errors | |
| uint64_t accept_errors | |
| uint64_t messages_sent | |
| uint64_t messages_received | |
| uint64_t bytes_sent | |
| uint64_t bytes_received | |
| int current_connections | |
| int inprogress_connections | |
| int current_snd_priority | |
| int current_ep_errors | |
| } | statistics |
| char | socket_name [64] |
| uint64_t nn_sock::accept_errors |
| uint64_t nn_sock::accepted_connections |
| uint64_t nn_sock::bind_errors |
| uint64_t nn_sock::broken_connections |
| uint64_t nn_sock::bytes_received |
| uint64_t nn_sock::bytes_sent |
| struct nn_clock nn_sock::clock |
| uint64_t nn_sock::connect_errors |
| struct nn_ctx nn_sock::ctx |
| int nn_sock::current_connections |
| int nn_sock::current_ep_errors |
| int nn_sock::current_snd_priority |
| uint64_t nn_sock::dropped_connections |
| int nn_sock::eid |
| struct nn_ep_options nn_sock::ep_template |
| struct nn_list nn_sock::eps |
| uint64_t nn_sock::established_connections |
| int nn_sock::flags |
| struct nn_fsm nn_sock::fsm |
| int nn_sock::inprogress_connections |
| int nn_sock::linger |
| uint64_t nn_sock::messages_received |
| uint64_t nn_sock::messages_sent |
| struct nn_optset* nn_sock::optsets[NN_MAX_TRANSPORT] |
| int nn_sock::rcvbuf |
| struct nn_efd nn_sock::rcvfd |
| int nn_sock::rcvmaxsize |
| int nn_sock::rcvtimeo |
| int nn_sock::reconnect_ivl |
| int nn_sock::reconnect_ivl_max |
| struct nn_list nn_sock::sdeps |
| int nn_sock::sndbuf |
| struct nn_efd nn_sock::sndfd |
| int nn_sock::sndtimeo |
| struct nn_sockbase* nn_sock::sockbase |
| char nn_sock::socket_name[64] |
| struct nn_socktype* nn_sock::socktype |
| int nn_sock::state |
| struct { ... } nn_sock::statistics |
| struct nn_sem nn_sock::termsem |


Phone Number: 021-48*****
Address: 123 Western Rd
Email<EMAIL_ADDRESS>Click the images for more information!
Blockchain is an increasingly popular technology due to the emergence of crypto-currency. As its name suggests,it's a sequence of blocks or groups of transactions that are chained together and distributed among the users. It can be programmed to record financial transactions. These records don't have any reliance on external authorities to ensure the integrity of the information that has been stored/recorded. Blockchain uses Hash functions which provide unique output code for input. This unique code is used to link blocks. As a result in the event of an attack, if one identifier is interfered with, it changes in all the blocks it is linked to and the chain can be made invalid due to the disruption. Furthermore, users need to meet an agreement about the validity of the chain before adding more blocks. Every time a node adds a new block, all the users have to validate the block by using a common protocol. Every user has its own copy of the Blockchain, and they share any update with the other users. This means there is no central copy of the information, but rather a similar copy is possessed by all users which again prevents alteration for the information. Miners are also a valuable component of Blockchain, as they come up with solutions for ensuring codes are restricted and unique. Blockchain is certainly a reliable and secure system for recording any kind of transaction or information.
Autonomous things are things that work autonomously without human guidance or direct intervention. Examples include autonomous drones and self-driving vehicles. use AI to automate functions previously performed by humans. Their automation goes beyond the automation provided by rigid programming models and they exploit AI to deliver advanced behaviors that interact more naturally with their surroundings and with people.
Immersion enhances everyday experiences, making them more realistic, engaging, and satisfying on all modern devices. A full quality immersion consists of 3 key ingredients: Visual quality, sound quality intuitive interactions. It is essentially the perception of being physically present in a non-physical world.


| Secure Scuttlebutt Working Group | . cryptix |
| SSB-Draft | SSBC |
| Intended status: Informational | September 09, 2019 |
| Expires: March 12, 2020 |
GabbyGrove (CBOR-based Feed Format)
draft-ssb-core-gabbygrove-00
This document defines a new binary format for append-only feeds as used by Secure-Scuttlebutt. That is, it defines the bytes that are used for computing the cryptographic signatures and hashes that make up a feed in this format. It strives to do two things: Be easier to implement compared to the current scheme. Hence, it uses CBOR [RFC7049] to encode the logical values that describe each entry. Secondly, the feed entry only references content by hash to enable content deletion without breaking verification of the feed.
SSB-Drafts are working documents of the Secure Scuttlebutt community. Note that other groups may also distribute working documents as SSB-Drafts.
SSB-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use SSB-Drafts as reference material or to cite them other than as "work in progress."
This SSB-Draft will expire on March 12, 2020.
Copyright (c) 2019 SSB Council and the persons identified as the document authors. All rights reserved.
This is the revised version of the ProtoChain proposal. The main difference to ProtoChain is that Gabby Grove uses CBOR instead of Protocol Buffers.
While this is would introduce new ways of doing things, like requiring CBOR for encoding and supporting multiple feed formats, it also makes concessions to how things are currently. In a sense this proposal should be seen as an overhaul of the current scheme, only adding off-chain capabilities. Let me elaborate on two of them which cater to this point specifically:
In principle, the timestamp is an application concern. Some types of messages could omit the timestamp and it could be considered cleaner to move them up into the content of messages which want to supply them. We recognize however that it would stir up problems for existing applications and this is something we are not interested in.
A similar argument could be made for the author. In the current design the author never changes over the lifetime of a feed, so why have it on each and every entry of a feed? Especially if you replicate one feed at a time it seems wasteful, since the author is already known.
Dominic Tarr made a security argument here. It should always be known which key-pair created a signature and thus having it reduces ambiguity and possible backdoors.
At first, this format would only encode the header fields of a message (subsequently called event) as CBOR, leaving the author of a feed to encode their content as they see fit. An encoding enumeration field on the event sets one of a set of known values for arbitrary data (0), JSON (1) and CBOR (2).
Since we don’t want to cause problems for applications, we suggest keeping the content portion in JSON [RFC8259] for now. This should allow for events to be mapped to full JSON objects which look just like regular, legacy messages so that they can be consumed by applications with minimal changes. CBOR should be good at converting it’s values to JSON for integration and backwards compatibility to other parts of the SSB stack.
A single entry on an feed with this format is called an event (formerly also known as Message). It contains a fixed number of fields:
The next needed structure is transfer. It consists of three byte arrays:
To validate the transfer, the receiver takes the byte strings eventData and signature and passes them to the cryptographic function that does the validation. The only supported functions of this format is, edwards25519 as defined in [RFC8032], also known as Ed25519 from the Networking and Cryptography library (NaCL).
If content is present, hashing it needs to compute the same hash as stated by the content.hash field on the event. To omit the content, it needs to be set to null (primitive 22 or 0xf6 in CBOR), so that the array the field is contained in has the same size in both cases.
The hash of a signed event (and the previous field of the next event) is the SHA256 of eventData and signature bytes concatenated.
The hashes and public key references are not base64 encoded readable ASCII text strings but are binary encoded.
In this first version we don’t plan to support many formats, which is why we don’t use something like IPFS Multihash, which supports every hash function under the sun.
Currently there are these different reference types:
Only 1, 2 and 3 are used on gabby grove event fields. 4 to 6 are intended to encode cipherlinks in CBOR encoded content when referencing feeds in the legacy format. I’m relatively certain and hopeful this will be revised and extended but it feels like a good starting point. They all should be convertible to and from the base64 encoded ASCII references we currently use in JSON. We add one byte as prefix to those bytes, making all references 33bytes long, for now.
Up until now SSB only had to deal with .ed25519 and .sha256 to identify a whole feed and individual entries respectively. Although I’d like to avoid a registry of known suffixes, my initial thoughts on how to do decent subjective name-spaces for identifier and networks are still very vague. For the meantime, this document proposes the .ggfeed-v1 suffix as a default feed reference and .ggmsg-v1 for messages.
The author also briefly looked into IPFS Content Identifiers (CID)s and Decentralized Identifiers (DIDs) but discarded them since it leaves the scope of this specification. It’s only important that we clearly discern and define type and data of these identifiers so that we can convert to and from them down the road.
The existing legacy format has an optional HMAC signing capability. When enabled, a hashed message authentication code (HMAC) is signed instead of the the message (the event bytes inside a transfer in our case). For this a (usually secret among the users of the network) key is needed. Without this key for the HMAC function, the receiver can’t validate the signature. Because messages are still communicated as clear text, this mode doesn’t add any confidentiality, which the needed key might imply. Therefore this mode is primarily usefull for splitting networks of feeds, like for testing purposes.
Currently this format uses exactly the same scheme as the legacy format for portability reasons. The used HMAC function is NaCLs crypto_auth, defined here.
If you never worked with CBOR, I suggest checking out it’s website and the definitions in [RFC7049]). Similar to JSON it is a self describing format. Which means, bytes of it can be translated to logical, typed values without the need for a schema definition.
The cbor-diag utilities (or the the playground at cbor.me with the same features) can help a lot to see how it works. With it, we can translate between encoded bytes and the diagnostic notation (defined in section 6 of CBORs RFC). Roughly speaking we can use JSON-like literals as diagnostic input for diag2pretty.rb (or the left side of the playground):
{ "type": "test", "count": 123, "true": false, "link": null }
which outputs a hexadecimal, indented and commented representation with type annotations:
A4 # map(4) 64 # text(4) 74797065 # "type" 64 # text(4) 74657374 # "test" 65 # text(5) 636F756E74 # "count" 18 7B # unsigned(123) 64 # text(4) 74727565 # "true" F4 # primitive(20) 64 # text(4) 6C696E6B # "link" F6 # primitive(22)
The comments (everything right of the # character) tell us the types and values again. The first line says “0xA4 means the following is a map with 4 entries”. Maps are key-value pairs, so we get three pairs of first the name (or key) of the pair and then the value. Next to signed and unsigned number types it also has predefined primitives for true, false and null. Notice that the keys are also typed (text of len N).
Let’s compare the previous example to an array of the same values, without the keys:
["test", 123, false, null]
results in
84 # array(4) 64 # text(4) 74657374 # "test" 18 7B # unsigned(123) F4 # primitive(20) F6 # primitive(22)
This results in 10 encoded bytes. The map example needs 31, in comparison.
Encoding the same well-defined objects as maps over and over again comes with a lot of overhead and redundant description of the field names.
This is also why the previous attempt to define a new feed format used Protocol Buffers. A self-describing format isn’t inherently useful since the fields of an event don’t change. As shown above, the size overhead of encoding structures as maps can be mitigated by encoding them as arrays instead.
We could define the first field of a transfer as an event itself instead of opaque byte strings but canonical encoding on this level of the protocol is seen as optional. Meaning: if the implementation can re-produce the same eventData from an stored Event, go ahead. Butt be wary, diverging one bit from the original eventData means that signature verification and hash comparison will fail. Over all this seems like an potentially instable and divergent way of exchanging feeds, producing incorrect references as heads of a feed if implementations incorrectly consume them.
However, as an experiment, implementers are advised to use the canonical CBOR suggestions defined in Section 3.9 of CBORs RFC. Since we only use bytes, integers and tags for our structures we can ignore the suggestions for map keys and floats.
Potentially, a canonical encoding would allow for skipping certain fields on the transport layer. author, sequence and even previous could be filled in by the receiver themselves to produce the full eventData.
It would also free implementors on the question of how to store events. It’s unclear to the author if this amounts to a worth-while endeavor compared to just storing the bytes of the transfer.
CBOR allows for augmenting the types of it’s values with an additional numeric tag. These are hints for the de- and encoders to treat some type of values differently. See Section 2.4 of CBORs RFC for more. A list of defined CBOR Tags is maintained by the IANA.
This kind of extensibility through type tags seems useful for SSB, especially if we ever change away from JSON as the content encoding. With it, we can explicitly mark cipherlinks as such, for instance. I took the liberty to take one of the first come first served numbers for the cipherlinks above, it’s 1050.
Section <IP_ADDRESS> of the CBOR RFC also defines tag number 24 to delay decoding of embedded cbor values (like the event in the transfer). Depending on how flexible the used CBOR libarary is, this might help input validation but since each field of an event has to be checked in context of the feed for append validation, this feature was not applied to this version of the format.
Another option would be to explicitly tag the whole transfer, which is otherwise just an array with three opaque byte string entries, and state how the signature was computed by the author’s key-pair referenced inside the event. And also define the role of the actual content bytes in relation to the content field in the event.
As a concrete example of all the above combined, here are some actual structures of this format encoded as CBOR.
of the ED25519 key-pair that was seeded with dead repeated 8 times, which is a poor choice for an actual key-pair but gives us deterministic test data. I tested sodium-native on javascript and ed25519 for Go by agl and x/crypto and they all gave me these public key bytes as a hexdump:
00000000 AED3DAB65CE9E0D6C50D46FCEFFB5522 |....\.....F...U"| 00000010 96ED21B6E0B537A6A0184575CE8F5CBD |..!...7...Eu..\.|
These are the first two messages of a feed authored by the keypair above.
1:85 # array(5) 2: F6 # primitive(22) 3: D9 041A # tag(1050) 4: 58 21 # bytes(33) 5: 01 6: AED3DAB65CE9E0D6C50D46FCEFFB5522 7: 96ED21B6E0B537A6A0184575CE8F5CBD 8: 01 # unsigned(1) 9: 24 # negative(4) 10: 83 # array(3) 11: D9 041A # tag(1050) 12: 58 21 # bytes(33) 13: 03 14: A7AC59B52AFF894BA89508B35F445AE9 15: 0628F6D5F358157E4F45F39B5B3BE96B 16: 09 # unsigned(9) 17: 00 # unsigned(0)
Let’s discuss line by line what this means:
Here is the next message:
85 # array(5) D9 041A # tag(1050) 58 21 # bytes(33) 02 CCD8FD8392C1B9D1E3026DEA42BEC93E 04B6F8ECEB9AF2D591489EB8B831C5E1 D9 041A # tag(1050) 58 21 # bytes(33) 01 AED3DAB65CE9E0D6C50D46FCEFFB5522 96ED21B6E0B537A6A0184575CE8F5CBD 02 # unsigned(2) 23 # negative(3) 83 # array(3) D9 041A # tag(1050) 58 21 # bytes(33) 03 95CCA4FA7B24ABC6049683E716292B00 C49509BE147AA024C06286BD9B7DBDA8 16 # unsigned(22) 01 # unsigned(1)
If you compare this to the above you should see some similarities. Instead of 0xf6 as the first element as the array we now have 0xD9041A5821. We have seen this sequence of bytes twice above already: It’s a cipherlink with 33 bytes of data. Instead of starting with byte 0x01 or 0x03, this starts with 0x02 which means, it’s a hash of a signed event.
The content type is 0x01 instead and the timestamp is advanced by 1 as well as the sequence.
Here is the transfer object for the first event:
83 # array(3) 58 53 # bytes(83) 85F6D9041A582101AED3DAB65CE9E0D6C50D46FCEFFB552296ED21B6E 0B537A6A0184575CE8F5CBD012483D9041A582103A7AC59B52AFF894B A89508B35F445AE90628F6D5F358157E4F45F39B5B3BE96B0900 58 40 # bytes(64) 8A3739FDB99D91E28552E9A2E22650C14A8CDBFE607CDCA5767569DB2 B1E24CAA3C31D65964143DC752E568B05C99E0E97C198885BFB8F3549 B9C6CCBC991205 49 # bytes(9) FF7330316D4279747A # "\xFFs01mBytz"
Similar to the above, we have an array with 3 elements, each in turn being a byte string of varying size. The first one is the eventData, the second one is the signature and the last one is the content data. (The long data chunks were broken into multiple lines for readability, consult the code repositories for actual test vectors.)
Here is the transfer object for the second event:
83 # array(3) 58 78 # bytes(120) 85D9041A582102CCD8FD8392C1B9D1E3026DEA42BEC93E04B6F8ECEB9 AF2D591489EB8B831C5E1D9041A582101AED3DAB65CE9E0D6C50D46FC EFFB552296ED21B6E0B537A6A0184575CE8F5CBD022383D9041A58210 395CCA4FA7B24ABC6049683E716292B00C49509BE147AA024C06286BD 9B7DBDA81601 58 40 # bytes(64) 3A7F29F7395CC454C3904DE2236EEF2C0147496B77C556ADE1A08BF57 D3E70D2A43A4C723AEB5366D4F073CEEB8B2677E03EC62E49D1647C67 0D95CC77F9DB07 56 # bytes(22) 7B2269223A312C2274797065223A2274657374227D0A
The current work-in-progress code, licensed under MIT is available for Go and javascript to show interoperability and that signature verification and content hashing works as expected. go-ssb also has integrated in it’s native sbot, testing against a demo plugin for ssb-server.
One open question would be how to get this into EBT while also supporting the classical/legacy way of encoding feeds. For replication of single feeds we can use the established stream command createHistoryStream which can pick the correct transfer encoding based on the passed feed reference.
Having worked with CBOR and Protocol Buffers, CBOR feels like the better tool for the job. Especially since it could also be used for encoding of the content itself where Protocol Buffers would require shared schemas for all types.
Possible alternatives:
Appendix E of CBORs RFC also shows how CBOR compares to ASN.1/DER/BER, BSON and UBJSON.
I believe we should leave this out of the spec and just give way for clients to drop content as wanted. Tuning replication rules with signed deletions or what ever can be done orthogonal if the chain/feed format allows validation with missing content.
This cuts down the amount of transmitted bytes considerably. As an example, a old contact message weighs in at roughly 434 bytes (JSON without whitespace, sequence in the hundreds range). Encoding a contact message with this, results in 289 bytes, 119 of which are still JSON. This overhead is small for longer posts but still wanted to mention it. The main driver of this reduction is the binary encoding of the references and being able to omit the field names. Converting content to a binary encoding would reduce it further but as stated above would require strict schemas for every type.
I think this is a solid format but wouldn’t mind to be superseded by something else once it surfaces. As a migration path, I’d suggest we double down on sameAs. The simplest case of it would be terminating one feed and starting a new one, while logically appending one to the other for higher levels of the protocol stack. The implications for indexing things like the friend graph and how to end feeds in the old format show that this needs to be covered in a separate spec.
Apart from choosing another library for marshalling bytes this proposal changed the name of a couple of things.
as @cft mentioned in his first comment, Message and Meta were not easy to speak and reason about. “What includes what?” wasn’t easy enough to answer. The Message was conceptually redundant as well since it’s fields can be in the transfer structure as well to achieve the same results. Which is why there is just a single concept for this called event.
Was not only wrong because it is already a named concept on the higher level (type:contact, type:post, etc.) but also because it is not specific enough. This field deals with the encoding of the content and thus should be named as such.
Remarks this proposal addresses over the first Off-chain content proposal:
The main idea of the first proposal was to add off-chain content without overhauling the verification scheme. We got numerous comments on this, the gist being that we tried to hard, improving something that should be deprecated altogether.
Therefore we chose a clean slate approach with a new encoding scheme. This comes with the downside of requiring multiple supported feed formats in the stack. Personally I think this is good though as it will pave the way for other formats, like bamboo, as well.
The idea to transmit content and metadata as two MUXRPC frames was my idea. It seems sensible/practical because it fitted into the existing stack but I see now that it tried to much to fit into the existing way and hid a dependency along the way.
This is why the transfer structure definition has a dedicated field for content which can be set to null to indicate unavailability.
| [RFC7049] | Bormann, C. and P. Hoffman, "Concise Binary Object Representation (CBOR)", RFC 7049, DOI 10.17487/RFC7049, October 2013. |
| [RFC8032] | Josefsson, S. and I. Liusvaara, "Edwards-Curve Digital Signature Algorithm (EdDSA)", RFC 8032, DOI 10.17487/RFC8032, January 2017. |
| [RFC8259] | Bray, T., "The JavaScript Object Notation (JSON) Data Interchange Format", STD 90, RFC 8259, DOI 10.17487/RFC8259, December 2017. |


You can optionally receive notifications when someone mentions you in a comment, replies to one of your comments, and for items that you are following.
Even if you opt to receive emails instantly for items that you are following, disabling emails in the global setting will override all other settings.
Changes to the settings change all *future* updates, but will leave existing updates untouched.


Click below to see the HTML version of this email.
http://link.cvs.com/r/FXUW197/XY3N6/TEFPWV/18MGX96/1RMX2/A5/t?a=FXUW197&b=E6SDF&c=FDGW0I7&d=TEFPWV&e=1&f=cac5072040055df68711
****************************************************
CVS/pharmacy®
****************************************************
Holiday cheer from CVS.com.
Visit our site >
http://link.cvs.com/r/FXUW197/XY3N6/TEFPWV/18MGX96/QWG0T/A5/t?a=FXUW197&b=E6SDF&c=FDGW0I7&d=TEFPWV&e=1&f=cac5072040055df68711
****************************************************
Add<EMAIL_ADDRESS>to your address book to continue receiving our emails.
****************************************************
You are receiving this email because you indicated you wanted to be informed of the latest news and specials from CVS/pharmacy online. If you prefer not to receive future emails, please unsubscribe below. Please note that if you are opted in for other CVS/pharmacy email communications, you will continue to receive them unless you opt-out specifically for those.
http://link.cvs.com/u/FXUW197/XY3N6/TEFPWV/18MGX96/3O/aHVibGVlcGg2MDZAdHVtYmxyLmNvbQ==/
© Copyright 2012 CVS.com
http://link.cvs.com/r/FXUW197/XY3N6/TEFPWV/18MGX96/9TISD/A5/t?a=EM_WIN_122412
One CVS Drive, Woonsocket, RI 02895
[[FXUW197-E6SDF-XY3N6-TEFPWV-18MGX96-M-M2-20121224-8648c3321e0ccbf]]


This release continues the march toward 64-bit support (it looks to be a long march). There are many under-the-hood changes to the compiler to make supporting both 32-bit and 64-bit targets possible, as well as a number of bug fixes. It also adds support for macOS 10.13 (High Sierra).
Rationalized the treatment of primitive operators in Absyn and FLINT, and removed unused primitive operators. These changes affected the pickle format, which means that the --rebuild option must be used when building the compiler from sources.
Added Target structure to Basics; this module specifies properties of the target, such as the size of ML values and the size of the default int type.
Changed the way that the InlineT structure is defined to be target sensitive. For example, on 32-bit targets, there will be an InlineT.i31add function for adding the default int type, whereas on 64-bit targets the corresponding function will be InlineT.i63add.
Restored the pre-110.80 behavior of having the shell command sml foo.sml return a non-zero exit status when there is an error in the compilation of foo.sml (bug #183).
Changed the way that we test for allocation-space addresses in minor GCs. Instead of using the BIBOP, we now do a pointer range test; this change produces a small speedup on 32-bit machines, but we expect a bigger benefit on 64-bit machines, which use the 2-level BIBOP.
Various changes to prepare for 64-bit targets, including adding a 2-level BIBOP implementation, and splitting assyntax.h into 32-bit (assyntax.h) and 64-bit (assyntax64.h) versions.
Here is a list of tracked bugs fixed (or closed) with this release, please see the bug tracker for more details.
| 123 | missing warning for non-exaustive binding at top level. |
| 183 | status code returned by sml REPL. |
| 185 | Bring command line help text into parity with man page. |
The following unnumbered bugs were also fixed:
We believe that SML/NJ will build and run on the following systems, but have only tested some of them:
Architecture Operating System Status Power PC Mac OS X 10.5 (Leopard) AIX Sparc Solaris Linux x86 Mac OS X 10.6 (Snow Leopard) Mac OS X 10.7 (Lion) Mac OS X 10.8 (Mountain Lion) Mac OS X 10.9 (Mavericks) Mac OS X 10.10 (Yosemite) Mac OS X 10.11 (El Capitan) Tested macOS 10.12 (Sierra) Tested macOS 10.13 (High Sierra) Tested Ubuntu 14.04.3 (GNU/Linux 3.13.0) Tested Other Linux variants BSD variants Windows 7 Windows 10 Tested Cygwin (hosted on Windows 7 or 10)


protein stress USP universal plant proteins domain gene sequence sequences genes ESTs drought plants functional {border-style viridiplantae Plant drought-responsive px;} #ffffff;} Arabidopsis transcripts dataset annotation identify Table bioinformatics including UniProt data response species Biology Research annotated database databases domains encoding function resources transcript Pfam Molecular USPs entries expressed number provide resource tandem ATP-binding expression identified multiple present px; repeats {font-family Acids EST Fig. File Genetics Nucleic Oryza Plantta comprehensive datasets drought. environmental extracted family font-size genomic markers responsive stress. text total unique Escherichia Furthermore, SSR associated available combination conditions contain containing cross-references derived diverse domain. double; genomics investigation microsatellite mining presence sativa simple tolerance (PF) BMC Bioinformatics Gene OMA Orthologous Populus SSRs Transcript Triticum Universal Viridiplantae ability abiotic algae alignment border-color border-width cDNA characterization comparative cross-database domains. genera information integrated land matrix microarray organized provided retrieved selected solid; strategy stresses subset types used {font-style {font-weight (SSRs) (Supplementary ArrayExpress Assemblies Atg Botany Chen Current EST-SSR Expressed Genomics Methods Nystrom Physcomitrella Physiology Protein Resource Sequence TIGR Tags Vitis additional analysis annotations barley based bold candidate coli collection complete conditions. courier; crop databases. dbEST diversity em; encode entries. entry genome green help higher involved known limited linked microsatellites mined molecular motif observed plants. proteins. provides pt;} research respectively. respond responses rice, salt searched source specialized tolerant using wheat


An executable file that participates in
dynamic linking shall have one
PT_INTERP
program header element.
During
exec
(BA_OS),
the system retrieves a path name from the PT_INTERP
segment and creates the initial process image from
the interpreter file's segments. That is,
instead of using the original executable file's
segment images, the system composes a memory
image for the interpreter.
It then is the interpreter's responsibility to
receive control from the system and provide an
environment for the application program.
As ``Process Initialization'' in Chapter 3 of the processor supplement mentions, the interpreter receives control in one of two ways. First, it may receive a file descriptor to read the executable file, positioned at the beginning. It can use this file descriptor to read and/or map the executable file's segments into memory. Second, depending on the executable file format, the system may load the executable file into memory instead of giving the interpreter an open file descriptor. With the possible exception of the file descriptor, the interpreter's initial process state matches what the executable file would have received. The interpreter itself may not require a second interpreter. An interpreter may be either a shared object or an executable file.
mmap
(KE_OS) and related services
[See ``Virtual Address Space'' in Chapter 3 of the processor
supplement].
Consequently, a shared object interpreter typically will
not conflict with the original executable file's
original segment addresses.
PT_INTERP
to an executable file, telling the system to invoke
the dynamic linker as the program interpreter.
Exec
(BA_OS)
and the dynamic linker cooperate to
create the process image for the program, which entails
the following actions:
exec
(BA_OS).
The link editor also constructs various data that assist the dynamic linker for executable and shared object files. As shown above in ``Program Header'', this data resides in loadable segments, making them available during execution. (Once again, recall the exact segment contents are processor-specific. See the processor supplement for complete information).
.dynamic
section with type SHT_DYNAMIC
holds various data.
The structure residing at the
beginning of the section holds the addresses
of other dynamic linking information.
.hash
section with type SHT_HASH
holds a symbol hash table.
.got
and .plt
sections with type
SHT_PROGBITS
hold two separate tables:
the global offset table and the procedure linkage table.
Chapter 3 discusses how programs use the global offset table
for position-independent code.
Sections below explain how the dynamic linker uses
and changes the tables to create memory images for object files.
Because every ABI-conforming program imports the basic system services from a shared object library [See ``System Library'' in Chapter 6], the dynamic linker participates in every ABI-conforming program execution.
As `Program Loading'' explains in the processor supplement, shared objects may occupy virtual memory addresses that are different from the addresses recorded in the file's program header table. The dynamic linker relocates the memory image, updating absolute addresses before the application gains control. Although the absolute address values would be correct if the library were loaded at the addresses specified in the program header table, this normally is not the case.
If the process environment [see exec
(BA_OS)]
contains a variable named LD_BIND_NOW
with a non-null value, the dynamic linker processes
all relocations before transferring control to the program.
For example, all the following environment entries
would specify this behavior.
LD_BIND_NOW=1
LD_BIND_NOW=on
LD_BIND_NOW=off
LD_BIND_NOW
either
does not occur in the environment or has a null value.
The dynamic linker is permitted to evaluate procedure linkage table
entries lazily, thus avoiding symbol resolution and relocation
overhead for functions that are not called.
See ``Procedure Linkage Table'' in this chapter of the processor
supplement for more information.
If an object file participates in dynamic linking,
its program header table will have an element of type
PT_DYNAMIC
.
This ``segment'' contains the .dynamic
section.
A special symbol, _DYNAMIC
,
labels the section, which contains
an array of the following structures.
typedef struct {
Elf32_Sword d_tag;
union {
Elf32_Word d_val;
Elf32_Addr d_ptr;
} d_un;
} Elf32_Dyn;
extern Elf32_Dyn _DYNAMIC[];
typedef struct {
Elf64_Sxword d_tag;
union {
Elf64_Xword d_val;
Elf64_Addr d_ptr;
} d_un;
} Elf64_Dyn;
extern Elf64_Dyn _DYNAMIC[];
For each object with this type, d_tag
controls the interpretation of d_un
.
d_val
d_ptr
To make it simpler for tools to interpret the contents of
dynamic section entries, the value of each tag, except for those in
two special compatibility ranges,
will determine the interpretation of the d_un
union. A tag whose value is an even number
indicates a dynamic section entry that uses d_ptr
.
A tag whose value is an odd number indicates a dynamic section entry
that uses d_val
or that uses neither d_ptr
nor d_val
. Tags whose values are less
than the special value DT_ENCODING
and tags
whose values fall between DT_HIOS
and
DT_LOPROC
do not follow these rules.
The following table summarizes the tag requirements for executable and shared object files. If a tag is marked ``mandatory'', the dynamic linking array for an ABI-conforming file must have an entry of that type. Likewise, ``optional'' means an entry for the tag may appear but is not required.
d_tag
| Name | Value | d_un |
Executable | Shared Object |
|---|---|---|---|---|
DT_NULL |
0 |
ignored | mandatory | mandatory |
DT_NEEDED |
1 |
d_val |
optional | optional |
DT_PLTRELSZ |
2 |
d_val |
optional | optional |
DT_PLTGOT |
3 |
d_ptr |
optional | optional |
DT_HASH |
4 |
d_ptr |
mandatory | mandatory |
DT_STRTAB |
5 |
d_ptr |
mandatory | mandatory |
DT_SYMTAB |
6 |
d_ptr |
mandatory | mandatory |
DT_RELA |
7 |
d_ptr |
mandatory | optional |
DT_RELASZ |
8 |
d_val |
mandatory | optional |
DT_RELAENT |
9 |
d_val |
mandatory | optional |
DT_STRSZ |
10 |
d_val |
mandatory | mandatory |
DT_SYMENT |
11 |
d_val |
mandatory | mandatory |
DT_INIT |
12 |
d_ptr |
optional | optional |
DT_FINI |
13 |
d_ptr |
optional | optional |
DT_SONAME |
14 |
d_val |
ignored | optional |
DT_RPATH* |
15 |
d_val |
optional | ignored |
DT_SYMBOLIC* |
16 |
ignored | ignored | optional |
DT_REL |
17 |
d_ptr |
mandatory | optional |
DT_RELSZ |
18 |
d_val |
mandatory | optional |
DT_RELENT |
19 |
d_val |
mandatory | optional |
DT_PLTREL |
20 |
d_val |
optional | optional |
DT_DEBUG |
21 |
d_ptr |
optional | ignored |
DT_TEXTREL* |
22 |
ignored | optional | optional |
DT_JMPREL |
23 |
d_ptr |
optional | optional |
DT_BIND_NOW* |
24 |
ignored | optional | optional |
DT_INIT_ARRAY |
25 |
d_ptr |
optional | optional |
DT_FINI_ARRAY |
26 |
d_ptr |
optional | optional |
DT_INIT_ARRAYSZ |
27 |
d_val |
optional | optional |
DT_FINI_ARRAYSZ |
28 |
d_val |
optional | optional | DT_RUNPATH |
29 |
d_val |
optional | optional | DT_FLAGS |
30 |
d_val |
optional | optional |
DT_ENCODING |
32 |
unspecified | unspecified | unspecified |
DT_PREINIT_ARRAY |
32 |
d_ptr |
optional | ignored |
DT_PREINIT_ARRAYSZ |
33 |
d_val |
optional | ignored |
DT_LOOS |
0x6000000D |
unspecified | unspecified | unspecified |
DT_HIOS |
0x6ffff000 |
unspecified | unspecified | unspecified |
DT_LOPROC |
0x70000000 |
unspecified | unspecified | unspecified |
DT_HIPROC |
0x7fffffff |
unspecified | unspecified | unspecified |
* Signifies an entry that is at level 2.
DT_NULL
DT_NULL
tag marks the end of the
_DYNAMIC
array.
DT_NEEDED
DT_STRTAB
code.
See
``Shared Object Dependencies''
for more
information about these names.
The dynamic array may contain multiple entries with
this type.
These entries' relative order is significant, though their
relation to entries of other types is not.
DT_PLTRELSZ
DT_JMPREL
is present, a
DT_PLTRELSZ
must accompany it.
DT_PLTGOT
DT_HASH
DT_SYMTAB
element.
DT_STRTAB
DT_SYMTAB
Elf32_Sym
entries for the 32-bit class of files and Elf64_Sym
entries for the 64-bit class of files.
DT_RELA
Elf32_Rela
for the 32-bit file class
or Elf64_Rela
for the 64-bit file class.
An object file may have multiple relocation sections.
When building the relocation table for an
executable or shared object file, the link editor
catenates those sections to form a single table.
Although the sections remain independent in the object file,
the dynamic linker sees a single table.
When the dynamic linker creates the process image for
an executable file or adds a shared object to the
process image, it reads the relocation table and performs
the associated actions.
If this element is present, the dynamic structure must also have
DT_RELASZ
and DT_RELAENT
elements.
When relocation is ``mandatory'' for a file, either
DT_RELA
or DT_REL
may occur (both are permitted but not required).
DT_RELASZ
DT_RELA
relocation table.
DT_RELAENT
DT_RELA
relocation entry.
DT_STRSZ
DT_SYMENT
DT_INIT
DT_FINI
DT_SONAME
DT_STRTAB
entry.
See
``Shared Object Dependencies''
below for more
information about these names.
DT_RPATH
DT_STRTAB
entry. This entry is at level 2. Its
use has been superseded by DT_RUNPATH
.
DT_SYMBOLIC
DF_SYMBOLIC
flag.
DT_REL
DT_RELA
,
except its table has implicit addends, such as
Elf32_Rel
for the 32-bit file class
or Elf64_Rel
for the 64-bit file class.
If this element is present, the dynamic structure must also have
DT_RELSZ
and DT_RELENT
elements.
DT_RELSZ
DT_REL
relocation table.
DT_RELENT
DT_REL
relocation entry.
DT_PLTREL
d_val
member holds DT_REL
or DT_RELA
,
as appropriate.
All relocations in a procedure linkage table must use
the same relocation.
DT_DEBUG
DT_TEXTREL
DF_TEXTREL
flag.
DT_JMPREL
d_ptr
member holds the address of relocation entries associated solely
with the procedure linkage table.
Separating these relocation entries lets the dynamic linker ignore
them during process initialization, if lazy binding is enabled.
If this entry is present, the related entries of types
DT_PLTRELSZ
and DT_PLTREL
must also be present.
DT_BIND_NOW
dlopen
(BA_LIB).
This entry is at level 2. Its use has been superseded
by the DF_BIND_NOW
flag.
DT_INIT_ARRAY
DT_FINI_ARRAY
DT_INIT_ARRAYSZ
DT_INIT_ARRAY
entry.
If an object has a DT_INIT_ARRAY
entry, it must
also have a DT_INIT_ARRAYSZ
entry.
DT_FINI_ARRAYSZ
DT_FINI_ARRAY
entry.
If an object has a DT_FINI_ARRAY
entry, it must
also have a DT_FINI_ARRAYSZ
entry.
DT_RUNPATH
DT_STRTAB
entry.
DT_FLAGS
DF_
flag_name.
Defined values and their meanings are described below.
All other values are reserved.
DT_PREINIT_ARRAY
DT_PREINIT_ARRAY
table is processed only
in an executable file; it is ignored if contained in a shared object.
DT_PREINIT_ARRAYSZ
DT_PREINIT_ARRAY
entry.
If an object has a DT_PREINIT_ARRAY
entry, it must
also have a DT_PREINIT_ARRAYSZ
entry. As with
DT_PREINIT_ARRAY
, this entry is ignored if it appears
in a shared object.
DT_ENCODING
DT_ENCODING
and less than DT_LOOS
follow the rules for the interpretation of the d_un
union
described above.
DT_LOOS
through DT_HIOS
d_un
union described above.
DT_LOPROC
through DT_HIPROC
d_un
union described above.
Except for the DT_NULL
element at the end of the array,
and the relative order of DT_NEEDED
elements, entries may appear in any order.
Tag values not appearing in the table are reserved.
DT_FLAGS
values
| Name | Value |
|---|---|
DF_ORIGIN |
0x1 |
DF_SYMBOLIC |
0x2 |
DF_TEXTREL |
0x4 |
DF_BIND_NOW |
0x8 |
DF_STATIC_TLS |
0x10 |
DF_ORIGIN
$ORIGIN
substitution string (see ``Substitution Sequences'').
The dynamic linker must determine the pathname of the object
containing this entry when the object is loaded.
DF_SYMBOLIC
DF_TEXTREL
DF_BIND_NOW
dlopen
(BA_LIB).
DF_STATIC_TLS
When the dynamic linker creates the memory segments for
an object file, the dependencies (recorded in
DT_NEEDED
entries of the dynamic structure)
tell what shared objects are needed to
supply the program's services.
By repeatedly connecting referenced shared objects and
their dependencies, the dynamic linker builds a complete process image.
When resolving symbolic references, the dynamic linker
examines the symbol tables with a breadth-first search.
That is, it first looks at the symbol table of the
executable program itself, then at the symbol tables
of the DT_NEEDED
entries (in order),
and then at the second level DT_NEEDED
entries, and
so on. Shared object files must be readable by the process;
other permissions are not required.
Names in the dependency list are copies either of the
DT_SONAME
strings or the path names of the shared objects used to build
the object file.
For example, if the link editor builds an executable
file using one shared object with a
DT_SONAME
entry of lib1
and another shared object library with the path name
/usr/lib/lib2
, the executable file will contain
lib1
and /usr/lib/lib2
in its dependency list.
If a shared object name has one or more slash (/
)
characters anywhere in the name, such as /usr/lib/lib2
or directory/file
, the dynamic linker uses that string directly
as the path name.
If the name has no slashes, such as lib1
,
three facilities specify shared object path searching.
DT_RUNPATH
gives a string that
holds a list of directories, separated by colons (:
).
For example, the string
/home/dir/lib:/home/dir2/lib:
tells the dynamic linker to search first the directory
/home/dir/lib
, then /home/dir2/lib
,
and then the current directory to find dependencies.
The set of directories specified by a given DT_RUNPATH
entry is used to find only the immediate dependencies
of the executable or shared object containing the DT_RUNPATH
entry. That is, it is used only for those dependencies contained in
the DT_NEEDED
entries of the dynamic structure containing
the DT_RUNPATH
entry, itself.
One object's DT_RUNPATH
entry does not affect the search
for any other object's dependencies.
LD_LIBRARY_PATH
in the process environment [see exec
(BA_OS)]
may hold a list of directories as above, optionally
followed by a semicolon (;
) and
another directory list.
The following values would be equivalent to the previous example:
LD_LIBRARY_PATH=/home/dir/usr/lib:/home/dir2/usr/lib:
LD_LIBRARY_PATH=/home/dir/usr/lib;/home/dir2/usr/lib:
LD_LIBRARY_PATH=/home/dir/usr/lib:/home/dir2/usr/lib:;
Although some programs (such as the link editor) treat the lists before and after the semicolon differently, the dynamic linker does not. Nevertheless, the dynamic linker accepts the semicolon notation, with the semantics described previously.
All LD_LIBRARY_PATH
directories are searched before those from
DT_RUNPATH
.
/usr/lib
or such other
directories as may be specified by the ABI supplement for a
given processor.
When the dynamic linker is searching for shared objects, it is
not a fatal error if an ELF file with the wrong attributes
is encountered in the search. Instead, the dynamic linker
shall exhaust the search of all paths before determining
that a matching object could not be found. For this determination,
the relevant attributes are contained in the following ELF header fields:
e_ident[EI_DATA]
,
e_ident[EI_CLASS]
,
e_ident[EI_OSABI]
,
e_ident[EI_ABIVERSION]
,
e_machine
,
e_type
, e_flags
and e_version
.
LD_LIBRARY_PATH
for set-user and
set-group ID programs.
It does, however, search DT_RUNPATH
directories
and the default directories.
The same restriction may be applied to processes that have more than
minimal privileges on systems with installed extended security
mechanisms.
DT_RPATH
,
has been moved to level 2 in the ABI.
It provides a colon-separated list of directories to search.
Directories specified by DT_RPATH
are searched
before directories specified by LD_LIBRARY_PATH
.
If both DT_RPATH
and DT_RUNPATH
entries appear in a single object's dynamic array,
the dynamic linker processes only the DT_RUNPATH
entry.
DT_NEEDED
or DT_RUNPATH
tags and in
pathnames passed as parameters to the dlopen()
routine, a
dollar sign ($
) introduces a substitution sequence.
This sequence consists of the dollar sign immediately followed
by either the longest name sequence or a name contained
within left and right braces ({
) and (}
).
A name is a sequence of bytes that start with either a letter or
an underscore followed by zero or more letters, digits or underscores.
If a dollar sign is not immediately followed by a name or a
brace-enclosed name, the behavior of the dynamic linker is unspecified.
If the name is ``ORIGIN
'', then the substitution
sequence is replaced by the dynamic linker with the absolute
pathname of the directory in which the object containing the
substitution sequence originated. Moreover, the pathname will
contain no symbolic links or use of ``.
'' or
``..
'' components.
Otherwise (when the name is not ``ORIGIN
'')
the behavior of the dynamic linker is unspecified.
When the dynamic linker loads an object that uses $ORIGIN
,
it must calculate the pathname of the directory containing the object.
Because this calculation can be computationally expensive,
implementations may want to avoid the calculation for objects
that do not use $ORIGIN
.
If an object calls dlopen()
with a string
containing $ORIGIN
and does not use $ORIGIN
in one if its dynamic array entries,
the dynamic linker may not have calculated the
pathname for the object until the dlopen()
actually
occurs. Since the application may have changed its current
working directory before the dlopen()
call,
the calculation may not yield the correct result.
To avoid this possibility, an object may signal its intention
to reference $ORIGIN
by setting the
DF_ORIGIN
flag.
An implementation may reject an attempt to use $ORIGIN
within a dlopen()
call from an object that
did not set the DF_ORIGIN
flag and did not
use $ORIGIN
within its dynamic array.
$ORIGIN
substitution sequences for set-user and
set-group ID programs. For such sequences that appear
within strings specified by DT_RUNPATH
dynamic
array entries, the specific search path containing the
$ORIGIN
sequence is ignored (though other
search paths in the same string are processed).
$ORIGIN
sequences within a DT_NEEDED
entry or path passed as a parameter to dlopen()
are treated as errors.
The same restrictions may be applied to processes that have more than
minimal privileges on systems with installed extended security
mechanisms.
Elf32_Word
objects supports symbol table access. The same table
layout is used for both the 32-bit and 64-bit file class.
Labels appear below
to help explain the hash table organization,
but they are not part of the specification.
nbucket |
nchain |
bucket[0] |
chain[0] |
The bucket
array contains nbucket
entries, and the chain
array contains nchain
entries; indexes start at 0.
Both bucket
and chain
hold symbol table indexes.
Chain table entries parallel the symbol table.
The number of symbol table entries should equal
nchain
;
so symbol table indexes also select chain table entries.
A hashing function (shown below) accepts a symbol name and returns a
value that may be used to compute a bucket
index.
Consequently, if the hashing function returns the value
x for some name, bucket[
x%nbucket]
gives
an index, y,
into both the symbol table and the chain table.
If the symbol table entry is not the one desired,
chain[
y]
gives the next symbol table entry
with the same hash value.
One can follow the chain
links until either the selected symbol table entry
holds the desired name or the chain
entry contains the value
STN_UNDEF
.
unsigned long
elf_hash(const unsigned char *name)
{
unsigned long h = 0, g;
while (*name)
{
h = (h << 4) + *name++;
if (g = h & 0xf0000000)
h ^= g >> 24;
h &= ~g;
}
return h;
}
Before the initialization functions for any object A is called, the initialization
functions for any other objects that object A depends on are called.
For these purposes, an object A depends on another object B,
if B appears in A's list of needed objects (recorded in the DT_NEEDED
entries of the dynamic structure).
The order of initialization for circular dependencies is undefined.
The initialization of objects occurs by recursing through the needed entries of each object. The initialization functions for an object are invoked after the needed entries for that object have been processed. The order of processing among the entries of a particular list of needed objects is unspecified.
The following example illustrates two of the possible correct orderings
which can be generated for the example NEEDED lists.
In this example the a.out is dependent on b
, d
, and e
.
b
is dependent on d
and f
, while d
is dependent on e
and g
.
From this information a dependency graph can be drawn.
The above algorithm on initialization will then allow the following
specified initialization orderings among others.
Similarly, shared objects and executable files may have termination
functions, which are executed with the
atexit
(BA_OS) mechanism after the base process begins its
termination sequence.
The termination functions for any object A must be called before
the termination functions for any other objects that object A depends
on. For these purposes, an object A depends on another object B,
if B appears in A's list of needed objects (recorded in the DT_NEEDED
entries of the dynamic structure).
The order of termination for circular dependencies is undefined.
Finally, an executable file may have pre-initialization functions. These functions are executed after the dynamic linker has built the process image and performed relocations but before any shared object initialization functions. Pre-initialization functions are not permitted in shared objects.
The dynamic linker ensures that it will not execute any initialization, pre-initialization, or termination functions more than once.
Shared objects designate their
initialization and termination code in one of two ways.
First, they may specify the address of a function to execute
via the
DT_INIT
and
DT_FINI
entries in the dynamic structure, described in
``Dynamic Section''
above.
Shared objects may also (or instead) specify the address and size of
an array of function pointers. Each element of this
array is a pointer to a function to be executed by the dynamic linker.
Each array element is the size of a pointer in the
programming model followed by the object containing
the array. The address of the array of initialization
function pointers is specified by the DT_INIT_ARRAY
entry in the dynamic structure. Similarly, the address of
the array of pre-initialization functions is specified by
DT_PREINIT_ARRAY
and the address of the array
of termination functions is specified by DT_FINI_ARRAY
.
The size of each array is specified by the DT_INIT_ARRAYSZ
,
DT_PREINIT_ARRAYSZ
, and DT_FINI_ARRAYSZ
entries.
The functions pointed to in the arrays
specified by DT_INIT_ARRAY
and by DT_PREINIT_ARRAY
are executed by the dynamic
linker in the same order in which their addresses appear in
the array; those specified by DT_FINI_ARRAY
are executed in reverse order.
If an object contains both DT_INIT
and DT_INIT_ARRAY
entries, the function referenced
by the DT_INIT
entry is processed before those
referenced by the DT_INIT_ARRAY
entry for that object.
If an object contains both DT_FINI
and DT_FINI_ARRAY
entries, the functions referenced
by the DT_FINI_ARRAY
entry are processed before the one
referenced by the DT_FINI
entry for that object.
atexit
(BA_OS)
termination processing normally will be done,
it is not guaranteed to have executed upon process death.
In particular, the process will not execute the termination processing
if it calls _exit
[see
exit
(BA_OS)]
or if the process dies because it received a signal
that it neither caught nor ignored.
The processor supplement for each processor specifies whether the
dynamic linker is responsible for calling the executable file's
initialization function or registering the executable file's
termination function with
atexit
(BA_OS).
Termination functions specified by users via the
atexit
(BA_OS)
mechanism
must be executed before any termination functions of shared objects.


General Guidelines. To donate blood or platelets, you must be in good general health,
weigh at least 110 pounds, and be at least 16 years old. Parental consent is required for
blood donation by 16 year olds; 16 year olds are NOT eligible to donate platelets.
What are the conditions for blood donation?
Any donor, who is healthy, fit and not suffering from any transmittable diseases can donate blood.
Donor must be 18 -60 years age and having a minimum weight of 50Kg can donate blood.

Can a weak person donate blood?
There's no doubt that donating blood can do a lot of good:
Donating just one pint of blood can save more than one person's life, according to the American Red Cross.
... But blood donation isn't without its disadvantages.


Molde1
Molde2
4th
5th
10 1
10th
11 1
11th
12th
14th
15th
16th
8th
9 1
9th
Ajo
Tomate
Aceite
Agua
Azucar
Betarraga
Espinaca
Harina
Levadura
Nueces
Oregano
Sal
Semillas
Zapallo


http://www.susangranger.com/
Susan Granger's review of "UNBREAKABLE" (Touchstone Pictures)
On paper, it looked great. Bruce Willis, the star, and M. Night Shyamalan, the creator, of "The Sixth Sense" teaming up for another supernatural thriller. On the screen, however, it's unintelligible and undeniably underwhelming. Bruce Willis is a Philadelphia football stadium security guard who is the sole survivor of a train wreck that killed 131 people. Why? he wonders. That question is shared by Elijah, a mysterious comic book entrepreneur who suffers from a brittle bone disease, played by Samuel L. Jackson - in an unkempt Afro - who poses not only a bizarre explanation but also theorizes a purpose for the rest of Willis's life. "I believe comic books are our last link to a form of history," he notes. Could, perhaps, Willis be a modern-day superhero? Willis's wide-eyed 12 year-old son (Spencer Treat Clark, trying hard to be Haley Joel Osment) is easily convinced but not his estranged wife (a surprisingly haggard-looking Robin Wright Penn) who claims, "I don't want violence in my life." As for Willis, he's just not sure of anything except that he's sad and that his world is crumbling around him - like the slow, stalemated story which has plot loopholes large enough to drive a city bus through. During the dark, creepy, climactic chase, where does Willis, the wet, caped crusader, get dumped on a dreary, damp, rainy night? Underwater - and we've already been told that water is like his Kryptonite. "Do you know what the scariest thing is?" Jackson concludes during what passes for a twist ending.  Now we know who you are and we know who I am." On the Granger Movie Gauge of 1 to 10, "Unbreakable" is an uncertain 3. Ostensibly about heroes and villains, basically, it's unadulterated poppycock. Unfathomable is more like it.
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


{% extends 'layout.html' %} {% set version = "v3" %} {% set heading = "Sorry, you cannot sign up" %} {% block beforeMain %} {% endblock %} {% block content %}
Only those 18 or over can use this service to sign up to be contacted for coronavirus vaccine research.
Find out more about taking part in clinical trials at the Be Part of Research website.


Few weeks ago, I was given a task to create an A/B test using HAProxy. I need to make HAProxy to split traffic between two different applications ( Rails and NodeJS )
In this blog post, I’ll explain how to achieve this.
Create ACL for the page you want to A/B test
The first step you have to do is to create an ACL for the URL you want to A/B test. In this example, the URL path is /ab-test-path
1
acl ab_test_url path_beg /ab-test-path
Direct the traffic based on ACL rule and cookie
1234567891011
# Send user to first backend if they have SITEID cookie with cookie_first_backend value
use_backend first-backend if { req.cook(SITEID) -m beg cookie_first_backend }
# Send user to second backend if they have SITEID cookie with cookie_second_backend value and the URL they request is ab_test_url
use_backend second-backend if { req.cook(SITEID) -m beg cookie_second_backend } ab_test_url
# If the doesn't have any cookie send them to ab-test backend
use_backend ab-test-backend if ab_test_url
# By default send all traffic to the first backend
default_backend first-backend
Create all the backends
12345678910111213141516171819
backend first-backend
appsession JSESSIONID len 52 timeout 3h
cookie SERVERID insert
balance leastconn
server backend02a-aws-syd <IP_ADDRESS>:80 check maxconn 3000 inter 30s
server backend02b-aws-syd <IP_ADDRESS>:80 check maxconn 3000 inter 30s
backend second-backend
server backend03a-aws-syd <IP_ADDRESS>:80 check maxconn 3000 inter 30s
backend ab-test-backend
balance roundrobin
cookie SITEID insert indirect nocache maxlife 48h
server backend02a-aws-syd <IP_ADDRESS>:80 weight 25 cookie cookie_first_backend
server backend02b-aws-syd <IP_ADDRESS>:80 weight 25 cookie cookie_first_backend
server backend03a-aws-syd <IP_ADDRESS>:80 weight 50 cookie cookie_second_backend
The final HAProxy config should be something like this:
Today, I have to copy files from one S3 bucket to another S3 bucket which sitting in separate AWS account.
Initially, I was thinking to use S3 clients ( Tranmit or Cyberduck ) to download the files first and manually upload the files again to the other S3 Bucket. However, this approach will consume a lot of bandwidth and really slow if you have a lot of files in your S3 bucket.
After a bit of research, I found that you can easily copy files between two S3 buckets. You can use either s4cmd or AWS CLI.
s3cmd or s4cmd
Run this command to install s4cmd
1
pip install s4cmd
After you finished setting up the AWS credentials, you can start the copying process.
I prefer using AWS CLI because it has more options and official support. AWS CLI has a built it support can specify the ACL and permission of the objects.
12
# The command below will allow the target bucket owner to have full access to the objectaws s3 cp s3://<source-bucket> s3://<target-bucket> --acl "bucket-owner-full-control" --recursive
Since my target bucket is sitting in separate AWS account, I have to set another permission to allow everyone to upload and delete files into my target bucket.
If you want to follow this approach, make sure to delete that permission after you finished with the copying.
Today, I was trying to create a backup of production database. The problem is we have two different version of PostgreSQL running on production and these databases can only be accessed from front end(FE) server. We have older version of PostgreSQL client installed in all FE server which means I can’t use it to run pg_dump.
SSH Tunnel to the rescue
One solution to this problem is to create a SSH tunnel. Since I have the latest version of PostgreSQL client installed in my machine, I can run pg_dump locally which will connect to the database through SSH tunnel.
At the moment, I am working on a Ruby on Rails projects using Rails Engines ( you can read more about Rails Engines here: http://guides.rubyonrails.org/engines.html ). In this post, I’ll share my tips and trick on how to configure your vim to work with Rails Engines.
NERDTree Bookmark
I am using NERDTree Bookmark to quickly jump between different engines. If you are using NERDTree, you can create a bookmark by putting your cursor on one of the Rails Engines directory and use the command below:
1
:Bookmark <engine name>
After you created the bookmark, you can see the bookmarks list by pressing B inside NERDTree window. See the screenshot below:
I also added these two options to my vimrc file.
123
" Automatically show bookmarks list when you open NERDTree
let NERDTreeShowBookmarks=1
let NERDTreeChDirMode=2
NERDTreeChDirMode changes the current working directory of your vim to your bookmark directory. This will also enable my favourite rails.vim feature which is open alternate file.
CtrlP Working Path Mode
It is normal for Rails Engines to share similar directory structure and filenames. However, this creates problem when you want to search a file using CtrlP plugin. Combined with NERDTreeChDirMode, you can tell CtrlP to search only in the current working directory.
Add this option to your vimrc file to enable this feature:
There are few known limitations when using Vagrant on Windows machine. One of these limitations is the lack of symbolic links support on synced folder.
Most of the time, you can get away with ‘npm —no-bin-link’ solution. However, you need more robust solution if you are using complex tools such as Grunt or Yeoman.
In this post, I’ll show you the proper way to add symbolic links support to your Vagrant machine.
First, you need to add this code snippet inside your Vagrantfile
VirtualBox disables symbolic links for security reasons. In order to pass this restriction, you need to boot up the Vagrant machine in Administrator mode.
You can do this by simply right clicking on your Command Prompt or Git Bash icon and click ‘Run as Administrator’. See the picture below if you can’t find it.
After that, boot up the Vagrant machine normally with ‘vagrant up’ command. Wait until the machine boots up, SSH to the machine and try to create symbolic link in the synced folder.
File path 255 character limit
Another annoying problem you might encounter is file path character limit. This happens quite often if you are using a node module with long name. You can easily solve this by following these steps:
Create ‘node_modules’ folder in your home folder
1
mkdir ~/node_modules
Add symbolic link to the ‘node_modules’ folder you just created inside your project folder
Basic HTTP authentication is one simple way to limit public access to your website prior to launch.
The first thing you need is .htaccess file which contains all the configurations. The second one is .htpasswd containing username and password. You can use this website to generate .htpasswd file for you http://www.htaccesstools.com/htpasswd-generator/
In the sample below, I am trying to enable HTTP authentication only on certain domain. On the first line, I set enviroment variable if the domain name is equal to “www.bundabergfestival.com.au”. On line 7, I tell .htaccess file to deny any access by using the live_uri variable. I hope that explanation is pretty straight forward.
12345678910
SetEnvIf Host "^www.bundabergfestival.com.au" live_uri
AuthName "Bundaberg Festival Website Coming Soon"AuthType Basic
AuthUserFile /var/app/.htpasswd
AuthGroupFile /dev/null
require valid-user
Order allow,deny
Allow from all
Deny from env=live_uri
Satisfy any
I spent some time last weekend to run through the new AngularJS course by Code School. This course is sponsored by Google which means you don’t need to pay for the Code School membership to play this course. AngularJS is one of the popular Javascript frameworks to build single page app application. You might be familiar with other frameworks such as Ember.js, Backbone.js and Knockout.js.
I really enjoyed the course and definitely learned something new from it. It covers the basic concept about directives, services and dependecy injection. I didn’t understand those features when the first time I learned about AngularJS. In the beginning of learning AngularJS, I tended to copy and paste code without understanding the meaning behind it. This caused confusion when I tried to learn more about the framework.
Code School also released another screencast on how to build AngularJS app from scratch. I’ll suggest you to check that one out as well so you can apply the knowledge that you have learned from the course to build real application. However, you have to become the member to get access to the screencast. There are also some other websites that provide AngularJS videos such as http://www.egghead.io and http://www.thinkster.io


To close this modal, please use the "Close" button provided. Note that swiping the modal will not dismiss it.