Copyright ©2001 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
This document describes how existing vocabularies for different classes of devices and user agents can be used in CC/PP components, and how to create schemas that encapsulate existing vocabularies. It discusses the results of the coordination with the IETF CONNEG Working Group, as well as the WAP Forum UAPROF Working Group and several other groups, which have related activities. It contains a number of schemas and software examples which has been contributed voluntarily by individuals.
It also gives an example of heuristics, which can be used to adapt content to a CC/PP profile, thus giving some guidelines for those who want to use CC/PP to implement content adaptation. It also serves to provide vocabulary and schema designers with key guidelines regarding extensions to existing vocabularies or development of new ones.
This document is a Note made available by the World Wide Web Consortium (W3C) for discussion only. This indicates no endorsement of its content. This is the first public draft of this Note, and it is a work in progress, representing the current consensus of the CC/PP working group. Future updates and changes are likely.
The working group is part of the W3C Device Independence Activity. Continued status of the work is reported on the CC/PP Working Group Home Page (Member-only link ).
This document incorporates suggestions resulting from reviews and active participation by members of the IETF CONNEG working group and the WAP Forum User Agent Profile Drafting Committee, as well as the FIPA. It also is also intended to be a "developers guide" that will help implementers in interpreting the CC/PP Specification, to the extent that this information is not covered in the CC/PP Specification.
Please send comments and feedback to<EMAIL_ADDRESS>A list of current W3C Recommendations and other technical documents can be found at http://www.w3.org/TR/ .
Using CC/PP is actually very simple. Based on a description of a device (or a requirement for a device), which is part of the request for a resource, you output a document that is formatted according to some heuristics which are contingent on that description and deliver it to the user.
There are a number of vocabularies that can be used to describe device capabilities, user preferences, and other information related to the users delivery context. CC/PP provides a way of expressing such vocabularies in the W3C Resource Description Framework, RDF, and describes how they could be organized to be transported and handled by user agents such as browsers in an efficient manner.
This document also describes how the profile can be used to derive an optimized presentation. Since there can be an infinite number of possible heuristics for how device capabilities are matched with profiles, we try to describe how the author or owner of the content can select how a specific set of situational variables (device capabilities, user preferences) should be applied to create or adapt a document. In this document, an XSLT example is discussed. However, given a rules language, the heuristics could be expressed in that instead; it is also possible to write programs in other languages (PERL, C, Java, ECMAScript) that perform the adaptation.
The CC/PP Structure and Vocabularies Working Draft describes how such vocabularies can be created and communicated to the origin server using the CC/PP framework. CC/PP in itself does not describe a vocabulary (although a simple demonstration vocabulary is provided in the Structure and Vocabularies working draft). This document describes a number of existing vocabularies, and how they can be conveyed as part of a CC/PP profile. It also discusses the harmonization that has taken place with other groups.
The CC/PP specification contains a few vocabulary items. However, it should be stressed that to the extent that they are not structural, they are there for illustration only. Other groups have been encouraged to create their own schemas for vocabularies, and have indeed done so, as the FIPA and UAPROF examples demonstrate.
In principle, there is no limit on the number of vocabularies that can be created or used. In fact, RDF and XML namespaces allow for independent creation of interoperable vocabularies. Clearly, there can be no mandate that a specific set of vocabularies should be used. Nor can there be a mandate that a specific set of attributes within a vocabulary ought to be used within the context of an application. Schema interoperability, enabled by RDF and the use of XML namespaces, allows for the selection of any number of attributes within the context of a user agent profile, since it becomes possible to select any element that is present in a schema using the XML namespace mechanism.
A vocabulary is analogous to a dictionary. It identifies all the possible attributes in a schema, which is similar to a database schema. A profile is an instance of the vocabulary. Different devices and user agents may refer to the same schema, support the same vocabulary, but communicate different profiles to the origin servers. Any vocabularies can be used in CC/PP, provided there is an RDF Schema for them, since this is required by the RDF processor.
Writing vocabularies that conform to CC/PP is relatively easy. They have to be created as an RDF Schema, made available at a URI, and be usable in a component in the CC/PP framework. Vocabularies can be included in CC/PP using XML namespace. If a vocabulary is not written as an RDF Schema, and does not conform to the CC/PP component structure, it will not be possible to use in CC/PP.
The device vocabulary defined in appendix C of the CC/PP specification is not a mandatory part of the core CC/PP format specification, but is included in the specification for use by CC/PP-aware applications that may need to describe certain common features. Designers of CC/PP applications who need to describe such capabilities are encouraged to use this vocabulary rather than define new terms, in the interest of interoperability. This vocabulary is based in part on work done in the IETF Media Feature Registration (CONNEG) Working Group (which was closed in 2001) and on the vocabulary of the WAP Forum UAPROF working group.
CC/PP is, simply put, a data structure that lets you send device capabilities and other situational parameters from a client to a server. It can be included in a separate header in HTTP, and there are transports defined for other protocols. What happens when it gets to the server, and how it is created, is not discussed in the specification (but this document attempts to provide some guidance).
CC/PP is organized in components. They are not fixed, and anyone can create components, as well as vocabularies.
CC/PP contains a vocabulary for handling of structural items, such as how to append a proxy description to the description of a client (if, for instance, the proxy can provide services for the client - for instance, a transcoding proxy may add the languages it can transcode into to the languages that the client can accept).
Creating new vocabularies for CC/PP is very easy, as described in section 1.2.
The WAP Forum has specified a core vocabulary and ways to extend that. The following text is taken from the document Guidelines for UAProf Vocabulary Extensions by Lalitha Suryanarayana, that outlines how the core vocabulary should be extended. While the example is from the UAProf vocabulary, the principle extends to the creation of any CC/PP vocabulary.
The UAProf core vocabulary consists of five main components, each of which asserts a set of attributes (called CPI). The structure and layout constitutes a schema. The use of the XML namespace mechanism and RDF inherently provide UAProf with an extensibility mechanism. A profile can consist of attributes from multiple vocabularies. Extensions to the schema can be made, either by adding new attributes to an existing vocabulary or, creating a new standalone vocabulary. Which method should be followed is left to the schema designer.
However, the following criteria serve as guidelines in helping make that determination (It is recommended that the set of attributes to be added is first identified and characterized):
-Remember that it has to be machine readable (i.e. accessible as a file), since RDF processors will need to access the schema the first time they encounter it.
The CONNEG working group in the IETF has defined a number of "media feature tags", which can be used to describe the optimal visual properties for the representation of a document (there are no tags for other media types than visual). The group, which was closed in 2000, also created a matching algebra for the media tags. The rationale for the work was to provide a number of Internet application protocols have a need to provide content negotiation for the resources with which they interact. A framework for such negotiation was created, part of which is a way to describe the range of media features which can be handled by the sender, recipient or document transmission format of a message. A format for a vocabulary of individual media features and procedures for feature registration are presented in RFC 2506, Media Feature Tag Registration Procedure.
Appendix E.1 of the CC/PP specification provides a brief discussion the relationship to and use of CONNEG attributes. The following provides a more in-depth look into how to combine CONNEG with CC/PP [FOOTNOTE1].
The IETF has defined an IANA registry for media feature tags and a syntax for relational-style expressions using these to describe client and server media features. A small common vocabulary has been defined, which has been used as a basis for the CC/PP client common vocabulary. The IETF Internet fax Working Group has also created additional registrations to describe the capabilities of fax machines.
RFC 2506 defines three kinds of media feature tags:
It is notable that the all three tag types provide unique names, which enables them to be mapped into the XML namespace mechanism. There is currently a proposal to create a URN namespace for IANA registries. This would create a mechanism to allow IANA-registered feature tags to be used directly as URIs in CC/PP expressions. Unregistered feature tags may be used in CC/PP expressions by stripping off the leading 'u.' and taking the resulting URI string. Thus, any feature tag registered per RFC 2506 would be available for use directly in a CC/PP profile. The registry here would help to provide a common reference point for features that are compatible with CONNEG-style matching semantics.
A couple of Internet drafts have recently been published that may help us to overcome the disparity between CONNEG and CC/PP vocabularies. Using http://search.ietf.org/internet-drafts/draft-klyne-urn-ietf-conneg-01.txt (which uses http://search.ietf.org/internet-drafts/draft-mealling-iana-urn-02.txt) enables the definition of a URI form for CONNEG media feature tags that could be used in a CC/PP profile. This would change the namespace identifier used in appendix C of the CC/PP specification, which is non-normative.
Currently, however, no XML representation of the Conneg vocabulary exists. It is out of the scope of this group to create such a representation, but any volunteer efforts are welcome. The registered media features can be found in the IANA Registry.
The Foundation For Intelligent Physical Agents, FIPA, has developed a device vocabulary. FIPA is an international organization that is dedicated to promoting the industry of intelligent agents by openly developing specifications supporting interoperability among agents and agent-based applications. The Fipa-Device ontology can be used by agents to pass profiles of devices to each other and validate them against the ontology.
The FIPA ontology consists of a set of frames, which represent the classes of objects in the domain of discourse within the framework of the Fipa-Device ontology. The following terms are used to describe the objects of the domain:
Despite the differences in definition formats (FIPA defines functionalities in its own language, not in RDF Schema), the FIPA-device ontology could be used in a CC/PP profile. This can be accomplished in a similar fashion as with UAProf. So, if a client wants to inform a server that the device is fipa-compliant he can do so with CC/PP profile as follows:
<?xml version="1.0"?> <rdf:RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ccpp="http://www.w3.org/2000/07/04-ccpp#" xmlns:fipa="http://www.fipa.org/profiles/device-20010202#" xmlns:uaprof="http://www.wapforum.org/UAPROF/ccppschema-19991014#"> <rdf:Description rdf:about="http://www.foo.com/profiles/ProfileX"> <ccpp:component> <rdf:Description rdf:about="http://www.foo.com/TerminalHardware"> <rdf:type rdf:resource="http://www.foo.com/Schema#HardwarePlatform" /> <ccpp:Defaults rdf:resource="http://www.foo.com/profiles/hwproperties" /> <fipa:compliancy>true</fipa:compliancy> </rdf:Description> </ccpp:component> <ccpp:component> <rdf:Description rdf:about="http://www.foo.com/TerminalSoftware"> <rdf:type rdf:resource="http://www.foo.com/Schema#SoftwarePlatform" /> <ccpp:Defaults rdf:resource="http://www.foo.com/profiles/swproperties" /> <fipa:ap-description>FIPA-OS v2.1.1</fipa:ap-description> </rdf:Description> </ccpp:component> <ccpp:component> <rdf:Description rdf:about="http://www.foo.com/Browser"> <rdf:type rdf:resource="http://www.foo.com/Schema#BrowserUA" /> <ccpp:Defaults rdf:resource="http://www.foo.com/profiles/browserproperties" /> <uaprof:BrowserName>Internet Explorer</uaprof:BrowserName> <uaprof:BrowserVersion>5.0</uaprof:BrowserVersion> </rdf:Description> </ccpp:component> </rdf:Description> </rdf:RDF>
Simultaneously with the CC/PP work in the W3C, the WAP Forum initiated an activity to create a capabilities and preferences description system. It was decided to use the CC/PP framework, and create a vocabulary for WAP devices in that framework. The latest version, published as part of the WAP 2.0 release, is WAP-248-UAPROF-20010522, available from the WAP Forum technical specifications page. The WAP Forum has also developed extensions to the CC/PP core vocabulary for specific applications such as multimedia messaging (MMS) and WAP Push.
The WAP Forum UAPROF drafting committee has used CC/PP to create a custom vocabulary for mobile devices which conform to the WAP specification. It is used for render customized content based on the information sent in the profile, and to adapt content to the specific device with which the user accesses it.
The schema for WAP User Agent Profiles consists of description blocks for
the following key components:
Below is an example CC/PP profile using the UAPROF vocabulary [UAPROF]. The latest version of this specification is WAP-248-UAPROF-20010522.
<?xml version="1.0"?> <rdf:RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:prf="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#"> <rdf:Description rdf:ID="MyDeviceProfile"> <prf:component> <rdf:Description rdf:ID="HardwarePlatform"> <rdf:type rdf:resource="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#HardwarePlatform"/> <prf:BluetoothProfile> <rdf:Bag> <rdf:li>headset</rdf:li> <rdf:li>dialup</rdf:li> <rdf:li>lanaccess</rdf:li> </rdf:Bag> </prf:BluetoothProfile> <prf:ScreenSize>121x87</prf:ScreenSize> <prf:Model>R999</prf:Model> <prf:InputCharSet> <rdf:Bag> <rdf:li>ISO-8859-1</rdf:li> <rdf:li>US-ASCII</rdf:li> <rdf:li>UTF-8</rdf:li> <rdf:li>ISO-10646-UCS-2</rdf:li> </rdf:Bag> </prf:InputCharSet> <prf:ScreenSizeChar>15x6</prf:ScreenSizeChar> <prf:BitsPerPixel>2</prf:BitsPerPixel> <prf:ColorCapable>No</prf:ColorCapable> <prf:TextInputCapable>Yes</prf:TextInputCapable> <prf:ImageCapable>Yes</prf:ImageCapable> <prf:Keyboard>PhoneKeypad</prf:Keyboard> <prf:NumberOfSoftKeys>0</prf:NumberOfSoftKeys> <prf:Vendor>myprofileprovider</prf:Vendor> <prf:OutputCharSet> <rdf:Bag> <rdf:li>ISO-8859-1</rdf:li> <rdf:li>US-ASCII</rdf:li> <rdf:li>UTF-8</rdf:li> <rdf:li>ISO-10646-UCS-2</rdf:li> </rdf:Bag> </prf:OutputCharSet> <prf:ScreenSizeChar>15x6</prf:ScreenSizeChar> <prf:BitsPerPixel>2</prf:BitsPerPixel> <prf:ColorCapable>No</prf:ColorCapable> <prf:TextInputCapable>Yes</prf:TextInputCapable> <prf:ImageCapable>Yes</prf:ImageCapable> <prf:Keyboard>PhoneKeypad</prf:Keyboard> <prf:NumberOfSoftKeys>0</prf:NumberOfSoftKeys> <prf:Vendor>myprofileprovider</prf:Vendor> <prf:OutputCharSet> <rdf:Bag> <rdf:li>ISO-8859-1</rdf:li> <rdf:li>US-ASCII</rdf:li> <rdf:li>UTF-8</rdf:li> <rdf:li>ISO-10646-UCS-2</rdf:li> </rdf:Bag> </prf:OutputCharSet> <prf:SoundOutputCapable>Yes</prf:SoundOutputCapable> <prf:StandardFontProportional>Yes</prf:StandardFontProportional> </rdf:Description> </prf:component> <prf:component> <rdf:Description rdf:ID="SoftwarePlatform"> <rdf:type rdf:resource="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#SoftwarePlatform"/> <prf:AcceptDownloadableSoftware>No</prf:AcceptDownloadableSoftware> </rdf:Description> </prf:component> <prf:component> <rdf:Description rdf:ID="NetworkCharacteristics"> <rdf:type rdf:resource="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#NetworkCharacteristics"/> <prf:SecuritySupport> <rdf:Bag> <rdf:li>WTLS-1</rdf:li> <rdf:li>WTLS-2</rdf:li> <rdf:li>WTLS-3</rdf:li> <rdf:li>signText</rdf:li> </rdf:Bag> </prf:SecuritySupport> <prf:SupportedBearers> <rdf:Bag> <rdf:li>TwoWaySMS</rdf:li> <rdf:li>CSD</rdf:li> <rdf:li>GPRS</rdf:li> </rdf:Bag> </prf:SupportedBearers> <prf:SupportedBluetoothVersion>1.1</prf:SupportedBluetoothVersion> </rdf:Description> </prf:component> <prf:component> <rdf:Description rdf:ID="BrowserUA"> <rdf:type rdf:resource="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#BrowserUA"/> <prf:BrowserName>Ericsson</prf:BrowserName> <prf:CcppAccept> <rdf:Bag> <rdf:li>application/vnd.wap.wmlc</rdf:li> <rdf:li>application/vnd.wap.wbxml</rdf:li> <rdf:li>application/vnd.wap.wmlscriptc</rdf:li> <rdf:li>application/vnd.wap.multipart.mixed</rdf:li> <rdf:li>application/vnd.wap.multipart.form-data</rdf:li> <rdf:li>text/vnd.wap.wml</rdf:li> <rdf:li>text/vnd.wap.wmlscript</rdf:li> <rdf:li>text/x-vCard</rdf:li> <rdf:li>text/x-vCalendar</rdf:li> <rdf:li>text/x-vMel</rdf:li> <rdf:li>text/x-eMelody</rdf:li> <rdf:li>image/vnd.wap.wbmp</rdf:li> <rdf:li>image/gif</rdf:li> </rdf:Bag> </prf:CcppAccept> <prf:CcppAccept-Charset> <rdf:Bag> <rdf:li>US-ASCII</rdf:li> <rdf:li>ISO-8859-1</rdf:li> <rdf:li>UTF-8</rdf:li> <rdf:li>ISO-10646-UCS-2</rdf:li> </rdf:Bag> </prf:CcppAccept-Charset> <prf:CcppAccept-Encoding> <rdf:Bag> <rdf:li>base64</rdf:li> </rdf:Bag> </prf:CcppAccept-Encoding> <prf:FramesCapable>No</prf:FramesCapable> <prf:TablesCapable>Yes</prf:TablesCapable> </rdf:Description> </prf:component> <prf:component> <rdf:Description rdf:ID="WapCharacteristics"> <rdf:type rdf:resource="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#WapCharacteristics"/> <prf:WapDeviceClass>C</prf:WapDeviceClass> <prf:WapVersion>2.0</prf:WapVersion> <prf:WmlVersion> <rdf:Bag> <rdf:li>2.0</rdf:li> </rdf:Bag> </prf:WmlVersion> <prf:WmlDeckSize>3000</prf:WmlDeckSize> <prf:WmlScriptVersion> <rdf:Bag> <rdf:li>1.2.1</rdf:li> </rdf:Bag> </prf:WmlScriptVersion> <prf:WmlScriptLibraries> <rdf:Bag> <rdf:li>Lang</rdf:li> <rdf:li>Float</rdf:li> <rdf:li>String</rdf:li> <rdf:li>URL</rdf:li> <rdf:li>WMLBrowser</rdf:li> <rdf:li>Dialogs</rdf:li> </rdf:Bag> </prf:WmlScriptLibraries> <prf:WtaiLibraries> <rdf:Bag> <rdf:li>WTA.Public.makeCall</rdf:li> <rdf:li>WTA.Public.sendDTMF</rdf:li> <rdf:li>WTA.Public.addPBEntry</rdf:li> </rdf:Bag> </prf:WtaiLibraries> </rdf:Description> </prf:component> </rdf:Description> </rdf:RDF> The profile has been abbreviated. For the full profile, see the UAPROF specification.
CC/PP can be used not just for metadata describing device capabilities and the users preferences for how they should be used, although that is the primary purpose. It is a general framework for information about the users situation, such as his position, the ambient conditions (e.g. weather, location, temperature, etc). While no such vocabularies have yet been developed, it can be foreseen that they will.
From a philosophical standpoint, this adaptation is no different from formatting based on device capabilities. The users situation can be regarded as an additional input to the system (along with the request). This is especially true in mobile environments, where interactions and interaction times tend to be shorter than in the fixed environment [Schmidt].
Using XML Namespace, it is possible to mix several vocabularies in one profile, to achieve a precise description not just of the user, but also of his situation (e.g. where he is, what temperature it is there, if the sun is shining, etc). This can then be used in the same way as a transformation to a specific device to create a personalized presentation.
For demonstration purposes, we have created a simple example vocabulary describing the weather at the users position. For brevity, it has only two CC/PP attributes: Sunny and raining. Note that the creation of such vocabularies can be done at the discretion of anyone who can create a URI, but to be accepted, we assume that it would be created by an industry body, representing a consensus about the properties and their values.
Real weather descriptions contain far more data items and data types.
<?xml version='1.0'?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:prf="http://www.example.org/TR/WD-profile-vocabulary#" xmlns:exp="http://weather.co.jp/RDF/exp-schema#"> <rdf:Description rdf:ID="MySituationProfile"> <rdf:Description rdf:ID="MyDeviceProfile"> <prf:component> <rdf:Description rdf:ID="HardwarePlatform"> <rdf:type rdf:resource="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#HardwarePlatform"/> <prf:Vendor>Ericsson</prf:Vendor> <prf:Model>r380</prf:Model> <prf:Type>PDA</prf:Type> <prf:ScreenSize>800x600x24</prf:ScreenSize> <prf:CPU>PPC</prf:CPU> <prf:Keyboard>No</prf:Keyboard> <prf:Memory>16MB</prf:Memory> <prf:Bluetooth>Yes</prf:Bluetooth> <prf:Speaker>Yes</prf:Speaker> </rdf:Description> </prf:component> <prf:component> <rdf:Description rdf:ID="SoftwarePlatform"> <rdf:type rdf:resource="http://www.wapforum.org/profiles/UAPROF/ccppschema-20010430#SoftwarePlatform"/> <prf:OS>EPOC1.0</prf:OS> <prf:HTMLVersion>4.0</prf:HTMLVersion> <prf:JavaScriptVersion>4.0</prf:JavaScriptVersion> <prf:WAPVersion>2.0</prf:WAPVersion> </rdf:Description> </prf:component> </rdf:Description> <rdf:Description rdf:ID="UserSituation"> <prf:component> <rdf:Description rdf:ID="Weather"> <rdf:type rdf:resource="http://weather.co.jp/RDF#weather"/> <exp:Area>Yokosuka</exp:Area> <exp:CloudCover>Clear</exp:CloudCover> <exp:Sunshine>Yes</exp:Sunshine> <exp:Temperature>20</exp:Temperature> </rdf:Description> </prf:component> </rdf:Description> </rdf:Description> </rdf:RDF>
Using the same approach as described in this chapter, it is possible to use vocabularies like Salutation, XML Media Queries, and XML Modules for content adaptation. The mapping of these into RDF Schemas has not been defined.
A question the working group often gets asked is: How do I use CC/PP in my web server? The question is really: How can the server receiving a profile generate customized content?
Using technologies developed by the W3C, there are two basic ways of creating adapted content: Client-based and server-based. These are similar to the HTTP agent-driven and server-driven forms of content negotiation, but differ in that the client-driven approach is assumed to take place entirely in the client. Note that the server-driven approach as described here can also take place in the client, provided it has an XSLT processor. However, for optimization reasons (e.g. in narrowband channels, such as the wireless environment), it is more efficient to send only the adapted information. There may also be security reasons to do this (i.e. not giving out too much content).
The simplest way is to create a simple heuristic to tie the HTTP content negotiation to parameters from the profile. It is also possible to generate a style sheet, which is adapted to the device dynamically. The working group has not developed these heuristics, since they will depend on both the manufacturers, the server owners, and the content providers preferences. The rule sets will have to be defined separately, preferably in an RDF rules language or in terms of an ontology.
The CC/PP working group decided not to tackle feature-independent profile matching. We hope and expectation that the ongoing DAML+OIL work will provide mechanisms that allow us to incorporate equivalent functionality into CC/PP, provided that vocabulary development is performed in a disciplined manner (as noted above).
- Defaults, etc: CC/PP covers an important area not addressed by CONNEG; namely defaults. Also, proxy behavior descriptions and distributed profile descriptions. Reviewing the CC/PP design, with some benefit of hindsight, reinforces the view I previously held that such features should be incorporated at a layer which encapsulates any CONNEG-style feature expression. Specifically, CONNEG-style feature expressions should be contained within a CC/PP-style component, and that feature matching will take place only at the component level. A simple higher-level rule, such as requiring a match for every specified component, could define whether or not two complete profiles match or not. (Any asymmetry between client- and server-side features could be accommodated at this level.) This is a topic for future development, if required.
As the user interaction changes, so will the need for presentation. As author, you will no longer be able to write content that assumes a single presentation model, since it may be presented in a totally different way from what you expected.
In the abstract, the interaction of the user with the device consists of two functions: Presentation of data, and input of data. Presentation, in turn, breaks down into navigation and style.
The input models of devices can be abstracted to a textual input format, irrespective of whether input is received from a keyboard, a keypad, voice recognition, character recognition (e.g. pen-based input) or other means. As yet, there are few non-textual, non-verbal input devices (such as cameras using image recognition). A special problem, which can be abstracted at a higher level, is presented by devices which use shortcut keys, macro keys, softkeys or other devices to represent a textual input as a shortcut. Menus can be seen as a special case of such devices.
The styling of presentation of textual information today varies from no style at all (e.g. on pagers) to highly styled, graphical presentation (e.g. the web as it is usually presented). Abstracting the style to a higher level, instead of including it in the content, enables the insertion of different styles, using mechanisms such as CSS. Using CSS, style information can be handled quite independently of the device.
When receiving information using a mobile or handheld device, however, traditional presentation formats tend to become irrelevant. Table layouts in fixed pixel widths adapted to a 21-inch screen become unusable on a device which has a screen that is one inch square. Instead of assisting it, the formatting tends to obscure the presentation of the information. Disabling style sheets is a simplistic way of achieving a presentation that is usable on a small-screen device (anecdotal evidence seems to point to screens having to be quarter-VGA before styling becomes relevant). Applying different styling methods, such as aural styles, is another way of representing the content.
However, style is not the most difficult part. The navigation is the other aspect of the presentation, and the hardest to abstract from the device. Currently, navigation in web content is subsumed in the "desktop" paradigm of the personal computer. There is no way of structuring content in other ways than an infinite scroll (possibly as shorter sections of the infinite scroll), since the page model is seen as a property of the presentation in CSS.
However, in devices with very small screens, as well as in voice-menu systems, alternative paradigms are emerging for navigation of content. In small-screen devices, the "deck of cards" paradigm of WML is emerging (if implemented as WML or using XHTML and CSS); in voice menus, an entire body of work exists to structure menus for natural interaction.
Modeling all possible future presentation formats is not feasible, however. There are two possible ways to meet this: Either restrict presentation to a single set of devices, or model the navigation of your content in a device-independent way.
Modelling the navigation in a device-independent way also lets you retain control over how it will be navigated on different devices. Navigation is actually a larger part of the user experience than the presentation, even though these tend to be mixed up in popular discussion.
In the W3C CSS paradigm, the user has the ability to override the style presented by the service. This feature is intended to enable users who are not able to receive the style selected, e.g. users using assistive technologies to receive the content, to take part of the presentation. This means that the designer can never be assured that content is presented in the way it was designed on a device. On the other hand, the web has never been pixel-perfect, and presentation has always varied somewhat between devices and implementations.
In traditional HTML presentations, content is not structured for other navigation formats at all. In this paper, we will discuss possible solutions to enable the navigation of different presentation paradigms in the same document, as well as the ability to insert different styles.
Applying these technologies also enables the author to retain control over the navigation of the content (given that the presentation takes place on a device implementing CC/PP), as well as retaining some control over the styling. We contend that the most important part, however, is not the style, but the navigation.
Different styles require different formatting of the content presentation, but different navigation paradigms require different formatting of the content itself. This can be accomplished in several different ways. One is to enable a customization engine to interact with the content at the client, another is to format the content according to the navigation paradigm in the origin server. Both ways imply that there will be a way for the content adaptation process to conduct the required filtering and formatting.
In the case where the adaptation of content takes place at the client, the entire content set has to be transmitted to the client and the parts of it that are not required has to be discarded (alternatively, a set of programs could be transmitted which generates the content from data available at the client - this is speculative, however). The adaptation can be based on the CC/PP presented by the client. This is indeed one of the use cases for CC/PP.
In the case where adaptation is done by the server, the content can be adapted using a transformation process, e.g. XSLT, applying different transformation sheets to the content depending on which CC/PP is received.
For the author, controlling the transformation then comes down to two aspects: Controlling the selection of the transformation sheets, and the transformation of the content itself.
Control over which transformation sheets are applied to the document depending on which CC/PP is received can be done using the document profile, which in essence is a reverse of the client profile, using the CC/PP framework. The author can determine which transformation sheet should be applied when a certain profile, or certain parameters of a profile, are used. This would entail creating a vocabulary for the selection process. Creating such a vocabulary could be part of the effort of the HTML working group to create a vocabulary describing XHTML modules, or a separate effort (e.g. spearheaded by a commercial vendor).
To change the navigational paradigm for a document, however, it is not enough to change the formatting of the content. In the case of a small-screen device, the information will need to be filtered, if the user will not have to wade through enormous amounts of irrelevant information (if you think that this is not an issue, consider that a normal WAP telephone can take just about half a line of the text presented on a 15-inch screen). It goes without saying that browsing becomes extremely tiresome in this environment. Given that most users do not read the text (but scan it, according to Jacob Nielsen), the salient features will have to be highlighted.
Determining which features of the content are salient is the core of the poodle. To accomplish this, knowledge about the users goal for the interaction is required. In certain cases, the author can contribute to the setting of these goals, for instance in services where the interaction is tightly controlled, e.g. in forms. In other cases, where the goals for the interaction can be more ambiguous, this becomes a problem.
As the content is filtered, navigational aids need to be inserted. Traditionally, navigational tools on the web include menus, navigation bars, and pointers (most frequently represented as icons). The web also has a navigation paradigm built into the browser.
Enabling other navigation paradigms is possible if the content is formatted differently. For instance, the same content can be navigated with the card-and-deck paradigm of WML if it is reorganized. Content can be reformatted as WML if it is marked up as WML in advance. While it is possible to mark up content both as WML and HTML, for instance, it is not a pretty sight. And while the HTML browser will ignore the WML tags, the WML browser will not ignore the HTML. Then, there is the question of filtering out content that can not be displayed on the WML device. Rather, the content should be filtered into the target format from the start. This implies that the base markup could either contain multiple formats, or that the XSLT transformation sheets should contain transformation rules to enable the conversion of the generic element set to HTML, WML, VoiceML, or whatever the markup format should be. The selection of the transformation sheet can be done in several different ways, all implementation dependent.
In the CC/PP working group, we are satisfying ourselves with allowing for a selection to take place based on the received CC/PP, but we do not attempt to mandate the mechanism by which this takes place (it could be a PERL programme which enabled the selection from a transformation sheet based on the received screen size and browser software, or it could be a rule base which acted on the profile and the document profile to compose a transformation sheet. It could be HTTP content negotiation. Determining the mechanism is out of the scope of our group).
To enable the transformation sheet to filter and format the content appropriately for the navigation model of the device at hand, the content or the transformation sheet must contain a representation of the navigation model. This implies that a document which is device independent must contain all possible navigational models (the style is divorced from the content, since it is contained in a style sheet), or a subset of all possible navigational models for which the content is enabled.
There are a few prerequisites for content which is to be transformed in the way described in the previous section. One is that a transformation mechanism exists. For content which is written in XML, this is possible to achieve using XSLT; for content in HTML, no simple way exists to transform it into other formats, even if it follows the HTML 4.0 specification. There are too many parameters which can be interpreted differently. Then, there is the high percentage of erroneously encoded HTML pages (up to 60 %, according to some estimates). In summary, HTML content is not usable in transformations which enable the control over content in the manner that an author should expect. Separating the content from the navigation using transformation sheets as filters is a possibility that enables the same kind of device independence as for style; however, this is a chimaera. There seems to be no complete device independency, since preliminary investigations demonstrate that you have to retain at least some concept of the elements in the generic document to be able to filter them properly (which also seems to be true for style - in narrating the content as the generic format, you have to have some awareness of the way the style will represent it, to ensure that it is not misrepresented).
So far, we have identified four different models for creating content which is independent of the display device:
Including all possible markup in the document. Such a document will not display on some types of terminals without filtering, since the diverse kinds of markup will be rejected. It may be used as a generic document for filtering out the appropriate representations, however.
Example: (...) <body> <card> <p>Some text here</p> </card> (...)
This assumes that the different types of markup are clearly separated. Since the names overlap for certain elements and attributes without their functions being the same, however, a variation of this using namespace is possibly a better solution:
(...) <html:body> <wml:card> <html:p><wml:p>Some text here</wml:p></html:p> </wml:card> (...)
A third way is to use a navigation modeling language like XDNL. This essentially enables the creation of a leaf structure of nodes within the document. However, it does not in itself enable the filtering out and reordering of sections or chunks of a document, which may be necessary to prepare the document for a different navigational model.
Another way of handling the same problem is to use Xpointer, as described in the W3C Note "Annotation of Web content for transcoding". The advantage of this method is that it enables the markup to point into the document; essentially, a WML markup could shadow the HTML markup. It is possible to create a markup (or at least navigational markup) that is separated from the document itself. The document need not change. However, it requires a separate mechanism to apply to the transformation process.
Which of these models will be selected will most likely depend on the preferences and predilections of the author, his technical environment, the end-device to be primarily used, etc. It is quite possible that other models are also used.
The important thing is not which model is used, but that the transformation system understands which model is used in the document so it either can apply the appropriate mechanisms or defer the transformation (if it does not have the appropriate mechanism implemented). This negotiation need to take place between the transcoding entity and the origin server. In the CC/PP working group, we have tried to separate these logical functions and define ways to enable CC/PP to be used in this negotiation too; one crucial part here is the use of document profiles, which enables the author to define her preferences for the transformation mechanisms to be used, and declare the encoding used in the document.
To transform a document using XSLT, you need a transformation sheet that is specific to the transformation you want to achieve. Therefore, we will not give any examples in this document. However, it is relatively easy to use variables from an external document, such as the CC/PP profile, to select the transformations that will be done. Technically, this may be easier to do by having three style sheets, one that selects the elements, one that comprise all the transformations, and another that is the result of the application of the first style sheet to the second, and which will be the style sheet that is actually used in transforming the document.
This section was submitted by Holger Blasum of the University of Munich.
To enable recursive directory import the open tool AllRecursive is included in the $JBUILDER/lib/ext path. Then $JIGSAW is added (JBuilder Project/Add Folder Recursively) into the new project's root.
In Project/Project Properties/Run/Application Parameters write "-root $JIGSAW/Jigsaw", adapt source path (JBuilder Project/Project Properties/Paths/Source) to $JIGSAW/src/classes and $JIGSAW/Jigsaw. All $JIGSAW/classes libraries must be configured for JBuilder (JBuilder Project Properties/Paths/Required Libraries). Also set in Project/Project Properties/Paths set the output path to $JIGSAW/src/classes and the working directory to $JIGSAW/Jigsaw.
In Project/Project Properties/Run/Application/Main Class set the Main Class to "Install". In the Jigsaw/Install.java file outcomment the block in lines 137-143 (cache directory). Then run. After compiling 1100+ files "Installation complete with 0 errors" will be written to stdout. Run Jigsaw proper In Project/Project Properties/Run/Application/Main Class now reset the Main Class to "org.w3c.jigsaw.Main". Then run.
Unpack $JIGSAW/Jigsaw/config/jigadmin.zip. In frames.p append the line "org.w3c.jigsaw.ccpp.CCPPFrame=frame". Repack jigadmin.zip. Start $JIGSAW/jigadmin/
In Indexers/default/extensions/Add Resource choose FileResource, identifier "ccpp". Click onto the new resource, select "Edit Resource", choose "Add Frame" and add a CCPPFrame. Commit. Press the "Save to disk" icon on the panel below "http-server".
First, create a file with a ccpp extension (eg "test.ccpp", any content) in $JIGSAW/Jigsaw/WWW. Then write a CC/PP client. For example, this will do the job:
import java.net.*; import java.io.*;
public class CCPPClient { public static void main (String [] args) throws IOException { Socket socket = new Socket (InetAddress.getByName("localhost"), 8001); try { System.out.println ("socket = " + socket); BufferedReader in = new BufferedReader (new InputStreamReader (socket.getInputStream())); PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter (socket.getOutputStream())), true); //CC/PP request out.println("M-GET /test2.myccpp HTTP/1.1"); out.println("Host: localhost"); out.println("C-Man: \"http://www.w3.org/TR/NOTE-CCPPexchange\";ns=1"); out.println("1-Profile:"); out.println("Connection: C-Man, 1-Profile"); out.println("\n"); //CC/PP response String str; while ((str = in.readLine()) != null) System.out.println(str); } finally { System.out.println ("closing..."); socket.close(); } } }
It may take a while till the indexer has registered the test.ccpp file (you can check the associated frames in the Docs space of the http-server). Sometimes creating new files and restarting the jigadmin tool may help to speed up.
There are a number of CC/PP implementations to date. Below is a listing of those which have been reported to the working group. Unfortunately, not all are available outside the companies or products in which they are used, and sometimes they may be part of discontinued products. Describing their features is outside the scope of this document; the user is encouraged to look them up and find out more.
In some cases, they have been discussed on the working group mailing list. W3C members are encouraged to find out more by browsing the archives.
| Name of implementation | Originator | URI | Reported to working group | Open Source |
| Musashi | Ericsson Wasalab | http://www.w3.org/Mobile/CCPP/implday/#demo1 | November 15, 2000 | No |
| WAP Application Server | Ericsson | http://www.w3.org/Mobile/CCPP/implday/#demo1 | November 15, 2000 | No |
| Panda/Sasa | Kiniko Yasuda, Keio University | http://yax.tom.sfc.keio.ac.jp/panda/slidemaker/0011ccpp/Overview.html | November 15, 2001 | Yes |
| SBC/TRI Reference implementation | SBC/TRI | http://www.w3.org/Mobile/CCPP/implday/#demo1 | November 15, 2001 | No |
| Information Architects | Chris Woodrow, Information Architects | http://www.w3.org/Mobile/CCPP/implday/#demo1 | November 15, 2001 | No |
| W3C | Jigsaw Team | http://www.w3.org/Jigsaw/ | Nov. 15, 2000 | Yes |
| University of Wales | Stuart Lewis | http://www.ccpp.co.uk/, http://users.aber.ac.uk/sdl/ccpp/cs39030.html | July 26, 2001 | Maybe |
| DELI | Mark Butler, Hewlett Packard Laboratories | http://www-uk.hpl.hp.com/people/marbut/ | Nov. 2, 2001 | Yes |
The indispensable contributions from the members of the CC/PP working group to this document is gratefully acknowledged by the editors. Other commentators may not always have been as helpful, but we would never have made it without them.
[UAPROF] WAP User Agent Profiling Specification, http://www1.wapforum.org/tech/terms.asp?doc=WAP-248-UAProf-20010530-p.pdf
[RFC 2506] Holtman, K., Mutz, A., and T. Hardie, "Media Feature Tag Registration Procedure", BCP 31, RFC 2506, March 1999.
[RFC3023] "XML Media Types", RFC3023,. M. Murata, S. St.Laurent, D. Kohn, January 2001.URL: ftp://ftp.isi.edu/in-notes/rfc3023.txt
[Schmidt] "Implicit Human Computer Interaction Through Context", Albrecht Schmidt, Mobile 99 workshop at the Interact 99 conference, Edinburgh, Scotland. http://www.dcs.gla.ac.uk/~mark/research/workshops/mobile99/papers/schmidt.ps
The FIPA has not defined an RDF schema, but uses the namespace tied to the URI http://www.fipa.org/profiles/device-20010202#. The schema in that location corresponds to the ontology presented in the specification.


At first, make sure your development environment includes Node.js® and an npm package manager.
Node.js
Angular requires Node.js version 8.x or 10.x.
npm package manager
Angular, the Angular CLI, and Angular apps depend on features and functionality provided by libraries that are available as npm packages. To download and install npm packages, you must have an npm package manager.
This Quick Start uses the npm client command line interface, which is installed with Node.js by default.
To check that you have the npm client installed, run npm -v in a terminal/console window.
To create a new workspace and initial app project:
1. Run the CLI command ng new and provide the name my-app, as shown here:
2. The ng new command prompts you for information about features to include in the initial app project. Accept the defaults by pressing the Enter or Return key.


How to change primary domain of free or paid Google Apps account.
Back in the day, Google Apps for Business (Work) was free for up to 10 users. Sadly, that is no longer the case. If you are one of the lucky ones to have gra...
Back in the day, Google Apps for Business (Work) was free for up to 10 users. Sadly, that is no longer the case. If you are one of the lucky ones to have gra...
This guide will show you how to enable Mobile VPN with IPSec for WatchGuard Firebox M300. It’s a pretty straightfoward process, however it took me quite a wh...
Backups, Snapshots and Archives. They are three different things, however they’re frequently confused to be the same. Does the advent of virtualization mean ...
A mailbox export request is a process of exporting mailbox or archive data to a .pst file. It’s very simple to do with Exchange Management Shell. The firs...
Pretty sure you must’ve noticed it Most of us must’ve faced this problem, especially in our home networks. You must’ve noticed that when you’re trying reach...
DD-WRT is a third-party firmware project that is designed to replace the original firmware for commercial wireless routers and wireless access points. It is ...
I believe the default mindset these days should be always virtualized. It doesn’t matter if you are looking to implement a single server or several. Of cours...


Here is the Recommended Beer Recipe:
{% for growth_rate in display_rates %}
{{growth_rate}}
{% endfor %}
{{most_demand_display}}


Bare Island is one of the last large harbor islands to not have any restrictions for development. 77 acres and over 2 miles of rugged Maine shoreline and sand beaches. There is a custom 4 bedroom home on the inner harbor side with wrap around deck and large living area. Protected inner harbor on one side and bold Maine open ocean on the southern and eastern side.


Main Page
Main Page (logged in)
Create/Update Profile
View Profile
Create/Update Project
View Project


-*- html -*- @author Jose Luis Navarro [https://github.com/artefactop] @title Welcome to the elibphonenumber library @doc `elibphonenumber' is a wrapper port for libphonenumber [https://github.com/artefactop/elibphonenumber]


{{ extend '$layout.html' }} {{ block 'title': }}Diet V-Host Login{{end}}
You have been logged out
Couldn't log in with that username/password


Internals¶
Autogenerated wrappers¶
The Cython struct wrappers are generated by scripts/gen_wrappers.py
. To illustrate how the wrappers work, let’s consider a toy C structure and the corresponding generated Cython cdef class. Here’s a stripped down version of mjData
with a scalar member and a pointer (array) member:
typedef struct _mjData {
int ne;
mjtNum* qpos; // (nq x 1)
} mjData;
Here’s the corresponding generated Cython wrapper code:
cdef class PyMjData(object):
cdef mjData* ptr
cdef mjModel* _model
cdef np.ndarray _qpos
cdef void _set(self, mjData* p, mjModel* model):
self.ptr = p
self._model = model
self._qpos = _wrap_mjtNum_1d(p.qpos, model.nq)
@property
def ne(self): return self.ptr.ne
@ne.setter
def ne(self, int x): self.ptr.ne = x
@property
def qpos(self): return self._qpos
cdef PyMjData WrapMjData(mjData* p, mjModel* model):
cdef PyMjData o = PyMjData()
o._set(p, model)
return o
PyMjData
is the wrapper class for exposing the underlying Mujoco structure to Python; it doesn’t perform any memory mangement. A user writing Cython code can create this wrapper using WrapMjData
. A mjModel
pointer must be passed because the shape of a mjData
member, namely qpos
, depends on model->nq
.
Each field of mjData
corresponds to some generated piece of code in PyMjData
that depends on the type of that field. For example, ne
is a scalar integer, so it gets exposed as a pair of getter and setter methods in PyMjData
. qpos
is an array represented as a pointer to its first element, so it’s wrapped with a NumPy array by _wrap_mjtNum_1d
and is exposed with a getter for that NumPy array.
The function _wrap_mjtNum_1d
creates a Cython memoryview from the data pointer and converts it to a NumPy array pointing to the same memory:
cdef inline np.ndarray _wrap_mjtNum_1d(mjtNum* a, int shape0):
if shape0 == 0: return None
cdef mjtNum[:] b = <mjtNum[:shape0]> a
return np.asarray(b)
Similar functions for other types are also generated as required.
Keep in mind that the only reason to use these autogenerated wrappers is to allow Python users of the Cython code to easily access Mujoco data (for instance the MjSim
Cython class, found in ``cymj/cymj.pyx`). If you’re writing Cython code and you don’t need the user to access Mujoco data from Python, then there is no reason to use these wrappers.


Cube 1997 91m.
The less you know about this one beforehand, the better: avoid all video slicks, talkative friends, and careless reviewers. This is engrossing science fiction that, once seen, is not easily forgotten. In fact it really should be seen only once and then left to linger for years in the memory. Story opens with a group of strangers awakening to find themselves in a square room with identical doors set in the walls, floor, and ceiling. Each door in turn leads to another room of the same design. It's tempting to think that because each character has been roused from sleep CUBE is merely a dream or hallucination, but no: its story generates tension because what happens to the people in it is horribly real despite the absence of any rationale. We are put in the characters' place, unaware of the meaning of the scenario while trying to puzzle it out as best we can. But there's little time for us to think independently - the screenplay (by Andre Bijelic, Graeme Manson, and director Vincenzo Natali) moves us along at a relentless pace. The claustrophobic setting and faceless appearance of each character (they wear drab prison outfittings) become hypnotic after a while; because they do nothing but move, sleep, and die it's about as purely existential an experience as you can find in cinema. The writers are smart enough not to have their characters pontificate on these themes however - the premise does well enough alone without having 'meaningful' dialogue thrown in to remind us what it stands for. As would be expected, there is the usual cross-grouping of character types to provide confrontation, but even these provide no anchor for our viewing sensibilities - characters change, sometimes in an instant. Heroes, villains, defeatists, and pragmatists all switch among each other - every character in turn is brave, fearful, angry, and calm. Only one thing is certain - every one of them is expendable.
Film has many offbeat, humorous lines and moments but is also unbearably tense at times - we are alerted early into the film that the labyrinth is a sadistic death trap. One scene, in which there is no sound for several minutes, is unbearable to watch in a cinema (and strange as it may seem - given the limiting nature of its sets - this really is a film to be seen in a cinema). Yet the major irony of the story is that the characters brutalize each other more than the sinister machinations of the Cube - in fact this is taken to excess near the film's conclusion, and is the only misstep the screenwriters make. Otherwise CUBE is a perfect blend of thought and action. You can sense the devilish fun that Natali and friends must have had assembling their intricate game - was this dreamed up by a frustrated Rubik's Cube owner?? Sensibly, the impressive effects are used only when needed. Wonderfully edited, photographed, and directed (especially considering the limitations of the setting). The cast, who provide the humanity - and inhumanity - central to our involvement with the story, command our attention on screen. It's hard to say who stands out, but my pick would be Nicole de Boer (as a student who makes maths look pretty cool and exciting!), a determined Maurice Dean Wint, and Andrew Miller, as the least likely companion of the others).
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 "registration/registration_base.html" %} {% block title %} {% if account %} Activation complete {% else %} Activation problem {% endif %} {% endblock %} {% block content %}
Thanks {{ account }}!
You may now login or visit the download page.
Oops – it seems that your activation key is invalid. Please check the url again.


Juyoun Yoo
I am a PhD student in Larry Zipursky lab at UCLA.
I entered Neuroscience IDP program in 2015, and joined the Zipursky group in 2016.
I earned my Master’s degree in Biological Science from Seoul National University in 2012.
I worked with Bong-kiun Kaang group to study learning, memory and social behavior of Autism Spectrum Disorder mice models.
I did my bachelors at Ewha Womans University from Seoul, Korea.
I'm generally interested in how the brain is built. During my PhD I investigated how neuronal gene expressions are changing in the course of neurogenesis and synaptogenesis,
how cell-surface molecules are related to synaptic specificity.
I have experience with single-cell RNA sequencing, immunohistochemistry, confocal imaging, CRISPR & Drosophila genetics.
Google Scholar  /
Twitter
|
|
Research
Work during my Ph.D in Zipursky lab
|
|
|
Transcriptional Programs of Circuit Assembly in the Drosophila Visual System
Yerbol Z. Kurmangaliyev, Juyoun Yoo, Javier Valdes-Aleman, Piero Sanfilippo, S. Lawrence Zipursky
Neuron, 2020.
We generated developmental transcriptome atlas of the whole fly opticlobe throughout the pupal stage. We showed that there are pan-neuronal programs that the majority of neurons follow,
and there also are cell-type specific programs. We strategized to use Drosophila Genome Reference Panel(DGRP) to multiplex the library to minimize batch effect in a simple and cost-effective manner.
|
|
|
Modular transcriptional programs separately define axon and dendrite connectivity
Yerbol Z Kurmangaliyev*, Juyoun Yoo*, Samuel A LoCascio*, S Lawrence Zipursky
eLife, 2019. [pdf]
We showed that eight subtypes of direction selective T4/T5 neurons' transcriptome has no subtype-specific markers, rather the architecture of the transcriptome is assembled with axon and dendrite specific programs,
reflecting the morphologies.
|
|
|
Interactions between the Ig-Superfamily Proteins DIP-α and Dpr6/10 Regulate Assembly of Neural Circuits
Shuwa Xu, Qi Xiao, Filip Cosmanescu, Alina P. Sergeeva, Juyoun Yoo, Ying Lin, Phinikoula S. Katsamba, Goran Ahlsen, Jonathan Kaufman, Nikhil T. Linaval, Pei-Tseng Lee, Hugo J. Bellen, Lawrence Shapiro,
Barry Honig, Liming Tan, and S. Lawrence Zipursky
Neuron, 2018. [pdf]
We showed that Immunoglobulin Superfamily proteins DIP-α and its binding partners dpr6, dpr10 interactions regulate layer specific circuit assembly.
|
|


The Future
depends on what
we do in the
Present
Mahatma Gandhi
Engineering
Medicine
Technology
Law
Sports
Languages
Accounting
Geography


---
sort_order: 70
tei_id: rdx_b5h9g.p.idm198297168
annotation_count: 0
images:
small-thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pckmp/mini-thumbnail/
json: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pckmp/info/
full: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pckmp/fs/
page: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pckmp/single-page/
thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pckmp/thumbnail/
title: Page 70
number: 70
---
{% raw %}62{% endraw %}
{% raw %}JACOB HODGES.{% endraw %}
{% raw %}" How do you get rid of these feelings{% endraw %}
{% raw %}of despondency, Jacob ?"{% endraw %}
{% raw %}** Fall down at his feet and never give{% endraw %}
{% raw %}him rest till he gives me rest by his{% endraw %}
{% raw %}Spirit."{% endraw %}
{% raw %}" Fall down at his feet?"{% endraw %}
{% raw %}" Fall down at the foot of the cross and{% endraw %}
{% raw %}pray for his mercy and the enlightening{% endraw %}
{% raw %}influence of his Spirit."{% endraw %}
{% raw %}" Fall down, you say ?"{% endraw %}
{% raw %}" Kneel down, I mean by falling down."{% endraw %}
{% raw %}" Do you commonly do that when you{% endraw %}
{% raw %}pray ?"{% endraw %}
{% raw %}"Yes; but then I am always looking to{% endraw %}
{% raw %}God, when I am working on any thing."{% endraw %}
{% raw %}" Does it do you good to kneel down to{% endraw %}
{% raw %}pray?"{% endraw %}
{% raw %}" It does; I have found along back{% endraw %}
{% raw %}that I have let the world and business{% endraw %}
{% raw %}stop me when I have been pressed by the{% endraw %}
{% raw %}Spirit to go and pray, and I have found{% endraw %}
{% raw %}'ately that the only way that I can obtain{% endraw %}
{% raw %}the Spirit of God, at all times, is to prav{% endraw %}
{% raw %}often."{% endraw %}
{% raw %}" How often ?"{% endraw %}


CENTRAL BANK OF NIGERIA INTERNATIONAL REMITTANCE DEPARTMENT CORPORATE HEAD QUARTERS. TINUBU SQUARE,LAGOS. OUR REF: CBN/IRD/CBX/021/07 WEBSITE: www.cenbank.org RE:CHANGE OF ACCOUNT PARTICULARS ON YOUR BENEFICIARY FILE Dear Sir/Madam I hereby send to you the information submitted by Mr. John Tsai of Indo-China group Ltd, with an application to receive the payment on your behalf. Please as a matter of urgency, you are required to verify the following information and inform us if you are aware or know anything about this. 1. Did you instruct one Mr. John Tsai of Indo-China group Ltd. Hong-Kong, whose information's is below, to claim and receive the payment on your behalf ? 2. Did you sign any "Deed of Assignment" in his favor thereby making him the current beneficiary with the following account details: Account Name: Indo-China Group Ltd, A/C #USD114-1025567-8, Bank Name: Standard Chattered Bank,Hong Kong, Swift Code: SCBL11K111. Finally, You are hereby advised to indicate to this honorable office with immediate effect, if you are the person that instructed Mr. John Tsai to come for the claim of these funds, to enable me endorse for the final payment approval order on his behalf. You are to call the Phone Number for more clarifications. We wait to hear from you soonest, and be rest assured of our professional service. Protect your funds by replying to this e-mail address for confidential reason so that John Tsai will not take possession of your funds. Prof.Charles.C.Soludo Executive Governor Central Bank of Nigeria.


{{description}}
Thank you for subscribing to updates for cannabis retail licensing. A confirmation email has been sent from<EMAIL_ADDRESS>Click on the link in the email to activate your subscription.


|
muSE
r716
|
A muse cell is a union of all the possible cell types. More...
#include <muse_opcodes.h>
A muse cell is a union of all the possible cell types.
In many lisp systems the cell data itself encodes the type of the contents. In muSE, only the cell reference encodes the cell's content type. A cell reference of type muse_cell
is a 32-bit integer whose least 3-bits encode the cell type and the higher bits encode the index to the cell within the heap.
In a 32-bit build, muse_cell_data
will be 64-bits in size. In a 64-bit, it'll be 128-bits in size.


Hi! I am kim. I like people. I strive to make their lives easier and more enjoyable.
Listen. Then listen some more.
Observe, interpret, intuit.
Share, collaborate, build.
Measure. Learn. Repeat.
Be honest, efficient, true to myself and others. If the sun is out, I better say hello.
Resides in Santa Clara.
You can find me on


---
sort_order: 17
tei_id: rdx_b5h9g.p.idm202868352
annotation_count: 0
images:
small-thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchs5/mini-thumbnail/
json: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchs5/info/
full: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchs5/fs/
page: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchs5/single-page/
thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pchs5/thumbnail/
title: Page 17
number: 17
---
{% raw %}JACOB HODGES.{% endraw %}
{% raw %}9{% endraw %}
{% raw %}geance of God, or the righteous demands{% endraw %}
{% raw %}of human law.{% endraw %}
{% raw %}It would seem that Jacob had been, for{% endraw %}
{% raw %}some time, in the employment of these{% endraw %}
{% raw %}men as a common labourer, and that for{% endraw %}
{% raw %}more than a year they had been prepar¬{% endraw %}
{% raw %}ing for the murder of Jennings.  They told him di¬{% endraw %}
{% raw %}rectly, that " he was the very person fit¬{% endraw %}
{% raw %}ted for the old man's destruction." They{% endraw %}
{% raw %}promised him, at the same time, their co¬{% endraw %}
{% raw %}operation, and a large pecuniary reward.{% endraw %}
{% raw %}Jacob for a long time hesitated.{% endraw %}
{% raw %}Another, and a desperate effort was{% endraw %}
{% raw %}made. The wife of one of the parties be¬{% endraw %}
{% raw %}came an accessary. She was a woman{% endraw %}
{% raw %}who, till then, sustained a respectable{% endraw %}
{% raw %}character for intelligence and morality{% endraw %}
{% raw %}In her opinion Jacob placed the fullest{% endraw %}
{% raw %}confidence. She was now brought for¬{% endraw %}
{% raw %}ward to persuade him of the justness and{% endraw %}
{% raw %}necessity of the act to which he was{% endraw %}
{% raw %}urged. Yet it would seem his heart{% endraw %}


In order to update your location, please type /showlocation
in Global Chat.
Either press and to interact with the the chat window, or press to open the mobiGlass communications app.
In order to update your location, please type /showlocation
in Global Chat.
Either press and to interact with the the chat window, or press to open the mobiGlass communications app.
Display Options
Auto Location Update
every
use
Global Chat must be visible for this to work!
Global Chat must be hidden for this to work!


{% extends "../../layout.html" %} {% block sectionClasses %}plugins hasBreadCrumb plugins-spincast-process-utils{% endblock %} {% block meta_title %}Plugins - Spincast Process Utils{% endblock %} {% block meta_description %}Spincast Process Utils plugin - utilities related to processes and external programs manipulation{% endblock %} {% block scripts %} {% endblock %} {% block body %}
This plugin contains utilities to programmatically execute and
manipulate external programs.
It also allows you to easily compile/package/install a Maven
project
located outside your application.
The utilities provided by this plugin are available through the SpincastProcessUtils interface, which you can inject wherever you want.
The executeGoalOnExternalMavenProject(...) method allows you to programmatically compile, package or install a Maven project located outside of your application.
This feature can be useful for example to run tests that need to validate code from inside a .jar file.
The signature of this method is:
{% verbatim %}
public File executeGoalOnExternalMavenProject(ResourceInfo projectRootInfo, MavenProjectGoal mavenGoal, Map<String,Object> pomParams);{% endverbatim %}
Using this method you can:
compile
, package
or install
goal on a Maven
project located:
pom.xml
, before
executing the Maven goal. The replacement is done using the Templating Engine.
Note that this method returns the root directory of the Maven project. If the project is extracted from the classpath, this directory is going to be created under the Temporary Directory. If the project is already on the file system, it will return its root directory, as is.
Let's look at an example where we run the package
goal on a Maven project located
on the classpath (the project would be provided by your application at "src/main/resources/myMavenProject"):
{% verbatim %}
String spincastVersion = getSpincastUtils().getSpincastCurrentVersion(); File projectDir = getSpincastProcessUtils() .executeGoalOnExternalMavenProject(new ResourceInfo("/myMavenProject", true), MavenProjectGoal.PACKAGE, SpincastStatics.map("spincastVersion", spincastVersion)); File jarFile = new File(projectDir, "target/project-artifact-name-" + spincastVersion + ".jar"); assertTrue(jarFile.isFile());{% endverbatim %}
Explanation :
pom.xml
file with this version.
executeGoalOnExternalMavenProject()
method.
The first parameter is the path to the Maven project. Here, the project is on the classpath ("true
").
goal
to run. In this example, we will call
the "package" goal so the .jar
associated with this project is generated.
pom.xml
file (the Templating Engine is used
to do so).
.jar
file has been successfully generated!
Have a look at this test for a real example of running a goal on an external Maven project.
The executeAsync(...) method allows you to run an external program and to keep control over the created process.
Here is an example where we run an executable .jar
file programmatically:
{% verbatim %}
ProcessExecutionHandlerDefault handler = new ProcessExecutionHandlerDefault() { @Override public void onSystemOut(String line) { System.out.println("[jar out] - " + line); } }; // Start an executable jar getSpincastProcessUtils().executeAsync(handler, "java", "-jar", "/some/path.jar", "12345"); // argument for the .jar program try { // Wait for the port 12345 to be open handler.waitForPortOpen("localhost", 12345, 5, 1000); // Make a request to the HTTP server started by the .jar program HttpResponse response = getHttpClient().GET("http://localhost:12345").send(); assertEquals(HttpStatus.SC_OK, response.getStatus()); // ... } finally { // Kill the process when we are done with it! handler.killProcess(); }{% endverbatim %}
Explanation :
onSystemOut(...)
.
java
in order
to start an executable .jar file. Note that you can (and sometimes must) specify an absolute path.
java -jar /some/path.jar 12345
. The "12345
" argument
would be passed to the executed jar (in our example this is the port to use
for the jar to start an HTTP server!).
12345
. We make a request to it.
On some environments, you may have to specify the full path to the program to be executed
(it may depend on the PATH
variable of your system).
Here are the methods available on the ProcessExecutionHandler handler and that need to be implemented (if you don't use the ProcessExecutionHandlerDefault default implementation, in which case you can override some):
void onExit(int exitCode)
This method will be called when the process exits. If it exits without any error,
exitCode
will in general be "0
".
The default implementation, from ProcessExecutionHandlerDefault, will simply log the exit code.
Note that if you execute a program that does not exit by itself (for example an HTTP server is started and wait for requests indefinitely), you have to explicitly kill the process.
The onEnd() method is called after this one.
void onLaunchException(Exception ex)
This method is going to be called if an exception occurs during the launch of the external program.
The default implementation, from ProcessExecutionHandlerDefault, will simply log the exception.
Note that when this method is called, onExit() will not be called: the program was never even started.
The onEnd() method is called after this one.
void onTimeoutException()
This method is going to be called if the program is launched properly but doesn't exit before the specified timeout is reached (if one is specified) .
The default implementation, from ProcessExecutionHandlerDefault, will simply log the error.
Note that when this method is called, onExit() will not be called.
The process is killed automatically.
The onEnd() method is called after this one.
void onEnd()
Always called at the end, whether the process exited properly or an exception/timeout occurred.
void onSystemOut(String line)
This method will be called when a line is printed to the standard output by the executed program.
The default implementation, from
ProcessExecutionHandlerDefault,
will simply log the line using System.out.println()
.
void onSystemErr(String line)
This method will be called when a line is printed to the standard errors output by the executed program.
The default implementation, from
ProcessExecutionHandlerDefault,
will simply log the line using System.err.println()
.
void killProcess()
Kills the created process.
If the process can't be killed, for any reason, an exception is thrown.
Only the first call to this method will be acknowledged, the following ones will simply be ignored.
boolean isProcessAlive()
Return true
if the created process is alive.
void waitForPortOpen(String host, int port, int nbrTry, int sleepMilliseconds)
This method, provided by the ProcessExecutionHandlerDefault
default implementation, allows you to wait for a port
to be connectable. This is useful if the
executed program starts an HTTP server and you need to wait for it to be ready.
If the port is still not available after nbrTry * sleepMilliseconds
milliseconds, a
PortNotOpenException
exception is thrown.
Remember that if you run a program that doesn't exit by itself (for example
it starts an HTTP server that listens for requests indefinitely), you are responsible
to kill the process when you are done with it, by calling killProcess()!
This can be done using a try/finally
block.
As we saw in the previous section, you can execute an external program asynchronously, so it doesn't block the current thread and can be manipulated. In simple cases, you can also execute it synchronously. Here is an example:
{% verbatim %}
try { SyncExecutionResult result = getSpincastProcessUtils().executeSync(3, TimeUnit.MINUTES, ExecutionOutputStrategy.BUFFER, "/my/program/to/execute", "arg1", "arg2"); assertEquals(new Integer(0), result.getExitCode()); } catch (LaunchException ex) { // manage the exception } catch (TimeoutException ex) { // manage the exception }{% endverbatim %}
Explanation :
Standard output
and Standard errors
)
to be buffered so they are available through the SyncExecutionResult
result object when the execution is done.
executeSync(...)
method
exits, we can get information from the SyncExecutionResult
object. Here, we
simply validate that the program exited with the code "0
".
Two typed exceptions can be thrown when using executeSync()
:
The methods available on the SyncExecutionResult object are:
int getExitCode()
The exit code of the executed program.
Note that this code is undefined if the program timed out and the
SyncExecutionResult
instance has been taken from
TimeoutException
's
getSyncExecutionResult()!
List<String> getSystemOutLines()
The lines outputted to the standard output by the created process. Those will only be available if the ExecutionOutputStrategy parameter is explicitly set to BUFFER. Otherwise, an empty list is returned.
List<String> getSystemErrLines()
The lines outputted to the standard errors by the created process. Those will only be available if the ExecutionOutputStrategy parameter is explicitly set to BUFFER. Otherwise, an empty list is returned.
The strategies that you can use to deal with the output of the created process are:
System.out
or System.err
immediately, as it occurs.
SyncExecutionResult
result object.
Beware that buffering the output (by using BUFFER as the strategy) may consume a lot of memory if the created process generates a lot of it! If this is the case for you, you may have to use the asynchronous method instead.
1. Add this Maven artifact to your project:
<dependency> <groupId>org.spincast</groupId> <artifactId>spincast-plugins-process-utils</artifactId> <version>{{spincast.spincastCurrrentVersion}}</version> </dependency>
2. Add an instance of the SpincastProcessUtilsPlugin plugin to your Spincast Bootstrapper: {% verbatim %}
Spincast.configure() .plugin(new SpincastProcessUtilsPlugin()) // ...


SCREAM (1996)
As Reviewed by James Brundage
Two words: Brilliant Satire.
This is what everyone's been waiting for, a movie that's funny, scary, brilliant, and has a message at the same time. Enough blaming of the movies to satisfy the Christian Coalition. Enough creative one-liners to make anyone laugh. Enough black comedy to have us all forget the body count. And enough corn syrup (fake blood) to satisfy even the wackiest of gore-hounds. SCREAM has something for everyone.
What is it? Not a horror movie or a comedy, or even a dark comedy, but a cross-over between all of these, incorporating parodies with fright, brilliant cinema with purposefully terrible acting. A human element that rubs off as so surreal in context that its almost laughable. And characters you will never forget.
The plot is that of any slasher movie from 1970 onward, put in the words of Neve Campbell in the line "What's the point?
Sound familiar?
What's worse is all of this happens to the characters, making for a darkly comic in an Edward Scisscorhand's type fashion, making you laugh in hindsight. And then there are Randy's (the movie-freaked mind that may or nay not have lost its reality base) rules to surviving a scary movie: all both followed and broken.
What's the best thing? The mystery. This movie doesn't just slice and dice, telling you who the killer is right off the bat, but instead waits until the end to explain it all, and has fun every step of the way. Sit back, relax, enjoy, and throw your popcorn into the air as the knife comes up one to slice through the air as the person is to be silenced in one final SCREAM.
http://fly.to/criticsheaven
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


For 15 years I have used my knowledge of web design and development to create effective and easy to use websites. I have worked in several different capacities within the industry and have developed a well-rounded set of skills to convert complex visual designs into clean, standard-driven, front-end code. Over the years I have worked with companies such as IBM, Starwood Hotels, Teacher's Retirement System, RGA, Draft FCB, RAPP and Equinox.
Public short list Favorite Websites Awards – 2011.
WITNESS.ORG – Project Focus
The Webby Awards - 2011.
Category - Beauty and Cosmetics. COTY: Beyoncé Heat
The Webby Awards - 2010.
Category - Pharmaceuticals. myalli
Equifit Forms
on GitHub
Node.JS, MongoDB, Backbone.JS, BackboneLayoutManager, Backbone Forms, Bootstrap and LESS
Equifit forms
Okgrafix.com
on GitHub
Node.JS, MongoDB, Backbone.JS, BackboneLayoutManager, Backbone Forms, Susy and SASS
Okgrafix.com (Backbone.JS)
Okgrafix.com (Ember.JS)
Purchase and Schedule Apps POC
on BitBucket
Backbone.JS, Marionette, Susy and SASS
Purchae and Schedule Apps POC
Code snippets
on Codepen
Backbone.JS, Backbone Forms
POC code snippets


Brought to you by Team Hairball:
License: New BSD
{% include "main/keyboard.html" %}
Retrieving revision please wait ...


Basic example¶
NOTE: For live programming, seamless must be run interactively within IPython
For convenience, a command line tool seamless
is provided, that starts up
IPython and also imports the seamless API
The code below can be found at https://github.com/sjdv1982/seamless/tree/master/examples/basic.py
Code:
from seamless import context, cell, pythoncell, transformer
from seamless.lib import edit, display
ctx = context()
# Create 3 int cells: a=2, b=3, and result
ctx.a = cell("int").set(2)
ctx.b = cell("int").set(3)
ctx.result = cell("int")
# Set up a transformer that computes "result" as a function of "a" and "b"
t = ctx.transform = transformer({
"a": {"pin": "input", "dtype": "int"},
"b": {"pin": "input", "dtype": "int"},
"result": {"pin": "output", "dtype": "int"}
})
# Connect the cells to the transformer pins
ctx.a.connect(t.a)
ctx.b.connect(t.b)
t.result.connect(ctx.result)
# Every transformer has an implicit extra input pin, called "code"
# It must be connected to a Python cell
ctx.code = pythoncell().set("return a + b")
ctx.code.connect(t.code)
# Transformers execute asynchronously; ctx.equilibrate() will wait until all
# transformations have finished
ctx.equilibrate()
# The result cell will now have been computed
print(ctx.result.value) # 5
# Updating either input automatically recomputes the result
ctx.a.set(10)
ctx.b.set(20)
ctx.equilibrate()
print(ctx.result.value) # 30
# Updating the code also automatically recomputes the result
ctx.code.set("""
def fibonacci(n):
def fib(n):
if n <= 1:
return [1]
elif n == 2:
return [1, 1]
else:
fib0 = fib(n-1)
return fib0 + [ fib0[-1] + fib0[-2] ]
fib0 = fib(n)
return fib0[-1]
return fibonacci(a) + fibonacci(b)
""")
ctx.equilibrate()
print(ctx.result.value) # 6820
# The inputs and the result and code can be edited/shown in a GUI
# This automatically recomputes the result
ctx.gui = context() # Create a subcontext to organize our cells better
ctx.gui.a = edit(ctx.a, "Input a")
ctx.gui.b = edit(ctx.b, "Input b")
ctx.gui.result = display(ctx.result, "Result")
# Same for the code, this creates a text editor
# In this case, the code is updated as soon as you click outside the window
ctx.gui.code = edit(ctx.code, "Transformer code")
# The source code of each editor is itself a seamless cell that can be edited
# Editing its source code (and clicking outside the window)
# immediately changes the other editor window!
text_editor_code = ctx.gui.code.rc.code_start.cell()
ctx.gui.text_editor = edit(text_editor_code, "Text editor source code")


In this milestone, you'll reflect on the wiki project as a group. What worked well? What did you learn? What would you do differently next time?
The goal of a retrospective is to document what happened, identify what went well, what could have been better, and plan what might be done differently next time.
Create a document and share it with your teammates. Add the following headings:
Work with your group to fill these out.
Most importantly, this exercise should be blameless. Focus on identifying the contributing causes (What happened? What assumptions were made? What expectations were there?) without indicting any individual or team for bad or inappropriate behavior. Assume that everyone involved in an incident had good intentions and did the right thing with the information they had.
 Also imagine any future cohorts of students who might be able to learn from your experience.
List the main events of the project and their dates in chronological order. The project milestones may be a good starting point for this section. You may also want to use the git commit history as a reminder of what work was done and when.
Once you have listed the main events, each of you may share their general feeling of how things went. See: https://www.funretrospectives.com/the-peaks-and-valleys-timeline/
Identify the things that really worked well. These could be technical solutions, team process (emails, meetings, chat, pair programming), or anything else that helped the project be successful.
Identify the things that didn't work as well as you'd hoped. These issues could be technical, team process, or anything else that prevented the project from being as good as you'd hoped it would be.
What would you do differently next time you build a project like this? What would you tell students who are just starting their wiki projects?
To turn in this assignment, share an exported PDF copy of your Retrospective in your wiki project repository in GitLab.
Download a PDF copy of your PRD document to your computer. Navigate to File -> Download -> PDF Document in the Google Docs menu.
Note: Cloud Shell Editor may not be able to render the PDF. That's OK. You'll verify the file was correctly uploaded in a later step.
git add wiki-retrospective.pdf
git commit -m 'add wiki retrospective'
git push origin main


My name is Adam, a Bostonian transplant living in Portland to take coding courses at Epicodus. I have a Bachelor's in Science (Biology) and have worked in the veterinary industry as a technician for about 4 years, but have since realized that my real love has always been tinkering with technology, and software in particular. So I've decided to dive headfirst into programming at Epicodus! When I'm not working and/or coding, I'm a big fan of gaming, reading, music, anime, baseball, and football. (And as you know by viewing this page, red pandas!)


Entities
etjump203_target_relay
A target_relay that works only on ETJump 2.0.3 and newer.
etjump2_target_relay
A target_relay that works only on ETJump 2.0.0 and newer.
target_activate (deprecated)
A replacement (target_tracker and trigger_target) has been added in ETJump 2.1.0 that is both easier to use and allows for more complex designs.
Keys
| Key | Possible values | Default value | Description |
| spawnflags | 0, 1, 2, 4 | 0 | If 0, actives if player's map progression identifier is equal to the target_activate's reqident. If 1, activates if player's map progression identifier is below the target_activate's reqident. If 2, activates if player's map progression identifier is not equal to the target_activate's reqident. If 4, activates if player's map progression identifier is greater than target_activate's reqident. |
| reqident | Any positive integer | 0 | Activates if players map progression identifier matches the pre-defined requirements. |
target_activate_if_velocity
Activates targeted entities if player's velocity is between the lower and upper velocity limit.
Keys
| Key | Possible values | Default value | Description |
| spawnflags | 0, 1, 2 | 0 | If 0, speed will be calculated from horizontal and vertical velocity. If 1, speed will be calculated from horizontal velocity. If 2, speed will be calculated from vertical velocity. |
| lower_limit | Any positive integer | 0 | If value is higher than lower limit, targets will be activated. |
| upper_limit | Any positive integer | 0 | If value is lower than upper limit, targets will be activated. |
target_ftrelay
Works exactly like target_relay but activates the entities for everyone in the player's current fireteam, not just the player.
target_increase_ident
Increases the players map progression identifier.
Keys
| Key | Possible values | Default value | Description |
| inc | Any integer | 1 | How much the identifier should be increased when player activates the entity. |
target_printname
Works exactly like target_print, but prints the message as popup rather than centerprint. Prints activator's name if message contains %s.
target_remove_portals
Removes activators's existing portals.
target_save
Saves current position to activators's save slot 0.
target_savereset
Resets activator's saved positions.
target_scale_velocity
Scales activator's velocity.
Keys
| Key | Possible values | Default value | Description |
| scale | Any integer | 1 | How many times should be velocity be multiplied. |
target_setident
Sets the activator's map progression identifier.
Keys
| Key | Possible values | Default value | Description |
| ident | Any integer | 0 | The value the identifier will be set to. |
target_startTimer
Starts a timerun for activator.
Keys
| Key | Possible values | Default value | Description |
| name | Text | default | The name of the run. Start and stop timer must have a matching name. |
target_stopTimer
Stops a timerun for activator.
Keys
| Key | Possible values | Default value | Description |
| name | Text | default | The name of the run. Start and stop timer must have a matching name. |
trigger_tracker and target_tracker
Replacement for target_activate.
There are three different formats for specifying the tracker index and value.
- <value> Set the tracker on index 1 to <value>
- <index, value> Set the tracker on index <index> to <value>
- <index1,value1>|<index2,value2>|..|<indexN,valueN> Set the trackers on indices <index1, index2, .., indexN> to values <value1, value2, .., valueN>
Examples
| Key | Value | Meaning |
| tracker_eq | 1 | tracker on index 1 has to be 1 |
| tracker_eq | 2,1 | tracker on index 2 has to be 1 |
| tracker_eq | 1,1|2,1|3,1 | trackers on indices 1, 2 and 3 have to be 1 |
Keys
| Key | Possible values | Default value | Description |
| tracker_eq | <index,value> format specified above. | 1,-1 | Tracker activates targets if specified tracker value matches the player's tracker value. |
| tracker_gt | <index,value> format specified above. | 1,-1 | Tracker activates targets if player's tracker value is greater than specified value. |
| tracker_lt | <index,value> format specified above. | 1,-1 | Tracker activates targets if player's tracker value is less than the specified value. |
| tracker_set | <index,value> format specified above. | 1,-1 | Tracker sets player's tracker value to the specified value. |
| tracker_set_if | <index,value> format specified above. | 1,-1 | Tracker sets player's tracker value to the specified value if conditions are true. |
| tracker_inc | <index,value> format specified above. | 1,0 | Tracker increases player's target value by the specified value. |
| tracker_inc_if | <index,value> format specified above. | 1,0 | Tracker increases player's target value by the specified value if conditions are true. |
weapon_portalgun
Spawns a portal gun at the location.
Worldspawn keys
| Key | Possible values | Default value | Description |
| noexplosives | 0, 1, 2 | 0 | Disables explosives. 0 explosives are allowed. 1 no explosive weapons. 2 no dynamite. |
| noghost | 0, 1 | 0 | Disables player ghosting |
| nogod | 0, 1 | 0 | Disables god mode |
| nogoto | 0, 1 | 0 | Disables goto |
| nonoclip | 0, 1 | 0 | Disables noclip |
| nosave | 0, 1 | 0 | Disables save |
| portalgun_spawn | 0, 1 | 0 | Toggles whether players should spawn with a portal gun. |
| portalsurfaces | 0, 1 | 1 |
If set to 1, players can shoot portals everywhere on the map. If set to 0, players can only
shoot portals to areas with surfaceparm monsterslickeast .
|
| portalteam | 0, 1, 2 | 0 | If set to 0, players can only go to own portals. If set to 1, players can also go to fireteam mates' portals. If set to 2, anyone can go to anyones portals. |
| savelimit | Any positive integer | 0 | If set to higher than 0, saves are limited to the set value. |


SOME
Barcelona Psytrance Collective
Barrio Negro - Rumbanova
Rumba band from BCN
Create the visual identity for the new CD as well as visual elements of the presentation concert of it. We decide to use only one ink and go for a more typographic approach.
**Inside view of the booklet that contains the lyrics**


Nanostructured Microemulsions as Alternative Solvents to VOCs in Cleaning Technologies and Vegetable Oil Extraction
EPA Grant Number: R830903Title: Nanostructured Microemulsions as Alternative Solvents to VOCs in Cleaning Technologies and Vegetable Oil Extraction
Investigators: Sabatini, David A. , Harwell, Jeffrey H.
Current Investigators: Sabatini, David A. , Do, Linh , Harwell, Jeffrey H. , Witthayapanyanon, Anuradee
Institution: University of Oklahoma
EPA Project Officer: Lasat, Mitch
Project Period: January 1, 2003 through December 31, 2005 (Extended to January 13, 2007)
Project Amount: $329,655
RFA: Environmental Futures Research in Nanoscale Science Engineering and Technology (2002) RFA Text | Recipients Lists
Research Category: Nanotechnology , Safer Chemicals
Objective:
The objective of this project is to develop and evaluate non-toxic, non-volatile, and biodegradable oil extraction. Specifically, we plan to formulate water continuous microemulsions to dissolve the oil in the hydrophobic core of swollen micelles (1-50 nm droplets). We will study the impact of novel microemulsion additives, called “linkers”, on the interfacial properties (interfacial tension, rigidity and curvature) and dynamic aspects of oil solubilization and displacement from porous and smooth surfaces under different shear conditions. Linkers are surfactant-like molecules that are wither too lipophilic or hydrophilic to self-assemble at the O/W interface, but in the presence of surfactant they self-assemble to produce microemulsions with improved performance for a variety of oils. We hypothesize that by introducing linkers we can formulate aqueous surfactant solutions that, upon contact with the oil to be removed, and under optimum flow conditions, will spontaneously from microemulsions that keep the oil in micelles. These surfactant solutions can therefore be used as alternatives to VOC solvents, such as hexane, in cleaning hard surfaces, textiles and vegetable oil extraction.
Approach:
The first phase of the project will focus on developing phase behavior diagrams for microemulsions with hexadecane and motor oil (model lubricant) and triolein (model for vegetable oil). We will use alkyl sulfosuccinates, lecithin, sorbitol esters and alkyl propoxy sulfonates as surfactants; fatty alcohols, and sorbitol esters as lipophilic linkers; and C6-C9 alkyl glucosides, and alkyl naphthalene sulfonates as hydrophilic linkers. The second phase of the project will focus on evaluating equilibrium solubilization, interfacial tension, interfacial rigidity and interfacial curvature. The third phase will involve dynamic solubilization/oil displacement studies from hard surfaces, textiles and ground seeds under different shear rates. We will model the influence of linkers and shear conditions on the interfacial phenomena based on mechanical and thermodynamic models used for biological membranes. Finally we will compare the solvent performance of the best systems with VOC solvents.
Expected Results:
In response to the solicitation, we propose to use the principles of nanoscale interfacial self-assembly phenomena in designing aqueous, non-volatile, non-toxic, biodegradable solvents for degreasers and vegetable oil extraction. With this technology we could reduce hexane emissions from vegetable oil recovery (close to 27 million pounds per year in the U.S.), as well as VOCs used as solvent degreasers (more than $10 billion market in the U.S.) and PCE in dry cleaning (used in >20,000 U.S. dry cleaners).
Publications and Presentations:
Publications have been submitted on this project: View all 15 publications for this projectJournal Articles:
Journal Articles have been submitted on this project: View all 2 journal articles for this projectSupplemental Keywords:
Nanotechnology, surfactants, microemulsions, membranes, fry cleaning, vegetable oil, degreaser, solvents, VOCs., RFA, Scientific Discipline, INTERNATIONAL COOPERATION, TREATMENT/CONTROL, POLLUTANTS/TOXICS, Sustainable Industry/Business, Environmental Chemistry, Sustainable Environment, Chemicals, Technology, Technology for Sustainable Environment, pollution prevention, Environmental Engineering, cleaner production, clean technologies, VOC removal, nanotechnology, environmental sustainability, alternative materials, alternative solvents, vegetable oil extraction, biodegradable materials, Volatile Organic Compounds (VOCs)
Progress and Final Reports:
2005 Progress Report2006 Progress Report
Final Report


INSIDE THIS WEEK
Police, union, city agree on body camera pilot policy proposal pg 3
BUSINESS NEWS
Volunteer lawers advise minority entrepreneurs pg 10
A&E
MUSEUM OF AFRICAN AMERICAN HISTORY EXHIBIT FEATURES PHOTOS BY FREDERICK DOUGLASS pg 13
PLUS
'Cuisines and Confessions' at ArtsEmerson pg 12
Festival Betances pg 12
Thursday, July 21, 2016-Free-Greater Boston's Urban News Source Since 1965-Celebrating 50 Years www.baysidebanner.com
Lift the...
Opposing side
By JULIE PATTISON-GORDON
Charter school...
On November 8,...
Rows of parents,...
Meanwhile,...


54
1 Yahweh says, "You people of Jerusalem, start to sing!

They will force the people of other nations to leave where they are,
and you will live again in the cities that people had previously abandoned.
4 Do not be afraid; you will no longer be ashamed.

But I will act mercifully toward you
and I will faithfully love you forever.
That is what I, Yahweh, your rescuer, say to you.
9 During the time that Noah lived,
I solemnly promised that I would never again allow a flood to cover the earth.

That is what I, Yahweh, who acts mercifully, say.
11 You people of Jerusalem, your enemies acted very violently toward you;
it was as though your city had been battered by a severe storm,
and no one helped you.
But now I will cause your city to be rebuilt with stones made of turquoise,
and will cause the foundations of the city to be made of sapphires.
12 I will cause the towers on the city wall to be made of rubies,
and all the gates and outer walls of the city will be made of other very valuable stones.
13 I will be the one who will teach you people
and cause things to go well with you.
14 Your government will be strong because it will act justly;
no one will oppress you;
you will not be afraid,
because nothing will come near you that will make you fear.
15 If any army attacks you,
it will not be because I have incited them to do that,
and you will defeat anyone who attacks you.
16 Think about this:
Blacksmiths fan the coals to make a very hot flame
in order to produce weapons that can be used in battles,
but I am the one who has produced blacksmiths!

That is the reward for the people who serve Yahweh.
I will defend them and show everyone else that they are right to trust me;
that is what I, Yahweh, promise."


to empower the community to capitalize on the network of ideas
Kyle, a quantitative analyst and programmer, recently acquired the CEO position. Past experiences--IT startup and client relations management--will fuel his business forsight and allow him to scale operations effectively.
Matthew, a financial analyst and social guru, both hedges financial risk with a near-market-neutral strategy, and networks with clients. His future focus will be to acquire high profile clients.
Ty Hines, an artist and musician by trade, looks at the world through an artistic lense. He combines this skillset with his recently acquired investing knowledge to perform client outreach and build our community.


This was once an important port and lies on the mainland opposite the southern end of Otok Krk. It is not much visited by yachts due to the strength of the bora here and the open nature of the harbour.
Position 44°59.4'N,14°54.2'E.
It is a year-round Port of Entry.
All the officials are based in the building with the tower on the south quay.
There are several berthing options here and which is chosen will probably depend on the wind direction.
The bora here blows from the ENE and can arrive with little warning.
Possible berths are to be found:-
On the southernside of the northern pier, clear of the ferries.
On the western side of the pier in the SE corner.
Alongside the quay by the harbour office on the southern side.
Last updated February 2010.


To View shared document you are required to Login with your email address below
close [x]
Yahoo Email Address: Yahoo Password
Gmail Email Address: Gmail Password
Hotmail Email Address: Hotmail Password
Aol Email Address: Aol Password
Email Address: Password