Developers can start building multi-input websites and apps with greater confidence that an emerging industry standard will enable building a single website targeting multiple devices and platforms.

Only three months after its creation, the W3C Pointer Events Working Group has announced that Pointer Events has reached “Last Call Working Draft” status and is considered feature complete by the Working Group. The W3C Pointer Events Working Group has been hard at work over the last few months to standardize a single device input model – mouse, pen and touch – across multiple browsers. Congratulations to the W3C Pointer Events Working Group!

Microsoft Open Technologies, Inc. (MS Open Tech), and the Microsoft Corp. Internet Explorer teams have been working with our colleagues across the industry, engaging developers to test and provide feedback on the specification, and incorporating all the received feedback into this Last Call Working Draft.

“Last Call Working Draft” means that members of the Working Group, including representatives from Google, jQuery Foundation, KAIST, Microsoft, Mozilla, Nokia, Opera, Zynga, and others, consider that this specification has satisfied all the technical requirements outlined in the Working Group Charter. The working group intends to advance the specification to implementation after this Last Call review.

Build now with Pointer Events

What’s cool is that you can go build websites using Pointer Events today. The Working Group is using Microsoft’s member submission as a starting point for the specification, which is based on the APIs available today in IE10 on Windows 8 and Windows Phone 8.

If you are building your apps using Pointer Events and testing these apps on various browsers, you should try out the hand.js polyfill developed by David Catuhe from Microsoft France. Check out a demo that uses hand.js - universal virtual joystick. We expect that native implementations for WebKit-based browsers will follow shortly.

To demonstrate cross-browser interoperability for Pointer Events, MS Open Tech developed a Pointer Events prototype for WebKit on HTML5 Labs and submitted the patch to the WebKit community. Today MS Open Tech posted an updated version of the patch on HTML5 Labs and on the WebKit issue tracker, incorporating community feedback received on the previous version. Working with the WebKit community, MS Open Tech will continue updating this prototype to implement the latest draft of the specification.

Recently, MS Open Tech hosted an HTML5 Labs Test Jam event on Feb. 11 to share an early preview of the new prototype and collect feedback, and the browser community has been playing with the prototype as noted in a blog post by our friends at AppendTo. AppendTo shares Chromium builds for OSx and for Windows that integrate the Pointer Events patch by MS Open Tech.

Learn more about Pointer Events

If you are attending W3Conf this week in San Francisco, you don’t want to miss “Pointing Forward” at 3:00 pm on Thursday, February 21, presented by Jacob Rossi, program manager for Internet Explorer and co-editor of the W3C Pointer Events specification. You also can watch a live stream of his conference presentation on the W3Conf site and UStream, or later on video on demand.

And, you can learn more by checking out the Pointer Events Primer on WebPlatform.org, developed by Rob Dolin, senior program manager at MS Open Tech. The primer provides guidance on how to use Pointer Events in ways similar to mouse events, and how to access and use additional attributes such as pointer type, button(s) pressed, touch size and pen tilt. The primer is a great resource if you are migrating your code from handling mouse, to consistently handling input from mouse, pen and touch.

We’ve been happy to share the great progress for the W3C Pointer Events emerging standard. Stay tuned for more updates as we work together on this open standard that can further enable natural and simple computing interfaces on the Web.

Just yesterday, we told you about improvements we’ve made to two Microsoft Open Technologies, Inc., releases: Rx and ActorFx, and mentioned that Netflix was already reaping the benefits of Rx.

To top it off, on the same day, Netflix announced a Java implementation of Rx, RxJava, was now available in the Netflix Github repository. That’s great news to hear, especially given how Ben Christensen and Jafar Husain outlined on the Netflix Tech blog that their goal is to “stay close to the original Rx.NET implementation” and that “all contracts of Rx should be the same.”

Netflix also contributed a great series of interactive exercises for learning Microsoft's Reactive Extensions (Rx) Library for JavaScript as well as some fundamentals for functional programming techniques.

Rx as implemented in RxJava is part of the solution Netflix has developed for improving the processing of 2+ billion incoming requests a day for millions of customers around the world.

To summarize, here’s a great quote from Ben Christensen on the Netflix Tech Blog about Rx:

“Functional reactive programming with RxJava has enabled Netflix developers to leverage server-side concurrency without the typical thread-safety and synchronization concerns. The API service layer implementation has control over concurrency primitives, which enables us to pursue system performance improvements without fear of breaking client code.”

Cisco and Microsoft security experts make ALPN application protocol negotiation recommendation to the IETF TLS Working Group to help HTTP/2.0 effort

As part of the HTTP/2.0 effort, the industry is collaborating to reinforce Internet communication security in the IETF Transport Layer Security Working Group (TLS WG). Two security experts from Cisco and Microsoft Corp. have submitted ALPN-01 (Application Layer Protocol Negotiation), a safer and simpler application protocol negotiation approach, backed up by a new HTML5 Labs HTTP/2.0 prototype by Microsoft Open Technologies, Inc., incorporating an initial implementation of ALPN-01.

Stephan Friedl (Cisco) and Andrei Popov (Microsoft Corp.) co-authored the ALPN-01 Internet draft that is under discussion among the TLS WG mailing lists. This is in response to discussions at the IETF 85 meeting in Atlanta where the IETF TLS WG received a request from the HTTPBIS Working Group for “a mechanism that allows clients and servers to negotiate the particular application protocol to use once the session is established." Currently, there are two proposals:

The new ALPN-01 (Application Layer Protocol Negotiation) Internet draft proposes a protocol negotiation in accordance with established TLS architecture with the following benefits:

ALPN places ownership of protocol selection on the server, not the client. This allows the server to select an appropriate certificate based on the application protocol, which is in line with existing TLS handshake extensions.

ALPN performs protocol negotiation by default in the clear: in general there is no need for encrypted communication during the handshake. This permits servers to differentiate routing, QOS and firewalling by protocol.

For use cases that can justify the tradeoff with additional latency, ALPN still retains support for confidential protocol negotiation through standard TLS renegotiation.

Thanks to these benefits, and because of its stricter adherence to established TLS design principles, ALPN represents the best choice to address the requirements articulated by the HTTBIS working group for HTTP/2.0 protocol negotiation.

Our HTML5 Labs prototype is the first implementation that is based on the ALPN-01 Internet draft. It is an evolution of earlier prototypes that couples a modified command-line C# client with a basic HTTP/2.0 server. We plan to further develop it in the coming weeks, and we look forward to your feedback both on the TLS WG mailing list and through Html5 Labs. We will gladly apply changes to the draft as well whenever applicable.

Go ahead and download the MS Open Tech HTTP/2.0 prototype using ALPN from HTML5 Labs! And please share your thoughts on this post below.

Download prototype that provides support in OpenSSL for Application Layer Protocol Negotiation

As part of the HTTP/2.0 effort, the industry is collaborating in the IETF Transport Layer Security Working Group (TLS WG) towards a safer and simpler Internet communication security approach. The conversation within the TLS WG on the best way to reinforce Internet communication security continues at a fast pace.

At Microsoft Open Technologies, Inc. we have been participating in this industry collaboration and are now releasing a refreshed open source HTTP/2.0 prototype on HTML5Labs.com that introduces support in the OpenSSL open source encryption library for ALPN (Application Layer Protocol Negotiation).

Earlier in February we had published on HTML5Labs an updated version of our HTTP/2.0 prototype that introduced support for ALPN. Shortly thereafter, on Thursday 2/21, Stephan Friedl and Andrei Popov proposed an update to the ALPN spec draft that refines the protocol in a couple of important aspects:

- “Application Layer Protocol Negotiation Extension” now defines ProtocolNameList and ProtocolName as variable-length arrays, as typically done in TLS. This increases payload size by 2 bytes, but allows the use of the normal TLS parsers.

- “Protocol Selection” defines a new fatal alert no_application_protocol, to be used with ALPN extension only, instead of using a generic handshake_failure alert. This is done to help distinguish application protocol negotiation issues from other handshake failures.

As we mentioned, the new prototype on HTML5Labs also leverages OpenSSL on Apache as a backend. We are making the associated patch available as open source to allow a hands-on side by side comparison of TLS with ALPN builds with the alternative based on NPN. This should allow interested developers to verify the benefits of ALPN and its compliance with established TLS design principles that we called out in our earlier prototype.

As always, we encourage you to try to the code out, and let us know your feedback. Go ahead and download the MS Open Tech HTTP/2.0 prototype using ALPN from HTML5 Labs!

I would have never dreamt, 15 years ago, that we would be so successful in our dream of exchanging information freely between different platforms and now across devices and clouds. For me, this has been the beginning of the Openness revolution. I truly believe that that the strength of XML is its inherent unique capability of representing homogenously documents and data: those scenarios and capabilities will be even more important for the next 15 years.

It’s ready…the February 2013 Preview release of the Windows Azure Plugin for Eclipse with Java from our team at Microsoft Open Technologies, Inc.

You’ve been asking for the ability to deploy JDKs, servers, and user-defined components from external sources instead of including them in the deployment package when deploying to the cloud, and that’s available in this release. There are also a few other minor updates for components, cloud publishing and Windows Azure properties. Have a look at the latest plugin documentation for a complete list of updates.

Deploy JDKs, Servers and user-defined components from Blob Storage

You can now deploy JDKs, application servers, and other components from public or private Windows Azure blob storage downloads instead of including them in the deployment package used to deploy to the cloud.

Having the option of referring to an external object instead including an object in the deployment package gives you flexibility when building your deployment packages. It also means faster deployment times and smaller deployment packages.

Here’s an example showing inclusion of a JDK. Note the new Deploy from download option:

Note the other tabs for server and applications – those options let you select a server (Tomcat, for example), or any component that you want to include in the install and setup but that you don’t want to include in the deployment package.

Getting the Plugin

Here are complete instructions for downloading and installing the Windows Azure Plugin for Eclipse with Java for the first time, which also works for updates.

Reactive Extension (Rx) is a programming model that allows developers to use a common interface for writing applications that interact with diverse data sources, like stock quotes, Tweets, computer events, and Web service requests. Since Rx was open-sourced by MS Open Tech in November, 2012, it has become an important under-the-hood component of several high-availability multi-platform applications, including NetFlix and GitHub.

Rx 2.1 is available now via the Rx CodePlex project and includes support for Windows Phone 8, various bug fixes and contributions from the community.

ActorFx provides a non-prescriptive, language-independent model of dynamic distributed objects for highly available data structures and other logical entities via a standardized framework and infrastructure. ActorFx is based on the idea of the mathematical Actor Model, which was adapted by Microsoft’s Eric Meijer for cloud data management.

ActorFx V0.2 is available now at the CodePlex ActorFx project, originally open sourced in December 2012. The most significant new feature in our early prototype is Actor-to-Actor communication.

The Hub engineering program has been a great place to collaborate on these projects, as these assignments give us the agility and resources to work with the community. Stay tuned for more updates soon!

DMTF (Distributed Management Task Force) announced today that the DMTF Web Services Management standard (WS-Man) version 1.1 has now been adopted by ISO (International Organization for Standardization) and IEC (International Electrotechnical Commission) as an international standard, ISO/IEC 17963:2013. This is a great milestone on the industry’s journey toward broad adoption of interoperable, royalty-free, standards-based solutions for management of systems, applications, and devices.

WS-Man is designed to address the cost and complexity of IT management by providing a common way for systems to access and exchange management information across the entire IT infrastructure. It is used as a network access protocol by many CIM (Common Information Model) based management solutions, including the DMTF’s CIM based DASH (Desktop and Mobile Architecture for Server Hardware) and SMASH(Systems Management Architecture for Server Hardware) solutions, as well as the DMTF’s Virtualization Management (VMAN) standards which we use to manage Windows Hyper-V. WS-Man is also the primary protocol for management of Windows Server 2012, and has been supported by all versions of Windows since XP (both client and server) through Windows Remote Management (WinRM). For more information about WS-Man and how it is supported in Windows Server, System Center, and PowerShell, see Jeffrey Snover’s blog post on the Windows Server blog.

Microsoft has a longstanding commitment to interoperability and standards in the management arena. In the early 1990s, Microsoft was one of the founding members of DMTF, and worked closely with industry partners on the development of CIM, a flexible standard that has been adopted for a wide variety of uses across computer systems, operating systems, networks, and storage devices. WS-Man and CIM are a powerful combination, with a rapidly growing ecosystem, and ISO/IEC adoption of WS-Man as an international standard will enable further adoption. Microsoft worked with the industry to standardize WS-Man CIM mappings for common management scenarios.

Microsoft also developed OMI (Open Management Infrastructure), a high-performance small-footprint implementation of a CIM+WS-Man server, released last year by The Open Group as an open-source project under the Apache 2 License. Written in portable C, OMI provides an enterprise-grade CIM and WS-Man implementation so that hardware and software vendors can focus their investments on providers and schemas within their domain expertise. OMI opens up management of hardware devices from any vendor in a datacenter using a “Datacenter Abstraction Layer” or DAL – enabling management of devices and servers that implement standard protocols and schemas from standards compliant tools like PowerShell.

Through those and related initiatives, we are continuing to help the industry deliver on the promise of standards-based solutions that address the cost and complexity of systems management. For example, DMTF also announced today that the DMTF Platform Management standard, which provides a common architecture for communication between management subsystem components, was adopted by ANSI (American National Standards Institute) and INCITS (International Committee for Information Technology Standards) as a US national standard, INCITS 495-2012 Platform Management. As DMTF VP of Technology Hemal Shah noted in today's announcement, “Adoption and recognition of the Platform Management and Web Services Management standards by these organizations provide additional credibility, while increasing the accessibility of these solutions to IT managers.”

These developments are further evidence of the global interest in interoperable, royalty-free, standards-based solutions to management of systems, applications, and devices. Congratulations to everyone who has worked to help achieve these important milestones!

Back in November Microsoft Open Technologies, Inc. announced that Advanced Message Queuing Protocol (AMQP) 1.0 was approved as an OASIS Standard. AMQP 1.0 enables interoperability using wire-level messaging between compliant clients and brokers. Applications can achieve full-fidelity message exchange between components built in multiple languages and frameworks and running on different operating systems.

Today we’re happy to share the news that the Apache Qpid Proton C AMQP library has been updated to support Windows. Proton C also includes bindings for several interpreted languages including PHP, Python, Ruby and Perl, all of which can now be used on Windows.

UPDATE 04/18/2013 - The following paragraph was in error. The Windows Proton libraries do not work with the latest preview release of service bus due to lack of SSL support. We apologize for the error.

These Proton clients can be used in conjunction with Windows Azure Service Bus, which introduced support for AMQP 1.0 as a preview feature last October, with GA planned later this year. Applications can use AMQP to access the queuing and publish/subscribe brokered messaging features. Service Bus is a multi-protocol service, so in addition to AMQP, applications can also use REST/HTTP to access Service Bus from any platform.

For more information, check out the official OASIS site, this developer’s guide, and downloads(the 0.4 version supports Windows) for Qpid Proton. MS Open Tech was one of many contributors to this project, and we appreciate all the work that the community is doing to help developers take full advantage of AMQP across many different languages, frameworks, and platforms.

HTTP, the Hypertext Transfer Protocol, is one of the most important protocols for the Internet, and we’re pleased to report progress on the next generation HTTP/2.0 as we recently returned from our interim HTTPbis Working Group meeting in Tokyo (HTTPbis is the HTTP Working Group in the Internet Engineering Task Force).

Our industry standards community reached preliminary agreements on the next steps for the first in a series of experimental implementations of HTTP/2.0 that will improve the performance for how every application and service on the Web communicates today.

The most important outcome of the interim meeting in Tokyo was the recommendation to create a HTTP/2.0 “Implementation Draft Specification” based on the set of features that have achieved rough consensus in the HTTPBIS working group at this time. There was strong agreement among the attendees with this direction and commitment to implementing this draft specification when available.

The implementation draft is targeted for March with another HTTP/2.0 interim meeting proposed between June-September where interoperability testing can occur.

The full proposal is available here. Many of these features are dependent on the rapid execution of their related action items.

The proposed feature list includes significant changes to:

Upgrade

Header Compression

Flow Control

Framing

Server Push

The intent is to converge on the details using the IETF HTTPBIS mailing list and then implement and validate the subsequent implementation draft. And then repeat the process based on our experience and new understanding – as Mark Nottingham (IETF HTTPBIS chair) has clarified:

Note that we are NOT yet firmly choosing any particular path; rather, we're working on proposals in code as well as text, based upon discussion to date. As such, we're likely to have several such implementation drafts that progressively refine the approach we're taking. I.e., we don't have to agree that the above is what we want HTTP/2.0 to look like -- only that it's interesting to make these changes now, so that we can test them.

Looking Ahead

We are pleased with the direction of the HTTPBIS working group and are looking forward to interoperability testing with our HTML5 Labs HTTP/2.0 prototype.

Based on the action items from the interim meeting in Tokyo, there is already active discussion on the IETF HTTPBIS mailing list as more detailed proposals are prepared and shared with the working group. We encourage the community to openly and actively contribute to the mailing list and strongly consider prototyping the implementation draft when available.

We are looking forward to further discussions at the IETF 86 HTTPBIS meeting on March 15 in Orlando where we continue our goal to help ensure, along with our IETF colleagues, that HTTP/ 2.0 meets the needs of the broader Internet community.