spec - Kenyth Zeng on Diigo

05 Jan 10

11 Dec 09

The Official YAML Web Site

YAML: YAML Ain't Markup Language

What It Is: YAML is a human friendly data serialization
standard for all programming languages.

www.yaml.org - Preview

data format YAML spec

03 Nov 09

Types, Values, and Variables

java.sun.com/...typesValues.html - Preview

java programming language spec type starred

every variable and every expression has a type that is known at compile time.
values of a reference type are references to objects.
11 more annotations...
- The correspondence between types and classes or interfaces is incomplete for two reasons:
  
  At run-time, classes and interfaces are loaded by the Java virtual machine using class loaders. Each class loader defines its own set of classes and interfaces. As a result, it is possible for two loaders to load an identical class or interface definition but produce distinct classes or interfaces at run-time.
  
  Type arguments and type variables (§4.4) are not reified at run-time. As a result, different parameterized types (§4.5) are implemented by the same class or interface at run time. Indeed, all invocations of a given generic type declaration (§8.1.2, §9.1.2 )share a single run-time implementation.
- heap pollution
- Type:
  PrimitiveType
  ReferenceType
- The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
- which can convert from an integral value to a value of any specified numeric type
- ReferenceType:
  ClassOrInterfaceType
  TypeVariable
  ArrayType
- Compatibility of the value of a variable with its type is guaranteed by the design of the Java programming language
- It is possible that a variable of a parameterized type refers to an object that is not of that parameterized type.
- Array components are unnamed variables
- The exceptional situation involves the switch statement (§14.11), where it is possible for control to enter a block but bypass execution of a local variable declaration statement.
- The compile time type limits the possible values that the variable can hold or the expression can produce at run time. If a run-time value is a reference that is not null, it refers to an object or array that has a class, and that class will necessarily be compatible with the compile-time type.

02 Nov 09

Types, Values, and Variables

hepunx.rl.ac.uk/...valvar.htm - Preview

spec programming language javascript 1.1 type

27 Sep 09

HTTP/1.1: Method Definitions

www.w3.org/...rfc2616-sec9.html - Preview

http 1.1 spec

it is possible that a sequence of several requests is non-
idempotent, even if all of the methods executed in that sequence are
idempotent.
This method allows the client to
determine the options and/or requirements associated with a resource,
or the capabilities of a server, without implying a resource action
or initiating a resource retrieval.
6 more annotations...
- If the Request-URI is an asterisk ("*"), the OPTIONS request is
  intended to apply to the server in general rather than to a specific
  resource.
- The HEAD method is identical to GET except that the server MUST NOT
  return a message-body in the response.
- The POST method is used to request that the origin server accept the
  entity enclosed in the request as a new subordinate of the resource
  identified by the Request-URI in the Request-Line.
- If the Request-URI refers to an already
  existing resource, the enclosed entity SHOULD be considered as a
  modified version of the one residing on the origin server.
- The PUT method requests that the enclosed entity be stored under the
  supplied Request-URI.
- The DELETE method requests that the origin server delete the resource
  identified by the Request-URI.

12 Aug 09

VM Spec Threads and Locks

java.sun.com/...Threads.doc.html - Preview

jvm java spec memory thread concurrent starred

Because it is impossible
for one thread to access parameters or local variables of another thread, it does
not matter whether parameters and local variables are thought of as residing in the
shared main memory or in the working memory of the thread that owns them.
Every thread has a working memory in which it keeps its own working copy of variables that it must use or assign. As the thread executes a program, it operates on these working copies. The main memory contains the master copy of every variable. There are rules about when a thread is permitted or required to transfer the contents of its working copy of a variable into the master copy or vice versa.
4 more annotations...
- the operations in main memory on behalf of any one thread are performed in the same order as the corresponding operations by that thread.
- an occurrence of V as an operand of the + operator requires that a single use operation occur on V ; an occurrence of V as the left-hand operand of the assignment operator = requires that a single assign operation occur.
- If the following rules forbid T to perform a required use as its next action, it may be necessary for T to perform a load first in order to make progress.
- treated as if it were two variables of
  32 bits each; wherever the rules require one of these operations, two such operations
  are performed, one for each 32-bit half.

Threads and Locks

java.sun.com/...memory.html - Preview

programming language java thread spec concurrent book starred memory

These threads independently execute code that operates on values and objects residing in a shared main memory.
Each object in Java is associated with a monitor, which a thread can lock or unlock. Only one thread at a time may hold a lock on a monitor.
6 more annotations...
- The synchronized statement (§14.19) computes a reference to an object; it then attempts to perform a lock action on that object's monitor and does not proceed further until the lock action has successfully completed.
- A synchronized method (§8.4.3.6) automatically performs a lock action when it is invoked; its body is not executed until the lock action has successfully completed. If the method is an instance method, it locks the monitor associated with the instance for which it was invoked (that is, the object that will be known as this during execution of the body of the method). If the method is static, it locks the monitor associated with the Class object that represents the class in which the method is defined.
- The Java programming language memory model works by examining each read in an execution trace and checking that the write observed by that read is valid according to certain rules.
- intra-thread semantics.
- Memory that can be shared between threads is called shared memory or heap memory.
- Local variables (§14.4), formal method parameters (§8.4.1) or exception handler parameters are never shared between threads and are unaffected by the memory model.

06 Aug 09

Draft: PubSubHubbub Core 0.1 -- Working Draft

pubsubhubbub.googlecode.com/...pubsubhubbub-core-0.1.html - Preview

spec protocol instant web

As opposed to more developed (and more complex) pubsub specs like Jabber Publish-Subscribe (Millard, P., Saint-Andre, P., and R. Meijer, “Publish-Subscribe,” .) [XEP‑0060] this spec's base profile
(the barrier-to-entry to speak it) is dead simple. The fancy bits required
for high-volume publishers and subscribers are optional. The base profile
is HTTP-based, as opposed to XMPP (see more on this below).

26 Jul 09

The most common use
of this structure is to identify an instant messaging user, the
server to which the user connects, and the user's connected resource
(e.g., a specific client) in the form of <user@host/resource>.
<room@service/nick> (where "nick" is the occupant's room nickname).
27 more annotations...
- <?xml version='1.0'?>
  <stream:stream
  to='example.com'
  xmlns='jabber:client'
  xmlns:stream='http://etherx.jabber.org/streams'
  version='1.0'>
- The start of an XML stream is denoted unambiguously by an opening
  XML <stream> tag (with appropriate attributes and namespace
  declarations), while the end of the XML stream is denoted
  unambiguously by a closing XML </stream> tag.
- Three kinds of XML stanza are
  defined for the 'jabber:client' and 'jabber:server' namespaces:
  <message/>, <presence/>, and <iq/>.
- The <presence/> element can be seen as a basic broadcast or
  "publish-subscribe" mechanism, whereby multiple entities receive
  information about an entity to which they have subscribed (in this
  case, network availability information).
- with each resource differentiated
  by the resource identifier of an XMPP address (e.g., <node@domain/
  home> vs. <node@domain/work>)
- The <presence/> element can be seen as a basic broadcast or
  "publish-subscribe" mechanism
- An XML stanza exists at the direct child
  level of the root <stream/> element
- The <presence/> element can be seen as a basic broadcast or
  "publish-subscribe" mechanism
- The <presence/> element can be seen as a basic broadcast or
  "publish-subscribe" mechanism, whereby multiple entities receive
  information about an entity to which they have subscribed (in this
  case, network availability information).
- the XML data is processed directly by the server itself on
  behalf of the client and is not routed to another entity.
- Examples are gateways to email (see [SMTP]),
  Internet Relay Chat (see [IRC]), SIMPLE (see [SIMPLE]), Short Message
  Service (SMS), and legacy instant messaging services such as AIM,
  ICQ, MSN Messenger, and Yahoo! Instant Messenger.
- The RECOMMENDED port
  for connections between servers is 5269
- the address
  of an XMPP entity is called a Jabber Identifier or JID.
- The domain identifier is the primary identifier and is the only
  REQUIRED element of a JID (a mere domain identifier is a valid JID).
- Two fundamental concepts make possible the rapid, asynchronous
  exchange of relatively small payloads of structured information
  between presence-aware entities: XML streams and XML stanzas.
- can send an unbounded
  number of XML elements over the stream, either elements used to
  negotiate the stream (e.g., to negotiate Use of TLS (Section 5) or
  use of SASL (Section 6)) or XML stanzas
- in order to enable
  information exchange from the receiving entity to the initiating
  entity, the receiving entity MUST negotiate a stream in the
  opposite direction (the "response stream").
- there is no necessary coupling of an XML stream to a [TCP]
  connection (e.g., two entities could connect to each other via
  another mechanism such as polling over [HTTP])
- a "push" mechanism whereby
  one entity pushes information to another entity
- a basic broadcast or
  "publish-subscribe" mechanism
- Info/Query, or IQ, is a request-response mechanism, similar in some
  ways to [HTTP].
- * get -- The stanza is a request for information or
  requirements.
  
  * set -- The stanza provides required data, sets new values, or
  replaces existing values.
  
  * result -- The stanza is a response to a successful get or set
  request.
  
  * error -- An error has occurred regarding processing or
  delivery of a previously-sent get or set (see Stanza Errors
  (Section 9.3)).
- XMPP does not require the parsing of arbitrary and
  complete XML documents, there is no requirement that XMPP needs to
  support the full feature set of [XML].
- namespace-aware
- A default namespace declaration is REQUIRED and is used in all XML
  streams in order to define the allowable first-level children of the
  root stream element.
- The order of layers in which protocols MUST be stacked is as follows:
  
  1. TCP
  2. TLS
  3. SASL
  4. XMPP
- At a minimum, all implementations MUST support the following
  mechanisms:
  
  for authentication: the SASL [DIGEST-MD5] mechanism
  
  for confidentiality: TLS (using the TLS_RSA_WITH_3DES_EDE_CBC_SHA
  cipher)
  
  for both: TLS plus SASL EXTERNAL(using the
  TLS_RSA_WITH_3DES_EDE_CBC_SHA cipher supporting client-side
  certificates)

25 Jul 09

Draft Protocol Spec ‎(Google Wave Federation Protocol)‎

www.waveprotocol.org/draft-protocol-spec - Preview

Google Wave spec doc

A wave consists of XML documents
wave addresses which consist of a user name and a
wave provider domain in the same form as an email address, namely
<username>@<domain>.
29 more annotations...
- A gateway
  translates between waves and other communication and sharing
  protocols such as email and IM.
- A wave consists of a set of wavelets.
- Each
  wavelet has a list of participants, and a set of documents that make
  up its contents.
- different
  users have different wave views for a given wave.
- the user's read/unread
  state for the wave, is stored in a user-data wavelet in the wave with
  the user as the only participant.
- a private reply within a
  wave, which is represented as a wavelet
- A wavelet has a wavelet id which is unique within its wave.
- A wavelet is hosted by the wave
  provider of the participant who creates the wavelet.
- Wavelets in the same wave can be hosted by different wave providers.
- user-data is not federated
- Annotations are key-value pairs
- Each wavelet is a container for any number of
  documents.
- It is composed of an XML document and a set of
  annotations.
- The blips in a wave form a threaded
  conversation.
- The central pieces of the wave service is the wave store,
  which stores wavelet operations, and the wave server, which resolves
  wavelet operations by operational transformation and writes and reads
  wavelet operations to and from the wave store.
- The
  wave server is responsible for processing the wavelet operations
  submitted to the wavelet by local participants and by remote
  participants from other wave providers.
- a wave provider is "upstream" relative to its local
  wavelets and that it is "downstream" relative to its remote
  wavelets.
- The wave service uses two components for peering with other wave providers, a
  "federation host" and a "federation remote".
- The federation
  host maintains (in persistent storage) a queue of outgoing
  operations for each remote domain. Operations are queued until their
  receipt is acknowledged by the receiving federation remote.
- It is used to push new wavelet
  operations applied to a local wavelet to the wave providers of any remote participants.
- <wavelet-update
  xmlns="http://waveprotocol.org/protocol/0.2/waveserver"
- <delta-history
  xmlns="http://waveprotocol.org/protocol/0.2/waveserver"
- <applied-delta
  xmlns="http://waveprotocol.org/protocol/0.2/waveserver">
- <submit-request
  xmlns="http://waveprotocol.org/protocol/0.2/waveserver">
- <submit-response
  xmlns="http://waveprotocol.org/protocol/0.2/waveserver"
- the operation does not modify the input document
- A document is a sequence of items, where each item is a character,
  a start tag, or an end tag. Each item has a key-value map of
  annotations.
- After the final component, the annotations update must be empty,
  and the cursor must be to the right of the last item in the input
  document.
- A document operation is a set of instructions that specify how to
  process an input document, reading its sequence of items from left
  to right, to generate an output document.

InfoQ: OSGi: The Next Release

www.infoq.com/...osgi-next-release - Preview

OSGi release spec feature toread

02 Jul 09

Packages

java.sun.com/...packages.html - Preview

package java spec organize convention

The members of a package are class and interface types (§7.6), which are declared in compilation units of the package, and subpackages, which may contain compilation units and subpackages of their own.
There is no special access relationship between a package named oliver and another package named oliver.twist