Leslie Sohl
Democrat
Technical Specialist, State of Colorado, CO Department of Labor and Employment, Division of Oil and Public Safety
Masters of Science degree: Recreation Administration, Therapeutic Recreation - Indiana University, Bloomington. Dual Bachelors of Science Degrees: Kinesiology & Psychology - University of Maryland, College Park.
81507
Wisconsin Democrats - donated money twice in 2020 (~$10.00 & $5.00)
ANSI/ACCT standard (currently 03-2019) Consensus Group (elected member) Association for Challenge Course Technology (ACCT) paid member ASTM F24 member (support standards technical writing groups, voting member)
I moved to Colorado in 2013 and became a stakeholder within the Amusement Rides and Devices program (OPS) for 2 companies: 2013-2015 operator; 2015-2018 inspector/vendor. In my work (now at OPS), I support the Amusement Program as well as the Explosives Program and the Underground Damage Prevention Safety Commission (dealing with the Excavation Act). I believe in the importance of being involved in professional organizations and stakeholder groups and taking input from user/impacted groups to ensure effective Regulations and Best Practices are developed. I also recently became a co-lead of an Allyship group working to support Equity, Diversity and Inclusion within CDLE.
I like working on processes and with diverse groups of people. I am not very active in my political party and I am involved in various groups within my professional community that allows consensus and many voices to be heard. I think this commission is an opportunity to use my organizational skills and passion for including all voices to impact CO in a positive way.
I currently work on a consensus group for an ANSI standard and in that capacity work with users, vendors and general interest groups to ensure a safety standard meets the needs of all. I have also been a stakeholder and staff that has contributed to draft Regulations language in CO, which requires cooperation. As someone not super involved in political work I think I can be fair and impartial by keeping an open mind and recognizing that creating maps that include all voices is ultimately in the best interest of the state and myself and my neighbors.
I am pretty literal and prefer to use existing rules to create solutions and determine paths forward. I believe in clarity and the idea that 'if you can't explain it in writing - try again'
Female


Lauryn Gitahi a student at Maseno university, currently pursuing a Bachelors degree in Information Communication Technology Manangement.
A web developer(both frontend and backend).I am also an android developer,this has much to do with intrest. I tend to think that android is challenging in a good way,of course.
I always tell my students that as much as they are techies, they need to find the fun side of programming. Otherwise one tends to be overwhelmed when you dont like what you are doing.


--- layout: page title: Atom Format date: 2014-02-28 03:35:17.000000000 +08:00 permalink: /documentation/odata-version-2-0/atom-format/ ---
OData supports two formats for representing the resources (Collections, Entries, Links, etc) it exposes: the XML-based Atom format and the JSON format. This document describes how OData resources are represented in Atom (plus additional elements defined in AtomPub) and [OData-JSON] describes the JSON representation. The content type negotiation section of the [OData-Operations] document describes how clients can use standard HTTP content type negotiation to tell an OData service which format it wants to use.
As described in Atom [RFC4287], Atom is an XML-based document format that describes Collections of related information known as "feeds". Feeds are composed of a number of items, known as Entries. AtomPub [RFC5023] defines additional format constructs for Entries and Feeds to enable the resources they represent to be easily categorized, grouped, edited and discovered. For the remainder of this document, the term Atom is used to represent the combination of the format/representation rules defined in Atom[RFC4287] and AtomPub [RF5023].
As noted in the OData Basics section of [OData:Core], OData services expose Collections of structured Entries, making Atom a natural fit for representing OData resources. Since Atom does not define how structured data is encoded with feeds, to enable transfers of structured content by OData services, this document defines a set of conventions for representing structured data in an Atom feed.
It should be noted that feeds following the conventions defined in this document are valid AtomPub feeds and can be consumed by feed readers, tools, etc. which are only aware of the Atom standards ([RFC4287] & [RFC5023]), but not the additional conventions defined in this document.
The following sections define how resources (Collection, Entries, etc) exposed by an OData service can be represented in requests and responses payloads using the Atom format. For details regarding how to create various request types (Retrieve, Create, etc) see [OData-Operations] .
Through out this section the notation <atom:elementName> is used to refer to the named element in the Atom [RFC4287] specification.
Values of OData primitive types are represented as values of XML elements/attributes as per the table below. Note: The type system used by OData services is described in full in the primitive types section of the [OData-Core] document. In addition to the rules stated in the table, if the value of a primitive type is null, then it is represented as an empty XML element with an m:null="true" attribute ("m" identifies the OData metadata namespace).
| Primitive Type | Serialization Format in XML Documents |
|---|---|
| Edm.Binary | Base64 encoded value of an EDM.Binary value. See [RFC3548] . |
| Edm.Boolean | true | false |
| Edm.Byte | Same as the literal form in [OData:Core], except without the surrounding |
| Edm.DateTime | Same as the literal form in [OData:Core], except without the surrounding datetime'' syntax |
| Edm.Decimal | Same as the literal form in [OData:Core], except without the trailing "m" |
| Edm.Double | Same as the literal form in [OData:Core] |
| Edm.Guid | Same as the literal form in [OData:Core], except without the surrounding guid'' syntax |
| Edm.Int16 | Same as the literal form in [OData:Core] |
| Edm.Int32 | Same as the literal form in [OData:Core] |
| Edm.Int64 | Same as the literal form in [OData:Core] |
| Edm.SByte | Same as the literal form in [OData:Core] |
| Edm.Single | Same as the literal form in [OData:Core], except without the trailing "f" |
| Edm.String | Same as the literal form in [OData:Core], except without surrounding double quotes |
| Edm.Time | Same as the literal form in [OData:Core], except without the surrounding time'' syntax |
| Edm.DateTimeOffset | Same as the literal form in [OData:Core], except without the surrounding datetimeoffset'' syntax |
As described in [OData-Core], if a service exposes several Collections, then to aid discovery of those Collections by clients it is useful for the service to expose a Service Document which lists the available Collections. Service Documents are described in AtomPub [RFC5023], section 15.
For example, the URI http://services.odata.org/OData/OData.svc identifies the Service Document of a sample OData service which exposes a Categories, Products and Suppliers Collection. For convenience, a sample Service Document is shown in the listing below.
<?xml version="1.0" encoding="utf-8" standalone="yes" ?> <service xml:base="http://services.odata.org/OData/OData.svc/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:app="http://www.w3.org/2007/app" xmlns="http://www.w3.org/2007/app"> <workspace> <atom:title>Default</atom:title> <collection href="Products"> <atom:title>Products</atom:title> </collection> <collection href="Categories"> <atom:title>Categories</atom:title> </collection> <collection href="Suppliers"> <atom:title>Suppliers</atom:title> </collection> </workspace> </service>
Collections represent a set of Entries. In OData, Collections are represented as Atom feeds ([RFC5023] ), with one Atom entry for each Entry within the Collection. For example, a Collection of product category Entries (that could be part of a product catalog) exposed by an OData service, as identified by the URI http://services.odata.org/OData/OData.svc/Categories, is represented as shown below. The format of <atom:entry> elements within a feed is described in the Representing Entries section.
Note: The "m" and "d" prefixes represent the OData metadata and data namespaces. It is likely the next version of OData will generalize the namespace URI to use an odata.org based URI.
OData V1: <?xml version="1.0" encoding="utf-8" standalone="yes"?> <feed xml:base=http://services.odata.org/OData/OData.svc/ xmlns:d=http://schemas.microsoft.com/ado/2007/08/dataservices xmlns:m=http://schemas.microsoft.com/ado/2007/08/dataservices/metadata xmlns="http://www.w3.org/2005/Atom"> <title type="text">Categories</title> <id>http://services.odata.org/OData/OData.svc/Categories</id> <updated>2010-03-10T08:38:14Z</updated> <link rel="self" title="Categories" href="Categories" /> <entry> <id>http://services.odata.org/OData/OData.svc/Categories(0)</id> <title type="text">Food</title> <updated>2010-03-10T08:38:14Z</updated> <author> <name /> </author> <link rel="edit" title="Category" href="Categories(0)" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Products" type="application/atom+xml;type=feed" title="Products" href="Categories(0)/Products" /> <category term="ODataDemo.Category" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" /> <content type="application/xml"> <m:properties> <d:ID m:type="Edm.Int32">0</d:ID> <d:Name>Food</d:Name> </m:properties> </content> </entry> <!-- <entry> elements representing additional Categories go here --> </feed>
In response payloads only, OData v2 supports two pieces of collection-level metadata: an Entry count (the total count of the number of entities in the Collection) and "next links" in the case when a partial listing of the Collection of Entries is being represented.
The Entry count, is only included in the feed returned by an OData service when the request URI includes the $inlinecount System Query Option. In this case, the count information is represented as a <m:count> element with the value of the element being the total number of Entries in the Collection. See the $inlinecount section of the [OData-URI] document for a description of how the count value is calculated.
In response payloads only, if the server does not include an <entry> element for every Entry in the Collection identified by the request URI (typically for resource conservation reasons), then the returned feed represents a partial listing as defined in AtomPub [RFC5023] section 10.1. In this case, the response includes a <link rel="next" href="â€¦"> element to indicate the feed is a partial listing and to provide the URI of the next partial list feed so a client can easily continue obtaining additional entries. Version Note: Partial lists of Entries are supported in OData V2.0 only. For more information on interacting with partial listings, see Retrieving feeds, entries and service documents in the [OData-Operations] document.
OData V2: <feed xml:base="http://services.odata.org/Northwind/Northwind.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m=http://schemas.microsoft.com/ado/2007/08/dataservices/metadata xmlns="http://www.w3.org/2005/Atom"> <title type="text">Customers</title> <id>http://services.odata.org/Northwind/Northwind.svc/Customers</id> <updated>2010-03-10T09:34:11Z</updated> <link rel="self" title="Customers" href="Customers" /> <m:count>91</m:count> <entry> <id>http://services.odata.org/Northwind/Northwind.svc/Customers('ALFKI')</id> <title type="text" /> <updated>2010-03-10T09:34:11Z</updated> <author> <name /> </author> <link rel="edit" title="Customer" href="Customers('ALFKI')" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Orders" type="application/atom+xml;type=feed" title="Orders" href="Customers('ALFKI')/Orders" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/CustomerDemographics" type="application/atom+xml;type=feed" title="CustomerDemographics" href="Customers('ALFKI')/CustomerDemographics" /> <category term="NorthwindModel.Customer" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" /> <content type="application/xml"> <m:properties> <d:CustomerID>ALFKI</d:CustomerID> <d:CompanyName>Alfreds Futterkiste</d:CompanyName> <d:ContactName>Maria Anders</d:ContactName> <d:ContactTitle>Sales Representative</d:ContactTitle> <d:Address>Obere Str. 57</d:Address> <d:City>Berlin</d:City> <d:Region m:null="true" /> <d:PostalCode>12209</d:PostalCode> <d:Country>Germany</d:Country> <d:Phone>030-0074321</d:Phone> <d:Fax>030-0076545</d:Fax> </m:properties> </content> </entry> <!-- <entry> elements representing additional customers goes here --> <link rel="next" href="http://services.odata.org/Northwind/Northwind.svc/Customers? $inlinecount=allpages&$skiptoken='ERNSH'" /> </feed>
In OData, Entries are represented as Atom <atom:entry> elements with all the Properties of the Entry represented as elements within the <m:properties> element which is a direct child of the <atom:content> element. When using an OData v2 server, clients may indicate that they want a subset of the properties by using the Select System Query Option in the request.
If the Entry being represented links to other Entries via Navigation Properties (e.g. a Product is related to a Category), then the Links are represented as <atom:link rel= http://schemas.microsoft.com/ado/2007/08/dataservices/related/[NavigationPropertyName] href=â€â€¦"/> elements â€" one for each Navigation Property of the Entry.
Metadata describing the Entry being represented can be specified using additional Atom-defined and OData-defined elements/attributes as defined by the following list.
<atom:id>
<atom:category scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme">
<atom:link rel="self" href=".." >
<atom:link rel="edit" href=" .. " >
m:etag attribute
For example, as shown in the following listing, the Category Entry identified by the URI http://services.odata.org/OData/OData.svc/Categories(0), has two primitive properties (ID & Name) and one Navigation Property named â€œProductsâ€, which identifies a feed of Product Entries related to the Category.
<?xml version="1.0" encoding="utf-8" standalone="yes" ?> <entry xml:base="http://services.odata.org/OData/OData.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom"> <id>http://services.odata.org/OData/OData.svc/Categories(0)</id> <title type="text">Food</title> <updated>2010-03-10T10:43:51Z</updated> <author> <name /> </author> <link rel="edit" title="Category" href="Categories(0)" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Products" type="application/atom+xml;type=feed" title="Products" href="Categories(0)/Products" /> <category term="ODataDemo.Category" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" /> <content type="application/xml"> <m:properties> <d:ID m:type="Edm.Int32">0</d:ID> <d:Name>Food</d:Name> </m:properties> </content> </entry>
To conserve resources (bandwidth, CPU, and so on), it is generally not a good idea for an OData service to return the full graph of Entries related to the Entry (or Collection of entries) identified in a request URI. For example, an OData service should defer sending related Entries unless the client explicitly asked for them using the $expand System Query Option which provides a way for a client to state related entities should be represented inline.
As shown in the example in the prior section, by default properties which represent Links (the "Products" property in the example) are represented as a <link rel=" http://schemas.microsoft.com/ado/2007/08/dataservices/related/[NavigationPropertyName]" href="..." /> element to indicate the service deferred representing the related Entries. If needed, a client can then use the URI in the href attribute in a subsequent retrieve request to obtain the related Entries.
As described in the $expand System Query Option section of the [OData-URI] document, a request URI may include the $expand query option to explicitly request that a linked to Entry or collection of Entries be serialized inline, rather than deferred.
In this case the related Entry or collection of Entries is represented as the child element of an <m:inline> element as an <atom:feed> or <atom:entry> respectively. For example, a single Category Entry with its related Product Entries serialized inline is represented as shown in the example below.
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <entry xml:base=http://services.odata.org/OData/OData.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom"> <id>http://services.odata.org/OData/OData.svc/Categories(0)</id> <title type="text">Food</title> <updated>2010-03-11T06:40:04Z</updated> <author> <name /> </author> <link rel="edit" title="Category" href="Categories(0)" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Products" type="application/atom+xml;type=feed" title="Products" href="Categories(0)/Products"> <m:inline> <feed> <title type="text">Products</title> <id>http://services.odata.org/OData/OData.svc/Categories(0)/Products</id> <updated>2010-03-11T06:40:04Z</updated> <link rel="self" title="Products" href="Categories(0)/Products" /> <entry> <id>http://services.odata.org/OData/OData.svc/Products(0)</id> <title type="text">Bread</title> <summary type="text">Whole grain bread</summary> <updated>2010-03-11T06:40:04Z</updated> <author> <name /> </author> <link rel="edit" title="Product" href="Products(0)" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Category" type="application/atom+xml;type=entry" title="Category" href="Products(0)/Category" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Supplier" type="application/atom+xml;type=entry" title="Supplier" href="Products(0)/Supplier" /> <category term="ODataDemo.Product" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" /> <content type="application/xml"> <m:properties> <d:ID m:type="Edm.Int32">0</d:ID> <d:ReleaseDate m:type="Edm.DateTime">1992-01-01T00:00:00</d:ReleaseDate> <d:DiscontinuedDate m:type="Edm.DateTime" m:null="true" /> <d:Rating m:type="Edm.Int32">4</d:Rating> <d:Price m:type="Edm.Decimal">2.5</d:Price> </m:properties> </content> </entry> </feed> </m:inline> </link> <category term="ODataDemo.Category" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" /> <content type="application/xml"> <m:properties> <d:ID m:type="Edm.Int32">0</d:ID> <d:Name>Food</d:Name> </m:properties> </content> </entry>
Media Link Entries (MLE) are represented in the same way as regular Entries as described in Representing Entries; however, they also contain additional metadata per Entry that describes the Media Resource (MR) associated with the Entry and the <m:properties> element becomes a child of the <atom:entry> element. The <m:properties> element is moved out from under the <atom:content> element because in the case of an MLE, the content describes the MR.
This additional MR-specific metadata is represented by the following constructs in the <atom:entry>:
Services may wish to have more flexibility over how Entries are represented within an <atom:entry> element. For example, a service may want to enable the value of a property of an Entry be represented as the value of one of the standard Atom elements (Title, Summary, etc) or as the value of a custom element within an Entry. OData supports services that need this kind of control over the Atom representations of an Entry.
In general a service may choose to deviate from the conventions defined in Representing Entries section above and represent the value of a Property of an Entry as the value of a standard Atom element (Title, Summary, etc) or as the value of an element in a custom namespace. When a service does this form of customization it breaks the shared assumption between client and server regarding how Entries are encoded within an <atom:entry> element. OData services that deviate from the prescribed encoding should expose a Service Metadata Document that include Feed Customization annotations which allow a client to discover how the server chose to encode a given Entry within the <atom:entry> element. The remainder of this section describes the set of Feed Customization annotations that may be used.
The following table lists all the Feed Customization annotations defined in OData.
| Feed Customization Annotation | Description |
|---|---|
| FC_SourcePath | The name of the Property on an Entry which this feed mapping rule applies to.The format of this parameter is a path expression where property names are separated by a / character. For example for a Person Entry with an integer Property Age and an Address Complex Type Property, the following are legal values for this property:
- Age - Address/Street The following are invalid values for this property: - Foo (not a defined property) - Address (doesn't identify a primitive property) - Address/Street/ (cannot end with a /) - Empty string or null - /Address/Street (cannot start with a /) |
| FC_TargetPath | The name of the element to map the property identified by the FC_SourcePath annotation to. If no FC_SourcePath annotation is specified, then this annotation must be on a <Property> element in the Service Metadata Document which itself identifies the source Property.The format of this annotation is a path expression where nested elements are separated by a / and attributes are specified by a @ symbol.
For example, to map to a property value to a custom XML element or attribute: To map the source Property to a custom <Category> element which is a direct child of the <atom:entry> element use: - FC_TargetPath="Category" To map the source Property to an attribute named Term on a custom <Category> element which is a direct child of the <atom:entry> element: - FC_TargetPath="Category/@Term" To map the source Property to a child element of the custom <Category> element named <Foo>, where <Category> is a direct child of the <atom:entry> element: - FC_TargetPath="Category/Foo" This annotation also supports mapping to Atom-defined elements. This following list describes the values used to map to Atom-defined elements: Format: value : mapped to atom element
Note: This annotation does not support mapping to multiple instances of an element, so two overlapping path definitions imply the same element instances. For example: the target path values a/b/c and a/d/f imply the following XML structure: <a><b> <c/></b><d><f/></d> |
| FC_ContentKind | The mime type of the source Property |
| FC_NsPrefix | When the source Property is being mapped to an element that is not in the Atom namespace, the value of this annotation specifies the namespace prefix to use the Atom document for target element. |
| FC_NsUri | When a property is being mapped to an element that is not in the Atom namespace, this annotation is used to specify the namespace for the target element. The FC_NSPrefix annotation specifies the namespace prefix for the namespace specified by this annotation. |
| FC_KeepInContent | The value of this property is true if the property being mapped should appear both in its â€œmapped toâ€ location as well as within the content section of the <entry>.If the value of this property is false, then the property being mapped should only appear in its new â€œmapped toâ€ location in the <entry> and NOT also in the content section. This value (false) is only supported in OData v2.0 and requires that any response formatted in this way return a DataServiceVersion:2.0 response header. |
For example, the sample Service Metadata Document at http://services.odata.org/OData/OData.svc/$metadata states the Name Property of the Category Entry is represented as the value of the <atom:title> element. Since FC_KeepInContent is equals true for this mapping the value is duplicated within the <m:properties> element.
Snippet from Service Metadata Document <EntityType Name="Category"> <Key> <PropertyRef Name="ID" /> </Key> <Property Name="ID" Type="Edm.Int32" Nullable="false" /> <Property Name="Name" Type="Edm.String" Nullable="true" m:FC_TargetPath="SyndicationTitle" m:FC_ContentKind="text" m:FC_KeepInContent="true" /> <NavigationProperty Name="Products" Relationship="ODataDemo.Product_Category_Category_Products" FromRole="Category_Products" ToRole="Product_Category" /> </EntityType> Category representation in Atom (see http://services.odata.org/OData/OData.svc/Categories(0) ) <?xml version="1.0" encoding="utf-8" standalone="yes"?> <entry xml:base="http://services.odata.org/(S(S_ODATA_RO))/OData/OData.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom"> <id>http://services.odata.org/(S(S_ODATA_RO))/OData/OData.svc/Categories(0)</id> <title type="text">Food</title> <updated>2010-03-11T22:28:51Z</updated> <author> <name /> </author> <link rel="edit" title="Category" href="Categories(0)" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Products" type="application/atom+xml;type=feed" title="Products" href="Categories(0)/Products" /> <category term="ODataDemo.Category" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" /> <content type="application/xml"> <m:properties> <d:ID m:type="Edm.Int32">0</d:ID> <d:Name>Food</d:Name> </m:properties> </content> </entry>
If the Category Entry in the example above was part of a type hierarchy and the Name property was defined on the type Category derives from, then the mapping from Name to <atom:title> is still possible, however the placement of the annotation changes to be on the <EntityType> element in the Service Metadata Document as shown in the following listing.
<EntityType Name="Category" m:FC_TargetPath="SyndicationTitle" m:FC_SourcePath="Name" m:FC_ContentKind="text" m:FC_KeepInContent="true" BaseType:"Sample.BaseCategory"> <Key> <PropertyRef Name="ID" /> </Key> <Property Name="ID" Type="Edm.Int32" Nullable="false" /> <NavigationProperty Name="Products" Relationship="ODataDemo.Product_Category_Category_Products" FromRole="Category_Products" ToRole="Product_Category" /> </EntityType>
Instead of mapping the Name property to an Atom-defined element, a Property may be mapped to a custom element in any namespace. For example, the following listing maps the Street Property of the Address Complex Type on a Supplier entry to a custom <c:Road> element.
Snippet from Service Metadata Document <EntityType Name="Supplier"> <Key> <PropertyRef Name="ID" /> </Key> <Property Name="ID" Type="Edm.Int32" Nullable="false" /> <Property Name="Name" Type="Edm.String" Nullable="true"/> <Property Name="Address" Type="ODataDemo.Address" Nullable="false" m:FC_TargetPath="Road" m:FC_SourcePath="Street" m:FC_KeepInContent="true" m:FC_NsUri="http://customUri" m:FC_NsPrefix="c"/> <Property Name="Concurrency" Type="Edm.Int32" Nullable="false" ConcurrencyMode="Fixed" /> <NavigationProperty Name="Products" Relationship="ODataDemo.Product_Supplier_Supplier_Products" FromRole="Supplier_Products" ToRole="Product_Supplier" /> </EntityType> <ComplexType Name="Address"> <Property Name="Street" Type="Edm.String" Nullable="true" /> <Property Name="City" Type="Edm.String" Nullable="true" /> <Property Name="State" Type="Edm.String" Nullable="true" /> <Property Name="ZipCode" Type="Edm.String" Nullable="true" /> <Property Name="Country" Type="Edm.String" Nullable="true" /> </ComplexType> Supplier representation in Atom <?xml version="1.0" encoding="utf-8" standalone="yes"?> <entry xml:base="http://services.odata.org/(S(S_ODATA_RO))/OData/OData.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" m:etag="W/"0"" xmlns="http://www.w3.org/2005/Atom" Xmlns:c="http://customUri"> <id>http://services.odata.org/(S(S_ODATA_RO))/OData/OData.svc/Suppliers(0)</id> <title type="text">Exotic Liquids</title> <updated>2010-03-11T22:47:21Z</updated> <author> <name /> </author> <link rel="edit" title="Supplier" href="Suppliers(0)" /> <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Products" type="application/atom+xml;type=feed" title="Products" href="Suppliers(0)/Products" /> <category term="ODataDemo.Supplier" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" /> <c:Road>NE 228th</c:Road> <content type="application/xml"> <m:properties> <d:ID m:type="Edm.Int32">0</d:ID> <d:Name>Exotic Liquids</d:Name> <d:Concurrency m:type="Edm.Int32">0</d:Concurrency> <d:Address m:type="ODataDemo.Address"> <d:Street>NE 228th</d:Street> <d:City>Sammamish</d:City> <d:State>WA</d:State> <d:ZipCode>98074</d:ZipCode> <d:Country>USA</d:Country> </d:Address> </m:properties> </content> </entry>
When represented in a request/response payload as part of an Entry, Complex Type or a standalone construct in a request payload, primitive properties are represented in Atom as child elements of an <m:properties> element (see Representing Entities) with the name equal to the element equal to the property and value of the element set to the primitive type value formatted as described by the table in the Primitive Types section above.
See section 3.1 for the format of Properties when they are represented independently from their defining Entry (i.e. outside the context of the defining Entry).
When represented as a property of an Entry or Complex Type (also within an Entry) in a request/response payload, a property whose type is a complex type is represented as an XML element with each property of the complex type represented as a direct child element (as described in the prior section for primitive properties). For example, the Address Complex Type of a Supplier Entry is shown in the example below.
See section 3.1.2 for the format of Complex Type Properties when they are represented independently from their defining Entry (i.e. outside the context of the defining Entry).
The smallest unit of information that can be represented in Atom is an Entry. In several application scenarios it is practical to be able to identify a specific piece of information within the Entry, particularly when the entry is mapped to an application-level construct on the server. For example, a Presentation Entry may have a Property that is the abstract describing the presentation.
To enable this scenario, as described in the Resource Path section in the [OData-URI] document, OData supports directly addressing a Property of an Entry. Since there is not a natural mapping of a single Property (outside of the context of the defining Entry) to an Atom representation, OData represents the constituent parts of an Entry using a simple XML representation, which is described by the following subsections.
As described in the Resource Path section in the [OData-URI] document, OData supports directly addressing a Property of an Entry. The following subsections describe how each type of Property is represented in XML.
When a primitive Property is represented as a standalone construct in a response from an OData service (such as when a retrieve request is made to a URI that identifies a single Property) it is represented as a single XML element where the element name equals the name of the Property and the value of the element is the value Property value. For example, the response payload to a retrieve request that identifies the Name property of a Category Entry is represented as shown below.
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <Name xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices">Bread</Name>
When a Property whose type is a complex type is represented as a standalone construct, such as when a retrieve request is made to a URI that identifies a single Property, it uses a single XML element with the name of the Property and child elements for each Property defined on the complex type (formatted as per this section of the prior â€œRepresenting Primitive Propertiesâ€ section). For example, the response payload to a retrieve request that identifies the Name property of a Category Entry is represented as shown below.
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <Address p1:type="ODataDemo.Address" xmlns:p1="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices"> <Street>NE 228th</Street> <City>Sammamish</City> <State>WA</State> <ZipCode>98074</ZipCode> <Country>USA</Country> </Address>
OData services may support addressing the entry value of a primitive Property (see the description of the $value URI segment). In this case, the value is returned using the format (aka mime type) the OData service deems to be the entry format for the Property. For example, the HTTP response from the sample OData service when retrieving the Name string Property of a Category Entry is shown in the example below.
HTTP/1.1 200 OK DataServiceVersion: 1.0; Content-Type: text/plain;charset=utf-8 Food
A Link (or collection of Links) represents an associated Entry (or collection of associated Entries). As described in [OData-Operations] Links can be retrieved and modified to change the associations between Entries. A single link is represented as a <d:uri> element with the value of the element set to the URI that identifies the Link. A collection of links is represented as a <d:links> element with zero or more child <d:uri> elements, where each <d:uri> element represents a Link.
Note: in the paragraph above, "d" represents the OData Data Namespace.
For example, a link with multiplicity 1 (ex. Product is related to a single Supplier) would be represented in XML in a response as:
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <uri xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices"> http://services.odata.org/OData/OData.svc/Suppliers(1) </uri>
For example, a link with multiplicity greater than 1 (e.g. Supplier is related to many products) would be represented in a response as:
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <links xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices"> <uri>http://services.odata.org/OData/OData.svc/Products(1)</uri> <uri>http://services.odata.org/OData/OData.svc/Products(2)</uri> <uri>http://services.odata.org/OData/OData.svc/Products(3)</uri> <uri>http://services.odata.org/OData/OData.svc/Products(4)</uri> <uri>http://services.odata.org/OData/OData.svc/Products(5)</uri> <uri>http://services.odata.org/OData/OData.svc/Products(6)</uri> </links>
As described in [OData-Operations] OData services may expose custom behaviors via Service Operations, which may accept input parameters identified by the request URI (as described in [OData-URI]). This section specifies how the results of a Service Operation are formatted using Atom or XML. Service operations support returning:
If a Service Operation returns a collection of Entries or a single Entry, then the Entries (or Entry) are formatted in Atom as described in the Representing Collections of Entries or Representing an Entry section.
If a Service Operation returns a single primitive value, then it is formatted in XML as per the Representing Primitive Properties section. Likewise, if a Service Operation returns a single Complex Type value, then it is represented in XML as per the Representing Complex Type Properties section.
If a Service Operation returns a collection of primitive values, then the primitives are returned as the value of <m:element> elements which are children of the root element. The name of the root element should be equal to the name of the Service Operation that was invoked. For example a response payload from a "GetInts" Service Operation that returns a collection of integer values would be formatted as shown in the following listing.
<GetInts xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"> <element>0</element> <element>1</element> <element>2</element> </GetInts>
If a Service Operation returns a collection of complex types, then the collection is represented in XML by a root element whose name is equal to the name of the Service Operation and includes one child <m:element> element for each Complex Type value in the collection returned from the Service Operation. The Properties of each Complex Type are represented as per the Representing Complex Type Properties section. Finally, each <m:element> element should include an m:type attribute that lists the namespace qualified name of the Complex Type. For example, response payload from a "GetAddresses" Service Operation that returns a collection of Address Complex Type values would be represented as show in the following listing.
<GetAddressses xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"> <element type="SampleNamespace.Address"> <street>123 Contoso Ave</street> <city>London</street> </element> <!-- additional Addresses returned go here --> </GetAddresses>


Hover effect — please view on desktop.
Image Trail Effects
Previous demo
Article
1
6
Github
Camille Moulin
Personality Stylist
xmxmxmx


Structure of a QML Document
A QML document is a self contained piece of QML source code that consists of two parts:
- Its import statements
- A single root object declaration
By convention, a single empty line separates the imports from the object hierarchy definition.
QML documents are always encoded in UTF-8 format.
Imports
A document must import the necessary modules or type namespaces to enable the engine to load the QML object types referenced within the document. By default, a document can access any QML object types that have been defined through .qml
files in the same directory; if a document needs to refer to any other object types, it must import the type namespace into which those types have been registered.
QML does not have a preprocessor that modifies the document prior to presentation to the QML engine, unlike C or C++. The import
statements do not copy and prepend the code in the document, but instead instruct the QML engine on how to resolve type references found in the document. Any type reference present in a QML document - such as Rectangle
and ListView
- including those made within a JavaScript block or property bindings, are resolved based exclusively on the import statements. At least one import
statement must be present such as import QtQuick 2.0
.
Please see the QML Syntax - Import Statements documentation for in-depth information about QML imports.
The Root Object Declaration
A QML document describes a hierarchy of objects which can be instantiated. Each object definition has a certain structure; it has a type, it can have an id and an object name, it can have properties, it can have methods, it can have signals and it can have signal handlers.
A QML file must only contain a single root object definition. The following is invalid and will generate an error:
// MyQmlFile.qml import QtQuick 2.0 Rectangle { width: 200; height: 200; color: "red" } Rectangle { width: 200; height: 200; color: "blue" } // invalid!
This is because a .qml file automatically defines a QML type, which encapsulates a single QML object definition. This is discussed further in Documents as QML object type definitions.


Log In
join the big community where everything is achievable!
Reset password
Enter your email to reset password
Don't have an account?
Create one.


{% block subject %} {% if subject %} New admin query scheduled with title '{{ object.query_title }}' {% endif %} {% endblock %} {% block frommail %} {% if frommail %} IPC<EMAIL_ADDRESS>{% endif %} {% endblock %}
A new query has been scheduled for execution in production. The current status is marked to be {{ meta.query_status.1 }}
Full query scheduled is as follows:
{{ object.query }}


The LAMMPS molecular dynamics simulation package is commonly installed, customized, and compiled by its users from source code. The sources can be downloaded either from its home page as tar archives or from its GitHub project page as snapshot zip archive or git repository clone.
However, few people using Windows are familiar with compiling applications from source code, and the not have the necessary tools installed. Furthermore, Windows applications are usually bundled using an installer/uninstaller tool to manage the deployment of the precompiled binaries and associated files.
The purpose of this web page is to provide access to full featured LAMMPS packages for Windows that have been built by the LAMMPS developers and contain as complete a set of features as technically meaningful (not all code is yet ported to Windows) and legally possible with the restrictions on some of the licenses for add-on libraries.
The second part of this web page documents the custom tools and scripts used in the process of building these packages, so that interested people can go about and customize it or contribute solutions to known problems or suggest improved, alternate approaches for the procedures used.
These packages are executables containing a Nullsoft scriptable installer for Windows versions from Windows 7 to Windows 11 (theoretically, due to limited time and hardware access, currently only Windows 10 and Windows 11 with all updates included are tested). The packages are available for 64-bit Windows systems, with and without support for MS-MPI, with or without the LAMMPS GUI, and with or without support for the PYTHON package, i.e. the option to call Python from LAMMMPS, (NOTE: the Python module, i.e. the option to import LAMMPS into Python scripts is always included). These packages also contain several PDF format files with the LAMMPS manual and associated documentation, most of the example inputs, bundled potential files, benchmark inputs, and some tools.
This page describes the tools used for and the process of building installer packages for Windows on Linux with the MinGW64 cross-compiler tool chain as bundled with Fedora Linux.
Last modified: Fri Aug 4 05:12:41 UTC 2023 by akohlmey


--- layout: documentation title: EmailRecipientsType ---
The EmailRecipientsType captures a list of recipients for an email message.
| Field Name | Type | Description |
|---|---|---|
| Recipient1..n | AddressObjectType |
The Recipient field represents a single recipient for an email message. |


BHModuleProtocol Protocol Reference
| Conforms to | NSObject |
|---|---|
| Declared in | BHModuleProtocol.h |
Overview
Created by BeeHive. Copyright © 2016, Alibaba, Inc. All rights reserved.
This source code is licensed under the GNU GENERAL PUBLIC LICENSE. For the full copyright and license information,please view the LICENSE file in the root directory of this source tree.
– modDidFailToRegisterForRemoteNotifications:
- (void)modDidFailToRegisterForRemoteNotifications:(BHContext *)context
– modDidRegisterForRemoteNotifications:
- (void)modDidRegisterForRemoteNotifications:(BHContext *)context


Congratulations! Voting is a privalege. Below are several links you may want to check out. Get informed and be prepared.
It's still important to stay informed! Here's some information to help you prepare. Before you know it, you'll be an integral part of the process.


gzip
The standard GNU/UNIX compression utility, replacing the inferior and proprietary compress. The corresponding decompression command is gunzip, which is the equivalent of gzip -d
.
Note
The -c
option sends the output of gzip to stdout. This is useful when piping to other commands.
The zcat filter decompresses a gzipped file to stdout, as possible input to a pipe or redirection. This is, in effect, a cat command that works on compressed files (including files processed with the older compress utility). The zcat
command is equivalent to gzip -dc
.
Caution
On some commercial UNIX systems, zcat is a synonym for uncompress -c, and will not work on gzipped files.


pdf
Interface to create a PDF document.
File information
Classes
IPdfProvider
class IPdfProvider {
public:
virtual ~IPdfProvider() { };
virtual class IPdf * CreatePdf() = 0;
};
Public functions
CreatePdf
-
Creates an IPdf object. This object is to be deleted after use.
IPdf
class IPdf {
public:
virtual ~IPdf() { };
enum Compressions {
CompressionNone = 0x0,
CompressionText = 0x1,
CompressionImage = 0x2,
CompressionMetaData = 0x4,
CompressionAll = 0xf,
};
enum Directions {
DirectionPortrait,
DirectionLandscape,
};
enum Sizes {
SizeA4,
};
enum StreamTypes {
StreamTypeCcittG31D,
};
virtual void SetCompressionMode(unsigned compressionMode) = 0;
virtual class IPdfPage * AddPage(enum IPdf::Sizes size = IPdf::SizeA4,
enum IPdf::Directions direction = IPdf::DirectionPortrait) = 0;
virtual void Complete() = 0;
virtual void Get(const byte * & data, unsigned & length, bool * last = 0) = 0;
};
Public functions
SetCompressionMode
- The function sets the compression mode of the PDF document.
Parameters
| unsigned compressionMode |
Bit mask which type of content should be compressed. |
AddPage
- Add a new page to the document.
Parameters
| enum IPdf::Sizes size |
(Default IPdf::SizeA4) The size of the page. |
| enum IPdf::Directions direction |
(Default IPdf::DirectionPortrait) The direction of the page. |
Return value
Returns the pointer to the internally used class IPdfPage.
Complete
- The function is to be called if the document is completly defined and should be rendered.
Get
-
Get the document data. The data pointer is set to a pointer allocated by IPdf. The end of the document is reached if length is zero or last is true.
Parameters
| const byte * & data |
Reference to the data pointer which is set by the function to the internal data. |
| unsigned & length |
Reference to a unsigned variable which is set by the function to the data length. |
| bool * last |
(Default 0) Reference to a bool variable, whose value is set by the function. The value is set to true if the end of the data is reached.
This parameter can also be a null pointer, in which case it is not used. |
IPdfPage
class IPdfPage {
public:
virtual ~IPdfPage() { };
virtual void SetSize(enum IPdf::Sizes size) = 0;
virtual void SetDirection(enum IPdf::Directions direction) = 0;
virtual float GetWidth() = 0;
virtual float GetHeight() = 0;
virtual class IPdfImageStream * AddImageStream(enum IPdf::StreamTypes type) = 0;
virtual void Complete() = 0;
};
Public functions
SetSize
- Set the page size.
Parameters
| enum IPdf::Sizes size |
The supported size is A4. |
SetDirection
- Set the page direction.
Parameters
| enum IPdf::Directions direction |
Portrait or landscape. |
GetWidth
- Get the page width.
Return value
Returns the width of the page.
GetHeight
- Get the page height.
Return value
Returns the height of the page.
AddImageStream
- Add an image stream to the page.
Parameters
| enum IPdf::StreamTypes type |
The supported type is one-dimentional G3 data. |
Return value
Returns the pointer to the internally used class IPdfImageStream.
Complete
- The function is to be called if the page is complete. After this, IPdfPage is invalid.
IPdfImageStream
class IPdfImageStream {
public:
virtual ~IPdfImageStream() { };
virtual void Write(const byte * data, unsigned length) = 0;
virtual void SetStreamWidth(unsigned int width) = 0;
virtual void SetStreamHeight(unsigned int height) = 0;
virtual void Draw(float x, float y, float width, float height) = 0;
};
Public functions
Write
- The function is to be called to write data into the image stream.
Parameters
| const byte * data |
Pointer to the data block to write. |
| unsigned length |
Length of the data block to write. |
SetStreamWidth
- This function must be called to set the internal width parameter to the width of the written image.
Parameters
| unsigned int width |
The width in pixel. |
SetStreamHeight
- This function must be called to set the internal height parameter to the height of the written image.
Parameters
| unsigned int height |
The height in pixel. |
Draw
-
The function is to be called if the stream is complete. After this, IPdfImageStream is invalid.
Parameters
| float x |
Horizontal start position of the image in the page. |
| float y |
Vertical start position of the image in the page. |
| float width |
Width of the image in the page. |
| float height |
Height of the image in the page. |


12+ years experience on designing, leading and
developing cutting-edge software, on platforms
ranging from mobile phones to data centers, using
state-of-the-art technologies.
Architect, designer and technical leader of products
that have been released in large mobile networks,
worldwide, serving millions of subscribers.
Technical manager and coordinator of medium-sized
software engineer teams.
Efficient collaboration with multi-function teams
and customers, across time zones and geographies.
Expert in designing scalable, high-performance
network services software, across OSs.
Expert in multithreaded programming and
asynchronous/multiplexing I/O techniques.
Honed and highly-tuned analytical skills, proven in
software development and in real-customer issues
investigation and resolution.
PERSONAL STATEMENT
EXPERIENCE
Principal Software Engineer
Velti SA, Patras, Greece
Technical manager for the Product Development
& Innovation remote team, in charge of 6
software engineers working
for various R&D projects and products.
Technical leader for an HTML5/Javascript based, media
authoring and publishing environment for building
mobile sites, web applications and rich media ads
(MRAID) for mobile ad networks.
Architect and designer for a native application
building service, enabling users to export a mobile-friendly
web application as a native application, running on
various mobile platforms.
Technical leading research projects for web, mobile app
and multichannel analytics platforms.
Performance evaluation of big data processing
for campaign data analysis using Graph DBs.
Apr 2012 - Present
Principal Software Engineer
Bytemobile EDC, Patras, Greece
Development of a core network element, providing
adaptive data traffic management capabilities to
mobile operator networks.
Designer and technical leader for the IPv6 support of
this product. Integration with IPv6-enabled RADIUS,
LDAP and PCRF interfaces. Integration with in-house
Analytics platform.
Architect, designer and technical leader of a novel
Content Adaptation product for mobile network
operators, enabling access to complex web pages for
any mobile device. Product deployed on a number of
mobile operator networks worldwide.
Designer and technical leader of a high performance
multi-threaded proxy, responsible for handling high
volumes of concurrent adaptation transactions.
Integration with a third-party content adaptation
engine. Integration with centralized cluster
management and data storage.
Designer and technical leader, for the implementation
of in-house content adaptation engine based on
Mozilla, capable to apply adaptation algorithms on
the DOM tree.
Tight and efficient collaboration with engineers, QA,
architects, product management, customer support and
customers across company sites and geographies
(EMEA, US, APAC).
Product presentation and training to the Professional
Services/Presales teams of the company.
Debugging and troubleshooting complex customer
related issues on Bytemobile products.
May 2006 - Mar 2012
Senior Software Engineer
Bytemobile EDC, Patras, Greece
Redesign of the Bytemobile optimization client,
supporting new features and portability between
Symbian OS and Windows. Technical lead for the
Symbian variant of the client.
Implementation of performance analysis tools for
Symbian OS. Including prototype packet sniffer for
the Symbian OS, installable as a device driver in
the device network stack.
Design and implementation of an experimental device
driver for Symbian OS, for the transparent
forwarding of TCP packets between the device browser
and the optimization client.
Performance tuning of the Bytemobile optimization
client for Symbian 9.x. Instrumentation and profiling
using custom tools and techniques.
Jan 2004 - Apr 2006
Senior Software Engineer
Daedalus Networks Ltd, Patras, Greece
(Acquired by Bytemobile Inc., in Jan 2004)
Member of the founding team of Daedalus Networks Ltd.
Architect and technical leader for the implementation
of a scalable traffic/event reporting system,
gathering and on-the-fly correlating data from
an IP gateway in a mobile operator network.
Architect and lead developer of a prototype
Performance Enhancement Proxy (PEP) for Mobile,
ISP and Corporate Data Networks.
Design and implementation of a high performance
logging library, suitable for use with multithreaded
applications.
2001 - Dec 2003
Software Engineer / Researcher
High Performance Information Systems Lab, CEID, University of Patras
Design and implementation of a resource scheduler
for SMP platforms, at the kernel level, as a loadable
kernel module.
Design and implementation of a user-level threads
library for Windows 2000.
Implementation and evaluation of scheduling policies
of a user level resource manager.
1997 - 2002
EDUCATION
Master in Computer Science
Computer Engineering and Informatics Dept.,
University of Patras
Thesis: Implementation of a user-level threads
library for SMPs.
Sep 1998 - May 2001
Diploma in Computer Engineering and Informatics
Computer Engineering and Informatics Dept.,
University of Patras
Dissertation: Implementation and evaluation of
scheduling policies on SMPs.
Expert in C, C++, Python; Advanced in Javascript, Java,
Perl, PHP, C#, Objective-C, Matlab, HTML;
In fact I can understand/edit almost any piece of
code in any procedural/OO language.
A Multiprogramming Aware OpenMP Implementation.
V. K. Barekas, P. E. Hadjidoukas, E. D.
Polychronopoulos, T. S. Papatheodorou. Scientific
Programming, Volume 11(2), pp. 133-141, 2003.
An OpenMP Implementation for Multiprogrammed
SMPs. V. K. Barekas, P. E. Hadjidoukas,
E. D. Polychronopoulos, T. S. Papatheodorou. In
Proceedings of the 3rd European Workshop on OpenMP
(EWOMP2001), Barcelona, Spain, September 2001.
A Portable Kernel-Mode Resource Manager on Windows
2000 Platforms. P. E. Hadjidoukas, V. K. Barekas,
E. D. Polychronopoulos, T. S. Papatheodorou. In
Proceedings of the 12th IASTED International
Conference on Parallel and Distributed Computing and
Systems (PDCS 2000), Las Vegas, Nevada, USA, November
2000.
Nanothreads vs. Fibers for the Support of Fine
Grain Parallelism on Windows NT/2000 Platforms.
V. K. Barekas, P. E. Hadjidoukas, E.
D. Polychronopoulos, T. S. Papatheodorou. In
Proceedings of the 3rd International Symposium on
High Performance Computing (ISHPC 2000), LNCS No.
1940, pages 146-159, Tokyo, Japan, October 2000.
RESEARCH PROJECTS
DIG: Digital Interactive Graffiti,
Programme: FP7-SME-2011, Project reference: 286927.
POP: Performance Portability of OpenMP,
Long Term Research IST Project No. IST-2001-33071.
High Performance Computations for Scientific and
Multimedia Applications, Greek General Secretariat
of Research and Technology Project 99ΕΔ-566.
NANOS: Effective Integration of Fine-Grain
Parallelism Exploitation and Multiprogramming,
ESPRIT EC-DGIII Basic Research Project 6634.
OTHER ACTIVITIES
Long-distance running, cycling, traveling, reading
literature, sailing, and being environmental friendly.


EMEmvAdditionalDataFieldTemplate Protocol Reference
| Conforms to | EMEmvTemplate |
|---|---|
| Declared in | EMEmvAdditionalDataFieldTemplate.h |
Overview
Holds additional data fields that could be present in the QR code. It provides a simple interface to retrieve value of such fields.
– billNumber
required method
Returns the invoice number or bill number, that could be provided by the merchant or could be an indication for the mobile application to prompt the consumer to input a Bill Number.
For example, the Bill Number may be present when the QR Code is used for bill payment.
This parameter is optional.
- (EMEmvOptional<NSString*> *)billNumber
Return Value
Returns bill number as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– mobileNumber
required method
Returns the mobile number, that could be provided by the merchant or could be an indication for the mobile application to prompt the consumer to input a Mobile Number.
For example, the Mobile Number to be used for multiple use cases, such as mobile top-up and bill payment.
This parameter is optional.
- (EMEmvOptional<NSString*> *)mobileNumber
Return Value
Returns mobile number as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– storeLabel
required method
Returns a distinctive value associated to a store. This value could be provided by the merchant or could be an indication for the mobile application to prompt the consumer to input a Store Label.
For example, the Store Label may be displayed to the consumer on the mobile application identifying a specific store.
This parameter is optional.
- (EMEmvOptional<NSString*> *)storeLabel
Return Value
Returns store label as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– loyaltyNumber
required method
Returns a loyalty card number. This number could be provided by the merchant, if known, or could be an indication for the mobile application to prompt the consumer to input their Loyalty Number.
This parameter is optional.
- (EMEmvOptional<NSString*> *)loyaltyNumber
Return Value
Returns Loyalty number as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– referenceLabel
required method
Returns transaction identification value. This value could be provided by the merchant or could be an indication for the mobile app to prompt the consumer to input a transaction Reference Label.
For example, the Reference Label may be used by the consumer mobile application for transaction logging or receipt display.
This parameter is optional.
- (EMEmvOptional<NSString*> *)referenceLabel
Return Value
Returns reference label as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– customerLabel
required method
Returns value identifying a specific consumer. This value could be provided by the merchant (if known), or could be an indication for the mobile application to prompt the consumer to input their Customer Label.
For example, the Customer Label may be a subscriber ID for subscription services, a student enrolment number, etc.
This parameter is optional.
- (EMEmvOptional<NSString*> *)customerLabel
Return Value
Returns customer label as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– terminalLabel
required method
Returns a distinctive value associated to a terminal in the store. This value could be provided by the merchant or could be an indication for the mobile application to prompt the consumer to input a Terminal Label.
For example, the Terminal Label may be displayed to the consumer on the mobile application identifying a specific terminal.
This parameter is optional.
- (EMEmvOptional<NSString*> *)terminalLabel
Return Value
Returns Terminal label as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– purposeOfTransaction
required method
Returns value defining the purpose of the transaction. This value could be provided by the merchant or could be an indication for the mobile application to prompt the consumer to input a value describing the purpose of the transaction.
For example, the Purpose of Transaction may have the value “International Data Package” for display on the mobile application.
This parameter is optional.
- (EMEmvOptional<NSString*> *)purposeOfTransaction
Return Value
Returns purpose of transaction as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– additionalConsumerDataRequest
required method
Contains indications that the mobile application is to provide the requested information in order to complete the transaction. The information requested should be provided by the mobile application in the authorization without unnecessarily prompting the consumer.
For example, the Additional Consumer Data Request may indicate that the consumer mobile number is required to complete the transaction, in which case the mobile application should be able to provide this number (that the mobile application has previously stored) without unnecessarily prompting the consumer.
This parameter is optional.
- (EMEmvOptional<NSString*> *)additionalConsumerDataRequest
Return Value
Returns additional consumer data request as string wrapped in {@link EMEmvOptional}.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– emvRfuDataObjects
required method
Provides list of data objects reserved for future use of EMV
- (NSArray<id<EMEmvDataObject> > *)emvRfuDataObjects
Return Value
Returns list of {@link EMEmvDataObject} or empty list if none are present in the QR code. Note: It is advised to use {@link EMEmvDataObject#type} method to check concrete type and safely cast the list members.
Declared In
EMEmvAdditionalDataFieldTemplate.h
– paymentSystemSpecificTemplates
required method
Provides list of Payment System specific templates.
- (NSArray<id<EMEmvDataObject> > *)paymentSystemSpecificTemplates
Return Value
Returns list of {@link EMEmvDataObject} or empty list if none are present in the QR code. Note: It is advised to use {@link EMEmvDataObject#type} method to check concrete type and safely cast the list members.
Declared In
EMEmvAdditionalDataFieldTemplate.h


{% extends "base.html" %} {% load static %} {% block extended_head %}
{{ message }}
Your username and password didn't match. Please try again.


Distributed applications with BEAM
- Gabriele Santomaggio - @gsantomaggio
- RabbitMQ contributor/ supporter
- Co-author of RabbitMQ Cookbook
Distributed Erlang - Base concepts
- Nodes (full-mesh)
(example)
- .erlang.cookie
- epmd
OTP - Distributed calls
- Synchronous distributed calls
- Replies and/or Bad Nodes
- Asynchronous distributed calls
Distributed calls in this presentation
- gen_server
- gen_server:multi_call(..)
- gen_server:abcast(..)
Add new feature
- Search example
- Add nodes
- Distributed search
Nodes type family
- Same type
- Standard TCP/UPD connections
- SSL and/or different cookie
Nodes type family - Example
- RabbitMQ
- TCP Connection
- Message:
Send
Links
- @beam_italia
- @erlangsolutions
- beam-italia.slack.com
Thank you
- Any questions ?
- @gsantomaggio
- Erlang Elixir Fac. Rome 7 April
Node
Total
Processes
Processes Used
System
Atoms Used
Active Users
Log Users


data class StartNumber
Starting number that determines the starting order.
StartNumber(number: Int)
Number
val number: Int


© NZ Wella YPS 2008
Koleston Perfect is the brand for hair colour – indispensable in over 18,000 salons throughout the world. Broken down into five different shade families with a portfolio of over 90 shades, the new Koleston Perfect will allow you to exceed the limits of permanent hair colouring.
 Color Touch the world’s most popular long-lasting semi-permanent colour allows you to express your modern, lively personality with a variety of shades, from cool iridescent browns to icy blondes. Color Touch provides even, vibrant colour results with hair transforming colour pigments, keratin and natural wax.
Discover the power of lightening and explore the stunning shades of the entire colour spectrum with Magma high lightening colour. From a cool blonde to a brilliant, contrast-rich red to a shiny brunette, only Magma makes lightening and shading so luminous, vibrant and alluring – and in just one easy step. Play with colour, create a unique look and be empowered by shining light.
Put the energy and purity of light into hair and get the blonde look desired. Blondor contains oil-based active ingredients with moisture binding lipids and provides perfect and individualised lightening from sun-kissed hair to even the lightest blonde – for the most alluring blonde ever.
High Hair styling contains a Multi Protector Formula with Provitamin B5 which strengthens and improves the hair structure leaving it shiny, healthy, smooth and supple. Discover the incredible performance of products like Flat Iron Spray, Style Manager and Peppermint Pep. Mix, match and create our own styling cocktail for the perfect finishing touch.
For advice on these fantastic products and how they can help achieve perfect results call the Wella Technical Services Hotline on 0800 658 329. Please note that the New Zealand product and shade portfolios may differ to other international markets, for confirmation on availability please contact the Wella Technical Services Hotline.
Only Wella colour, chemical waving, and High Hair styling products can be used on your model’s hair for the Wella YPS Awards regional and national final. For further product information, please click on the logos.


- Write a draft of my "All the World's Code" talk for Allhands.
- Update my "Introduction to Twisted" talk for a Canonical-wide audience, and polish up the slides, probably moving them to OpenOffice format.
- Update my "Your Code Sucks" talk for same audience, polish up the slides etc.
- Read about Lisp compilers for tomorrow's reading group.
- Do something fun and irrational.


Issue TYPE-OF-AND-PREDEFINED-CLASSES:UNIFY-AND-EXTEND Summary
These passages are relevant to issue
TYPE-OF-AND-PREDEFINED-CLASSES:UNIFY-AND-EXTEND
:
Condition Type PARSE-ERROR
Condition Type SIMPLE-ERROR
Condition Type SIMPLE-TYPE-ERROR
Condition Type SIMPLE-WARNING
Function TYPE-OF
System Class BROADCAST-STREAM
System Class BUILT-IN-CLASS
System Class CLASS
System Class CONCATENATED-STREAM
System Class ECHO-STREAM
System Class FILE-STREAM
System Class LOGICAL-PATHNAME
System Class STANDARD-CLASS
System Class STANDARD-METHOD
System Class STREAM
System Class STRING-STREAM
System Class STRUCTURE-CLASS
System Class SYNONYM-STREAM
System Class TWO-WAY-STREAM
Type Relationships
Copyright 1996, The Harlequin Group Limited. All Rights Reserved.


Relations and Booleans
Programming languages have operations for relations. For example:
a < b
a <= b
a > b
a >= b
a == b
a != b
Relations are different than many other binary operators in that the result type is a boolean, not the same type as the operands. For example:
>>> a = 2
>>> b = 3
>>> a < b
True
>>> a > b
False
>>>
For booleans, there are additional logical operations for and
,
or
, and not
:
>>> a < b and a > 0
True
>>> a > b or a < 0
False
>>> not a < b
False
>>>
Wabbit uses the syntax &&
, ||
, and !
for these operations.
Precedence Rules
Relations have lower precedence than other math operators. For example:
>>> 1 + 4 < 3 + 5
True
>>>
Evaluates as:
>>> (1 + 4) < (3 + 5)
True
>>>
Boolean operators and
and or
have lower precedence than relations:
>>> 2 < 3 and 0 < 1
True
>>>
Evaluates as:
>>> (2 < 3) and (0 < 1)
True
>>>
Python allows comparison operators to be chained together:
>>> 2 < 3 < 0
False
>>> 2 < 3 > 0
True
>>> 2 < 3 > 0 < 10 > -1
True
>>>
Chaining is the same as this:
>>> 2 < 3 and 3 < 0
False
>>> 2 < 3 and 3 > 0
True
>>> 2 < 3 and 3 > 0 and 0 < 10 and 10 > -1
True
Syntactically, it’s a little weird to write things such as x < y > z
.
In fact, most programming languages don’t permit it. So, this
is something you might want to disallow in your programming language.
That is, the relations can only be used to compare two values.
Short-circuit Evaluation
One thing you might ponder is whether or not you support short-circuit
evaluation of booleans operators and
and or
. In most languages,
evaluation stops once the final result can be determined. Here’s an
example that illustrates:
>>> x = 10
>>> (x != 0) or (x / 0)
True
>>>
Notice how the division by zero did not take place. Since the first
operand was True
, there’s no need to evaluate the second operand.
You do NOT need to implement short-circuit evaluation in your compiler, but think about it. If you think you can add it, do it.
Relations in Wabbit
Wabbit supports the following operators:
a < b
a <= b
a > b
a >= b
a == b
a != b
a && b // Logical and
a || b // Logical or
!a // Logical negation
In addition, Wabbit has a bool
data type along with
true
and false
literals. For example:
var a bool = true;
var b bool = false;
All relations and logical operators always produce a result type of
bool
.
With relations, you get more precedence rules. Here is the precedence of operators, from lowest to highest:
|| (lowest precedence)
&&
<, <=, >, >=, ==, !=
+, -
*, /
Unary : +, -, ! (highest precedence)
If possible, your compiler should not allow chained relations. For example:
a < b // OK
a < b < c // Error
The logical-and, logical-or, and logical negation operators always expect the operands to be of type bool. Thus, you will need to account for things like this:
var a int = 3;
var b int = 4;
var c bool = (a != 0) || (b != 0); // OK
var d bool = a || b; // ERROR
IR Code Generation
The IR code specification doesn’t provide for bools. To do it, booleans should be represented by the integers 0 and 1. When generating the IR for relations and other operations, use integer operations assuming these values. Note: The IR specification has operators for bitwise AND and OR on integers.
This mirrors the actual behavior of a CPU. CPUs don’t generally have a special "bool" datatype or boolean-specific operations. They have integer operations and integer bit-wise operators for things like AND, OR, and NOT.
LLVM Code Generation
To perform comparisons in LLVM, you need to use the icmp_signed
and
fcmp_ordered
methods of the builder. Here is a guide of how to do
numeric comparisons in LLVM:
Integer compares:
builder.icmp_signed('<', left, right, target) # left < right
builder.icmp_signed('<=', left, right, target) # left <= right
builder.icmp_signed('>', left, right, target) # left > right
builder.icmp_signed('>=', left, right, target) # left >= right
builder.icmp_signed('==', left, right, target) # left == right
builder.icmp_signed('!=', left, right, target) # left != right
Float compares:
builder.fcmp_ordered('<', left, right, target) # left < right
builder.fcmp_ordered('<=', left, right, target) # left <= right
builder.fcmp_ordered('>', left, right, target) # left > right
builder.fcmp_ordered('>=', left, right, target) # left >= right
builder.fcmp_ordered('==', left, right, target) # left == right
builder.fcmp_ordered('!=', left, right, target) # left != right
All of the above operations return a boolean type IntType(1)
.
Depending on how you are doing things, you might need to take the result
and extend it to a 32-bit integer so that it is compatible with the
normal integer type. Use this:
builder.zext(value, IntType(32), target) # Zero-extend value to a new type
If you ever need to take an integer and truncate it down to a bool, you can use this:
builder.trunc(value, IntType(1), target) # Truncate an int to a bool
There are a few other instructions you’ll also need for boolean expressions:
builder.and_(left, right, target) # left && right
builder.or_(left, right, target) # left || right
Web Assembly Generation
Generating code for relations should be extremely straightforward. There are separate op-codes for each kind of comparison as well as AND and OR instructions. Review the official WASM specification for the encoding.


We propose a robust uncalibrated multiview photometric stereo method for high quality 3D shape reconstruction. In our method, a coarse initial 3D mesh obtained using a multiview stereo method is projected onto a 2D planar domain using a planar mesh parameterization technique. We describe methods for surface normal estimation that work in the parameterized 2D space that jointly incorporates all geometric and photometric cues from multiple viewpoints. Using an estimated surface normal map, a refined 3D mesh is then recovered by computing an optimal displacement map in the same 2D planar domain. Our method avoids the need of merging view-dependent surface normal maps that is often required in conventional methods. We conduct evaluation on various real-world objects containing surfaces with specular reflections, multiple albedos, and complex topologies in both controlled and uncontrolled settings and demonstrate that accurate 3D meshes with fine geometric details can be recovered by our method.
Jaesik Park, Sudipta N. Sinha, Yasuyuki Matsushita, Yu-Wing Tai, and In So Kweon
IEEE Transactions of Pattern Analysis and Machine Intelligence (TPAMI)
@article{Park_Robust_TPAMI_2016,
Title={Robust Multiview Photometric Stereo using Planar Mesh Parameterization},
Author={Jaesik Park and Sudipta N. Sinha and Yasuyuki Matsushita and Yu-Wing Tai and In So Kweon},
Journal={IEEE Transactions of Pattern Analysis and Machine Intelligence (TPAMI)},
Year={2016}
}
Jaesik Park, Sudipta N. Sinha, Yasuyuki Matsushita, Yu-Wing Tai, and In So Kweon
The 14th International Conference on Computer Vision (ICCV)
Paper Poster Executable Data BibTeX
@inproceedings{Park_Multiview_ICCV_2013,
Title={Multiview Photometric Stereo using Planar Mesh Parameterization},
Author={Jaesik Park and Sudipta N. Sinha and Yasuyuki Matsushita and Yu-Wing Tai and In So Kweon},
Booktitle={Proceedings of the The 14th International Conference on Computer Vision (ICCV)},
Year={2013}
}


A question of age: Lacking support, youth at risk of homelessness
To submit a letter to The Age, email<EMAIL_ADDRESS>Please include your home address and telephone number.
The plight of young people (pictured) who grew up in care and who lose support from the state when they turn 18 – "Tossed out on the street to survive alone" (The Age, 19/11) – is a huge problem. Some people argue that this care should continue until they are 21.
However, what your article highlights is the lack of decent, affordable housing and an appropriate transition program for these young people. Couple this with the low Newstart allowance and we are forcing them into homelessness and poverty. It is time the federal government increased Newstart and the Victorian government provided more social housing units and support programs for these young people.
Graham Reynolds, Soldiers Hill
A few more years to help them become independent
I wonder if there could be a scheme whereby families whose children have left home could offer to host a young person (who grew up in the care of the state) for one to three years until they have found their feet. The cases in your article concerned those who were studying and working hard to improve their lives. Enabling them to connect with families who would be willing to host them, and help them become independent, could provide a better start in life than extended care homes.
Sarah Blatchford, Hampton East
Older workers pay the price of tax cuts for wealthy
Josh Frydenberg says "the new dynamic" in the way our population is ageing will require new policies to ensure the nation's heavy lifting is not left to a diminishing number of younger people (The Age, 19/11). His solution: people in their mid and late 60s should continue to work to stimulate the economy so that services such as education, health and welfare will be funded in the future.
Translation: As a government, we would like to see older people who have paid taxes all their lives continue to work longer so we can deliver the tax cuts to the wealthy as promised. Because woe that they should have to pay their fair share.
Daniela Goldie, Camperdown
Too often, older workers are overlooked for jobs
I applaud Josh Frydenberg's effort to keep people who want to work in jobs for longer, but his fine intentions belie his disconnection from the workforce. Ageism is rampant, as well it might be when generation after generation of fresh talent comes through wanting their turn, which is fair enough.
However, structural changes occur across many sectors, meaning workers lose their skills base and employers advertise for "junior", "entry-level" and "graduate" roles that ask for far more experience than should be expected at the low salaries they are offering.
The problem of ageism will become the great challenge of our time if older workers (I am talking about people as young as mid-40s) continue to be moved on or are overlooked by employers who are trying to save money and improve their bottom line.
Paul Bugeja, Footscray
My working life turned on its head at the age of 70
Josh Frydenberg, aged 70, I was happily employed doing a Department of Human Services project entitled Creating Opportunities for Mature Age Employees, until I was run over by a careless driver while walking to my workplace.
I suffered multiple, serious injuries. But the worst suffering was, firstly, the age discrimination which existed in the Transport Accident Commission's "loss of earnings benefit and loss of income and employment compensation" scheme. Secondly, and even more cruelly, the financial abuse perpetrated by Centrelink in appropriating my "pain and suffering and loss of income compensation" payment. Despite by then being 74, Centrelink treated me as if I were a 40-year-old who, regardless of her permanent injuries, could return to work and recoup her lost earnings, superannuation and other benefits. So, Treasurer, address those inequities against older workers first and I might be able to complete that project.
Kerry Bergin, Abbotsford
THE FORUM
In praise of introversion
If indeed bosses are choosing noisy, extroverted types for higher level jobs (Comment, 18/11), it could be a big mistake. Sure, some extroverted people may be better at managing unruly meetings where people speak out of turn. But even an introverted person can learn methods to handle that. And as Gary Martin notes, introverts are often more skilled at the extended, one-on-one meeting along with dozens of other good qualities. I wonder where this unproductive hiring practice arose. It may well have cost many companies billions of dollars by choosing the least suitable candidates for important roles.
David McRae, Kangaroo Flat
Positive male role models
There has been a real effort to encourage more females into male-dominated occupations which, quite rightly, has had substantial community acceptance. These industries include the trades, engineering and IT.
"Men disappearing from classroom" (The Age, 18/11) highlights the gender imbalance in schools. The Department of Education's response – "We recruit teachers based on their merit. Gender is not a factor" – is disappointing. Is gender balance only a one-way situation? In this era of increased domestic violence, young children and adolescents would benefit by having regular contact with male teachers who could provide positive role models in behaviour and attitude. We need strategies to increase the number of male teachers, especially in the early years of schooling
Ian Bennett, Jan Juc
We need a vision
Our community cannot afford another Hazelwood-type closure – "Unions urge Yallourn closure deal" (The Age, 19/11). We need all governments and councils to work with transitioning communities to create a vision and jobs. Rather then be pushed away from coal, we need to build lifeboats. We ned to create a national transition association involving workers and communities. Many people across Australia fear what will happen to their communities as the market moves them away from coal. Let us create a plan before it is too late.
Wendy Farmer, Voices of the Valley, Newborough
Jobs in renewable energy
The Victorian Energy Policy Centre has warned that if Alcoa's Portland smelter were to close, it could hasten the demise of coal-fired generators in the Latrobe Valley – "Higher night power prices to ease peak" (The Age, 19/11). Perhaps we should look at this differently. If the smelter were powered by renewable energy, it could also hasten the demise of coal power – and that would be good. This would save Portland jobs and create many more in building the renewable energy facilities. Certainly the short-term costs would be high, but as the world moves towards sustainable energy, coal-fired aluminium production will die anyway. Furthermore, the cost of wind and solar energy continues to fall.
Keith Burrows, Fairfield
Controlled burning is...
While controlled burning of the bush may "mitigate the effects of fires, their intensity, capacity to spread uncontrollably and resources required to fight them in extremis" as Mike Seward maintains (Letters, 18/11), this seems a backward practice in these times.
It is increasingly difficult to find safe times for burning, as the fire season has become longer. Plus the costs are very high. Like land clearing, control burning reduces vegetation at a time when we need every hectare we have of trees and bush to slow climate change. And burning forests means the release of greenhouse gasses, adding to global warming.
Perhaps it would be better to approach the issue from a town planning perspective: Is this area safe enough for housing to be sited there? Should more housing be permitted? And if housing already exists, can we add extra escape routes in various directions?
Freya Headlam, Glen Waverley
...not a simple matter
The Wilsons Promontory bushfire of April 2005 was initiated by a "controlled burn" but instead turned into a wildfire. Eleven days later it had destroyed 6880 hectares. In contrast, the 2009 bushfire began with a lightning strike on April 8, and was left to burn for three months.
It is disturbing that native animals were not seen as a valuable asset. The impact of both fires on native animals was horrific, with the estimated loss of hundreds of wombats, koalas, wallabies, echidnas and emus. So let us take the risk of bushfires in Victoria seriously, but also be mindful that controlled burns are not a simple matter.
Valerie Gerrand, West Melbourne
Climate change and 'sin'
I am sorry, Israel Folau, but you are wrong. God paid me a visit and told me to pass on this message to you: droughts and fires are divinely ordained features of our landscape, and have been for millennia. The abolition of gay marriage and cessation of abortion would not alter this by one iota.
No, what God is fuming about are your many lurid tattoos. You flaunt them in flagrant disobedience to His divine command in Leviticus 19:28. You must repent of this grievous sin, have them removed by a doctor (expensive, but hey, you can afford it) and then enrol with the Westboro Baptist Church in the United States, a gang of like-minded chosen favourites who also think they can link meteorological conditions to the sins of others.
Barbara McNeill, Williamstown
Think of your families
Freedom of speech is often controversial, especially when it is done by outspoken individuals who are politicians and celebrities. Israel Folau and Prince Andrew have both demonstrated that you can hang yourself in public with your own words. It is time that some of them stepped away from public life and stopped embarrassing themselves as it has severe ramifications for their own families.
Jenny Smith, East Melbourne
Why his God is so angry
If Israel Folau's God was so upset about abortion and same-sex marriage, why did he/she/it take so long to react? Can Folau demonstrate that there is the connection he claims? I doubt it and until he does, he is talking through an orifice devoid of a mandible. I have an alternate explanation. The disasters Folau refers to are God's punishment for him being an insensitive homophobe.
Claude Tomisich, Pascoe Vale South
Double standard on rights
"Brutal" detention, incarceration, deaths in custody, controversial killings and internationally scandalous rates of detention etc – "'Merciless' assault on Muslims revealed" (The Age, 18/11). Unfortunately it sounds all too familiar.
Tim Hurburgh, Collingwood
Welcome Hongkongers
Hong Kong once had the Union Jack in the corner of its flag. I reason that the United Kingdom, Canada, New Zealand, Australia and other countries of our Commonwealth have a duty to offer prioritised emigration and political asylum to the people of Hong Kong. I wonder if our government would welcome people who are prepared to put their lives on the line for democracy and freedom.
Ronald Elliott, Sandringham
Will China lose patience?
The fact the protests are now in their sixth month in Hong Kong is testament to Hong Kongers' belief that their democracy is under threat from mainland China.
My daughter is resident in Hong Kong. She teaches English to private students and says her student numbers have decreased as most are unwilling to leave their homes at night, fearful of indiscriminate tear-gas attacks. Apparently word on the street is that the mainland police have infiltrated the Hong Kong Police Force and are the main cause of the escalating violence, angry student protesters aside.
My daughter is not afraid to remain in Hong Kong. It seems most Hongkongers believe mainland China needs their home more than Hong Kong needs mainland China, which they believe will keep stronger action in check for the time being.
How much longer can protesters maintain the momentum? Mainland China must be asking the same question. Meanwhile, I hope my daughter remains safe, never to witness China's wrath reigning upon Hong Kong when it loses patience with the protesters.
Name withheld, Sunbury
A cruel half-life existence
How is it possible that a man with an acquired brain injury, unfit to stand trial, is sent to jail and remains there for three years (The Age, 16/11)? Answer: Because it is too easy for the responsible department to shut the door on him and too expensive to design "one-off" supports appropriate for his needs.
Fifty years ago, Veterans Affairs advised my brother, a young soldier who had been critically injured in battle in Vietnam, his brain filled with shrapnel and limbs twisted and useless, that there was "nowhere" to care for him, and sent him home to his ageing parents. After the family broke down, he was sent to live in a locked dementia ward with orderlies providing "care". For 15 years he endured beatings, illness and despair because the only response he could draw on was to shout profanities and lash out.
Nothing has changed. As a society, our values ensure the "sacredness" of saving lives under any circumstances, yet the very few people with catastrophic acquired brain injury who do survive are condemned to a half-life existence and treated with cruel indifference.
It it possible to design appropriate care for those few. However, it is expensive and our values are eroding in terms of individual rights for some minority groups, such as people with severe and multiple disabilities. It is just "too hard" and the will is not there to rectify these terrible injustices.
Geraldine Colson, Mentone
AND ANOTHER THING
Politics
Josh, any retraining options for the over-65s? Grave-digging?
Annie Wilson, Inverloch
Advice to politicians intending to visit China: Don't be Hastie.
Doug Shapiro, Doncaster East
Do we really have to go through "reds under the beds" again?
Irene Bolger, Apollo Bay
Could government MPs concerned about China's Muslims extend their compassion to Manus refugees and grant them their human rights and freedom?
Iris Owen, East Geelong
Face masks are banned at protests in Victoria, yet a similar ban has been overturned in Hong Kong.
Bill O'Connor, Beechworth
If Trump was serious about jailing Clinton, why didn't he give her a position in his administration?
Mary Mandanici, West Preston
It's time we followed NSW and banned political donations from developers.

Ann Young, Chirnside Park
Israel Folau
He should have worn a helmet during his playing days.
Peter Moskovic, Park Orchards
Folau teaches hate under the guise of religion.
Dolores Bellemo, The Patch
I am comforted by the conviction that his god is not my God.
Helen Buckley, Richmond
Folau's pronouncement is a foretaste of what we can look forward to if the divisive, flawed religious freedom laws are enacted.
Geoff Feren, St Kilda East
Furthermore
A tree in the middle of the road? Roll out the old sign: "Road Plant Ahead".
Jon Smith, Leongatha
If Prince Andrew didn't sweat before his interview, he will now.
Mary Fenelon, Doncaster East
What if Prince Andrew is telling the truth?
Graeme Lee, Fitzroy
*Sign up to editor Alex Lavelle's exclusive weekly newsletter at: www.theage.com.au\editornote.


--- title: Tutorial walkthrough keywords: fastai sidebar: home_sidebar summary: "We do a walkthrough the nbdev tutorial so that we understand how it works :) The original tutorial can be found [here](https://nbdev.fast.ai/tutorial/)" ---
This is a guide for me to follow while doing a live tutorial for my fellow jupyter notebook/lab users at ICFO. I'm mainly doing this guide to get familiar with nbdev and, hopefully, don't look at it during the tutorial.
The first thing to do is to actually install nbdev via pip install nbdev
. At some point we will also need fastcore
that can be installed in the same way pip install fastcore
.
Quickly set a GitHub account if there is not any.
The easiest way to get started is to start a repo from the nbdev template in GitHub. This link only works if loged into GitHub and can be found in the original tutorial.
{% include image.html file="/nbdev_metatuto/images/repo_from_template.png" %}
We can name the repo whatever we want. It does not matter at all so feel free to be creative!
Edit the file directly in GitHub: uncomment and fill the first mandatory fields. It is important that lib_name is the same as the repo to prevent problems afterwards with the docs.
{% include image.html file="/nbdev_metatuto/images/edit_settingsini.png" %}
Commit the changes with whatever message you feel like providing to yourself or the future collaborators of the repo.
With GitHub pages we can have our automatically-generated documentation by nbdev hosted in a free server based on jekyll.
It is interesting to mention the jekyll installation, as it takes a while.
The last step before getting hands on is to install the git hooks. Within the repo directory, run nbdev_install_git_hooks
in the terminal. This will strip the notebooks from a lot of metadata that generally causes commit conflicts out of nowhere.
Nonetheless, if we ever get a conflict, we can also run nbdev_fix_merge filename.ipynb
and it will do some fixing. If the conflict still remains, it will generate a merged file with all the cells with highlighted conflicts as in any other document.
Let's start with the code editing.
Open a jupyter notebook/lab and open 00_core.ipynb
. The core
is the name of the package that will be lib_name.core
and set with # default_exp core
(names need to be consistent). The number is completely optional although recommended.
There are a few comands or special coments that will tell nbdev what to include where:
# default_exp module_name
tells nbdev to export the notebook as lib_name.module_name.py
#hide
prevents the cell from appearing in the documentation and excludes it from the module#export
includes the cell in the exported package and the documentation#exports
includes the cell in the package and the source code in the documentation (s stands for source)These comments need to be always in the first line of the cell.
00_core.ipynb
¶Start by changing the module name and writing down a description. Try to be creative.
Then, proceed to define a function
#export
def say_hi(to):
"Enthusiastically say hi to someone"
return f'Hii {to}!'
Since I put #export
also in the tutorial, we can see the function documentation right below.
Feel free to add a markdown description too. The string in the source code becomes function descrption in the documentation, as you can see right above.
We can also add tests. It is always good to have them in the documentations as they show new users what behavior they should expect. For that we will need to import fastcore
. Since we don't want it to be included in the docs, we can just either put it in the previous cell with
#hide
from nbdev.showdoc import *
to hide both imports, or we can just make a whole new cell with #hide
. To test the function, we can write:
#hide
from fastcore.test import *
test_eq(say_hi("Bitz"), "Hii Bitz!")
In this notebook's source code we can find both cells: one with #hide
and the other one with the test. Provided that no command is written for the test cell, it is included in this documentation (right below) but not in the package.
test_eq(say_hi("Bitz"),"Hii Bitz!")
This can also be done with assert
(notice that this time I didn't embed the code in the markdown and what we see now is the exported cell)
assert say_hi("Gorka") == "Hii Gorka!"
We can now proceed to build the python module with nbdev. In the terminal, go to our project folder and run nbdev_build_lib
. For this tutorial, we now have a new nbdev_metatuto
folder where we can find tutorial.py
and core.py
.
$ nbdev_build_lib
Converted 00_tutorial.ipynb.
Converted 01_core.ipynb.
Converted index.ipynb.
Basically, the project becomes a python package and each notebook is a module.
index.ipynb
will be the source for the documentation home page and the project readme.
We need to change the first cell to import our library. Change the name of the library to yours, e.g., nbdev_metatuto.core
and nbdev_metatuto.tutorial
in my case. Write down a brief description and provide a function example to ensure that it works.
{% include image.html file="/nbdev_metatuto/images/index_edit.png" %}
It is also extremely useful to use %autoreload
to avoid resetting the kernel every time we change the package.
%load_ext autoreload
%autoreload 2
We are now ready to build the documentation. In the terminal, go to the project folder and run nbdev_build_docs
$ nbdev_build_docs
converting: /home/brequena/GitHub/nbdev_metatutorial/00_tutorial.ipynb
converting: /home/brequena/GitHub/nbdev_metatutorial/index.ipynb
converting: /home/brequena/GitHub/nbdev_metatutorial/01_core.ipynb
converting /home/brequena/GitHub/nbdev_metatutorial/index.ipynb to README.md
docs/images/
If we go to the docs
directory, we can see now the files core.html
, index.html
, tutorial.html
for this tutorial.
Commit! We can see all the changes with git status
.
Notice that the __init__.py
is created automatically by default, but we can edit it freely. For example, if we add the line
from .core import *
we can then just import the library without specifying the core in our index.
Github will check that everything is okey. Edit .github/workflows/main.yml
if you don't like it (I never tried).
Go to the commits and see whether we had any issue building the docs. Spoiler alert we did. We always do. Click the cross to see what went wrong. {% include image.html file="/nbdev_metatuto/images/failed_push.png" %}
The problem is that we did not specify the dependencies of our library in settings.ini
. Add the library names with space separations:
# Optional. Same format as setuptools requirements
requirements = fastcore
# Optional. Same format as setuptools console_scripts
# console_scripts =
Commit and push again!
{% include image.html file="/nbdev_metatuto/images/successful_push.png" %}
GREAT!
Have a look at the docs clicking on the link that we generated at the beginning!
{% include image.html file="/nbdev_metatuto/images/first_doc.png" %}
Add a class to 00_core.ipynb
like:
class SoothSayer:
"Yell hi at someone until they are annoyed enough to either reply or flee"
def __init__(self,to): self.to = to
def say(self): return say_hi(self.to)
Notice that this time we can see the source code and the class documentation because I included #exports
. However, the method documentation does not appear for classes unless we explicitly indicate it with show_doc()
from nbdev.showdoc
(already imported).
It would be nice to include a docstring better just as follows:
class SoothSayer:
"Yell hi at someone until they are annoyed enough to either reply or flee"
def __init__(self,to): self.to = to
def say(self):
"Do your thing, stalker!"
return say_hi(self.to)
It is always a good idea to put titles and sections that will make the library more readable.
{% include image.html file="/nbdev_metatuto/images/sections.png" %}
Also, remember to provide examples and tests of the classes and their methods.
sayer = SoothSayer("Maciej")
sayer.say()
Instead of going to the terminal to export our notebooks with nbdev_build_lib
we can execute the command from any cell with
#hide
from nbdev.export import notebook2script
notebook2script()
from nbdev.export import notebook2script
notebook2script()
We can also run all the tests in all notebooks in parallel from the terminal with nbdev_test_nbs
. If something goes wrong, we get a traceback to the errors. Be careful with what we #export
!
$ nbdev_test_nbs
testing: /home/brequena/GitHub/nbdev_metatutorial/00_tutorial.ipynb
testing: /home/brequena/GitHub/nbdev_metatutorial/01_core.ipynb
testing: /home/brequena/GitHub/nbdev_metatutorial/index.ipynb
All tests are passing!
To prevent any issue with nbs that we are currently working on and are not finished yet, we can exclude them from the test by adding _
at the beginning of the name, e.g., _core.ipynb
.
We can see the documentation without having to push and checking the github page if we install jekyll to generate the docs locally. It can take a while to install. While following the installation guide, it is important to run sudo apt-get update
and then sudo apt-get upgrade
as well as gem update
before doing gem install bundler
or it might be that the bundler is outdated (version needs to be $>2$). I didn't fooken manage tho.
With jekyll installed, go to the docs
directory and run bundle install
. Then, run make docs_serve
, which will launch a docs server on port 4000.
There are a lot more functionalities, such as setting up requirements (we already saw it), set up console scripts, upload to pypi, etc.