• Interoperability @ Microsoft

    MongoDB on Azure – Onsite in New York City!

    • 0 Comments

    Excitement is in the air for the MongoDB community and Microsoft Open Technologies, Inc. this week as MongoDB’s inaugural global community event -MongoDB World is now underway at the Sheraton in New York City. I’m here and I’ll be around for the whole event – I’m looking forward to meeting the global MongoDB community!   Check out the full post on the MS Open Tech Blog

  • Interoperability @ Microsoft

    Identity “Mash-up” Federation Demo using Multiple Protocols (OpenID and WS-Federation)

    • 1 Comments

    [Guest blogger Mike Jones, from the Federated Identity Team]

    At the last Interoperability Executive Customer (IEC) Council meeting in October 2009, there was broad agreement to involve third party software vendors to work with IEC Council members and Microsoft on specific interop scenarios brought forward by the council members.  We are pleased to report that over the last five months, the council was able to engage in very productive discussions with PayPal on an Identity Management interoperability scenario proposed by Medtronic.

    Medtronic, PayPal, and Microsoft worked together to produce a multi-protocol federated identity “mash-up” demo using multiple protocols (OpenID and WS-Federation). This demo was shown at the Internet Identity Workshop and to members of the IEC Council.  The demo shows how Medtronic customers could use PayPal identities when signing up for and participating in a medical device trial.

    clip_image001

    You can view a video of the demo here.

    We called it an “identity mash-up” because claims from the PayPal identity are combined with (“mashed-up” with) additional claims added by Medtronic for trial participants to create a composite Medtronic trial identity.  Medtronic creates “shadow” accounts for trial participants, but from the user’s point of view they’re always just using their PayPal account whenever they have to sign for the trial.

    It’s multi-protocol because the PayPal claims are delivered to Medtronic using OpenID 2.0, whereas the claims from Medtronic are delivered to its relying parties using WS-Federation.  It’s interop because the demo uses both .NET and the Windows Identity Foundation on Windows and PHP on Linux, with interoperable identity protocols letting them seamlessly work together.

    Southworks, the company that built much of the demo, has released the source code and documentation for a proof-of-concept OpenID/WS-Federation Security Token Service (STS) based on the one used in the demo, should you be interested in prototyping something similar.

    We want to thank Medtronic and PayPal for their leadership and partnership of this effort and Southworks for their professionalism, agility, and execution.  We appreciate the opportunity to work with other industry leaders both to understand and demonstrate the interoperability that’s possible with our current product offerings and to inform the planning efforts for our future identity products.”

    Mike Jones, Senior Program Manager, Federated Identity Team

  • Interoperability @ Microsoft

    Microsoft Donates JavaScript Materials to Web Platform Docs

    • 1 Comments

    We’d like to highlight a pleasant spring surprise from our Microsoft colleague Eliot Graff who this week has informed the tech community that Microsoft is proving additional content to the Webplatform.org project by donating over 400 pages of JavaScript reference materials.

    Microsoft Open Technologies, Inc., and the Microsoft Internet Explorer team represented by Eliot, have been involved from the very beginning of the W3C’s Web Platform Docs (WPD), a community site designed to be a comprehensive and authoritative resource for developers to help build modern web applications that will work across browsers and devices. We strongly believe this community site is key in the journey to an interoperable web platform and same markup.

    From Eliot’s Blog post:

    “To date, JavaScript remains one of the areas in Web Platform Docs where we are still in need of robust reference documentation. I am pleased to announce that Microsoft is donating over 400 pages worth of additional content to Web Platform Docs, in order to boost our library in this regard.”

    So what does this mean for you, the developer?

    You will save time and resources, knowing you can consult confidently with a community-curated site to learn about standards, innovations and best practices including:

    • What technologies really interoperate across platforms and devices;
    • The standardization status of each technology specification;
    • The stability and implementation status of specific features in actual browsers.

    Microsoft's involvement in the Web Platform Docs project dates back to its inception almost two years ago. Ten supporting steward organizations (the W3C, Adobe, Facebook, Google, HP, Intel, Microsoft, Mozilla, Nokia, and Opera) have pooled their resources in order to create a single, centralized, nonpartisan, accurate, complete, and comprehensive collection of educational and reference materials for web development.

    We trust this additional contribution from Microsoft will strengthen the existing foundation to the JavaScript reference materials.

    WPD is a community effort. Anyone can join or contribute. The infrastructure is set up using an instance of MediaWiki, the same as Wikipedia. You can visit the site at www.webplatform.org and watch an overview video. From there, check out the docs or the community content. You can also join the effort and start editing, writing, and contributing in other ways. You can add a little code sample, write a tutorial, or join in for some of the organized doc sprints or other activities.

    Begin simplifying your web development and check out W3C’s Web Platform Docs today. Better still, sign up for an account, find a topic of interest, and contribute your expertise!

  • Interoperability @ Microsoft

    New WebSockets Update Continues to Interoperate with Firefox, Eclipse's Jetty

    • 0 Comments

    The WebSockets prototype has been updated on our HTML5 Labs site, bringing the implementation in line with the recently released WebSockets 07 Protocol Specification.

    This latest release updates both the server and client prototype implementations based on 07 specification. The majority of the changes in this update are around client-to-server masking. 

    In the WebSockets 06 Protocol Specification, the entire frame was masked using the 32-bit masking-key, which appeared before the frame. Now,  in the 07 protocol spec, only data following opcode and length are masked, again using the 32-bit masking-key that appears after opcode and length.

    We are also hosting a WebSocket endpoint, which implements the proposed IETF interop tests, which are defined here.  You can find the WebSocket endpoint here: ws://html5labs.cloudapp.net:4502/interoptests.

    In addition, our client and server implementations continue to be interoperable with Firefox and Jetty (an open source project providing an HTTP server, HTTP client, and javax.servlet container, developed by the Eclipse community.)

    This prototype forms part of our HTML5 Labs Web site, a place where we prototype early and not yet fully stable drafts of specifications developed by the W3C and other standard organizations. The WebSocket API is currently being standardized by the W3C and the WebSocket protocol is being standardized by the IETF.

    Building these prototypes in a timely manner will also help us have informed discussions with developer communities, and give implementation experience with the draft specifications that will generate feedback to improve the eventual standards.

    This is the fourth update to our WebSockets prototype since it was released on the HTML5 Labs site in December, the IndexedDB prototype has been updated to bring it in line with the latest version of the specification, and we recently added a new WebSockets demo.

    We anticipate further HTML5 Labs prototypes of WebSockets when the current Last Call review is completed and an updated draft comes out.  We will also update the prototype when the W3C Web Applications Working Group updates the API specification to reflect the resolution of a currently open bug.  There appears to be an emerging consensus in the discussion and we expect an update of the editor’s draft soon.

    Coming next is the Media Capture API prototype, a draft specification that defines HTML form enhancements to provide access to the audio, image and video capture capabilities of a device.

    The first release of the prototype includes Audio capabilities only, but we plan to add video support shortly after the release of the first version.

    So, stay tuned for the Media Capture  prototype and other new ones that we are working on right now.

    Thanks!

    Claudio Caldato,

    Principal Program Manager, Interoperability Strategy Team

  • Interoperability @ Microsoft

    OData submitted to OASIS for standardization

    • 2 Comments

    Citrix, IBM, Microsoft, Progress Software, SAP AG, and WSO2 have submitted a proposal to OASIS to begin the formal standardization process for OData. You can find all the details here, and OData architect Pablo Castro also provides some context for this announcement over on the OData.org blog. It’s an exciting time for the OData community!

    OData is a REST-based web protocol for querying and updating data, and it’s built on standardized technologies such as HTTP, Atom/XML, and JSON. If you’re not already familiar with OData, the OData.org web site is the best place to learn more.

    Many organizations are already working with OData, and it has proven to be a useful and flexible technology for enabling interoperability between disparate data sources, applications, services, and clients. Chris Woodruff has a blog post this week that lists many OData implementations, and as he explained in a post last week, “By having data that is easy to consume and understand organizations can allow their customers and partners (via the developers that build the solutions using one or more of the available OData libraries) to leverage the value of curated data that the organization owns.” Many organizations are already pursuing that vision – as Ralf Handl of SAP AG told us at a recent OData meetup, “my job is relatively simple: I want to put OData into all of our products.”

    We support OData in many Microsoft products and services, and the list is growing longer all the time. This includes OData consumers such as Microsoft Excel (via the free PowerPivot add-in) as well as OData producers such as Microsoft SharePoint, Microsoft SQL Server Reporting Services, and Microsoft Dynamics CRM. Windows Server supports OData, and Windows Azure provides OData support in many areas, including Windows Azure Storage Table Service, Windows Azure Marketplace, and ACS Management Service. We’re also making many Microsoft data sources available in OData format. For example:

    • The OData feed from Microsoft Research can be used to query against publications, projects, events, and other entities.
    • The Windows Azure Marketplace DataMarket offers OData feeds for Business, Government, Health Science, Retail, and many other categories.

     A variety of OSS technologies can benefit from OData support, and our team has delivered tools to make it easy for OSS developers to expose data as OData from a variety of platforms. Earlier this year we announced Open Source OData Tools for MySQL and PHP Developers, including the OData Producer Library for PHP and the OData Connector for MySQL. We’re continuing to work closely with various OSS communities on OData support, and we’ll be releasing information soon on new ways to provide OData feeds from popular OSS frameworks and applications.

    OData’s query syntax is straightforward from a developer’s perspective. For example, here’s a query that you can use in any browser to return the count of the number of products in the sample Northwind database OData feed on OData.org:

            http://services.odata.org/Northwind/Northwind.svc/Products/$count

    In a typical application, that query would be generated behind the scenes, and the returned result would be rendered in a nicely formatted manner as appropriate for the particular application.

    To enable those sorts of scenarios, developers need OData support for the languages, framework, and tools that they’re already using. Many developer tools already offer OData support. Here are a few examples:

    • Microsoft Visual Studio offers comprehensive OData support through WCF Data Services.
    • OData support is provided by OSS SDKs for iPhone, Android, and other frameworks.
    • Telerik has developed a variety of developer tools and services for creating OData consumers and producers.
    • ComponentOne offers OData support in their BarChart and LineChart controls.
    • Validation is a critical step in creating robust OData services, and the Outercurve Foundation provides an OData Service Validation Tool that can be used to test implementations against the OData spec.
    • The OData4j project is an open-source toolkit to help Java developers add OData support to their applications and services.

    As you can see, the OData ecosystem is growing, and awareness of OData is growing with it. At the OData meetup earlier this year, we heard from many people who are finding innovative ways to use OData in their organizations to improve customer service, enable new scenarios, and increase efficiency. Anant Jhingran of APIgee stated in his presentation at the meetup that “if data isn’t your core business, then you should give it away.” It was a provocative statement, and for those who share that philosophy, OData is a great tool for making it easier to share data.

    If you’re interested in implementing OData or contributing to the OData standard, now’s the time to get involved. You can work with the odata.org community to help drive awareness and share implementation experiences, or join the OASIS OData technical committee (OData TC) to contribute to the standard.  The OData TC will be a vibrant and diverse group of people – just like the community who got us here today – working together to open up data sources in a standardized way. As Pablo stated in his blog post, the main value of OData is not any particular design choice, but the fact that enough people agree to the same pattern, thus removing friction from sharing data across independent producers and consumers. The first TC call will be in late July, so there’s still plenty of time to get involved if you’d like to be part of the team that will be helping OData evolve.

    Congratulations to everyone who has worked so hard to get OData to this important step on the journey to standardization! We’re looking forward to working with the community to develop OData into a formal standard through OASIS.

    Doug Mahugh
    Senior Technical Evangelist
    Microsoft Open Technologies, Inc.
    A subsidiary of Microsoft Corporation

  • Interoperability @ Microsoft

    New Reactive Extension Support for JavaScript Developers – Compatibility Builds, a lite version, and other improvements in RxJS 2.2

    • 0 Comments

    From the Rx team,

    Claudio Caldato, Principal Program Manager Lead, MS Open Tech
    Snesha Foss, Senior Program Manager, MS Open Tech
    Kirk Shoop, Senior Software Development Engineer, MS Open Tech
    Matthew Podwysocki, Software Engineer, Microsoft

    Today Microsoft Open Technologies, Inc. (MS Open Tech), is happy to share the news of recent improvements we have made to Reactive Extensions.

    We recently highlighted a release of Reactive Extensions Core as well as Rx.cpp. Today we want to let you know that RxJS 2.2 is now available via the Rx.js CodePlex project and includes various bug fixes and contributions from the community.

    Reactive Extensions (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, UI events, and Web service requests. Since Rx was open-sourced by MS Open Tech in November, 2012, Rx has become an important under-the-hood component of several high-availability multi-platform applications, including NetFlix and GitHub. For a more detailed overview, have a look at the Beginner’s Guide to Reactive Extensions.

    Updates:
    Compatibility Builds

    The core Rx.js now supports browsers that support ES5 only. We have moved all of our previously shipped ES5 polyfills to rx.compat.js. This saves a number of bytes, and allows developers to use any polyfill library of your choosing in order to support older browsers. We also have Compatibility builds for other key libraries, a few of which h are mentioned below.

    Introducing Rx-Lite

    One common question from our customers is, "Could we get a core of RxJS with a set of operators we use most often in a single, smaller library?" We hear you and have now provided rx.lite.js. This library consists of the most commonly used features, including factory methods for creating observable sequences, standard operators such as where, select, and zip, relative-time based operators and the most commonly used features from rs.async.js, including events, callbacks and promises bindings. The file size has is drastically reduced – currently just 7k when zipped. We also provide a compatibility build, rx.lite.compat.js to support older browsers.

    Events, callbacks and promises with rx.async.js updates

    Traditionally RxJS has not included many bridges to such things as events, promises or even callbacks. In version 2.2, we’re introducing the fromEvent to bind to events, fromCallback to support bridging to callbacks, fromNodeCallback to support Node.js style callbacks in which the error is always the first parameter, and Promises library binding in rx.async.js. With this library, you can easily compose events, promises and callbacks within a single library without having to bring in any other bridge library such as jQuery or HTML DOM. For older browsers, the compatibility build is rx.async.compat.js.

    Control Virtual Time with rx.virtualtime.js

    To decrease the size and scope of rx.js, all virtual time mechanisms were moved from the core library and into their own library, rx.virtualtime.js. This includes the VirtualTimeScheduler and the HistoricalScheduler.

    Operator Changes and Additions:
    • The create factory function now takes as its return value a function which encapsulates disposal logic, or nothing if no cleanup is required. This deprecates the need for Observable.createWithDisposable.

    • Fixed the behavior of scan, to produce a sequence with only the seed if a sequence is empty but a seed was provided. If the sequence is empty and without a seed, an empty collection is created.

    • The share method was added to create a shortcut for publish().refCount(), a common function for sharing a single observable sequence.

    • A new shareLast method has been added to create a shortcut for the often used publishLast().refCount() to turn cold observables into hot observables and add reference counting.

    • The shareReplay method was added to create a shortcut for replay().refCount() to turn a hot observable into a cold observable and add reference counting.

    • The shareValue method was added to support a shortcut for publishValue().refCount() to publish a shared single value with reference counting added.

    Other Recent Changes
    • rx.modern.js renamed to rx.js and old rx.js renamed to rx.compat.js for older browser support

    • VirtualTimeScheduler and HistoricalScheduler classes moved to rx.virtualtime.js

    • Rx.Observable.start and Rx.Observable.prototype.toAsync methods moved to rx.async.js

    Deprecation Warnings:

    The following Node,js specific methods in rx.node.js are being removed in favor of those in rx.async.js

    • Rx.Node.fromEvent - Now use Rx.Observable.fromEvent

    • Rx.Node.fromCallback – Now use Rx.Observable.fromCallback

    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, and please try out our work and pitch in!

  • Interoperability @ Microsoft

    Advanced Message Queuing Protocol (AMQP) 1.0 approved as an OASIS Standard

    • 0 Comments

    We are very excited to share the news that AMQP 1.0 was approved as an OASIS Standard on October 29, 2012.

    AMQP 1.0 libraries are available for a variety of languages and platforms. The interest amongst users is growing. Support for AMQP 1.0 is anticipated in various message-oriented middleware implementations. AMQP 1.0 is the protocol of choice for open and interoperable messaging from the client all the way to the cloud!

    AMQP 1.0 as an open, interoperable, wire level messaging protocol enables interoperability between compliant clients and brokers. Applications can achieve full-fidelity message exchange between components built using different languages and frameworks and running on different operating systems. Further, as an inherently efficient application layer binary protocol, AMQP 1.0 enables new possibilities in messaging that scale from the client to the cloud.

    IIT Software GmbH, INETCO Systems Ltd., Microsoft, Red Hat and StormMQ have publicly posted statements about their use of AMQP 1.0 to the OASIS AMQP Technical Committee.

    Several AMQP 1.0 client libraries are currently available:

    1. AMQP 1.0 JMS library for Java from Apache Qpid

    2. AMQP 1.0 library for Java from SwiftMQ (IIT Software GmbH)

    3. Proton AMQP 1.0 library for C (including PHP and Python bindings) from Apache Qpid (Linux only today)

    Several other AMQP 1.0 client libraries are being developed. For example, the Apache Qpid community is porting the Proton AMQP 1.0 library to Windows. AMQP 1.0 client libraries for other languages, such as JavaScript and Ruby, are anticipated in the next several months.

    Windows Azure Toolkit for Eclipse, November 2012 Preview (version 1.8.0) now includes a new component “Package for Apache Qpid Client Libraries for JMS (by MS Open Tech)” which makes it easier for Java developers who use Eclipse to develop Java applications that use AMQP 1.0 for messaging.

    Stay tuned for more information as more libraries and implementations become available!

    Thanks,
    Ram Jeyaraman (Co-chair of OASIS AMQP Technical Committee and Senior Program Manager, Microsoft Open Technologies, Inc., a subsidiary of Microsoft Corporation)
    Doug Mahugh (Senior Technical Evangelist, Microsoft Open Technologies, Inc., a subsidiary of Microsoft Corporation)

    Additional Information

    AMQP Member Section Site: http://www.amqp.org

    OASIS AMQP Technical Committee: http://www.oasis-open.org/committees/amqp

  • Interoperability @ Microsoft

    Acceptance of Media Source Extensions as W3C Candidate Recommendation will accelerate adoption of dash.js

    • 0 Comments

    Microsoft Open Technologies, Inc. welcomes the news that the Media Source Extensions (MSE) specification has moved to Candidate Recommendation (CR) at the W3C.MSE Overview showing how MSE allows JavaScript to directly manipulate media buffers.

    Media Source Extensions allow JavaScript to manage media buffers directly.

    This is a critical step towards broad adoption of the dash.js project which provides cross-browser support for MPEG-DASH adaptive streaming video using MSE, a W3C specification that extends the HTMLMediaElement (video and audio) to allow JavaScript to generate media streams for playback.  This capability facilitates a variety of use cases, including adaptive streaming and time shifting live streams.

    What is dash.js and why is MSE important to it?

    At MS Open Tech we have been working on a project called dash.js for some time. Dash.js is an open source MPEG-DASH video player written in JavaScript.

    The objective of the dash.js project is to provide a robust, cross-platform player that can be freely reused in applications that require video playback. It provides MPEG-DASH playback in any browser that supports the W3C Media Source Extensions (MSE). Today, that includes Chrome and Internet Explorer 11, other browsers have indicated their intent to support MSE in the future. Consequently, here at MS Open Tech we are very pleased to see MSE move to Candidate Recommendation status.

    Our primary reason for contributing to dash.js is to make it easier for third parties to build adaptive streaming video players using MPEG-DASH, the latest ISO standard for Internet media streaming. This standard represents the future of online video, more than 75% of surveyed European broadcasters plan to adopt MPEG-DASH by the middle of this year.

     What does it mean to be a Candidate Recommendation?

    Advancement to Candidate Recommendation is an explicit call to those outside of the W3C and its Working Groups for implementation and technical feedback. The latest version of both Chrome and Internet Explorer already provide implementations of MSE but this progression to Candidate Recommendation increases the likelihood that other browsers will support it. In fact, Mozilla has already made great progress in their implementation of MSE. Similarly the WebKit project is working towards MSE support.

    For dash.js this is a very important step forwards. Since dash.js uses MSE to deliver MPEG-DASH content in browser based applications an increased level of browser support for the standard will help to ensure dash.js a truly viable MPEG-DASH player. This was clearly illustrated during a recent dash.js panel at Streaming Media West where representatives of MS Open Tech., Google and Digital Primates all identified increased adoption of MSE in browsers as being at the top of their wish list for the dash.js project.

    Invitation to dash.js

    With MSE moving to Candidate Recommendation, it appears that work is also well underway for standards-compliant streaming to become a reality across browsers who plan to adopt the MPEG-DASH standard. We are excited about these developments, and encourage you to start exploring the possibilities  using dash.js to create an MPEG-DASH player in just a few lines of JavaScript.

  • Interoperability @ Microsoft

    New MS Open Tech Prototype of the HTTP/2.0 initial draft in an Apache HTTP server module

    • 0 Comments

    We continue to see good momentum within the HTTP/2.0 Working Group (IETF 85 meeting) toward identifying suitable technical answers for the seven key areas of discussion, which we had identified back in August, including an update to the HTTP/2.0 Flow Control Principles draft, which Microsoft co-authored with Google and Ericsson.

    Through our continuing support of the HTTP/2.0 standardization through code, we have made some updates to our prototypes and just posted them on HTML5 Labs. We have moved from the Node.js implementation used server-side by our earlier prototypes to a modified implementation of an existing Apache module for which we are making available in the associated patch.

    In this latest iteration, we have made three changes in particular to advance discussions on the HTTP/2.0 initial draft and thinking around interoperable implementations:

    Negotiation: we have improved upon our initial implementation of the protocol upgrade that we released last month, supporting the scenario where the server does not accept a protocol upgrade.

    Flow Control: our prototype uses an infinite Window Update size that is effectively the simplest possible implementation and can be expected to be chosen for many real-world deployments, e.g. by specialized devices for the “Internet of things.”

    Server push: we have implemented a behavior on the client that resets connections upon receipt of unrequested data from the server. This is particularly important where push might be especially unwelcome on mobile/low bandwidth connections.

    This iteration continues to demonstrate our ongoing commitment to the HTTP/2.0 standardization process. Throughout this journey, we have honored the tenets that we stated in earlier updates:

    • Maintain existing HTTP semantics.
    • Maintain the integrity of the layered architecture.
    • Use existing standards when available to make it easy for the protocol to work with the current Web infrastructure.
    • Be broadly applicable and flexible by keeping the client in control of content.
    • Account for the needs of modern mobile clients, including power efficiency, support for HTTP-based applications, and connectivity through tariffed networks.

    These tenets will continue to inform the direction of both our proposals to the IETF and of our engineering efforts.

    Please try out the prototype, give us feedback and we’ll keep you posted on next steps in the working group. We will also follow up soon with test data resulting from our work on this code.

    As we have stated throughout this process, we’re excited for the Web to get faster and more capable. HTTP/2.0 is an important part of that progress and we look forward to improving on the HTTP/2.0 initial draft in collaboration with our fellow working group participants and the Web community at large as we aim for an HTTP/2.0 that meets the needs of the entire Web, including browsers, apps, and mobile devices.

    Adalberto Foresti
    Principal Program Manager
    Microsoft Open Technologies, Inc.
    A subsidiary of Microsoft Corporation

  • Interoperability @ Microsoft

    The WebSockets Prototype Gets Another Update

    • 1 Comments

    As we continue to move forward with updating the prototypes on our HTML5 Labs site as quickly as possible, I am happy to tell you that we have once again updated the WebSockets prototype, a move that brings the implementation in line with the recently released WebSockets 05 Protocol Specification.

    The 05 spec introduces some changes to the masking algorithm.  Specifically, the masking key is no longer derived from the information that client and server exchange during the handshake, but is now fully contained within each frame.

    WebSockets is a technology designed to simplify much of the complexity around bi-directional, full-duplex communications channels, over a single Transmission Control Protocol (TCP) socket. It can be implemented in web browsers, web servers as well as used by any client or server application.

    Also, as we strongly believe that interoperability is very important, we have tested our implementation with another 05 WebSockets implementation that uses C++ and runs on Linux: libwebsockets

    In order to verify this, we setup a Fedora Linux machine with libwebsockets in our Interoperability lab.  We also set up another Windows 2008 R2 machine in the lab, and installed our WebSockets 05 prototype bits on it. Libwebsockets already comes with client and server samples, so we decided to use those for testing.

    The configurations we tested are:

    Server: libwebsockets

    Client: html5labs prototype

    In this configuration we ran the test libwebsockets server on Fedora Linux, which accepts a client connection and sends incrementing integer values to the client every 50ms.  The server resets the counter to 0 whenever it receives “reset” from the client. 

    This screenshot shows the libwebsockets test server starting and then confirming the handshake

     This screenshot shows the HTML5 Labs test client starting and then confirming the handshake

    For the client we created a .NET console application, which uses Microsoft.ServiceModel.WebSockets.DesktopClient.dll (the library that we have been releasing with the WebSockets prototypes).  The application creates a WebSocket connection to the Fedora machine, and receives incrementing integers from the server.  When it reaches the count of 200, it sends “reset” to the server.

    Server: html5labs prototype

    Client: libwebsockets

    In this configuration we created an equivalent .NET application, which acts as a server and sends incrementing integers to the client every 50ms.  This application uses Microsoft.ServiceModel.WebSockets.dll (the library that we have been releasing with the WebSockets prototypes).  We ran the client sample on the Fedora machine, which creates a WebSocket connection to the Win2008 server machine, and receives incrementing integers.

     This screenshot shows the HTML5 Labs test server starting and then confirming the handshake

     

     This screenshot shows the libwebsockets test client starting and then confirming the handshake

    This prototype forms part of our HTML5 Labs Web site, a place where we prototype early and not yet fully stable drafts of specifications developed by the W3C and other standard organizations. The WebSocket API is currently being standardized by the W3C and the WebSocket protocol is being standardized by the IETF.

    We believe that the HTML5 Labs approach has advantages over placing unstable specifications directly in the browser. First, developers can build on Internet Explorer 9 without worrying that their site will break as the underlying specs change. Second, we will iterate very quickly in HTML5 Labs and expect the standalone approach with prototypes to be closer to the latest specs. As an example with WebSockets, most browsers are still on the outdated versions of WebSockets-00 or older.

    Building these prototypes in a timely manner will also help us have informed discussions with developer communities, and give implementation experience with the draft specifications that will generate feedback to improve the eventual standards.

    Claudio Caldato,

    Principal Program Manager, Interoperability Strategy Team

  • Interoperability @ Microsoft

    Eclipse Plugin for Java Developers on Windows Azure

    • 1 Comments

    I’m pleased to announce the availability of the Windows Azure Plugin for Eclipse with Java (by Microsoft Open Technologies), June 2012 CTP.

    This has been the most ambitious and technically complex update we’ve had, focusing on improving the ease of creating projects, deploying apps to the cloud, and simplifying developers’ programmatic access to various services provided by Windows Azure. This update also includes a set of other enhancements driven by user feedback.

    These are the main additions:

    - New Windows Azure Deployment Project wizard – enables you to select your JDK, Java server, and Java apps right in the improved wizard UI. The list of out-of-the-box server configurations to choose from now includes Tomcat 6, Tomcat 7, GlassFish OSE 3, Jetty 7, Jetty 8, JBoss 6, and JBoss 7 (stand-alone), and it is user-customizable. (This UI improvement is an alternative to dragging and dropping compressed files and copying over startup scripts, which was previously the main approach. That method still works fine but will likely be preferred only for more advanced scenarios now.)

    - Server Configuration role property page – enables you to easily switch the servers and applications associated with your deployment after you create the project, as part of the Role Propertiesdialog box.

    - “Publish to cloud” wizard – an easy way to deploy your project to the Windows Azure cloud directly from Eclipse, automating all the heavy lifting of fetching credentials, signing in, uploading, and so on. (This is a contribution from our Java partner GigaSpaces Technologies Ltd.)

    - Widows Azure Toolbar – provides easy access to several commonly used actions: Run in emulator, Reset emulator, Create cloud package, New Windows Azure Project, Publish to Windows Azure cloud, Unpublish.

    - Componentsproperty page makes it easier for advanced users to set up project dependencies between individual Windows Azure roles in the project and other external resources such as Java application projects, as well as to describe their deployment logic.

    - Package for Windows Azure Libraries for Java (by Microsoft Open Technologies, Inc) consists of all the JAR files needed for programming the Windows Azure APIs, including the Windows Azure Libraries fo Java. It is installed by default when you install the main plugin. You add a reference to just this one Eclipse library from your Java project. You can now also easily embed the entire library in your WAR file at the same time with just a single check box (no need to configure the deployment assembly separately). This package is for users who do not use Maven and would rather not have to download all the JAR files on their own.

    - Instance input endpoint configuration UI– helps enable remote debugging and JMX diagnostics for specific compute instances running in the cloud in scenarios with multi-instance deployments. Users can do this by configuring this new type of Windows Azure endpoint. (Previously, remote debugging could be made to work reliably only for single-instance deployments.)

    - Windows Azure Access Control Services Filter (by Microsoft Open Technologies, Inc) – enables your Java application to seamlessly take advantage of Windows Azure Active Directory Access Control (ACS) authentication using various identity providers (such as Google, Live.com, and Yahoo). You don’t have to write authentication logic yourself, just configure a few options and let the filter do the heavy lifting of enabling users to sign in using ACS. Then just write the code that gives users access to resources based on their identity, as returned to your app by the filter inside the Request object.

    Martin Sawicki

    Principal Program Manager

    Microsoft Open Technologies, Inc.

    A subsidiary of Microsoft Corporation

  • Interoperability @ Microsoft

    HTTP/2.0 makes a great step forward in Vancouver, but this is just the beginning!

    • 0 Comments

    From:

    Henrik Frystyk Nielsen
    Principal Architect, Microsoft Open Technologies, Inc.

    Rob Trace
    Senior Program Manager Lead, Microsoft Corporation

    Gabriel Montenegro
    Principal Software Development Engineer, Microsoft Corporation

     

     

    We just came back from the IETF meeting in Vancouver, where the HTTP working group was meeting to decide on the way forward for HTTP/2.0. We are very happy with the discussions and overall outcomes as reflected in the meeting minutes and as summarized by the Chair, Mark Nottingham. At the meeting, the working group clarified the direction for HTTP/2.0 and began to draft a new charter. The group agreed that seven key areas need deep, data-driven discussion as part of the HTTP/2.0 specification process, and the resulting standard will not be backward compatible with any existing proposals (SPDY, HTTP Speed+Mobility, and Network-Friendly HTTP Upgrade). The charter calls for a proposed completion date for the standard of November 2014. In other words, while we are excited about where we are, it is clear that we are just at the beginning of the process toward HTTP 2.0.

    Seven Key areas under discussion

    The meeting outlined clearly the need for discussions and consensus over seven key technical areas such as Compression, Mandatory TLS, and Client Pull/Server Push. This list of issues is aligned with the position that Microsoft’s Henrik Frystyk Nielsen outlined in an earlier message to the HTTP discussion list (see excerpts below). Overall, we believe there needs to be robust discussions about how we bring together the best elements of the current SPDY, HTTP Speed+Mobility, and Network-Friendly HTTP Upgrade proposals.

      Area

      Opinion that seems to prevail

      1. Compression

      SPDY or Friendly

      2. Multiplexing

      SPDY

      3. Mandatory TLS

      Speed+Mobility

      4. Negotiation

      Friendly or Speed+Mobility

      5. Client Pull/Server Push

      Speed+Mobillity

      6. Flow Control

      SPDY

      7. WebSockets

      Speed+Mobility

     

    HTTP/2.0 specification must be data-driven

    We are particularly gratified to see this language in the proposed charter:

    It is expected that HTTP/2.0 will:
    * Substantially and measurably improve end-user perceived latency in most cases, over HTTP/1.1 using TCP.

    This supports Microsoft’s position that the HTTP update must be data-driven to ensure that it provides the desired benefits for users. . The SPDY proposal has done a good job of raising awareness of the opportunities to improve Web performance.

    Almost equal performance between SPDY and HTTP 1.1

    To compare the performance of SPDY with HTTP 1.1 we have run tests comparing download times of several public web sites using a controlled tested study. The test uses publically available software run with mostly default configurations while applying all the currently available optimizations to HTTP 1.1. You can find a preliminary report on the test results here: http://research.microsoft.com/apps/pubs/?id=170059. The results mirror other data (http://www.guypo.com/technical/not-as-spdy-as-you-thought) that indicate mixed results with SPDY performance.

    Our results indicate almost equal performance between SPDY and HTTP 1.1 when one applies all the known optimizations to HTTP 1.1. SPDY's performance improvements are not consistent and significant. We will continue our testing, and we welcome others to publish their results so that HTTP 2.0 can choose the best changes and deliver the best possible performance and scalability improvements compared to HTTP 1.1.

    We discussed those results in Vancouver and it was great to see the interest that this research received from the community on the IETF mailing list and on Twitter.

    Existing proposals will change a lot – No backward compatibility

    In light of the discussions and the proposed charter, HTTP2.0 will undoubtedly not be backward compatible with any of the current proposals (SPDY, Speed+Mobility, Friendly); in fact, we expect that it might differ in substantial ways from each of these proposals. Consequently, we caution implementers against embracing unstable versions of the specification too eagerly. The proposed charter calls for an IETF standard by November 2014.

    We are happy that the working group decided, for practical reasons, to use the text from http://datatracker.ietf.org/doc/draft-mbelshe-httpbis-spdy/ as a starting point. The discussions around the previously cited seven design elements will deeply modify this text . As the Chair wrote, “It’s important to understand that SPDY isn’t being adopted as HTTP/2.0” . This is in line with the Microsoft approach: Our HTTP Speed+Mobility proposal starts from both the Google SPDY protocol (a separate submission to the IETF for this discussion) and the work the industry has done around WebSockets, and the main departures from SPDY are to address the needs of mobile devices and applications.

    Looking ahead

    We’re excited for the web to get faster, more stable, and more capable. HTTP/2.0 is an important part of that progress, and we look forward to an HTTP/2.0 that meets the needs of the entire web, including browsers, apps, and mobile devices.

    Henrik Frystyk Nielsen, Gabriel Montenegro and Rob Trace

    Message to the IETF mailing list from Henrik

    Dear All,

    We remain committed to the HTTP/2.0 standards process and look forward to seeing many of you this week at the IETF meeting in Vancouver to continue the discussion.  In the spirit of open discussion, we wanted to share some observations in advance of the meeting and share the latest progress from prototyping and testing.

    There are currently three different proposals that the group is working through:

       * SPDY (http://tools.ietf.org/html/draft-mbelshe-httpbis-spdy),
       * HTTP Speed+Mobility (http://tools.ietf.org/html/draft-montenegro-httpbis-speed-mobility),
       * Network-Friendly HTTP Upgrade (http://tools.ietf.org/html/draft-tarreau-httpbis-network-friendly).

    The good news is that everyone involved wants to make the Web faster, more scalable, more secure, and more mobile-friendly, and each proposal has benefits in different areas that the discussion can choose from.

    --- A Genuinely Faster Web ---

    The SPDY proposal has been great for raising awareness of Web performance. It takes a "clean slate" approach to improving HTTP.

    To compare the performance of SPDY with HTTP/1.1 we have run tests comparing download times of several public web sites using a controlled tested study. The test uses publically available software run with mostly default configurations while applying all the currently available optimizations to HTTP/1.1. You can find a preliminary report on the test results here: http://research.microsoft.com/apps/pubs/?id=170059. The results mirror other data (http://www.guypo.com/technical/not-as-spdy-as-you-thought) that indicate mixed results with SPDY performance.

    Our results indicate almost equal performance between SPDY and HTTP/1.1 when one applies all the known optimizations to HTTP/1.1. SPDY's performance improvements are not consistent and significant. We will continue our testing, and we welcome others to publish their results so that HTTP/2.0 can choose the best changes and deliver the best possible performance and scalability improvements compared to HTTP/1.1.

    --- Taking the Best from Each ---

    Speed is one of several areas of improvement. Currently, there's no clear consensus that any one of the proposals is the clear choice or even starting point for HTTP/2.0 (based on our reading the Expressions of Interest and discussions on this mailing list. A good example of this is the vigorous discussion around mandating TLS encryption (http://tools.ietf.org/html/rfc5246) for HTTP/2.0.

    We think a good approach for HTTP/2.0 is to take the best solution for each of these areas from each of the proposals.  This approach helps us focus the discussion for each area of the protocol. Of course, this approach would still allow the standard to benefit from the extensive knowledge gained from implementing existing proposals.

    We believe that the group can converge on consensus in the following areas, based on our reading of the Expressions of Interest, by starting from the different proposals.

    ------------------|------------------
    Area              | Opinion that
                      | seems to prevail
    ------------------|------------------
    1. Compression    | SPDY or Friendly
    ------------------|------------------
    2. Multiplexing   | SPDY
    ------------------|------------------
    3. Mandatory TLS  | Speed+Mobility
    ------------------|------------------
    4. Negotiation    | Friendly or
                      |   Speed+Mobility
    ------------------|------------------
    5. Client Pull/   | Speed+Mobility
          Server Push |
    ------------------|------------------
    6. Flow Control   | SPDY
    ------------------|------------------
    7. WebSockets     | Speed+Mobility
    ------------------|------------------

    Below, we discuss each HTTP/2.0 element and the current consensus that appears to be forming within the Working Group.

    1. Compression

    Compression is simple to conceptualize and implement, and it is important. Proxies and other boxes in the middle on today's Web often face problems with it. The HTTP/2.0 discussion has been rich but with little consensus.

    Though some studies suggest that SPDY's header compression approach shows promise, other studies show this compression to be prohibitively onerous for intermediary devices. More information here would help us make sure we're making the Web faster and better.

    Also, an entire segment of implementers are not interested in compression as defined in SPDY.  That's a challenge because the latest strawman for the working group charter (http://lists.w3.org/Archives/Public/ietf-http-wg/2012JulSep/0784.html) states that the "resulting specification(s) are expected to be meet these goals for common existing deployments of HTTP; in particular, ... intermediation (by proxies, Corporate firewalls, 'reverse' proxies and Content Delivery Networks)."

    We think the SPDY or Friendly proposals is a good starting point for progress.

    2. Multiplexing

    All three proposals define similar multiplexing models. We haven't had substantial discussion on the differences. This lack of discussion suggests that there is rough consensus around the SPDY framing for multiplexing.

    We think that the SPDY proposal is a good starting point here and best captures the current consensus.

    3. Mandating Always On TLS

    There is definitely no consensus to mandate TLS for all Web communication, but some major implementers have stated they will not to adopt HTTP/2.0 unless the working group supports a "TLS is mandatory" position. A very preliminary note from the chair (http://lists.w3.org/Archives/Public/ietf-http-wg/2012JulSep/0601.html) states that there is a lack of consensus for mandating TLS.

    We think the Speed+Mobility proposal is a good starting point here as it provides options to turn TLS on (or not).

    4. Negotiation

    Only two of the proposals actually discuss how different endpoints agree to use HTTP/2.0.

    (The SPDY proposal does not specify a negotiation method. Current prototype implementations use the TLS-NPN (http://tools.ietf.org/html/draft-agl-tls-nextprotoneg) extension.  While the other proposals use HTTP Upgrade to negotiate HTTP/2.0, some parties have expressed non-support for this method as well.)

    We think either of the Friendly or Speed+Mobility proposals is a good starting point because they are the only ones that have any language in this respect.

    5. Client Pull and Server Push

    There are tradeoffs between a server push model and a client pull model. The main question is how to improve performance while respecting bandwidth and client caches.

    Server Push has not had the same level of implementation and experimentation as the other features in SPDY. More information here would help us make sure we're making the Web faster and better.

    We think the Speed+Mobility proposal is a good starting point here, suggesting that this issue may be better served in a separate document rather than tied to the core HTTP/2.0 protocol.

    6. Flow Control

    There has only been limited discussion in the HTTPbis working group on flow control. Flow Control offers a lot of opportunity make the Web faster as well as to break it; for example, implementations need to figure out how to optimize for opposing goals (like throughput and responsiveness) at the same time.

    The current version of the SPDY proposal specifies a flow control message with many settings are that are not well-defined. The Speed+Mobilty proposal has a simplified flow control model based on certain assumptions. More experimentation and information here would help us make sure we're making the Web faster and better.

    We think that the SPDY proposal is a good starting point here.

    7. WebSockets

    We see support  for aligning HTTP/2.0 with a future version of WebSockets, as suggested in the introduction of the Speed+Mobility proposal.

    --- Moving forward ---

    We're excited for the Web to get faster, more stable, and more capable, and HTTP/2.0 is an important part of that.

    We believe that bringing together the best elements of the current SPDY, HTTP Speed+Mobility, and Network-Friendly HTTP Upgrade proposals is the best approach to make that happen.

    Based on the discussions on the HTTPbis mailing list, we've suggested which proposals make the most sense to start from for each of the areas that HTTP/2.0 is addressing. Each of these areas needs more prototyping and experimentation and data. We're looking forward to the discussion this week.

    Sincerely,

    Henrik Frystyk Nielsen

    Principal Architect, Microsoft Open Technologies, Inc.

    Gabriel Montenegro

    Principal Software Development Engineer, Microsoft Corporation

    Rob Trace

    Senior Program Manager Lead, Microsoft Corporation

    Adalberto Foresti

    Senior Program Manager, Microsoft Open Technologies, Inc.”

  • Interoperability @ Microsoft

    Open Data Protocol (OData) .NET Framework Client Library – Source Code Available under Apache 2.0 license

    • 0 Comments

    OData_logo_MS_small Microsoft has just released the source code of the .NET Framework Client Libraries for OData. The source code is under the Apache 2.0 license and available for download on Codeplex: http://odata.codeplex.com 

    From Microsoft’s OData/WCF Data Service Team blog:

    This release represents the OData team’s continued commitment to the OData protocol and the ecosystem that has been built around it. We have had requests for assistance in building new client libraries for the OData protocol and we are releasing the source for the .NET Framework and Silverlight client libraries to assist in that process

    This new contribution goes along with the many other OData libraries (like Java, PHP, iPhone) that we’ve released and also strengthens our commitment to enable Data interoperability through the OData protocol.

    For more details, please visit www.odata.org.

    -- Jean-Christophe Cimetiere, Sr. Technical Evangelist

  • Interoperability @ Microsoft

    SAG Awards Drupal Website Moves to Windows Azure

    • 0 Comments

    The success of the recent Screen Actors Guild (SAG) Awards ceremony was buoyed by the move of its Drupal-based website hosted on internal Linux servers to one hosted on Windows Azure.

    The SAG Awards site is a highly visible, high-traffic website running on Drupal. Hosting it on Azure provides a scalable, public cloud environment for SAG team. They can tune up or down the compute and storage requirements according to expected website loads, thereby getting a more scalable, manageable and cost-effective solution for running their site.

    SAG also gets the benefits of PaaS – no need to manage the operating system patches, virtual machine images, network topology etc. This is particularly useful for SAG as the site has stable traffic for nine months, but which spikes for the three months from when award nominations open to the night of the event itself.

    The SAG Awards site was previously hosted on internal Linux boxes. In previous years, performance was negatively impacted by site outages and slow performance during peak-usage days, with SAG having to consistently upgrade their hardware to meet demand for those days. That upgraded hardware was then not optimally used during the rest of the year.

    The usage pattern for the SAG Awards site fluctuates, but spikes between November and February when the site is used for SAG award nominations in early November to the actual announcement of nominations in in mid-December. Peak usage is on the night of the awards ceremony where multiple uploads of pictures, news articles, and site visits happen.

    What is even more impressive is that both visits and page views almost doubled on the night of the event. In 2011, some 222,816 people visited the site and 434,743 pages were viewed, while this year there were some 325,303 site visits and 789,310 page views, reflecting the stability and performance of the site on Windows Azure.

    Microsoft started working with the SAG Awards team in May 2011, when their CIO Erin Griffin joined the Interoperability Executive Council (IEC) - founded by Microsoft in 2006 with a goal of identifying the industry’s greatest areas of need and to work together to create solutions - and attended a council meeting.

    In September Mike Story, SAG’s chief architect, attended an IEC work stream meeting and asked for Microsoft’s support in porting the site to Azure. The Business Platform Division’s Customer Experience (CAT) team, the Interoperability group and Windows Azure all started working with SAG in early October and, on December 20, 2011, the site went live on Windows Azure.

    “We moved to Windows Azure after looking at the services it offered,” said Erin Griffin, CIO at SAG. “Understanding the best usage scenario for us took time and effort, but with help from Microsoft, we successfully moved our site to Windows Azure and the biggest traffic day for us went off with flying colors.”

    This is just one real world outcome from the IEC, which has counseled Microsoft on many interoperability topics and introduced a number of real world scenarios for discussion. The IEC, working together with Microsoft, has developed a number of solutions for these scenarios, with this one for the SAG Awards being the latest.

    Curt Peterson, Microsoft’s Principal Group Program Manager, BPD Customer Experience, notes that the success of Sunday’s SAG Awards ceremony underscores how Windows Azure is a scalable, open Cloud platform ready for production use. “We are committed to making it easier for all our customers to use cloud computing on their terms with Windows Azure,” he says.

  • Interoperability @ Microsoft

    Microsoft at OSCON next week

    • 0 Comments

    OSCONMicrosoft returns to the O’Reilly Open Source Convention (OSCON) in Portland, Oregon next week. For us, OSCON is a great opportunity to meet and interact with developers, programmers, systems engineers and administrators who live and breathe open source every day. We’re excited to participate in this forum, as it gives us a chance to hear and see firsthand what exciting developments are happening and how and what bridges we can build to improve interoperability between platforms.

    Jean Paoli, Microsoft General Manager for Interoperability Strategy, will be keynoting on Thursday, talking about “Open Cloud, Open Data.” Jean has played a pivotal role in Microsoft’s interoperability efforts over the past few years and he continues to explore opportunities to create greater interoperability in new technical areas and with emerging platforms. In his keynote, Jean plans to address how interoperability is at the core of Microsoft’s vision of a cloud that can capture the imaginations of developers, unleash their creativity and enable them to build new breakthrough applications.

    If you won’t be at OSCON in person, you can still watch the keynote presentations through a streaming feed on the O’Reilly OSCON site.

    A crew of Microsoft people will be on the ground and would love to talk all things interop and open source with you. If you have a question, an idea, an observation, just poke us @openatmicrosoft or me @jccim, we’ll see you there. We will also have several speakers presenting track sessions throughout the week and I encourage you to check them out. Links to the session summaries are provided below.

    CoApp: Bringing Open Source Package Management to Windows
    Garrett Serack
    , Software Development Engineer for Microsoft
    Date: Wednesday, July 21
    Location: E143/E144
    Discover the changing landscape of Open Source on Windows, and how the introduction of the Common Opensource Application Publishing Platform is driving performance, stability and quality into OSS applications on Windows.

    Build Mission Critical Cloud Applications on Windows Azure Platform using Open Source Technologies
    Vijay Rajagopalan
    , Principal Architect for Microsoft
    Date: Thursday, July 22
    Location: E143/E144
    The purpose of this session is to demonstrate Microsoft's commitment to openness and interoperability by practical Cloud Application development scenarios on Windows Azure using Open Source Technologies and Languages

    Private Cloud Deployment with Microsoft and Novell: Driving Transformational Architecture in the Enterprise
    Fabio Da Cunha
    , Senior Manager, Interoperability Alliances for Microsoft
    Frank Rego, Senior Product Manager for Novell
    Date: Thursday, July 22
    Location: E143/E144
    The evolution of cloud computing promises significant efficiency gains and cost savings over today’s distributed architecture model. Many IT leaders, however, face tough choices about what to deploy to evolve their data center while, at the same time, leveraging existing assets and managing to a flat or often declining budget.

    Reactive Extensions For JavaScript
    Erik Meijer
    , Architect for Microsoft
    Date: Thursday, July 22
    Location: Portland 255
    The "A" in "AJAX" stands for "Asynchronous" and indeed almost all Web and mobile applications have to be written in an asynchronous and event-driven style. Reactive Extensions for JavaScript is a library for coordinating and orchestrating asynchronous and concurrent computations in a high-level and declarative way.

    Advancing Interoperability, Patient Safety, and Efficiency with the Microsoft Connected Health Platform Open Toolkits
    Teddy Bachour
    , Sr. Technical Strategist for Microsoft
    Date: Friday, July 23
    Location: F151
    The Microsoft Connected Health Platform (CHP) provides open toolkits and guidance for the information and communication technology (ICT) community to help them speed architecture, design and deployment of interoperable, efficient, and scalable e-Health infrastructures and solutions for the health industry.

    See you there!

    -- Jean-Christophe Cimetiere, Sr. Technical Evangelist, @openatmicrosoft

  • Interoperability @ Microsoft

    Apache Stonehenge, interoperability at work

    • 7 Comments

     

    When Microsoft decided to participate in the Apache Stonehenge project our goal was to deliver guidance through practical applications that span languages and platforms and demonstrate how to achieve interoperability. As I mentioned a few months ago multiple implementations including .NET, Java, Php, Python & Ruby of the Stonehenge Stocktrader sample application have been committed to the repository (check the code here: http://svn.apache.org/viewvc/incubator/stonehenge/contrib/stocktrader/)

    Since then we’ve been working and I’m glad to report that we’ve reached a key milestone: to deploy a first set of these samples and make them work together. The Stonehenge community is currently going through the final testing required for the “M1 release”, and it is taking votes on a release. From a simplified architecture point of view the Stonehenge Stocktrader application is built as follows:

    StonehengeM1_high_level_architecture

     

    • A User Interface layer delivering the web front end (HTML)
    • A middle tier layer including a Business Services layer (login, account processing) and an Order Processing layer (buy/sell transactions)
    • A Data Access layer to provide access to the database for the middle tier layer (Business Services and Order Processing)
    • And finally the database where the application data lives

    So far we have been focusing on the .NET, PHP, and Java interoperability scenarios, and have deployed the three Stocktrader implementations in multiple configurations. If you want to reproduce the environment, you can get the installation and configuration steps for the .NET, PHP and Java versions at http://cwiki.apache.org/confluence/display/STONEHENGE/Index. The PHP and Java implementations were contributed by WSO2 using their Web Services Frameworks (http://wso2.org/projects).

    Then we ran a series of tests mixing and matching the layers from the three implementations, playing with the configurations and leveraging the Web Services standards, including WS-Security, to provide message integrity and security.

    In short (that’s only a partial view of the scenarios), the following diagram shows where we were able to achieve interoperability using Web Services (each arrow represents Web Service based dialog):

    StonehengeM1-labscenario

    A detailed “interoperability walkthrough” explaining all the different configurations has been posted at http://cwiki.apache.org/confluence/display/STONEHENGE/Stonehenge+Interoperability+Walk-through

    From the end user perspective whichever middle tier layer (Business Services or Order Processing) is activated during the scenario is completely transparent, since each of the implementations executes the same transactions. Even though the most interesting part of the interoperability walkthrough happens at the Web Services standard level, I wanted to give you a sense of how the scenario looks from multiple perspectives. In the following example, we are looking at the “Buy Stocks” transaction in both the .NET & PHP applications (the current Java version does not implement any UI):

    Stocktrader .NET

    Stocktrader PHP

    Buying stocks

    StonehengeM1_user_scenario_buy_dotNET

     

    StonehengeM1_user_scenario_buy_PHP

    Transaction confirmation

    StonehengeM1_user_scenario_transaction_dotNET

     

    StonehengeM1_user_scenario_transaction_PHP

    Portfolio summary information

    StonehengeM1_user_scenario_portfolio_dotNET

     

    StonehengeM1_user_scenario_portfolio_PHP

    This new outcome from the Stonehenge project is very encouraging. With the implementation of the WS-* Standards, we get the benefit of distributed applications and platforms. We recognized that it is not always easy to achieve these goals, but I really feel this type of practical guidance will be helpful for these types of scenarios.

    We’re very encouraged by the success of this first step, and we invite you to take a closer look to give comments and feedback.  There are lots of roles for you to participate in the project, whether you are a developer or a user: developing code on your preferred platform, suggesting new scenarios and applications that will provide real value to people in your field, or even just looking over the code and documents to see if they address the challenges you might have had developing interoperable services. 

    We look forward to getting your comments and ideas about how to keep this project moving in a direction that meets real people’s needs.

     

  • Interoperability @ Microsoft

    Using Drupal on Windows Azure to create an OData repository

    • 1 Comments

    OData is an easy to use protocol that provides access to any data defined as an OData service provider.  Microsoft Open Technologies, Inc., is collaborating with several other organizations and individuals in development of the OData standard in the OASIS OData Technical Committee, and the growing OData ecosystem is enabling a variety of new scenarios to deliver open data for the open web via standardized URI query syntax and semantics. To learn more about OData, including the ecosystem, developer tools, and how you can get involved, see this blog post.

    In this post I’ll take you through the steps to set up Drupal on Windows Azure as an OData provider.  As you’ll see, this is a great way to get started using both Drupal and OData, as there is no coding required to set this up. 

    It also won’t cost you any money – currently you can sign up for a 90 day free trial of Windows Azure and install a free Web development tool (Web Matrix) and a free source control tool (Git) on your local machine to make this happen, but that’s all that’s required from a client point of view.  We’ll also be using a free tier for the Drupal instance, so you may not need to pay even after the 90 day trial, depending on your needs for bandwidth or storage.

    So let’s get started!

    Set up a Drupal instance on Windows Azure using the Web Gallery. 

    The Windows Azure team has made setting up a Drupal instance incredibly easy and quick – in a few clicks and a few minutes your site will be up and running.  Once you’ve signed up for Windows Azure and have your account set up, click on New > Quick Create > from Gallery, as shown here:

     

    clip_image002[13]

     

    Then click on the Drupal 7 instance, as shown here.  The Web Gallery is where you’ll find images of the latest Web applications, preconfigured and ready to set up.  Currently we’re using the Acquia version of Drupal 7 for Drupal:

    clip_image004[13]

    Enter some basic information about your site, including the URL (.azurewebsites.net will be added on t what you choose), the type of database you want to work with (currently SQL Server and MySQL are supported for Drupal), the region you want your app instance deployed :

    clip_image006[13]

     

    Next, add a database name, username and password for the database, and a region that the database should be deployed :

    clip_image008[13]

    That’s it!  In a few minutes your Windows Azure Web Site dashboard will appear with options for monitoring and working with your new Drupal instance:

    clip_image010[13]

     

    Setting up the OData provider

    So far we have a Drupal instance but it’s not an OData provider yet.  To get Drupal set up as an OData provider, we’re going to have to add a few folders and files, and configure some Drupal modules. 

    Because good cloud systems protect your data by backing it up and providing seamless, invisible redundancy, working with files in the cloud can be tricky.  But the Windows Azure team provide a free, easy to use tool to work with files on Windows azure, called Web Matrix.  Web Matrix lets you easily download your files, work with them locally, test your work and publish changes back up to your site when you’re ready.  It’s also a great development tool that supports most modern Web application development languages.

    Once you’ve downloaded and installed Web Matrix on your local machine, you simply click on the Web Matrix icon on the bottom right under the dashboard, as show in the image above.  Web Matrix will confirm that you want to make a local copy of your Windows Azure Web site and download the site:

    clip_image012[13]

    Web Matrix will detect the type of Web site you’re working with, set up a local instance Database and start downloading the Web site to the instance:

    clip_image014[13]

     

     

     

    When Web Matrix is done downloading your site you’ll see a dashboard showing you options for working with your local site.  For this example, we’re only going to be working with files locally, so click the files icon shown here:

    clip_image016[13]

    We need to add some libraries and modules to our Drupal Instance to make the Windows Azure standard configuration of Drupal 7 become an OData provider.  There are three sets of files we need to download and place in specific places in our instance.  You’ll need Git, or your favorite Git-compatible tool installed on your local machine to retrieve some of these files:

    1) Download the OData Producer Library for PHP V1.2 to your local machine from https://github.com/MSOpenTech/odataphpprod/
    Under the sites > all folder,  create a folder called libraries> odata (create the libraries folder if it doesn’t exist ) and copy in the downloaded files.

    2) Download version 2 of the Drupal Libraries API from your local machine from http://drupal.org/project/libraries
    Under
    the sites > all folder, create a folder called modules > libraries (yes, there are two libraries directories in different places) and copy in the downloaded files.

    3) Download r2integrated's OData Server files  to your local machine from //git.drupal.org/sandbox/r2integrated/1561302.git
    Under the sites > all folder, create a folder called modules > odata_server and copy in the downloaded files.

     

    Here’s what the directories should look like when you’re done:

    clip_image018[13]

     

    Next, click on the Publish button, to upload the new files to your Windows Azure Web site via WebMatrix. After a few minutes your files should be loaded up and ready to use.

    OData Configuration in Drupal on Windows Azure

    Next, we will configure the files we just uploaded to provide data to OData clients. 

    From the top Menu, Go to the Drupal modules, and navigate down to the “other”section.

    Enable Libraries and OData Server, then save configuration.  The modules should look like this when you’re done:

    clip_image020[13]

    Next, go to Site Configuration from the top menu, and navigate down to the Development section. Under development, click on OData Settings

    Under Node, enable page and or article, (click on expose then to OData clients), the select the fields from each Node you want to return in an OData search.  You can also return Comments, Files, Taxonomy Terms, Taxonomy Vocabularies, and Users.  All are off by default and have to be enabled to expose properties, fields, and references through the OData server:

    clip_image022[15]

    Click Save Configuration and you’re ready to start using your Windows Azure Drupal Web site as an OData provider! 

    One last thing - unfortunately, the default data in Drupal consists of exactly one page, so search results are not too impressive.  You’ll probably want to add some data to make the site useful as an OData provider. The best way to do that is via the Drupal feeds module. 

    Conclusion

    As promised at the beginning of this post, we’ve now created an OData provider based on Drupal to deliver open data for the open Web.  From here any OData consumer can consume the OData feed and doesn’t have to know anything about the underlying data source, or even that it’s Drupal on the back end.  The consumers simply see it as an OData service provider.  Of course there’s more effort involved in getting your data imported, organizing it and building OData clients to consume the data, but this is a great start with minimal effort using existing, free tools.
  • Interoperability @ Microsoft

    Windows Azure Plugin for Eclipse with Java - August 2012 Preview

    • 0 Comments

    Gearing up for back to school, the Microsoft Open Technologies Inc. team has been busy updating the Windows Azure Plugin for Eclipse with Java.

    This August 2012 Preview update includes some feedback-driven usability enhancements in existing features along with number additional bug fixes since the July 2012 Preview. The principal enhancements are the following:

    • Inside the Windows Azure Access Control Service Filter:
      • Option to embed the signing certificate into your application’s WAR file to simplify cloud deployment
      • Option to create a new self-signed certificate right from the ACS filter wizard UI
    • Inside the Windows Azure Deployment Project wizard (and the role’s Server Configuration property page):
      • Automatic discovery of the JDK location on your computer (which you can override if necessary)
      • Automatic detection of the server type whose installation directory you select

    You can learn more about the plugin on the Windows Azure Dev Center.

    To find out how to install, go here.

    Martin Sawicki
    Principal Program Manager
    Microsoft Open Technologies, Inc.
    A subsidiary of Microsoft Corporation

  • Interoperability @ Microsoft

    Jumpstarting Potential new Web standards Just got Easier and Faster

    • 0 Comments


    W3C has announced they are beta testing a W3C Community Process that allows groups to develop specifications and other useful documents under the W3C umbrella, but using a more lightweight process than the one used to create formal Recommendations.

    This means that jumpstarting potential new Web standards is becoming easier and faster at the W3C and that anyone, including non W3C members, will be able to participate. As Microsoft’s representative to the W3C Advisory Committee and an elected member of the Advisory Board, I’ve been involved in planning this for more than a year now.  We think that W3C is the right organization to host this new venue for collaboration on Web challenges, because they have experience in helping communities build real consensus and have a strong reputation as the most credible source of guidance on Web specifications.

    At Microsoft we, like many others, have been struggling with a challenge that has motivated us to participate in these planning discussions. Take the scenario where a group of web developers wish to get together to propose a new API that solves a particular problem they’re facing, but isn’t handled by Web standards today.  They work for different companies, large, and small, and whose employers participate in different standards organizations (or none at all). They know there are a bunch of legal details that might come back to haunt them, but don’t have the time or legal resources to identify them or craft a legal framework for the collaboration.  What can they do? 

    None of the options available right now are probably all that great for the group:

    • They could collaborate informally or via some established mailing list …. But this ignores questions such as “what happens if this idea takes off and one of us patents the ideas, or copyrights the document?”
    • They could work in an existing organization with a clear IPR policy for such matters… But these often charge membership dues, and / or make it difficult for non-members to participate.
    • Those who work for W3C members could start a group to address the problem and get the non-members “invited expert” status … but this is a time consuming process, and is overkill for just brainstorming possible approaches to a problem as opposed to standardizing a well-understood solution.  

    The W3C Community Process adds a new option for W3C members and non-members to work together to brainstorm specifications that could eventually become open web standards.  An earlier W3C blog post explains how:

    A Community Group is an open forum for developing specifications, holding discussions, developing test suites, and otherwise building communities around innovation. There are no fees, no charters, no end dates, and a lightweight set of participation agreements to make them fast to launch and open to all. Some Community Groups may produce results that are subsequently carried forward on the standards track, but others may not. That will be for the communities themselves to decide ...
    So, here’s how the process will work: to start a Community Group, you will pick a topic, write a short scope statement (for communications purposes), and get four other parties to support the creation of the group. Once you have enough support, the system we plan to have in place at launch will create the tooling (wiki, spam-controlled mailing lists, microblog, and other infrastructure) to support the group's activities.

    Community Groups will operate under a simple legal agreement intended to balance the concerns of implementers and potential IPR holders, and designed to provide a smooth transition to the W3C Patent Policy if a group ultimately decides to go in that direction.

    So, in summary, we are excited about this innovation and the opportunities it brings – both for us and for you. Jumpstarting potential new Web standards is becoming easier and faster at the W3C and all interested parties, including non W3C members, will now be able to participate.  We are also excited about the opportunity this brings to start working with you to propose new ideas in W3C Communities.

    Thanks,

    Michael Champion, Senior Program Manager, Interoperability Strategy Team

     

  • Interoperability @ Microsoft

    System Center VMM working with OVF community to improve virtual machine interoperability

    • 0 Comments

    Portability and interoperability of virtualization technologies across platforms using Linux and Windows virtual machines are important to Microsoft and to our customers.

    To that end, System Center VMM continues to gain valuable interoperability and portability experience using Open Virtualization Format (OVF) with their OVF Export/Import tool and partners such as Citrix and VMware.

    For more information, see System Center's most recent post from Cheng Wei and that of Citrix's technical architect Shishir Pardikar.

    Monica Martin
    Senior Program Manager
    Microsoft Open Technologies, Inc.

  • Interoperability @ Microsoft

    New plugin for Eclipse to get Java developers off the ground with Windows Azure

    • 0 Comments

    [3/22/2010 – 5:00pm – Updated – Added Installation instructions]

    As we said a few weeks ago we are hard at work Improving experiences for Java developers with Windows Azure. Today we’re announcing the availability of the fimageirst Community Technology Preview (CTP) of a new plugin for Eclipse, which provides Java developers with a simple way to build and deploy web applications for Windows Azure. Folks attending EclipseCon 2011 had sneak peek at the new plugin during Vijay Rajagopalan's session “Open in the Cloud:- Building, Deploying and Managing Java Applications on Windows Azure Platform using Eclipse”, now it the time for the full story!

    The Windows Azure Plugin for Eclipse with Java, March 2011 CTP, is an open source project released under the Apache 2.0 license, and it is available for download here. This project has been developed by Persistent Systems and Microsoft is providing funding and technical assistance. This CTP is not feature complete, and we’re now collecting feedback to ensure that configuring, packaging and deploying to Windows Azure integrates well with common Java developer scenarios. Give it a try by taking advantage of the Windows Azure free trial (Introductory Special offer ) which includes 750 hours per month (which is one server 24x7) of the Windows Azure extra-small instance, plus one small SQL Azure database.

    What’s in the Windows Azure Plugin for Eclipse with for Java, March 2011 CTP

    The plugin adds to Eclipse a set of wizards and dialogs which guide the Java developer through the configuration of all relevant projects settings. The plugin builds on top of the Windows Azure Starter Kit for Java (released last month), which is a simple template project including the typical files that constitute a Java project, as well as the required elements to package and deploy your application for Windows Azure.

    To install using the Eclipse "Available Software" wizard:

    1. Open Eclipse
    2. Select Help->Install New Software…
    3. In the "Work with" textbox, enter the URL http://webdownload.persistent.co.in/windowsazureplugin4ej/ and press Enter
    4. In the available software list check Windows AzurePlugin for Eclipse with Java and click Next -Tip: If your install process is slow uncheck "Contact allupdate sites during install to find required software"
    5. During the install you may be prompted by a security warningabout unsigned binaries. Accept the warning to continue
    6. Restart Eclipse

    Once installed, the plugin adds a “Windows Azure Project” perspective to Eclipse, and lets you create a Windows Azure project from scratch:

    2-NewProjectWizard

    Once you’ve created your project structure, you’re just a few steps away from deploying your applications in the cloud. Here’s what’s next:

    • Pick the Java server (Apache Tomcat, Jetty, etc.) and the Java runtime you want to use
    • Create or import your Java application
    • Test your application against the Windows Azure Compute Emulator (a “local” version of Windows Azure environment running on your machine for development and test purposes - see Getting the Windows Azure Pre-Requisites for more details)

    To get more details check out my video interview and demo with Martin Sawicki, Senior Program Manager in the Interoperability team:

    Stay tuned

    From the early days, Microsoft has been committed to making Windows Azure open and interoperable, offering choice to developers, including Java users. Delivering on this commitment, Microsoft is building and funding tools & SDKs to enable Java developers to easily take advantage of the Windows Azure cloud platform. So, now is the perfect time to jump in and try these tools out. We will continue to make available regular updates and of course we do appreciate your feedback – without it we can’t make them better! Please visit: http://java.interoperabilitybridges.com/cloud.

    Enjoy!

    Craig Kitterman
    Sr. Technical Ambassador
    @craigkitterman
    http://craig.kitterman.net

  • Interoperability @ Microsoft

    MS Open Tech develops the open source Android SDK for Windows Azure Mobile Services

    • 0 Comments

    imageFurthering the goal of bridging Microsoft and non-Microsoft technologies, Microsoft Open Technologies, Inc. developed the Android SDK for Windows Azure Mobile Services that is being announced today by Scott Guthrie on his blog.

    Windows Azure Mobile Services was created to make it easier for developers to build engaging and dynamic mobile apps that scale. By using Mobile Services, developers are not only able to connect their applications to a scalable and secure backend hosted in Windows Azure, but also store data in the cloud, authenticate users and send push notifications.

    The Android SDK lets you connect your favorite Android phone or tablet (Android 2.2+) to a cloud backend and deliver push notifications via Google Cloud Messaging. It also allows you to authenticate your users via their Google, Facebook, Twitter, or Microsoft credentials. To enable this, the MS Open Tech engineering team delivered the following key features:

    • Data API: this API simplifies the communication between Android apps and the tables exposed through Windows Azure Mobile Services using a fluent API for queries and automatic JSON serialization/deserialization.
    • Identity API: this API allows leveraging Microsoft Account, Facebook, Twitter or Google authentication in an Android app.
    • Service Filters: these components allow the developer to intercept and customize the requests between the Mobile client and Windows Azure Mobile Services, providing a filter pipeline to handle the generated requests and responses.

    The SDK is available on GitHub under the Apache 2.0 license and community contributions are very welcome.

    You can learn more about the new SDK reading Scott’s blog, and the getting started tutorial and come back soon as we are working on more samples/demos/tutorials.

    clip_image004

  • Interoperability @ Microsoft

    Windows Azure Storage plugin for WordPress

    • 2 Comments

    The Windows Azure Storage Plugin for WordPress was updated today to use the new Windows Azure SDK for PHP. The plugin comes with a comprehensive user guide, but for a quick overview of what it does and how to get started, see Brian Swan’s blog post. Cory Fowler also has some good information on how to contribute to the plugin, which is an MS Open Tech open-source project hosted on the SVN repo of the WordPress Plugin Directory.

    This plugin allows you to use Windows Azure Storage Service to host the media files for a WordPress blog. I use WordPress on my personal blog where I write mostly about photography and sled dogs, so I installed the plugin today to check it out. The installation is quick and simple (like all WordPress plugins, you just need to copy the files into a folder under your wp-content/plugins folder), and the only setup required is to point it at a storage account in your Windows Azure subscription. Brian’s post has all the details.

    The plugin uses the BlobRestProxy class exposed by the PHP SDK to store your media files in Windows Azure blob storage:

    Once the plugin is installed, you don’t need to think about it – it does everything behind the scenes, while you stay focused on the content you’re creating. If you’re writing a blog post in the WordPress web interface, you’ll see a new button for Windows Azure Storage, which you can use to upload and insert images into your post:

    Brian’s post covers the details of how to upload media files through the plugin’s UI under the new button.

    If you click on the Add Media icon (clip_image001) instead, you can add images from the Media Library, which is also stored in your Windows Azure storage account under the default container (which you can select when configuring the plugin).

    If you use Windows Live Writer (as I do), you don’t need to do anything special at all to take advantage of the plugin. When you publish from Live Writer the media files will automatically be uploaded to the default container of your storage account, and the links within your post will point to the blobs in that container as appropriate.

    To the right is a blog post I created that takes advantage of the plugin. I just posted it from Live Writer as I usually do, and the images are stored in the wordpressmedia container of my dmahughwordpress storage account, with URLs like this one:

    http://dmahughwordpress.blob.core.windows.net/wordpressmedia/2012/08/DSC_7914.jpg

    Check it out, and let us know if you have any questions. If you don’t have an Azure subscription, you can sign up for a free trial here.

  • Interoperability @ Microsoft

    Eclipse shines on Windows 7: Microsoft and Tasktop partnering to contribute code enhancement to Eclipse

    • 0 Comments

    eclipsecon I’m writing this from EclipseCon in San Jose, where Shawn Minto, from Tasktop Technologies and I presented the first results of efforts to enhance Eclipse on Windows 7. We are very excited to see this contribution being part of the next release (3.6) of the Eclipse Integrated Development Tool (IDE).

    This project was jointly initiated by Microsoft and Tasktop Technologies and announced last October at the Eclipse Summit in Germany. Microsoft is providing funding, technical & architectural assistance and Tasktop is implementing and contributing code. The goal is to improve Eclipse to take advantage of new features in Windows 7. This will empower eclipse developers to be productive and have a compelling experience developing applications using Eclipse on Windows 7. For this first phase, we have been focusing on the user interface components to allow Eclipse developers to take advantage of the new user interface features offered by Windows 7, directly from the Eclipse IDE and from any desktop applications built on top of the Eclipse platform.

    For more details, watch this video where Shawn Minto and I discuss the project and show a demo of the results.

    Get Microsoft Silverlight

    New features in next release of Eclipse

    In order to include the improvements in the Eclipse development cycle, the features were introduced in the Eclipse Bugzilla as follows:

    Let’s take look at some screenshots showing the final results:

    Taskbar Jump Lists: in this screenshot, the Mylyn plug-in for Eclipse exposes frequently used features:

    jumplist-newTask-zoom

    Taskbar Progress integration: the new Windows 7 progress bar is integrated in various part of the Eclipse IDE (the progress bar is also part of the application icon in the taskbar and shows progress horizontally across the icon):

    progress-installsoftware-zoom

    Note that these enhancements are made at the Standard Widget Toolkit (SWT) level, which means that developers will see the enhancements in the Eclipse IDE, but they can also take advantage of them in any desktop applications built on top of the Eclipse Rich Client Platform (RCP).

    As always, feedback from the developer community about “most wanted” features is very important to us. So if you have ideas, don’t be shy about speaking up—we would love to hear them.

    The broader Microsoft and Eclipse picture

    The collaboration between Microsoft, the Eclipse Foundation, and the Eclipse community may seem unusual for some people. But let’s be pragmatic, our mutual customers, partners and developers want greater choice and opportunities. We do believe that improving interoperability between our technologies is actually helping all parties. I encourage you to check Mike Milinkovich’s opinion on this as well.

    To close, I’d like to give you a quick update on other Eclipse related projects, which we are working on with Soyatec:

    Cheers!

    --Vijay Rajagopalan, Principal Architect

  • Interoperability @ Microsoft

    Doctrine supports SQL Database Federations for massive scalability on Windows Azure

    • 0 Comments

    Symfony and Doctrine are a popular combination for PHP developers, and now you can take full advantage of these open source frameworks on Windows Azure. We covered in a separate post the basics of getting started with Symfony on Windows Azure, and in this post we’ll take a look at Doctrine’s support for sharding via SQL Database Federations, which is the result of ongoing collaboration between Microsoft Open Technologies and members of the Symfony/Doctrine community.

    SQL Database Federations

    My colleague Ram Jeyaraman covered in a blog post last December the availability of the SQL Database Federations specification.  This specification covers a set of commands for managing federations as objects in a database. Just as you can use SQL commands to create a table or a stored procedure within a database, the SQL Database Federations spec covers how to create, use, or alter federations with simple commands such as CREATE FEDERATION, USE FEDERATION, or ALTER FEDERATION.

    If you’ve never worked with federations before, the concept is actually quite simple. Your database is partitioned into a set of federation members, each of which contains a set of related data (typically group by a range of values for a specified federation distribution key):

     

    This architecture can provide for massive scalability in the data tier of an application, because each federation member only handles a subset of the traffic and new federation members can be added at any time to increase capacity. And with the approach used by SQL Database Federations, developers don’t need to keep track of how the database is partitioned (sharded) across the federation members – the developer just needs to do a USE FEDERATION command and the data layer handles those details without any need to complicate the application code with sharding logic.

    You can find a detailed explanation of sharding in the SQL Database Federations specification, which is a free download covered by the Microsoft Open Specification Promise. Questions or feedback on the specification are welcome on the MSDN forum for SQL Database.

    Doctrine support for SQL Database Federations

    The Doctrine Project is a set of open-source libraries that help ease database development and persistence logic for PHP developers. Doctrine includes a database abstraction layer (DBAL), object relational mapping (ORM) layer, and related services and APIs.

    As of version 2.3 the Doctrine DBAL includes support for sharding, including a custom implementation of SQL Database Federations that’s ready to use with SQL Databases in Windows Azure. Instead of having to create Federations and schema separately, Doctrine does it all in one step. Furthermore, the combination of Symfony and Doctrine gives PHP developers seamless access to blob storage, Windows Azure Tables, Windows Azure queues, and other Windows Azure services.

    The online documentation on the Doctrine site shows how easy it is to instantiate a ShardManager interface (the Doctrine API for sharding functionality) for a SQL Database:

    The Doctrine site also has an end-to-end tutorial on how to do Doctrine sharding on Windows Azure, which covers creation of a federation, inserting data, repartitioning the federation members, and querying the data.

    Doctrine’s sharding support gives PHP developers a simple option for building massively scalable applications and services on Windows Azure. You get the ease and flexibility of Doctrine Query Language (DQL) combined with the performance and durability of SQL Databases on Windows Azure, as well as access to Windows Azure services such as blob storage, table storage, queues, and others.

    Doug Mahugh
    Senior Technical Evangelist
    Microsoft Open Technologies, Inc.

  • Interoperability @ Microsoft

    A busy OSCON for Microsoft on Interoperability and open source

    • 0 Comments

    clip_image002

    O’Reilly OSCON (Open Source Convention) has been an opportunity for Microsoft to make significant announcements and unveil new projects. For sure, Microsoft’s participation did not go unnoticed :), in fact it has been a busy week for us.

    First we announced the release of Linux Device Drivers, to enhance the performance of Linux when virtualized on Windows Server 2008 Hyper-V. The source code has also been submitted to the Linux Community. Read Peter Galli’s post on Port25: Microsoft Releases Device Driver Code to the Linux Community) and check the Channel9 interview.

    The next announcement was the Live Services Plug-in for Moodle, a free download released under the General Public License v2 that integrates Microsoft's Live@edu services such as email, calendar, instant messaging and search directly into the Moodle experience. Read more on the “Microsoft On the Issues” blog: Microsoft Develops Plug-in for Moodle to Aid Teachers, Students and check out the Channel9 interview:

    Then Vijay Rajagopalan, Principal Architect for Interoperability Technical Strategy team presented a session titled “Interoperability - Build Mission Critical Applications in PHP, Ruby, Java and Eclipse Using Microsoft Software +  Services” where he discussed our approach to interoperability & open source and illustrated this with three (Eclipse4SL, PHP Application development in Azure & .NET Services) of the open source initiatives that enabled bridging Microsoft Software + Service & Open Source Technologies. Finally, Vijay unveiled progress made on PHP SDK for Azure & tooling in Eclipse. He has demoed a prototype earlier this year at MIX. This time Vijay showed us how you can do "create, read, update & delete" (CRUD) operations on Azure Storage from the Eclipse IDE, leveraging the PHP SDK for Azure, screenshot below:

    crud

    Stay tuned, we’ll be able to say more about this in a few weeks.

    Vijay’s presentation is available for download (PDF & PPTX).

    It’s been an exciting conference, and I hope you can appreciate all the activities and projects that Microsoft is driving to show openness and interoperability in action.

    By the way if you want to follow us more closely on these topics, check out OpenAtMicrosoft twitter line.

    Jean-Christophe Cimetiere, Sr. Technical Evangelis

  • Interoperability @ Microsoft

    Check out the updated HTTP Speed+Mobility Open Source Prototype

    • 0 Comments

    Microsoft Open Technologies, Inc. has just released an update to the open source HTTP Speed+Mobility Prototype that it first announced in early May to the developer community. This update implements the latest changes made by Microsoft to the HTTP Speed+Mobility proposal to the IETF httbis workgroup on June 15, 2012.

    As Jean Paoli and Sandeep Singhal had articulated in their blog post back in March, the HTTPbis working group in the Internet Engineering Task Force (IETF) has approved a new charter to define HTTP “2.0” to address performance limitations with HTTP. The original HTTP Speed+Mobility proposal was the first contribution made by Microsoft toward that goal.

    The updated proposal reaffirms the guiding principles of HTTP Speed+Mobility. Specifically, in our view any successful update to the HTTP protocol will have to:

    • Maintain existing HTTP semantics.
    • Maintain the integrity of the layered architecture.
    • Use existing standards when available to make it easy for the protocol to work with the current web infrastructure.
    • Be broadly applicable and flexible, by keeping the client in control of content.
    • And, last but not least, account for the needs of modern mobile clients, including power efficiency, support for HTTP-based applications, and connectivity through costed networks.

    We would like to thank the community for your interest in our proposal and for providing valuable feedback on the initial prototype implementation. We made several notable enhancements to the proposal, which the new version of the prototype now implements:

    • We implemented an updated Session Layer to more clearly define the separation with the other layers. The Session Layer is now formally defined as a WebSocket extension.
    • The Streams Layer was simplified to take advantage of the WebSockets integration. We removed all of the redundancy within the WebSockets Framing. For example, HTTP Speed+Mobility frames no longer have a dedicated length field, as the length of the payload is already specified in the underlying Websocket frame.
    • Finally, a new flow control logic was implemented. The prototype implements a simple receive buffer management scheme based on the credit control mechanism now specified in the proposal. We believe that it provides a good balance between throughput and flow control, while adhering to our stated tenet that the Client is in control of the Content.

    Collectively, these changes make the HTTP Speed+Mobility protocol both better integrated with the existing RFCs it builds upon, and at the same time, simpler to implement and debug.

    As always, we encourage you to download the prototype, try it out, inspect the source code, and give us your feedback. We look forward to your contributions, as well as to constructive discussions about the next version of HTTP at the upcoming IETF meetings!

    Adalberto Foresti
    Senior Program Manager
    Microsoft Open Technologies, Inc.
    A subsidiary of Microsoft Corporation

  • Interoperability @ Microsoft

    PhoneGap mobile HTML5 framework adding support for Windows Phone Mango

    • 0 Comments

    [Cross posted from the Windows Phone Developer Blog]

    We’re very excited to join Nitobi to announce availability of a PhoneGap beta supporting Windows Phone Mango. This new option to build applications targeting Windows Phone gives more choices to developers. In particular, Web developers will be able to easily leverage their HTML5 skills to target Windows Phone.

    The beta version of the PhoneGap libraries can be downloaded from: https://github.com/phonegap/phonegap-wp7

    PhoneGapWindows Phone MangoIn case you’ve been so busy writing code for months and you’ve never heard about PhoneGap, it’s an open source mobile framework that enables developers to build applications targeting multiple platforms, by using standard web technologies (HTML5, CSS and JavaScript). On Windows Phone Mango PhoneGap leverages the new HTML5 support provided by IE9.

    We have been in touch with André Charland and Brian Leroux (Co-Founders of Nitobi the creator of PhoneGap), who are seeing a growing interest from the PhoneGap developer community to target Windows Phone. So we’ve started working with Nitobi, helping to speed up the development of Windows Phone Mango support in PhoneGap by providing engineering resources and technical support.

    The current beta version includes most of the basic features, and includes JavaScript APIs to use Windows Phone Mango features like:

    • Access Device Information (UDDI and stuff)
    • Add and search Contacts
    • Connection status (network / wifi connection status)
    • Alerts/Notification (alert and confirm)
    • Media Capture (Image and Audio)
    • Camera
    • Accelerometer
    • Geolocation

    Here’s a screen shot of the PhoneGap Unit Test application running on the Windows Phone emulator:

    PhoneGapTestApp

    I encourage you to read Nitobi’s blog post to get more details on how the whole process works.

    This is the first step toward having full PhoneGap support for Windows Phone Mango. Stay tuned, we will provide updates and more extensive demos as progress is made. With Windows Phone Mango Released to Manufacturing and developer tools hitting “Release Candidate”, it’s the perfect time to start testing, give feedback and join the PhoneGap open source project.

    Jean-Christophe Cimetiere, Sr. Technical Evangelist – Interoperability
    @jccim - blogs.msdn.com/interoperability

  • Interoperability @ Microsoft

    Sun Joins Microsoft on JavaOne Stage in support of Apache Stonehenge Incubator Project

    • 3 Comments

    As the co-owners of the Microsoft portion of the project, Kent Brown and I would like to thank everybody for their support and share our excitement over the future of the Stonehenge project.

    microsoft-sun-javaone There has been a lot of speculation surrounding Microsoft keynoting at JavaOne, and what it could mean to the Java world. Well, now we know that the announcement will be made: Sun has now agreed to participate in the Stonehenge project and will be contributing the Metro-based StockTrader application code. Steven Martin has just posted a note where you’ll find more details on the keynote, and on the new agreement with Sun.

    I’d just like to highlight the goals of Stonehenge : “While industry efforts like WS-* make interop possible, it still isn't always obvious or easy to figure out how to configure different products so that they actually interoperate […] Stonehenge will help us complete the “last mile” of interoperability between today’s standards-based infrastructure and tomorrow’s service-based applications.”

    I’m really thrilled and looking forward to working with Sun on developing new Stonehenge interoperability scenarios.

    Also, as I had hinted in my previous post, the M1 release of Stonehenge incubator project was reached last night. Congratulations to everyone on the Stonehenge team and a warm welcome to our friends from Sun Microssystems.

    Additional Stonehenge materials:

    Kamaljit Bath, Principal Program Manager


    [Update 06/09: JavaOne Radio episode (20 min audio) is available: Chris Mellisinos talks to Steven Martin of Microsoft after the Microsoft General Session keynote address at JavaOne
    javaoneradio ]

  • Interoperability @ Microsoft

    Node.js script for releasing a Windows Azure blob lease

    • 1 Comments

    This post covers a workaround for an issue that may affect you if you’re deploying Windows Azure virtual machines from VHDs stored in Windows Azure blob storage. The issue doesn’t always occur (in fact, our team hasn’t been able to repro it), and it will be fixed soon. If you run into the issue, you can use any one of several workarounds covered below.

    Blob leases are a mechanism provided by Windows Azure for ensuring that only one process has write access to a blob. As Steve Marx notes in his blog post on the topic, “A lease is the distributed equivalent of a lock. Locks are rarely, if ever, used in distributed systems, because when components or networks fail in a distributed system, it’s easy to leave the entire system in a deadlock situation. Leases alleviate that problem, since there’s a built-in timeout, after which resources will be accessible again.”

    In the case of VHD images stored as blobs, Windows Azure uses a lease to ensure that only one virtual machine at a time has the VHD mounted in a read/write configuration. In certain cases, however, we’ve found that the lease may not expire correctly after deleting the virtual machine and deleting the disk or OS image associated with the VHD. This can cause a lease conflict error message to occur when you try to delete the VHD or re-use it later in a different virtual machine.

    If you’re affected by this issue, you can explicitly break the lease that has not expired, or you can make a copy of the VHD and use that copy for provisioning a new virtual machine. Craig Landis has posted instructions on the Windows Azure community forum for how to do this from Windows machines; he also covers the same techniques in a separate post addressing a variation on the issue.

    For those who are managing Windows Azure virtual machines from Linux or Mac desktops, our team has developed a Node.js script that can be used to break a lease if needed. Here are the steps to follow for installing and running the script:

    1. Verify through the Windows Azure management portal that the VHD is not actually in use. Craig’s forum post provides guidance on how to do this.

    2. If you don’t have the Windows Azure command line tool for Mac and Linux installed, you can get it by installing the Windows Azure SDK for Node.js. SDK installation instructions for Windows, Mac, and Linux can be found on the Windows Azure Node.js Developer Center.

    3. Download and import your Windows Azure publish settings file, as covered under “Manage your account information and publish settings” in the command line tool documentation.

    4. Copy the the breakLease.js file (available here) to the node_modules/azure-cli subfolder under your Node.js global modules folder. You can find your global modules folder with the npm ls –g command. For example, on my Windows machine that command returns c:\Users\dmahugh\AppData\Roaming\npm, so I need to copy the script to c:\Users\dmahugh\AppData\Roaming\npm\node_modules\azure-cli.

    After you’ve completed those setup steps, you can break a blob lease by running the script with a single parameter, the URL of the blob:

    > node breakLease.js <absolute-url-to-blob>

    The script prints out information about the steps it takes to break the lease:

    image

    That’s all there is to it. As I mentioned earlier, this workaround is only needed in certain cases until the underlying cause has been fixed. Please let us know if you run into any issues using this script.

  • Interoperability @ Microsoft

    Microsoft working with Xandros responding to feedback from IEC council member NATO

    • 1 Comments

    I’m Claudio Caldato, Senior Program Manager in the Interoperability Technical Strategy team here at Microsoft. I’m going to talk about the work Microsoft did with Xandros in response to feedback from Interoperability Executive Customer Council (IEC) member NATO gave us, asking for heterogeneous system management scenarios.

    One of my key activities is to follow up on feedback provided by the Interoperability Executive Customer Council. Recently a few members of the council, and in particular NATO, raised the issue of the complexity in managing multiple heterogeneous systems across a large distributed network environment from a single point of access and the need to aggregate status information and alerts to other management applications. This is quite a broad topic, in retrospect!

    To narrow down the scope we worked with NATO to define a specific scenario and this scenario formed the basis of the “Multi-Platform System Management” lab. The lab comprised the following Applications and Services

    · Microsoft System Center Operations Manager 2007

    Because of the heterogeneous nature of the components, we choose to work under the Interop Vendor Alliance (IVA) with Xandros (a fellow IVA member) to create the following architecture:

    NATO-XANDROS-IVA-LAB-Architecture01

    The goal for the lab was to demonstrate the following functionality:

    • Use Microsoft System Center Operations Manager to monitor performance and availability of Microsoft and non-Microsoft platforms and applications such as: Windows Server 2003, Sun Solaris 10, Oracle Database, Oracle Application Express, Apache Web Server
    • Use Microsoft System Center Operations Manager to report performance and availability data to the IBM Tivoli and HP OpenView management consoles
    • Improve the monitoring of SLA’s by providing a single point of access for Hardware, OS, and application level monitoring, System troubleshooting, Failure analysis, Disc, Network, Memory, and CPU Metrics, and Application status and availability

    We were able to build the lab and, in so doing, are able to demonstrate to others how to solve the interoperability challenges that this sort of environment creates. One of these challenges was how to enable the System Center Operations Manager to manage applications running on Sun Solaris machines. The solution to this challenge came from Xandros in the form of the Xandros Bridgways Management Packs. This management pack is engineered to extend the capabilities of the System Center Operations Manager to applications of both Windows and non-Microsoft platforms, providing us with an ideal solution to the problem at hand.

    From a technical perspective, the lab included several other very interesting aspects that I encourage you to discover for yourself. These have been documented in the white paper that’s available on the IVA website under the Multi-Platform System Management Lab. The good news is that we were able to successfully address the specific needs expressed by the IEC Council’s feedback. I find it personally rewarding that we’re able to meet the expectations of our customers… particularly, IEC Council member NATO who commented on the outcome of this lab (quote extracted from the white paper):

    “NATO employs a diverse set of hardware and software and has to work with vendors that are committed to work on interoperability, said Detlef Janezic, NATO CIS Services Agency (NCSA) when participating in the Interoperability Executive Council sessions in 2008. NCSA mentioned on behalf of NATO some of the interoperability challenges experienced between Microsoft System Center and HP OpenView product lines. Based on these concerns, Microsoft engaged in an initiative geared to resolve the stated interoperability challenges. This solution was presented to NATO on 24 Mar 2009. The initial assessment of NCSA and the NATO C3 Agency (NC3A) on the chosen approach and its implementation is that the presented solution shows great potential. The two NATO agencies very much appreciate these Microsoft efforts and intend to implement & test the provided solution in its IT environment as soon as possible.”

    The Interoperability discussion related to system management does not end here. We continue to work with partners like Xandros, whom I’d like to thank for their help and contribution on setting this interoperability lab up.

    Claudio Caldato, Senior Program Manager

  • Interoperability @ Microsoft

    Openness Update for Windows Azure

    • 0 Comments

    As Microsoft’s Senior Director of Open Source Communities, I couldn’t be happier to share with you today an update on a wide range of Open Source developments on Windows Azure.

    As we continue to provide incremental improvements to Windows Azure, we remain committed to working with developer communities. We’ve spent a lot of time listening, and we have heard you loud and clear.

    We understand that there are many different technologies that developers may want to use to build applications in the cloud. Developers want to use the tools that best fit their experience, skills, and application requirements, and our goal is to enable that choice.

    In keeping with that goal, we are extremely happy to be delivering new and improved experiences for Node.js, MongoDB, Hadoop, Solr and Memcached on Windows Azure.

    This delivers on our ongoing commitment to provide an experience where developers can build applications on Windows Azure using the languages and frameworks they already know, enable greater customer flexibility for managing and scaling databases, and making it easier for customers to get started and use cloud computing on their terms with Windows Azure.

    Here are the highlights of today’s announcements:

    • We are releasing the Windows Azure SDK for Node.js as open source, available immediately on Github. These libraries are the perfect complement to our recently announced contributions to Node.js and provide a better Node.js experience on Windows Azure. Head to the Windows Azure Developer Center for documentation, tutorial, samples and how-to guides to get you started with Node.js on Windows Azure.
    • We will also be delivering the Node package manager for Windows (npm) code to allow use of npm on Windows for simpler and faster Node.js configuration and development. Windows developers can now use NPM to install Node modules and take advantage of its automated handling of module dependencies and other details.
    • To build on our recent announcement about Apache Hadoop, we are making available a limited preview of the Apache Hadoop based distribution service on Windows Azure.  This enables Hadoop apps to be deployed in hours instead of days, and includes Hadoop Javascript libraries and powerful insights on data through the ODBC driver and Excel plugin for Hive. Read more about this on the Windows Azure team blog. If you are interested in trying this preview, please complete the form here with details of your Big Data scenario.  Microsoft will issue an access code to select customers based on usage scenarios.
    • For all of you NoSQL fans, we have been working closely with 10Gen and the MongoDB community in the past few months, and if you were at at MongoSV last week you have already seen MongoDB running on Windows Azure. Head out to the 10Gen website to find downloads, documentation and other document-oriented goodies. If you’re using the popular combination of Node.js and MongoDB, a simple straightforward install process will get you started on Windows Azure. Learn more here.
    • For Java developers, take a look at the updated Java support, including a new and revamped Eclipse plugin. The new features are too many to list for this post, but you can count on a much better experience thanks to new and exciting functionality such as support for sticky sessions and configuration of remote Java debugging. Head over to the Windows Azure Developer Center to learn more.
    • Does your application need advanced search capabilities? If so, the chances are you either use or are evaluating Solr, and so the good news for you is that we just released a set of code tools and configuration guidelines to get the most out of Solr running on Windows Azure. We invite developers to try out the tools, configuration and sample code for Solr tuned for searching commercial and publisher sites. The published guidance showcases how to configure and host Solr/Lucene in Windows Azure using multi-instance replication for index-serving and single-instance for index generation with a persistent index mounted in Windows Azure storage.
    • Another great example of OSS on Windows Azure is the use of Memcached server, the popular open-source caching technology, to improve the performance of dynamic web applications. Maarten Balliauw recently blogged about his MemcacheScaffolder, which simplifies management of Memcached servers on the Windows Azure platform. That blog post is only focused on PHP, but the same approach can be used by other languages supported by Memcached as well.
    • Scaling data in the Cloud is very important. Today, the SQL Azure team made SQL Azure Federation available.  This new feature provides built-in support for data sharding (horizontal partitioning of data) to elastically scale-out data in the cloud. I am thrilled to announce that concurrent with the release of this new feature, we have released a new specification called SQL Database Federations, which describes additional SQL capabilities that enable data sharding (horizontal partitioning of data) for scalability in the cloud, under the Microsoft Open Specification Promise. With those additional SQL capabilities, the database tier can provide built-in support for data sharding to elastically scale-out data in the cloud, as covered in Ram Jeyaraman’s post on this blog.

    In addition to all this great news, the Windows Azure experience has also been significantly improved and streamlined. This includes simplified subscription management and billing, a guaranteed free 90-day trial with quick sign-up process, reduced prices, improved database scale and management, and more. Please see the Windows Azure team blog post for insight on all the great news.

    As we enter the holiday season, I’m happy to see Windows Azure continuing on its roadmap of embracing OSS tools developers know and love, by working collaboratively with the open source community to build together a better cloud that supports all developers and their need for interoperable solutions based on developer choice.

    In conclusion, I just want to stress that we intend to keep listening, so please send us your feedback. Rest assured we’ll take note!

  • Interoperability @ Microsoft

    Showcasing Open Source Community Contributors to Entity Framework, ASP.NET and Web API for Visual Studio

    • 1 Comments

    Microsoft Open Technologies, Inc.’s Hub engineering program continues to be a great place for community contributors to work and collaborate on key MS OpenTech projects. We’re thrilled to see so many non-Microsoft contributors. Thank you!

    In this post we’re showcasing (and thanking!) some of the open source developers who independently contribute code to improve key MS OpenTech open source projects: ASP.NET MVC, Web API, and Web Pages, SignalR and the Entity Framework.  Microsoft Corp. regularly takes great code contributions from these projects and builds them into the products that our customers know and love: they’re shipped with Visual Studio, in the Visual Studio Gallery and even sometimes in the core product. Working with community authors has earned us some wonderful community relationships in the process

    Entity Framework (EF)

    Entity Framework continues to benefit from input from a strong open source community since MS Open Tech announced it was open source about a year ago.

    Here’s a great intro to EF and EF concepts for newbies.

    Scott Guthrie did a great job of describing the latest and greatest features in this blog post. Back in May we highlighted a few developers and their open source contributions, and today we’d like to introduce you to some of them and dive a little deeper into their contributions.

    Independent Developer Profile – Erik Ejlskov Jensen

    Erik Ejlskov Jensen
    Erik Ejlskov Jensen

    In May we mentioned community contributions by Erik Ejlskov Jensen (ErikEJ), specifically ESqlCeFunctions, that provide a SQL Compact equivalent to SqlFunctions. I caught up with Erik on a quick call from his home in Denmark to share some information and answer a few questions about his contributions and experience so far. Erik has been working with Entity Framework since before it was a CodePlex project, originally working with ADO.

    Erik is coordinator for several projects on CodePlex and follows dozens of projects as well. One of his most notable contributions is the open source SQL Server Compact Toolbox, available as a Visual Studio add-in or a standalone app. Erik describes the toolbox in great detail in this Channel 9 video.

    Erik uses many other CodePlex projects in his own projects, so giving back to the community by providing tools to help others seems like a natural response to all the support and assistance he’s received from community members and tools in his development career.

    On his motivations for sharing enhancements for the Entity Framework, Erik says “The Entity Framework team has been very open towards contributors, you really feel that your contributions are appreciated and they take your contributions seriously”.

    Independent Developer Profile – Unai Zorilla Castro

    Unai Zorrilla Castro
    Unai Zorrilla Castro

    Unai Zorrilla Castro (UnaiZorrilla) also has been an independent open source contributor to EF since before it was EF – he was the author of several popular ADO books. He’s always been interested in the data access layer. Unai had the chance to meet with Daniel Simmons and Diego Vega on the EF team, who helped him understand the full capabilities of EF.

    Unai had several ideas for features that he thought could be interesting for the product. He’s contributed more than 10 open source additions to the product so far, some minor like changes to the code generated by migrations, and some more complex, like the creation of a pluralization service as a public and configurable service from DbConfiguration. He’s also contributed some interesting methods such as AddFromAssembly in ConfigurationRegistrar that enables entity mapping loading without having to specify entities in ModelBuilder, and AddRange and RemoveRange in DbSet that provides an optimized method to include or remove a set of entities.

    Unai believes that contributing has been more beneficial for himself than for the community, team or the product. Being able to work with the core EF team members is one of the best ways he has been able to learn and improve as a professional developer. Contributors must follow the same process as internal Microsoft developers, which provide a great source of important feedback.

    Unai also independently contributes to other Microsoft open source projects for the Microsoft team in Spain. Currently he’s involved in EF6.Contrib, a repository for draft contributions to EF 6 which for various reasons cannot be included in the core product code.

    As far as tips for other community members who want to contribute to the community, Unai says “don’t be afraid of having your code reviewed, feedback is always positive no matter what. We should dare to do these kind of things. Maybe they will work out or not, but if we don’t try we are sure to fail.”

    ASP.NET Web API

    Our ASP.NET and Web API for Visual Studio are also blockbuster Hub projects, with unprecedented interest and downloads of ASP.NET MVC, Web API, and Web Pages source code. Visit http://www.asp.net to find official installers, documentation, tutorials, samples, and videos.

    Independent Developer Profile - Brock Allen - CORS in the ASP.NET Web API

    Brock Allen
    Brock Allen

    The recently introduced CORS runtime configuration inside the ASP.NET Web API could not have been possible without the help of CORS developer Brock Allen (brockallen) . Brock video-conferenced in remotely to help show CORS Support for the ASP.NET Web API in this great video on Channel 9, also featuring Dan Roth and Yao Huang Lin of Microsoft’s ASP.NET Web API team.

     
     
     
     

    Independent Developer Profile - Tim McCall – Attribute Routing in MVC and Web API 2

    Tim McCall (mccalltd – CodePlex, NuGet) was integral in building the original open source project that eventually became the new Attribute Routing feature in ASP Web API 2, which gives you more control over the URIs in your web API. For more information, have a look at the tutorial: Create a REST API with Attribute Routing in Web API 2.

    Tim got involved as a contributor earlier this year when he saw Dan Roth talking about his project, MVC Attribute Routing on Microsoft’s Channel 9, and invited the author to get in touch with him to talk about the project “if he sees this video.” Tim was inspired by the Ruby-based Sinatra Framework, and wanted to make something as easy to use in ASP.NET. He created a NuGet package that really helped the solution take off and generated a lot of positive responses on Twitter as well. The NuGet and Twitter attention also helped his solution climb to the top of results in popular search results, generating even more attention.

    His advice to developers who want to contribute: “If you see code or features that you don’t like, and you have a way to make it better, make the change and contribute the change so others can see it. Get some open source code out there even if it’s not perfect, but works, and appreciate and respond to community members who take the time to provide feedback. Also, make sure to package your projects using a good open source package manager like NuGet, npm, or RubyGems to get extra exposure for your projects.”

    Summary

    We again thank all the contributors who have participated so far in improving MS Open Tech Hub projects via community contributions. If you have a contribution that we should be highlighting, please contact us by leaving a comment below, as you can see from our developer profiles in this post we are glad to help promote your contributions in any way we can!

    And if you’re new to the MS Open Tech Hub projects and want to get started, get the latest instructions on installing the Visual Studio 2013 Preview, release notes, documentation and tutorials here. Also, source code contributions to ASP.NET MVC, Web API, and Web Pages source code can be made by starting here, and Entity Framework contributors can get started here.

  • Interoperability @ Microsoft

    MongoDB Experts video series

    • 0 Comments

    MS Open Tech is pleased to announce a new series of videos on Channel 9 that covers MongoDB topics for developers working on Windows Azure and Windows. Each video in the series features insights from one of the MongoDB experts at 10gen, the leader in MongoDB development, support, training and consulting.

    The first three videos in the series have been posted, and more are coming soon. Here’s what has been covered in the first videos in the series …

    imageMongoDB Overview with Jared Rosoff provides a high-level overview of the approach that MongoDB takes for delivering highly scalable read and write operations. If you’re entirely new to MongoDB, this is the place to start. MongoDB is one of many database platforms that are often grouped together as “NoSQL databases,” but each NoSQL database has its own unique philosophy and personality. In this video, you’ll get a feel for MongoDB’s personality.

    imageMongoDB Replica Sets with Sridhar Nanjundeswaran covers the key concept at the heart of MongoDB scalability: replica sets, which are groups of MongoDB servers that can provide high availability and performance even in the face of failures at the network and hardware level. MongoDB replica sets are easy to set up and deploy, and Sridhar sets up a simple replica set from scratch and then shows how it gracefully handles various failover scenarios

    imageMongoDB C#/.NET Driver with Robert Stam is a hands-on look at how to do common database operations in C# through use of the C#/.NET driver from 10gen. Robert is the developer of the driver, and in this video he shows how to create, read, update and delete documents in MongoDB collections.

    MS Open Tech has been working closely with 10gen to improve the MongoDB experience on Windows Azure, and we’re working together on a variety of new initiatives to continue on that path. Future videos will cover the results of that work, as well as advanced topics related to the current videos (for example, Linq support in the C#/.NET driver) and other topics of interest to developers who are working with MongoDB on Windows Azure.

    Stay tuned, and if there are MongoDB/Azure topics you’d be interested in seeing covered in this series please let us know!

  • Interoperability @ Microsoft

    Netflix: Solving Big Problems with Reactive Extensions (Rx)

    • 0 Comments

    More good news for Reactive Extensions (Rx).

    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.”

  • Interoperability @ Microsoft

    W3C Pointer Events Gains Further Web Momentum with Patch For Mozilla Firefox

    • 0 Comments

    Microsoft Open Technologies, Inc., (MS Open Tech) has made another contribution towards interoperable support for Pointer Events across Web platforms by publishing an early open source prototype of the W3C Pointer Events Candidate Recommendation for Mozilla Firefox. This patch contribution advances the momentum around use of Pointer Events to build interoperable web sites that work with mouse, touch, and pen.

    The W3C Pointer Events emerging standard makes it easier to support many browsers and devices by saving Web developers from writing unique code for each input type. Pointer Events unifies how you code for point, click and touch across multiple devices.

    Previously, MS Open Tech announced further interoperable support for Pointer Events in Blink by submitting a formal Intent to Implement to enable our engineering team to actively collaborate and work toward a positive adoption of Pointer Events by the Blink developer community. Earlier this year, MS Open Tech published Pointer Events prototypes for WebKit on HTML5 Labs and submitted patches to the WebKit developer forum. Our previous Blogs have discussed Pointer Events adoption in Internet Explorer, Chrome/Blink, and in JavaScript libraries such as jQuery, and Dojo. This initial open source patch for Mozilla Firefox adds to the Web community convergence around the Pointer Events specification and we plan to continue our collaboration with the Blink, WebKit and Mozilla communities.

    MS Open Tech and the Microsoft Internet Explorer teams will continue to work with our colleagues across the industry, engaging developers to test and provide feedback on the specification to W3C.

    Contribute to the New Pointer Events Functionality in Firefox

    We encourage interested developers to participate in the community process and provide feedback to ensure that Mozilla Firefox will enable a great Pointer Events implementation. As you start building, migrating, or testing your Web apps using Pointer Events, you should check out the resources available on the Pointer Events Wiki at Web Platform Docs:

    Jump in, have fun with the demos, join the discussion at #PointerEvents and update your site with the cool capabilities of Pointer Events. Point. Click. Touch.

    Asir Vedamuthu Selvasingh, Principal Program Manager
    Microsoft Open Technologies, Inc.

    Adalberto Foresti, Principal Program Manager
    Microsoft Open Technologies, Inc.

    Oleg Romashin, Senior Engineer, Microsoft Open Technologies Hub

  • Interoperability @ Microsoft

    Taking advantage of Windows Azure Storage from PHP: example with a WordPress plugin

    • 3 Comments

    Continuing our efforts on improving interoperability between PHP and Microsoft technologies, we have created an example showcasing a new plugin for WordPress that allows WordPress developers to take advantage of the storage capacity of Windows Azure. This plugin enables WordPress to use Windows Azure Storage Service to host media for a WordPress-powered blog.

    The plugin, developed by Microsoft, is now available as an open source project from the WordPress repository: http://wordpress.org/extend/plugins/windows-azure-storage/

    About Windows Azure Storage and Content Delivery Network (CDN)

    Windows Azure Storage enables applications to store and manipulate large objects and files in the cloud via blobs, manipulate service state via tables, and provide reliable delivery of messages using queues. You can read more about Windows Azure Storage here.

    If you want to manage your media (images or any file offered for download) in a consistent way and share them across multiple websites then you might want to consider using Windows Azure Storage blobs. Windows Azure includes a service called Windows Azure Content Delivery Network (CDN) which offers developers a solution for delivering high-bandwidth content. Windows Azure CDN has currently 18 locations globally (United States, Europe, Asia, Australia and South America). Windows Azure CDN caches your Windows Azure blobs at strategically placed locations to provide maximum bandwidth for delivering your content to users. The benefit of using a CDN is better performance and experience for users who are farther from the source of the content stored in the Windows Azure Storage blobs. You can read more on the Windows Azure Team Blog and on MSDN

    Windows Azure Storage from PHP with a WordPress plug-in.

    The Windows Azure Storage plugin for WordPress allows developers running their own instance of WordPress to take advantage of the Windows Azure Storage services, including the Content Delivery Network (CDN) feature. It provides a consistent storage mechanism for WordPress Media in a scale-out architecture where the individual web servers don’t share a disk. Note that this scenario goes beyond WordPress and could also be very compelling any other web application where there’s a need to load balance across a number of web servers without shared disk.

    The plugin is a regular WordPress plugin developed in PHP, and can be deployed on any WordPress instance (running on Windows or Linux - requires at least version 2.8.0 and tested up to version 2.8.4). The plugin uses the Windows Azure SDK for PHP to handle the interactions with Windows Azure.

    Once the plugin is installed you’ll see it in the WordPress plugins management interface.

    Once the plugin is activated and configured, which simply consists of setting your Windows Azure account information and a few options, you can use it directly through the blog post editor:

    To include an image in the post, just click on the “Azure” icon. The following screen will pop up:

    From here you simply pick the image you want to include.

    When the plugin is installed, you can choose to have all media managed through the WordPress Media Management interface or during imports to also go to Windows Azure blob storage. Then it shows up in the regular list of media elements and not just under the Azure button.

    Once you have published the post you can see that your image lives on Windows Azure Storage, although your WordPress applications can be hosted anywhere else.

    Give it a try!

    The plugin is now available from the WordPress repository: http://plugins.svn.wordpress.org/windows-azure-storage/. Register for your Windows Azure account (try for free till July 31, 2010 with the Introductory Special), install the plugin, and get started!

    Feel free to share feedback!

    Additional links

    -- Jean-Christophe Cimetiere, Sr. Technical Evangelist, @openatmicrosoft

  • Interoperability @ Microsoft

    Windows Azure Libraries for Java Available, including support for Service Bus

    • 0 Comments

    Good news for all you Java developers out there: I am happy to share with you the availability of Windows Azure libraries for Java that provide Java-based access to the functionality exposed via the REST API in Windows Azure Service Bus.

    You can download the Windows Azure libraries for Java from GitHub.

    This is an early step as we continue to make Windows Azure a great cloud platform for many languages, including .NET and Java.  If you’re using Windows Azure Service Bus from Java, please let us know your feedback on how these libraries are working for you and how we can improve them. Your feedback is very important to us!

    You may refer to Windows Azure Java Developer Center for related information.

    Openness and interoperability are important to Microsoft, our customers, partners, and developers and we believe these libraries will enable Java applications to more easily connect to Windows Azure, in particular the Service Bus, making it easier for applications written on any platform to interoperate with each another through Windows Azure.

    Thanks,

    Ram Jeyaraman

    Senior Program Manager, Microsoft’s Interoperability Group

  • Interoperability @ Microsoft

    Managing “404/Page not found” Error on WordPress with Bing

    • 1 Comments

    Here’s an interesting way for WordPress developers to easily manage the “404/Page not found” error by leveraging the Bing search engine using the recently released Bing Search Library for PHP project (a wrapper on top of the Bing API, which provides a simple way to submit queries to and retrieve results from the Bing Engine). For this project, we’ve continued to work with PHP expert Cal Evans to create a scenario showing how to use the library.

    The Scenario

    The idea is simple: instead of sending the default WordPress “404/Page not found” error page to a user who gets the wrong page URL on your site, why not try to redirect the user to content that he or she may be looking for?

    The Solution

    URLs are often meaningful because they include important keywords (at least that’s a good SEO practice). So let’s try to extract those keywords from the URL, pass them on to Bing API to find the matching pages, and display smart suggestions to the user!

    As a result

    Tada…

    bing404WP

    A new plugin “Bing404 for WordPress” is born. Microsoft is making the plugin available through the WordPress Plugin Directory: http://wordpress.org/extend/plugins/bing-404/

    Need more details?

    phparchitekCal Evans has posted a tutorial on how to get started with the plugin on php|architect
    His article discusses the details about how the plugin is built. 

     

    Feel free to share feedback!

    Additional links

    -- Jean-Christophe Cimetiere, Sr. Technical Evangelist, @openatmicrosoft

  • Interoperability @ Microsoft

    Microsoft Drivers for PHP for SQL Server 2.0 released

    • 1 Comments

    Microsoft is announcing an important interoperability milestone: the release of the Microsoft Drivers for PHP for SQL Server 2.0!!

    The major highlight of this release is the addition of the PDO_SQLSRV driver, which adds support for PHP Data Objects (PDO). Providing the PDO_SQLSRV driver enables popular PHP applications to use the PDO data access “style” to interoperate with Microsoft’s SQL Server database and make it easier for PHP developers to take advantage of SQL Server's proven track record and to leverage features such as SQL Server's Reporting Services and Business Intelligence capabilities. In addition to accessing SQL Server, both drivers (SQLSRV and PDO_SQLSRV) also enable PHP developers to easily connect to and use Microsoft's cloud database offering, SQL Azure, and enjoy the benefits of a reliable and scalable relational database in the cloud, as well as functionality like exposing OData feeds.

    SQL ServerDriverforPHP_PDO

    Ashay Chaudhary (Program Manager at Microsoft) has all the details posted on the SQL Server Driver for PHP team blog:
    http://blogs.msdn.com/b/sqlphp/archive/2010/08/04/microsoft-drivers-for-php-for-sql-server-2-0-released.aspx

    -- Jean-Christophe Cimetiere, Sr. Technical Evangelist, @openatmicrosoft

  • Interoperability @ Microsoft

    Voice your opinion on .NET interoperability with Windows Communication Foundation (WCF)

    • 2 Comments

     

    Who says Microsoft doesn’t listen? Here is a chance to voice your opinion and make .NET more interoperable and easier to use when dealing with other languages/runtime through Web Services (WS-*).

    image[6]


    The .NET Windows Communication Foundation (WCF) team is planning its next set of features and wants to hear from developer’s experiences. For that purpose, they have provided a quick, to-the-point survey for you to provide a developer to developer feedback.

    Achieving interoperability between platforms should be easy and straightforward, right? We know it’s not always the case. So, go ahead provide your feedback today on what is keeping you awake at night and what would make you happy.  We are early in the product cycle, but need your feedback by July 15th to truly make the impact we all want.

    The survey is right here: http://mymfe.microsoft.com/WCF/Feedback.aspx?formID=283

    If you have any questions on the survey, please contact Abu Obeida Bakhach, Interoperability Program Manager at abu.obeida@microsoft.com

    Thanks!

  • Interoperability @ Microsoft

    News from TechEd 2014: Portability and flexibility with ASP.NET vNext

    • 0 Comments

    Outside, the Houston weather for the opening day of TechEd 2014 is a little gloomy, but inside the George R. Brown Convention center it’s a bright day for Openness at Microsoft with the announcement of ASP.NET vNext!   check out the full details on the MS Open Tech Blog

  • Interoperability @ Microsoft

    The FileAPI Prototype Gets Updated

    • 0 Comments

    I am happy to let you know that today we have made available an update to the FileAPI prototype we released on HTML5 Labs last month.

    The Interoperability team at Microsoft developed the File API prototype, which is based on the evolving  W3C specification that provides an API for representing file objects in web applications.

    This update implements  the changed behavior in File.slice explained by a note in the latest version of the w3c spec:

    The slice method previously had different semantics, which differed from both Array.prototype.slice and String.prototype.slice [ECMA-262]. This difference was an oversight which has been corrected in this edition of the specification. Some user agents implemented the previous semantics, notably Firefox 4, Chrome 10, and Opera 11. These user agents have agreed to vendor-prefix their slice implementations in subsequent releases.

    We also included a minor update to the existing features by adding support for selecting and reading multiple files sequentially via the FileList Interface.

    The prototype includes a simple demo that shows how FileAPIs can be used to select images on the local machines, preview them on the browsers, and it can easily extended to add the ability to upload the images on the server.

    As you may know, HTML5 Labs is the place where Microsoft prototypes early and unstable specifications from web standards bodies such as W3C. Sharing these prototypes helps us have informed discussions with developer communities, and enables us to provide better feedback on draft specifications based on this implementation experience.

    So far, we have released three updates to our WebSockets prototype since it was released on the HTML5 Labs site in December, the IndexedDB prototype has been updated to bring it in line with the latest version of the specification, and we recently added a new WebSockets demo.

    Coming next is the Media Capture API prototype, a draft specification that defines HTML form enhancements to provide access to the audio, image and video capture capabilities of a device. The first release of the prototype includes Audio capabilities only, but we plan to add video support shortly after the release of the first version. So, stay tuned for the Media Capture  prototype and other new ones that we are working on right now.

    Thanks,

    Claudio Caldato,

    Principal Program Manager, Interoperability Strategy Team

  • Interoperability @ Microsoft

    New command-line tool for PHP to deploy applications on Windows Azure

    • 0 Comments
    AzurePlusPHP

    I’ve just finished my MIX10 session (“Building PHP Applications using the Windows Azure Platform”) where I announced the new Windows Azure Command-line Tools for PHP Community Technology Preview (CTP). The tools are available under an open source BSD license and can be downloaded at: http://azurephptools.codeplex.com/

     

    In a nutshell, these tools enable developers to easily package and deploy PHP applications to Windows Azure using a simple command-line tool without any Integrated Development Environment (IDE). This project is actually the result of feedback we received from many PHP developers who are using various IDEs (or none), who told us that a command-line tool would be a great addition to the Windows Azure Tools for Eclipse project.

    The tools assist with creating new applications or converting existing PHP applications to Windows Azure and by creating the deployment package (.cspkg) and Configuration file (.cscfg). They will let developers deploy to the local Development Fabric or the Windows Azure Cloud for production.

    The tools offer a simple command-line interface with a few parameters to customize your deployment:

    AzureTool4PHPCommandLine

    From the developer point of view this is an easy three step process:

    1. Make sure you’ve gathered the assets to deploy (PHP engine, Code source, PHP Extensions)
    2. Run the Command-line with your custom parameters to create the package
    3. Upload the deployment package (.cspkg) and configuration file (.cscfg) to Windows Azure

    Your PHP application is ready to run on Windows Azure!

    AzureTool4PHPArchitectureFlow

    To see the tools in action, watch this Channel9 video where I demo how to convert and deploy a simple PHP application to Windows Azure.

    Get Microsoft Silverlight

    As always, if you have feedback, questions, or wishes, please join us on the project site: http://azurephptools.codeplex.com/.

    Additional links:

    Sumit Chawla, Technical PM/Architect, Microsoft Interoperability Strategy Team

  • Interoperability @ Microsoft

    Powering Search on PHP Web Sites with Bing

    • 0 Comments

    The Bing Search and Decision engine offers a comprehensive Application Programming Interface (API) that enables developers to programmatically submit queries to and retrieve results from the Bing Engine. If you are a PHP developer and looking for a way to easily enable the search feature on your website, you are in luck. Today, we’re pleased to introduce a new Bing Search Library for PHP,available on Codeplex.com, http://bingphp.codeplex.com, under an open source BSD license.

    Bing Search Library for PHPFor this project, Microsoft worked with Cal Evans, a seasoned PHP developer. The goal was to build this library following the appropriate PHP conventions and coding styles. So, Cal designed and wrote the code of the library for us, and he has just posted a tutorial with some sample code for PHP developers to quickly get started. Try it!

    The Bing Search Library for PHP is a wrapper on top of the Bing API, which provides a simple way to submit queries to and retrieve results from the Bing Engine.

    There are many ways to take advantage of the Bing API, since the API offers a choice of protocols from JSON, plain XML, to SOAP. So if you want to dig deeper into the Bing API, start here: http://www.bing.com/developers. In fact readers of this blog might recall the Bing 404 Web Page Error Toolkit for PHP project we presented a few months ago. This project focused on helping PHP developers use Microsoft Bing search engine to manage the 404 error (Page Not Found) on their web sites.

    As always, if you have feedback, questions, or feature requests, please join us on the project site: http://bingphp.codeplex.com

    Sumit Chawla, Technical PM/Architect, Microsoft Interoperability Strategy Team

  • Interoperability @ Microsoft

    The MS Open Tech Hub releases Rx 2.2

    • 1 Comments

    From the Rx team:
    Claudio Caldato, Principal Program Manager Lead, MS Open Tech
    Snesha Foss, Senior Program Manager, MS Open Tech
    Kirk Shoop, Senior Software Development Engineer, MS Open Tech
    Matthew Podwysocki, Software Engineer, Microsoft
    Donna Malayeri , Program Manager, Azure Mobile Services, Microsoft

    Today Microsoft Open Technologies, Inc. (MS Open Tech), is happy to share the news of recent improvements we have made to Reactive Extensions.

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

    Reactive Extensions (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, UI events, and Web service requests. Since Rx was open-sourced by MS Open Tech in November, 2012, Rx has become an important under-the-hood component of several high-availability multi-platform applications, including NetFlix and GitHub. For a more detailed overview, have a look at the Beginner’s Guide to Reactive Extensions. . Back in October, Bart De Smet provided an overview of what to expect on the latest release on Channel9, it’s a good start to get an overview of the updates.

    A lot of work has also gone into Rx.cpp since the last release, listed below. We’ve also added initial support for WinRT in C++/CX. A WinRT sample converted to use Rx.cpp is available on GitGub. It’s also worth noting that Rx.cpp compiles with clang on Mac OS X as well as MSVC on Microsoft Windows.

    Updates:

    Schedulers

    Schedulers control when a subscription starts and when notifications are published. The following schedulers have been implemented for this release: Immediate, CurrentThread, EventLoop, NewThread, Window (schedule to HWND message-loop).

    Sources

    Sources are generally adapters provide a Subscribe method for a data source so that Operators can be applied to the data. The following sources have been implemented for this release: Iterate, Interval, Return, Empty, Throw, Random (using engine and transform from the std namespace)

    Operators

    Operators are used to work with subscriptions and subjects. Operators are the async equivalent of STL algorithms, instead of iterators they take observables. The following operators have been implemented for this release: OrderBy, ForEach, Using, Scan, Throttle, TakeUntil, Skip, SkipUntil, ToVector, ToList, Zip, Concat, CombineLatest, Merge, ToAsync, Using, ConnectableObservable, Multicast, Publish, PublishLast, RefCount, ConnectForever, SubscribeOn, ObserveOn.

    Subjects

    The following Subjects have been implemented for this release: ConnectableSubject, GroupedSubject, BehaviorSubject, and AsyncSubject,

    Helper Classes

    New helper classes for this release are Producer and Sink.

    WinRT C++/CX

    Support for WinRT has been implemented in this release, and a great example has been provided on GitHub. Supported Classes and Methods are, BindCommand, DeferOperation, CoreDispatcherScheduler, FromEventPattern, FromAsyncPattern and ReactiveCommand.  Special mention goes to Paul Betts, who gave us permission to build a C++ version of the .NET ReactiveCommand class he created in the ReactiveUI library. Thanks for the inspiration!

    The MS Open Tech Hub engineering program has been a great venue for projects like this one, as it provides our team with the resources and agility we need to get these updates out to the community.

    Stay tuned for more updates soon, and please try out our work and pitch in on CodePlex!

  • Interoperability @ Microsoft

    Neo4j, the open source Java graph database, and Windows Azure

    • 0 Comments

    clip_image003[4]clip_image005[4] Recently I was travelling in Europe. I alwasy find it a pleasure to see a mixture of varied things nicely co-mingling together. Old and new, design and technology, function and form all blend so well together and there is no better place to see this than in Malmö Sweden at the offices of Diversify Inc., situated in a building built in the 1500’s with a new savvy workstyle. This also echoed at the office of Neo Technology in a slick and fancy incubator, Minc, situated next to the famous Turning Torso building and Malmö University in the new modern development of the city.

    My new good friends, Diversify's Magnus Mårtensson, Micael Carlstedt, Björn Ekengren, Martin Stenlund and Neo Technology's Peter Neubauer hosted my colleague Anders Wendt from Microsoft Sweden, and me. The topic of this meeting was about Neo Technology’s Neo4j, open source graph database, and Windows Azure. Neo4j is written in Java, but also has a RESTful API and supports multiple languages. The database works as an object-oriented, flexible network structure rather than as strict and static tables. Neo4j is also based on graph theory and it has the ability to digest and work with lots of data and scale is well suited to the cloud. Diversify has been doing some great work getting Java to work with Windows Azure and has given us on the Interoperability team a lot of great feedback on the tools Microsoft is building for Java. They have also been working with some live customers and have released a new case study published in Swedish and an English version made available by Diversify on their blog.

    I took the opportunity to take a video where we discuss the project, getting up on the cloud with Windows Azure and what's coming up on InteropBridges.tv,


    Video Interview on Channel9: Neo4j the Open Source Java graph database and Windows Azure

    Related to this effort and getting Java on Windows Azure there are a few more goodies to check out …

    Video of the presentation (skip ahead to ~12 mins) by Magnus (blog post) and Björn (blog post) at the Norwegian Developer Conference (NDC) on hosting a Java application on Windows Azure and their experiences using them together.

    clip_image009

    Magnus and Björn also got to do a radio interview on  .NET Rocks (mp3)  on Windows Azure and Java.

    image

    I want to thank the guys for taking the time to do the interview, meet with customers, getting some business out of the way and also being fabulous hosts and showing me around town. I am grateful for your Swedish hospitality!

    Resources:

    http://java.interoperabilitybridges.com/cloud

    http://www.windowsazure4j.org

    http://neo4j.org

    Jas Sandhu, Technical Evangelist, @jassand @openatmicrosoft

  • Interoperability @ Microsoft

    Microsoft Open Technologies releases Windows Azure support for Solr 4.0

    • 2 Comments

    Microsoft Open Technologies is pleased to share the latest update to the Windows Azure self-deployment option for Apache Solr 4.0.

    Solr 4.0 is the first release to use the shared 4.x branch for Lucene & Solr and includes support for SolrCloud functionality. SolrCloud allows you to scale a single index via replication over multiple Solr instances running multiple SolrCores for massive scaling and redundancy.

    To learn more about Solr 4.0, have a look at this 40 minute video covering Solr 4 Highlights, by Mark Miller of LucidWorks from Apache Lucene Eurocon 2011.

    To download and install Solr on Windows Azure visit our GitHub page to learn more and download the SDK.

    Another alternative for implementing the best of Lucene/Solr on Windows Azure is provided by our partner LucidWorks. LucidWorks Search on Windows Azure delivers a high-performance search solution that enables quick and easy provisioning of Lucene/Solr search functionality without any need to install, manage or operate Lucene/Solr servers, and it supports pre-built connectors for various types of enterprise data, structured data, unstructured data and web sites.

  • Interoperability @ Microsoft

    New Bing Translator Plugin lets users localize your WordPress site into the language of their choice

    • 0 Comments

    Good news for WordPress developers and webmasters!  Microsoft Open Technologies, Inc. has released a new Bing Translator plugin that lets you apply the power of Bing Translator to any WordPress site running version 3.8 or later. Visitors can translate your site into their preferred language in one click without leaving the page once this light-weight, cross-browser plugin is installed. This plugin also provides options for a setting a color scheme, as well as an option to allow visitors to suggest translations.  Check out the Blog post at msopentech.com for more detail. 

  • Interoperability @ Microsoft

    Apache Stonehenge new M2 release adds claims-based authentication scenarios

    • 0 Comments

    Web Services protocols have been around for ten years now. The specifications around these protocols have moved through major standards bodies and most vendors and open source projects have implementations of these web services protocols in their products. That being said, connecting heterogeneous platforms in an interoperable manner hasn’t always been easy. That’s why Microsoft and other vendors initiated the Apache Stonehenge incubator project, a little more than a year ago, “to develop a set of sample applications to demonstrate seamless interoperability across multiple underlying platform technologies by using currently defined W3C and OASIS standard protocols. By having a set of sample applications, with multiple language and framework implementations will become a useful and important part of the SOA landscape” (quote from the Why Apache Stonehenge? page).

    Our goal was to show that you can run an application across different platforms using different technologies purely on the foundation of the Web Services protocols and standards.

    Launched in January 2009, Stonehenge is designed to provide a public forum to test the interoperability of WS-* protocols on different technical stacks and to build open source sample applications that could provide best practices and coding guidelines for better interoperability.

    It is helpful for customers and the industry to have multiple implementations of these standards and have the ability to choose the best ones for their scenarios and requirements. Customers get working code on multiple platforms and vendors catch bugs and test interoperability issues in an open manner.

    The first version “M1” of the Stock Trader sample application showcased the main Web Services standards, including WS-Security.

    Today, we are glad to announce the availability of Stonehenge “M2”, the second iteration, now including WS-Trust 1.4 and WS-FED 1.1 protocols for claims-based authentication scenarios.

    clip_image002

    This allows the end-users’ to be authenticated through an independent Security Token Service (STS) that is trusted by the bank and to pass that token to the broker to process the transaction.

    Architecture

    Watch the video with Kent Brown (Product Manager, Microsoft) and I where we introduce Stonehenge and Kent presents an actual demo.

    People can download the M1 and M2 releases of Apache Stonehenge from http://www.apache.org/dist/incubator/stonehenge and the documentation is up on the wiki: https://cwiki.apache.org/confluence/display/STONEHENGE/Index

    We are looking forward to working with the community to shape out the next steps. As always, if you have feedback, questions, or wishes, please join us on the Stonehenge project site!

    Kamaljit Bath, Principal Program Manager

    Additional links:

  • Interoperability @ Microsoft

    Announcing the first Node hackathon in Redmond, November 7-8

    • 0 Comments

    The MS Open Tech team has been working with the Node.js community for more than two years to deliver a great experience on Windows and Windows Azure for Node developers. It’s been an exciting and rewarding experience, and we’re looking forward to taking it to the next level as we continue the journey together.

    To that end, we’re happy to announce the first Node/Windows Hackathon, sponsored by Microsoft Open Technologies, Inc. This event will take place in Redmond on November 7-8, 2013, at the new “Garage” facility currently under construction in building 27 of the Microsoft campus. The event is open to everyone. We’ll be sharing more details in the next few days, but we’re announcing the dates now so that you can reserve the date and make plans to participate.

    This will be a great opportunity for the Node community to get to know the many Microsoft developers who love to work with Node.js as much as they do, and we’ll work together to test new scenarios, explore new features, and make the Node experience even better for Windows and Windows Azure developers. There will be plenty of pizza and beverages, lots of time for hacking as well as socializing, and we’re planning a surprise announcement at the event that we think will make Node developers on Windows very happy.

    Please sign up at the EventBrite registration page and get involved if you’d like to participate, or have suggestions for projects and scenarios to explore.  We’d love to see you in Redmond for the event, but if you can’t be there in person we’ll also have opportunities for online attendance. (Details for online participation will be posted soon.)

    See you in November!

    Claudio Caldato, Scott Blomquist, Doug Mahugh
    Microsoft Open Technologies, Inc.

  • Interoperability @ Microsoft

    Open sourcing npm.net, a .NET library for the Node.js package manager (npm)

    • 0 Comments

    Today I’m happy to announce the open source release of the npm.net library. This is the same library that the WebMatrix team used to implement the NPM package discovery feature as explained in Justin’s blog. The library gives developers using managed code access to NPM commands to, for instance, deploy or update node.js modules on a client machine.

    We are releasing the source code of the library today so developers that are interested in building automation tools or any other sort of integration between node.js and .NET can leverage some of the work we have done for the WebMatrix team.

    Claudio Caldato
    Principal Program Manager
    Microsoft Open Technologies, Inc.

  • Interoperability @ Microsoft

    New version of the Command-Line Tools for PHP to Deploy Applications on Windows Azure

    • 0 Comments

    clip_image002Today at Tek-X during the “Tips & Tricks to get the most of PHP with IIS, and the Windows Azure Cloud” session, Microsoft showcased the new version of the Windows Azure Command-line Tool for PHP available for download under an open source BSD license at: http://azurephptools.codeplex.com/.

    AzurePlusPHP_3

    Announced in March 2010, the Windows Azure Command-line Tool for PHP enables developers to easily package and deploy new or existing PHP applications to Windows Azure using a simple command-line tool without an Integrated Development Environment (IDE). Developers have an option of deploying to the Development Fabric (a sort of local cloud for development and test) or directly to the Windows Azure Cloud. The new version of the Windows Azure Command-line Tool for PHP supports both Web and Worker service roles allowing developers the freedom to customize their applications to their needs (Web roles are the internet facing applications, and Worker roles are for background tasks).

    This project initially was started as the result of feedback we received from PHP developers who are using various IDEs (or none), who told us that a command-line tool would be a great addition to the Windows Azure Tools for Eclipse project.

    To get familiar with the tools you can read this post New command-line tool for PHP to deploy applications on Windows Azure or watch this video on Channel9 where I presented the new features and demo how to deploy a PHP application (using WordPress with SQL Server Build) to Windows Azure:

    This demo is actually an abstract of the “Welcome to the Cloud: Windows Azure Command-line tools for PHP” webcast I presented last Friday as part of the PHP Architect webcast series. The entire recording will be available soon at: http://www.phparch.com/. Stay tuned!

    As always, if you have feedback, questions, or wishes, please join us on the project site: http://azurephptools.codeplex.com/.

    Additional links:

    · Running WordPress on Windows with SQL Server: http://wordpress.visitmix.com/

    Sumit Chawla, Technical PM/Architect, Microsoft Interoperability Strategy Team

  • Interoperability @ Microsoft

    Microsoft on Open Source, OData, the Web and the Cloud at OSBC

    • 0 Comments

    5892ecb7327ae14e02b1f1a4670817da_OSBC_banner_750x87

    Microsoft was once again at the Open Source Business Conference (OSBC) held at the Palace Hotel in San Francisco on March 17-18, 2010. As  Platinum Sponsors, there was good presence by quite a few softies at the event, as attendees and delivering sessions.

    Stuart McKee, Microsoft's National Technology Officer for the United States, delivered a keynote address to attendees titled "Open Source at Microsoft: Meeting customer, developer and partner needs through a diversified ecosystem". McKee talked about the opportunities for open source applications interoperating with Microsoft platforms. From Windows, to SharePoint to Azure, and how increased flexibility and choice for the consumers of these technologies is good for everyone involved. McKee shared how internally Microsoft is changing and responding to a call from customers who demand a diverse ecosystem that includes open source. McKee gave examples of software from Apache, the MySQL database, and PHP all running on Microsoft's Windows Azure cloud platform. Microsoft in recent years has been endorsing open source via efforts such as sponsoring the Apache Foundation. The Microsoft-backed CodePlex Foundation, meanwhile, was set up last year as an effort to enable collaboration between open source communities and software companies. “More than ever, we are continuing to improve interoperability with open source products and platforms in addition to working with customers looking to optimize their mixed IT environments. Interoperability is important not only for the business world, but also for state and local governments. That's because the business of government is really about outcomes, regardless of how solutions are created," McKee said.

    Brian Goldfarb, the Director of Developer Platforms at Microsoft, participated on a panel titled "The Web Is the Platform," along with Dion Almaer from Palm and Dave Mcallister at Adobe. Mark Driver from Gartner moderated. It was an interesting discussion with most parties agreeing on the web as a platform that provides opportunity for companies to build business models, use different approaches and how open source plays a very strong part in that vision. Goldfarb shared how the Microsoft /web site for the Microsoft Web platform, features 23 open source applications out of a total of 25 applications. They include software from popular open source companies such as Acquia Drupal, Wordpress, Joomla, Umbraco, DotNetNuke, You can find them and more listed in the gallery.

    It was also great to see the folks at Geeknet at the Bird-of-a-Feather (BOF) talking about how Open Source on Windows is steadily climbing. 82% about 350,000 projects are Windows compatible and that is not a small number and fabulous news for those of us working with diverse languages and in mixed environments. These guys know something about the community considering they run sites like SourceForge, Slashdot, ThinkGeek, Ohloh, and freshmeat with over 40 million geeks visiting them.

    Other notable presentations …

    Tim O’Reilly, who is always fun to listen to, in a thought provoking session title “The Real Open Source Opportunity”, talked about how the future is about data and open access to it. It will be interesting on seeing how all the systems share and make sense of all the signal from the noise. I feel the work we are doing with OData.org and the cloud can play a big role on helping make this happen.

    Justin Erenkrantz, the President of the Apache Software Foundation, which we are working on a few things on, gave a presentation on “Writing and Distributing Software "the Apache Way" which should make it’s way up on his talks links soon.

    Matt Aslett, Analyst at The 451 Group presented  “From Support Services to Software Services – The Evolution of Open Source Business Strategies” around research regarding the best ways to make money from open source software and combining commercial and community interests.Matt, if you’re reading this,  it was nice chatting with you at lunch!

    Jono Bacon's session 'Unwrapping The Community Manager Talk" was one to catch and I’m looking forward to getting his slides too. At the same time as Jono’s session Matt Asay had a panel session too,  and there was some nice rivalry on who would fill their rooms first :) btw Who won? Jono, where are your slides?

    It was great to also see partners from the Interop Vendor Alliance, WS02 (nice to see you Jonathan and Devaka!) and Red Hat too!

    Tweets about OSBC provide interesting commentary!

    I’m looking forward to EclipseCon in Santa Clara next week, where we’ll share some more news around interoperability with open source projects. Maybe I’ll catch you there?

    Jas Sandhu , @jassand

  • Interoperability @ Microsoft

    FileAPI Prototype Added to HTML5 Labs, More Prototypes Coming

    • 0 Comments

    Last December, when we launched HTML5 Labs, the place where Microsoft shares prototypes of early and unstable standards, we committed to regularly update these prototypes and add additional prototypes based on what will most help with the testing of the specifications.

    Ongoing Prototype Updates, Spec Analysis and Investigation

    Since then, we have updated the WebSockets prototype three  times and we have analyzed a number of specifications, with three new areas currently under active investigation. Today I am truly pleased to announce that we have also added a new prototype -  FileAPI  - as well as made an announcement on our plans for the MediaCapture API. 

    We have also been working with, and listening to, the feedback from early users, and have updated the HTML5 Labs site and given it a new look and feel.

    Introducing the FileAPI Prototype

    The Interoperability team at Microsoft developed the File API prototype, which is based on the draft W3C standard that provides an API for representing file objects in web applications. The main goal here is to solve an old problem for web applications that want to allow the user to select some files and, for instance, upload them on the server in a secure manner. The prototype includes a demo that shows how FileAPIs can be used to select some images on the local machines, preview them on the browsers, and then upload them to the server. In order to enable these scenarios today, browser extensions need to be installed in some cases.

    WebSockets has Been Updated 3 Times, New Demo Available

    Last month we released the third update to our WebSockets prototype since we released it on the HTML5 Labs site in December. This update is based on the IETF WebSockets 06 Protocol Specification, and extended interoperability testing with other 06 protocol implementations: LibWebSockets; Jetty, an Eclipse community open-source project which provides an HTTP server,  HTTP client and javax.servlet container; as well as a test Firefox build. We also hosted a chat demo page on Azure, which can be opened in Firefox and will use native browser WebSocket instead of the Silverlight-based one. 

    We also previously updated the IndexedDB prototype to bring it in line with the latest version of the specification, and have just added a new WebSockets demo

      

     Game In Progress: When a player drags a tile, its position is communicated to the other browser

    via WebSockets  and drawn accordingly on the screen, as shown above and below.

     The source code for this game is available on the HTML5 Labs web site.

     Media Capture Prototype is in the Cards

    The next prototype we are already planning for the site will cover Media Capture API, a draft specification that defines HTML form enhancements to provide access to the audio, image and video capture capabilities of a device. The first release of the prototype includes Audio capabilities only, but we plan to add video support shortly after the release of the first version. So, stay tuned for the Media Capture  prototype and other new ones that we are working on right now.

    Microsoft's approach with Internet Explorer as outlined in this blog post by Dean Hachamovitch, the Corporate Vice President for Internet Explorer, is to implement standards as they become site-ready for broader adoption.

    Our Thanks

    I also really want to thank you for helping Microsoft and the Internet Explorer team build a better and more interoperable Web, and encourage you to participate in the appropriate standards bodies to help finalize the specifications.


    Many thanks,

    Claudio Caldato,

    Principal Program Manager, Interoperability Strategy Team

  • Interoperability @ Microsoft

    Microsoft at Node Summit

    • 2 Comments

    We are excited to be attending and participating at Node Summit in San Francisco this week.

    Among those Microsoft staffers on site are Server & Tools Corporate Vice President Scott Guthrie - who participated on a panel about Platform as a Service this morning and also gave a keynote address - and Gianugo Rabellino, the Senior Director for Open Source Communities, who was on a panel discussing the importance of cross-platform.

    You can read more about Scott's keynote on the Windows Azure blog here.

    As you may know, in December Microsoft announced that it was adding support for Node.js to the Windows Azure platform, which allows developers to easily take advantage of the powerful capabilities of Windows Azure with simple tools and a new open source SDK.

    As this work continues inside of Microsoft as well as with the Node.js community and our partner ecosystem, new and exciting capabilities are coming available allowing Node.js developers to have great experiences on the Windows platform.

    Today, during his keynote, Scott Guthrie demonstrated how easy it is to get up and running with Node.js on Windows and Windows Azure, while our partners at Cloud9 showcased new tooling experiences that provide even greater flexibility to Node.js for developers who want to build for Windows Azure.

    Microsoft has been closely partnering with Joyent for some time now to port Node.js to Windows. We have built an IO abstraction library with them that can be used to make the code run on both Linux and Windows.

    We also recently released the Windows Azure SDK for Node.js as open source, available on Github. These libraries are the perfect complement to our recently announced contributions to Node.js and provide a better Node.js experience on Windows Azure. The Windows Azure Developer Center provides documentation, tutorial, samples and how-to guides to get started with Node.js on Windows Azure.

    The Joyent team also recently updated the Node Package Manager for Windows (NPM) code to allow use of NPM on Windows. NPM is an essential tool for Node.js developers so now having support for it on Windows we have a better development experience on Windows.

    We are also working with the Joyent team on improving the development experience by leveraging the power of Microsoft Development tools and documentation that will make easier for developers to use Node.js APIs.

    And, relatedly, we have also been working closely with 10Gen and the MongoDB community in the past few months, and MongoDB already runs on Windows Azure. If you’re using the popular combination of Node.js and MongoDB, a simple straightforward install process will get you started on Windows Azure. You can learn more here.

    Our interest in, and support for Node.js is just one of the ways in which Windows Azure is continuing on its roadmap of embracing Open Source Software tools developers know and love, by working collaboratively with the open source community to build together a better cloud that supports all developers and their need for interoperable solutions based on developer choice.

    As Microsoft continues to provide incremental improvements to Windows Azure, we remain committed to working with developer communities.

    We also clearly understand that there are many different technologies that developers may want to use to build applications in the cloud: they want to use the tools that best fit their experience, skills, and application requirements, and our goal is to enable that choice.

    All of this delivers on our ongoing commitment to provide an experience where developers can build applications on Windows Azure using the languages and frameworks they already know, enable greater customer flexibility for managing and scaling databases, and making it easier for customers to get started and use cloud computing on their terms with Windows Azure.

  • Interoperability @ Microsoft

    The Developer’s Dilemma: How Do You Reach a New Audience without Spending Hours Recoding?

    • 0 Comments

    MSOpenTech_whiteboard_v3PERSP

    One of the greatest challenges of today’s developer is to develop lasting code that works across multiple platforms and devices. Because ultimately as creators, don’t we all want everyone (and anyone) to be able to access and appreciate our hard work? Writers want their books read. Singers want their songs heard. Developers want….well, you get the idea.

    Open source technologies are one of the solutions enabling developers to extend their reach reusing their skills and code as communities contribute adding support for new platforms all the time. Windows has always been a great playground for developer communities and many open source technologies already support Windows devices.

    clip_image002The Enyo team is a great example of how communities are considering all modern platforms to allow developers to concentrate on innovation and broaden their reach to many devices leveraging their existing skills and code. From the get go, they have considered and rapidly supported all the major mobile platforms including Windows Store apps and Windows Phone apps. The Confero app demonstrates how a dev can reach more customers with the same app on iOS, Android, Windows Phone, Blackberry and the Web.

    To further help developers have their code work seamlessly across platforms, Microsoft Open Technologies (MS Open Tech) has been working with many open source communities to add to the list of frameworks and tools developers can use to build Windows Store and Windows Phone apps.

    Whether you are a web developer coding with jQuery or other JavaScript frameworks and tools, or a C++ developer using Cinder, OpenCV, Cocos2DX, Ogre3D, Bullet, Box2D you can now use these frameworks and libraries, and reuse your code to port your existing applications or create new apps for Windows devices.

    Below we’ve broken down by developer the tools and resources MS Open Tech contributed to bring to Windows devices to help you introduce your applications to whole new audiences!

    clip_image004

    For C++ and Gaming Developers

    Do you use C++ for game and graphics development, favoring its native access to hardware acceleration? MS Open Tech has worked closely with various open source communities to contribute code to popular C++ frameworks optimizing them for Windows devices.

    • Cinder, a growing programming library for creative coding in C++ and used for design engineering has just been brought to Windows Store apps by MS Open Tech
    • Cocos2DX and Ogre3D which already supported Windows Phone 8, now fully support Windows Store apps. Porting a Cocos2D or Ogre3D game to Windows devices is now as simple as a copy paste of your code into a Visual Studio project for Windows Store or for Windows Phone.
    • Box2D and Bullet are other great gaming libraries joining the Windows Store apps party!
    • OpenCV, popular computer vision and machine learning framework, can now be used in Windows Store applications as well.

    For Web Developers

    Since Web technologies started to be used to build apps for devices, MS Open Tech has engaged with open source communities such as PhoneGap or jQuery Mobile to make Web developers life easier in their new ventures. From cross platform development tools, to HTML5/JavaScript frameworks, and development tools, we contributed to enable lots of open source technologies on Windows devices that let Web developers build apps for Windows 8 and Windows Phone 8 without wasting hours learning a new platform.

    jQuery now fully supports WinRT (the Windows Runtime, powering Windows Store apps), allowing web developers to build Windows 8 apps reusing their existing code and skills. As a direct result from this work, web developers can also use other frameworks that are based on jQuery, such as Backbone.js, Knockout, CanvasJS, RequireJS to build Windows Store apps. You can learn more about what it took to make jQuery support WinRT on this Nettuts tutorial.

    Developers who use HTML5 to build cross platforms apps for iOS and Android with tools such as Apache Cordova (aka PhoneGap) can easily port their apps to Windows Store and Windows Phone Store as Apache Cordova fully supports both platforms. If you want to learn more about the MS Open Tech’s partnership with Apache Cordova, join us at PhoneGap day in Portland at the end of the week.!

    Many HTML5/JS mobile frameworks come with themes for Windows Phone 8 that were created with MS Open Tech’s technical support. jQuery Mobile, Sencha Touch, Dojo, Enyo fully support Internet Explorer 10 and the WebBrowser control used to encapsulate web code in native apps on Windows Phone, in the exact same way as Android or iOS.

    And don’t forget weinre on Internet Explorer 10 for remote debugging of HTML5 pages and SQLite for data storage – both work seamlessly with Windows Phone 8 and Windows 8.

    Cloud-Based Services for Mobile Developers

    Lucky for us, the Windows Azure team is only a few minutes away by bus or car, and we have worked closely with this team to make robust and flexible mobile services available for developers to build apps that scale on all major platforms so you can focus on innovation, instead of constantly reinventing the wheel.

    Specifically, we built the Android SDK for Windows Azure Mobile Services to complement the support for Windows Store apps, Windows Phone, iOS and HTML5. Giving Android developers access to a range of advanced cloud-based services for storage authentication and notifications.

    We also contributed the Android SDK for the Windows Azure Notifications Hub which lets you broadcast push notifications to millions of devices across platforms from almost any backend hosted in Windows Azure. Last but not least, MS Open Tech created a Backbone adapter for Windows Azure Mobile Data Service, letting you seamlessly sync your data with the cloud using your usual favorite Backbone APIs.

    What’s next?

    All of these projects are ongoing, and we at MS Open Tech are always adding new ones to extend the list of technologies open source communities are bringing to Windows devices. Also, if your favorite open source framework doesn’t work on Windows Store apps or Windows Phone apps, let us know emailing us.

    You will also find that Windows and Visual Studio offer plenty of tools and programs to help you libraries and frameworks support Windows. Jason Olson, Program Manager in the Windows team presented a great session at the last //build/ event about technologies like NuGet, Visual Studio Extensions, and programs such as http://services.windowsstore.com. Check out the webcast on channel 9.

    You can find more detailed resources on developing apps for Windows devices as an open source developer visiting the MS Open Tech’s website. You will learn things such as how to get started with Windows apps development, how to develop for Windows 8 or Windows Phone 8 on a Mac or what were our contributions to these frameworks to make them work seamlessly on Windows devices.

    Now go get your Cocos2D based game or other open source based app run on Windows 8 and/or Windows Phone 8, and let us know how it works!

  • Interoperability @ Microsoft

    New version of Zend Framework adds support for Microsoft Windows Azure

    • 0 Comments

    Zend-Framework-Windows-Azure-SDK-PHP Zend Technologies Inc. has announced the availability of Zend Framework 1.10, which among other new features includes support for Microsoft Windows Azure cloud services. We’re very excited about this key milestone, which is the result of a fruitful collaboration! This particular project started last year when we announced the Windows Azure SDK for PHP CTP release and upcoming support in Zend Framework. I also want to thank again Maarten Balliauw who has been a key contributor to the initial project.

    With the new Zend Framework 1.10, by simply using the new Zend_Service_WindowsAzure component, developers can easily call Windows Azure APIs from their PHP applications and leverage the storage services, including Blob Storage, Table Storage and Queue Service, offering them a way to accelerate web application development and scale up on demand.

    With this announcement, PHP Developers now have great choice when it comes to writing web applications targeting Windows Azure. Besides the Windows Azure SDK included in Zend Framework, there is Windows Azure SDK for PHP which is already prepackaged in Windows Azure tools for Eclipse and the more simpler Simple Cloud API.

    Jean Paoli, General Manager Interoperability at Microsoft offered a comment about this announcement: “PHP developers find the Windows Azure platform compelling, Microsoft’s decision to contribute PHP-based Windows Azure components to Zend Framework helps demonstrate Microsoft’s commitment to openness and interoperability by providing greater choice and opportunity for Microsoft customers and partners.”

    All of this is very well aligned with Windows Azure Interoperability approach www.windowsazure.com/interoperability in particular and  the overall interoperability effort Microsoft is conducting around PHP (see http://www.interoperabilitybridges.com/projects/tag/PHP.aspx and http://www.microsoft.com/web/php)

    Vijay Rajagopalan, Principal Architect

  • Interoperability @ Microsoft

    New MS Open Tech HTML5 Labs HTTP/2.0 prototype shows a safer and simpler Internet communication security approach

    • 0 Comments
    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.

  • Interoperability @ Microsoft

    Interoperability Elements of a Cloud Platform: Technical Examples

    • 0 Comments

    Two years ago we shared our view on Interoperability Elements of a Cloud Platform. Back then we talked to customers and developers and came out with an overview of an open and interoperable cloud, based on four distinct elements: Data Portability, Standards, Ease of Migration and Deployment, and Developer Choice. Since then, we have been laser focused on the quest for an interoperable and flexible cloud platform that would enable heterogeneous workloads.

    Windows Azure is committed to openness across the entire application stack, with service APIs and service management APIs exposed as RESTful endpoints that can be used from any language or runtime, key services such as Caching, Service Bus, and Identity that can be hosted either on-premises or in the cloud, and open source SDKs for popular languages that give developers a choice of tools for building cloud-based applications and services.

    In this blog post I’ll recap some of the most important news of the last year in each of these areas. As I mentioned in a blog postearlier this year, when a journey reaches an important milestone it’s good to look back and think about the road so far. We’ve come even farther down that road now, and here are many technical examples of what has been accomplished.

    Data Portability

    When customers create data in an on-premises application, they have a high level of confidence that they have control over the data stored in the on-premise environment. Customers should have a comparable level of control over their data when they are using cloud platforms. Here are some examples of how Windows Azure supports Data Portability:

    Standards

    Cloud platforms should reuse existing and commonly used standards when it makes sense to do so. If existing standards are not sufficient, new standards may be created. Here are some of the ways we’re working to support standards for cloud computing:

    Ease of Migration and Deployment

    Cloud platforms should provide a secure migration path that preserves existing investments and enable co-existence between on-premise software and cloud services. Here are some examples of ease of migration and deployment on Windows Azure:

    Developer Choice

    Cloud platforms should enable developer choice in tools, languages and runtimes to facilitate the development of interoperable customer solutions. This approach will also broaden the community of developers that write for a given cloud platform and therefore enhance the quality of services that the platform will offer to customers. Here are some of the ways that Windows Azure is delivering on  developer choice:

    It’s exciting to see how far we’ve come, and we still have much to do as well. The Interoperability Elements of a Cloud Platform originally came out of discussions with customers, partners, and developers about what they need from an interoperable cloud, and we’re continuing those discussions going forward, and we will continue to deliver on these important elements!

    Gianugo Rabellino
    Senior Director, Open Source Communities
    Microsoft Open Technologies, Inc.

  • Interoperability @ Microsoft

    Microsoft announces Apache Cordova integration in Visual Studio for Multi-Device Hybrid App development

    • 3 Comments

    Today at TechEd US, Microsoft announced the preview release of Visual Studio tooling support for Apache Cordova. This new capability is based on the open source project Apache Cordova, whereby developers can target Android, iOS, Windows Store and Windows Phone 8 from a single project using existing HTML5 and JavaScript skills and code to build apps that take advantage of the native capabilities of the device.

    Read more on the MS Open Tech blog.

  • Interoperability @ Microsoft

    New interoperability lab: Remote Desktop between Windows and Mac

    • 0 Comments
    RemoteDesktopMacWindowsInteroperabilityLabWhitePaper

    We have just published a new Lab on InteropVendorAlliance.org titled Remote Desktop Interoperability Lab.

    This lab explores scenarios for establishing Remote Desktop connections between Macintosh and Windows based machines.

    It gives me the opportunity to welcome Aqua Connect to the Interop VInteropVendorAllianceAquaConnectendor Alliance (IVA). Aqua Connect is a leading solution provider of connectivity between Windows and Macintosh. They have been a great partner to work with, and we are excited to show the results of our partnershiop in this lab. A big thank you to Ronnie Exley and the Aqua Connect team for their participation.

    The lab demonstrates how to establish remote desktop connections between Macintosh and Windows based machines:

    • Utilizes Remote Desktop Client for Mac 2 for Mac to PC connectivity
    • Utilizes Aqua Connect’s Mac Remote Desktop Beta.

    RemoteDesktopMacWindowsInteroperabilityLab

    As part of its development of a Mac terminal server, Aqua Connect obtained a license from Microsoft for the Remote Desktop Protocol (RDP, more detail here) and integrated the protocol into their solution. Using the protocol documentation that Microsoft had made publicly available, on its developer website (msdn.microsoft.com), Aqua Connect took advantage of the access Microsoft provided to its Interoperability Lab facilities, as well as key Microsoft RDP engineers, to develop a bridge between Windows and Macintosh systems. The result is that any Windows machine can now connect (with the Remote Desktop Connection client) to a Mac with the Aqua Connect Mac Remote Desktop installed.

    Further details on the lab are available on the www.InteropVendorAlliance.org site:

    Jas Sandhu, Interoperability Vendor Alliance Manager

    @jassand

  • Interoperability @ Microsoft

    MS Open Tech contributes to open source adaptive streaming video player DASH.js

    • 0 Comments

    Adaptive streaming is an important part of the future of broadband video, and interoperability matters more than ever. People want to experience Web content swiftly and smoothly across a variety of devices. Microsoft Open Technologies, Inc. (MS Open Tech), is working with others in the industry to define guidelines for the delivery of video online, as well as contributing open source code that demonstrates interoperability of adaptive streaming across a variety of devices. 

    Adaptive streaming allows streamed video content to adjust to the bandwidth available at any given time. The result is a more fluid streaming experience for the viewer. However, today’s proprietary technologies make it difficult for content to be delivered to the many consumer devices available. The MPEG-DASH standard (ISO/IEC 23009-1) seeks to address this problem. In addition it provides many other advantages, such as switching between camera views, low-latency live streaming and improved subtitles and captioning.

     

    Microsoft Corp. is a founding member of the DASH Industry Forum (DASH-IF), an incorporated non-profit organization with over 65 members working to catalyze the adoption of MPEG-DASH. DASH-IF recently surveyed a group of European Broadcasters. They found that the biggest barrier to adoption is the lack of available clients capable of playing MPEG-DASH content. One of the reasons for this is that MPEG-DASH is a large and complex standard with many potential variations in implementation.

    DASH-IF has published a set of guidelines for implementation (called DASH-AVC/264). Using these guidelines, organizations can more easily build MPEG-DASH solutions that are interoperable. MS Open Tech, along with Digital Primates and a number of other DASH-IF partners, are building an open source DASH-AVC/264 reference implementation called DASH.js.

    Dash.js is permissively licensed (under the BSD license) and can therefore be studied and reused by anyone seeking to provide their own DASH-AVC/264 compliant player. The goal is to make it easier for third-parties to build adaptive streaming video players.

    In order to achieve this goal, the DASH.js player needs to be useful in as many environments as possible. Therefore, the DASH.js project seeks to be as open as possible to contributions. MS Open Tech is leading the definition of a fully inclusive project governance model to help ensure the success of the project. A governance model is a small set of rules and guidelines under which the project community operates. It ensures wide participation without a loss of efficiency and agility.

    Of course, governance is secondary to the production of useful software. MS Open Tech developers, along with other contributors to DASH.js, are already hard at work. At the same time other parts of Microsoft are working to support MPEG-DASH, for example Windows Azure Media Services recently announced a preview feature that enables MPEG-DASH live profile streaming.

    MPEG-DASH is important to the future of broadband video. Come and join the MS Open Tech team in making the DASH.js project a success.

  • Interoperability @ Microsoft

    MS Open Tech Updates HTML5Labs HTTP/2.0 Prototype Delivering Internet Security in Open Source Encryption Libraries

    • 2 Comments

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

    Adalberto Foresti
    Principal Program Manager,
    Microsoft Open Technologies, Inc.

    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!

     

  • Interoperability @ Microsoft

    Windows Azure Tools for Eclipse for PHP: new update, new tutorial

    • 1 Comments

    Things are moving pretty fast!
    A few weeks back we announced a series of new and updated Tools/SDKs for PHP developers targeting Windows Azure, which included the Windows Azure Tools for Eclipse/PHP, a comprehensive set of tools that use the Eclipse development environment to create, test and deploy modern cloud applications for the Windows Azure Platform.

    Today we’re releasing the October 2010 Community Technology Preview (CTP). This update is based on your feedback and includes many new features, as well as enhancing the workflow of features for version 2, which should be released by November. Here’s a quick rundown of the features we’re introducing:

    clip_image002[4]

    • One-click deployment of PHP Applications from Eclipse directly to Windows Azure
    • Support for Windows Azure Diagnostics
    • Integration of Open Source AppFabric SDK for PHP Developers for connecting on-premise PHP applications to cloud applications.
    • Support for multiple Web Roles and Worker Roles for large PHP applications
    • Support of Windows Azure Drive to enable ease of migration of legacy PHP applications.

     

    To learn more, take a look at Brian Swan’s complete “Get Started” tutorial called Using the Windows Azure Tools For Eclipse with PHP, in which Brian shows how to get the most out of Windows Azure.

    The Windows Azure Tools for Eclipse/PHP can be downloaded from here: http://www.windowsazure4e.org/download/, and will of course work from auto upgrade functionality in Eclipse.
    As always, do give us your feedback at http://sourceforge.net/tracker/?group_id=266877&atid=1135912

    Vijay Rajagopalan, Principal Architect

  • Interoperability @ Microsoft

    New CU-RTC-Web Prototype from MS Open Tech Demonstrates WebRTC Video Support Without SDP Offer/Answer

    • 0 Comments

    Supporting ORCA, a new W3C Community Group for WebRTC

    Today, Microsoft Open Technologies, Inc., (MS Open Tech) is publishing a new prototype implementation of CU-RTC-Web on HTML5Labs that continues our exploration of alternatives to the SDP Offer/Answer approach. The CU-RTC-Web approach is based on two basic principles: that JavaScript APIs for realtime communications should not be based on passing under-specified SDP blobs and should not require implementation of the SDP Offer/Answer state machine. These principles, first articulated in the original CU-RTC-Web proposal have continued as basic tenets within our prototyping efforts, which have demonstrated the practicality of the approach with running code.

    This prototype demonstrates how to support H.264/AVC video without SDP, by building the appropriate JavaScript code and without introducing any changes in the specification. Previous prototypes of CU-RTC-Web included demonstrations of cross-platform interoperability (voice interop between Chrome on a Mac and IE10 on Windows) and roaming between cellular and Wi-Fi connections. Because CU-RTC-Web is a contribution to the ongoing standardization process, it does not represent a planned feature of any Microsoft product, and the prototypes should not be used for the development of commercial products.

    As experience with the WebRTC APIs has accumulated, more and more developers posting on the IETF and W3C mailing lists are reporting that their attempts to develop WebRTC applications have been impeded by the underspecified complexities of SDP and the unwieldy Offer/Answer model. As a result, several participants collaborated on an internet draft WebRTC JavaScript Object API Rationale that critiques the SDP Offer/Answer approach to a WebRTC API and outlines the rationale for an alternative API. Erik Lagerway of HookFlash has also provided a well-crafted Blog post on the issues – WebRTC JS Object API Model.

    At MS Open Tech, we are excited to see this work toward an “ObjectRTC” API. ObjectRTC and CU-RTC-Web share the same principles (e.g. no SDP Offer/Answer) and we look forward to a public discussion of how to synthesize the best ideas from both proposals. Pursuing multiple interoperability experiments such as CU-RTC-Web and ObjectRTC is how standardization works at its best. If you wish to participate in the discussion, an ObjectRTC Community Group (CG) has been established at the W3C - ORCA.

    The recent vibrant and open discussion as well as availability of an open source repository for the development of an alternative JavaScript API represents a major step forward for the real-time communications developer community and the principles of the open web. As these developments evolve, MS Open Tech will continue its prototyping efforts, which may in future be based on a constructive synthesis emerging from the Working Group or Community Group activities.

    As with our previous release, we hope that publishing this latest working prototype in HTML5Labs provides guidance in the following areas:

    • Clarify the CU-RTC-Web proposal with working code, so as to provide details on how the API could be used to solve real-world use cases in an interoperable way.
    • Encourage others to develop comparable interoperable example code for their proposals.
    • Seek developer feedback on how the CU-RTC-Web addresses interoperability challenges in Real Time Communications.
    • Provide a source of ideas for how to resolve open issues with the current draft API as the CU-RTC-Web proposal is cleaner and simpler.

    This is a great time for the community to come together to evaluate the draft specs to make sure they’re understandable, interoperable and implementable, and synthesize ideas to enable them to work together. We encourage you to engage with one or more of the discussions in IETF and W3C, such as ORCA CG, and we offer this new prototype to contribute to that discussion with running code. The latest CU-RTC-Web prototype can be downloaded from HTML5Labs. We look forward to receiving your feedback: please comment on this post or send us a message once you have tried out the prototype, and stay tuned for even more to come.

  • Interoperability @ Microsoft

    Relationships … It’s Complicated!

    • 0 Comments

    Isn't Valentine's Day a perfect occasion to think about relationships? Other than my family, the relationship I care most about nowadays is the one between Microsoft and the Open Source communities which, to put it mildly, have been interesting in the past. As I'm learning my way through this new adventure, I have been considering our track record from the early stages and, more importantly, thinking about the future.

    Make no mistake. Relationships are hard and high in maintenance – especially when there is some history to them. Entering the state where water is really under the bridge is tough, and the one and only remedy I can think of is to build those bridges one stone at a time, and show that you really care. I firmly believe Microsoft is on the right track here: first as an outsider, then as a partner, and finally as an employee. For the past few years I saw the tide turning, and Microsoft becoming increasingly more open. We are building those bridges, and we are doing it in the one and only way Open Source communities care: by showing commitment, and contributing code.

    We understand that we are far from being done, which is why I have started looking outside of Microsoft and reaching out to communities to continue the ongoing conversation, and to show the world how much we have changed and become more open. But showing the whats and the hows is notenough: we want to get to the next step, and delve into the reasons leading us to steer the ship towards open water. As the story unfolds and I start touring the world to meet as many communities as I can and gather the feedback we need so much to move forward and have a productive relationship.

    Speaking of travel, I just came back from my European tour, where I visited Italy, Germany, the UK and Belgium. This was my first “toe in the water”, and it was a priceless learning experience, where I managed to reconnect with old friends and meet new people from the Open Source world. In Italy I had a chance to see how HTML5 is going to play a huge part in the future of the Web (you don’t want to lose the upcoming “HTML, ci siamo” event). In Germany I walked away with a miniature model of the “we love developers” double decker Microsoft bus that is making the rounds to show all the efforts Microsoft is doing in enrolling developers. In the UK, I was blown away by the amount of information, tutorials, interviews and other good stuff the www.ubelly.com fine folks are doing. And in Belgium I had a great meeting with some of the most well respected PHP developers who are constructively having a discussion on how to improve their experience on Azure, and helping to plug on the community creativity with a very contest (if you live in Europe, and grok PHP, you should definitely sign up!).

    On top of that, I spent my last day in Europe visiting and attending FOSDEM, the largest Free Software event in Europe. There, I had the pleasant surprise of a day packed with casual encounters in the hallways which turned into extremely practical conversations on how Microsoft and the FLOSS communities can move on and work together on real problems, real projects and real code.

    And code does definitely matter, so let me finish by announcing some new released projects, freshly baked and wrapped in a proper Valentine's day chocolate box. Today we announced the availability of four new extensions for Joomla! that allow Joomla! administrators/developers to provide users with the following integrated features: Bing Maps, Windows Live ID, OData and the Silverlight Pivot Viewer. These extensions are developed and contributed by Schakra and MindTree, with funding provided by Microsoft. Here’s a quick overview of the extensions:

    Bing Maps extension (http://joomlacode.org/gf/project/bingmaps/):
    With this extension, Joomla! users can easily include customized Bing Maps into the content they are publishing, and administrator can preconfigure how the map should look, and where it can be added.
    clip_image002 clip_image004

    Silverlight Pivot viewer extension (http://joomlacode.org/gf/project/pivotviewer/):
    With this extension Joomla! users can visually navigate with the Silverlight Pivot viewer through large amount of data. Administrators define what is the data source using a set of preconfigured options like OData, RSS, media files, etc, .

    clip_image006 clip_image008

    Windows Live ID extensions(http://joomlacode.org/gf/project/windowsliveid/):
    With this extension Joomla! users can associate their Joomla! account to their Windows Live ID, and then to login on Joomla! with Windows Live ID.
    clip_image010

    OData extension (http://joomlacode.org/gf/project/odata/):
    With this extension Joomla! administrator can provide users with quick access to any OData source, like the Netflix catalog (check the list of live OData services), and let them include these in any content type (such as articles). The generic extension includes a basic OData query builder and renders data in a simple HTML Table.

    clip_image012 clip_image014

    Code speaks, content matters. To close on Joomla!, we’ve also just published a new tutorial explaining how to get Joomla! up and running on Windows Azure using the Windows Azure Companion. And by the way we will be at J-and-Beyond conference May 6th-8th, to showcase more Joomla! and Microsoft technologies interop.

    As always I look forward to your comments and feedback.

    Gianugo Rabellino, Senior Director of Open Source Communities

  • Interoperability @ Microsoft

    Nokia Developers: learn Windows Phone even faster

    • 0 Comments

    It’s my great pleasure to announce today a comprehensive package to leverage your development skills while learning to build applications for Windows Phone. The Microsoft & Nokia agreement has been described at length over the past few months and, like Matt Bencke highlighted, one of our goals has been to make it easy for Nokia Symbian developers to learn Windows Phone.

    So, folks from Microsoft and Nokia worked together to build a great package to help you get started. This helpful package contains the following tools and documentation to help you along the path to learning Windows Phone development:

    These complement the similar iOS/Android guidance & mapping work we released a couple months ago.

    The “Windows Phone Guide for Symbian Qt Application Developers” white paper is about 100 pages organized in 8 chapters.

    • clip_image002Chapter 1: Introducing Windows Phone Platform
      to Symbian^3 Qt Application Developers
    • Chapter 2: Windows Phone Application Design Guidelines
    • Chapter 3: Windows Phone Developer and Designer Tools
    • Chapter 4: C# programming
    • Chapter 5: Introducing Windows Phone Application Life Cycle
    • Chapter 6: Porting Applications to Windows Phone
    • Chapter 7: Windows Phone Example Applications
    • Chapter 8: Using the API Mapping Tool

    The white paper is available in different formats (HTML, DOCX & PDF). Feel free to leave comments, suggestions, and/or corrections on the online version.

    Chapter 6 introduces porting tutorials, in which you will find practical examples and tips on how to port your applications, like the RSS Reader applications or the “Diner” example, a catalog-type restaurant information application. From design consideration to data binding, the porting story addresses many aspects of the process that will be useful to you; the developer.

    clip_image004

    The full list of samples and source code is available to you.

    The addition of Symbian Qt to the Windows Phone API mapping tool is another perk we wanted to deliver in order to speed up the learning curve to Windows Phone. For this first iteration of the mapping, we’ve focused on the core libraries for Qt 4.7 for Symbian (QtCore, QtGui, QtLocation, QtNetwork, QtSensors, QtSql, QtXml, QtWebKit, QML Elements, QML Components ). We invite you to offer up ideas about what additional mapping you feel would make sense and would like to see included in the tool.

    clip_image006

    Finally, keep an eye on the “Nokia Windows Phone Training” roadshow, starting today in Paris, France. During this one day training event, you’ll learn how to take your ideas and get them running on the Windows Phone platform. Upcoming dates and locations for the roadshow are as follows: Milan, Italy (Sept 26), Madrid, Spain (Sept 29), Berlin, Germany (Oct 4) , London, United Kingdom (Oct 10) and Silicon Valley, USA - date & details coming soon!
    Similar events are also happening in Australia: Sydney (Sept 24-25[SOLD OUT], Oct 8-9), Melbourne (Oct 8-9[SOLD OUT, wait list]) and Brisbane (Oct 8-9).
    We realize this is only a few dates and locations, so for all the developers who want to learn Windows Phone, I recommend that you follow at your own pace the EXCELLENT “Window Phone Mango Jump Start” online video training. And stay tuned, there’s more to come!

    Start Today!

    We’re all eager to see the Nokia hardware running Windows Phone. Windows Phone Mango is just out of the door, so don’t wait, go get your copy of the “Windows Phone Guide for Symbian Qt Application Developers white paper and take advantage of its guidance!

    Jean-Christophe Cimetiere, Sr. Technical Evangelist
    @jccim - blogs.msdn.com/interoperability

    [Cross-posted on the Windows Phone Developer blog]

  • Interoperability @ Microsoft

    HTML5 Moves Forward

    • 0 Comments

    In case you missed it earlier this week, the W3C announced that it had extended the charter of the HTML Working Group, including clear milestones for HTML5, the next version of the platform-neutral HyperText Markup Language standard used worldwide for rendering Web pages, and the cornerstone of W3C's Open Web Platform for application development.

    There has been a lot of online discussion about all this, positive and negative, as well as a number of media reports on the move, which is great as we at Microsoft strongly believe in an open discussion. I have referenced some of those reports in this blog, which is my synopsis of some of the issues.

    Under the milestone timetable announced this week, the W3C said the Working Group will advance HTML5 to "Last Call," the point at which the W3C thinks the standard's features are set. Last Call is also essentially a call for all communities to confirm the technical soundness of the specification, after which the group will then shift focus to gathering implementation experience and building a comprehensive test suite.

    As Joab Jackson reported in ComputerWorld and other online publications, the W3C expects no new features to be added after the Last Call. After Last Call is completed the group will take feedback only from implementers and through trials of the test suite, Philippe Le Hégaret, lead for the W3C Interaction Domain, which oversees the development of HTML, CSS (Cascading Style Sheets), SVG (Scalable Vector Graphics) and other Web standards, told Jackson.

    Microsoft is pleased with this time table, especially with Last Call in just three months. The HTML Working Group chairs set the Last Call schedule last year, and it's encouraging to see that the Working Group has stepped up to meet that schedule. This is a great step forward and we look forward to continuing to work with the hundreds of other members of the HTML Working Group to advance the specification.

    And, as Jeff Jaffe, the W3C CEO, said in a statement earlier this week, even as innovation continues, advancing HTML5 to Recommendation provides the entire Web ecosystem with a stable, tested, interoperable standard. "The decision to schedule the HTML5 Last Call for May 2011 was an important step in setting industry expectations. Today we take the next step, announcing 2014 as the target for Recommendation," he said.

    As CNet's Stephen Shankland correctly points out in his report on the news, the latest timetable doesn't mean interested parties won't be able to employ the new technology until 2014. "On the contrary, key phases of the coming years' development involve getting feedback from real-world use that's already well under way and ironing out wrinkles that may arise implementing the standard in Web browsers," he says.

    To quote Ian Jacobs, the head of W3C marketing as told to Scott Gilbertson at Webmonkey, "developers can use HTML5 now and we encourage them to do so."

    Because HTML5 anchors the Open Web Platform, the W3C has also started work on a comprehensive test suite to ensure the high levels of interoperability that diverse industries demand. Microsoft has already donated test cases to the current test suite. While it's the most comprehensive test suite of HTML5 so far, it is far from complete. But the test suite is an important step as it identifies differences in implementation and encourages implementers to fix deviations from the specification.

    The W3C has invited test suite contributions from the community and, starting in March, will also dedicate new staff to drive development of an HTML5 test suite. Its first task is to expand the existing test framework by the mid-2011, which will encourage browser vendors and the community to create test cases.

    CNet's Shankland also points out that HTML5 will become the first new revision since HTML 4.01 was released in 1999, noting the features in this next-generation Web page description language include built-in video and audio, a "canvas" element for two-dimensional graphics, new structural labels such as "article" to smooth programming, and a codified process to consistently interpret the hodgepodge styles of real-world Web pages, even when improperly coded.

     And, after the W3C releases the first last call working draft in May, it plans to begin tackling the early stages of what it's currently referring to as HTML.next. So stay tuned and follow along as the momentum around HTML5 keeps growing.

    Peter Galli

    Senior Community Manager

  • Interoperability @ Microsoft

    jQuery Mobile Open Source Framework Support for Windows Phone

    • 0 Comments

    Hello web and mobile developers!

    As you probably noticed, jQuery Mobile version 1.0 was announced this week. We are pleased to use this exciting occasion to reinforce our commitment to supporting popular open source mobile frameworks.

    Of the most recent activities, I want to highlight the work done to supporting PhoneGap by adding support for Windows Phone 7.5 (Mango), and now we are moving up the stack to improve support of jQuery Mobile on Windows Phone 7.5.

    As you probably know, jQuery Mobile framework is a Javascript HTML5-based user interface system for mobile device platforms, built on the jQuery and jQuery UI foundation.

    While today’s version 1 and the recent RC releases contain many features, we wanted to take a minute and highlight the collaboration we started with the jQuery Mobile team. In the last few weeks we have focused our attention on supporting Kin Blas and others in the community to improving the performance on Windows Phone 7.5.

    In particular, as the RC3 blog published earlier this week outlines, Windows Phone performance has improved quite dramatically as shown by the two showcase apps:

    • 226% improvement in rendering the form gallery, bringing it down from 5 to 2.2 seconds
    • 20x improvement in rendering the complex 400 item listview, from 60 seconds to 3 seconds

    The jQuery team has additional performance optimization tips for Windows Phone in the change log that saves additional perf time in certain scenarios.

    We are pretty encouraged with this progress, and will continue working with community to bring higher levels of performance and support for jQuery features to Windows Phone... stay tuned, and congratulations again to the jQuery Mobile Team!

    Abu Obeida Bakhach

    Interoperability Strategy Program Manager

  • Interoperability @ Microsoft

    New Open Source Portable Class Library for SQLite

    • 0 Comments

    Microsoft Open Technologies has released an interesting Portable Class Library for SQLite, offering .Net developers a single API for integrating SQLite across Windows Store, Windows Phone and .Net 4.5 apps.

    The library is released as open source and is available as a NuGet Package (and source code).

    To learn more, read the full blog post on msopentech.com/blog

  • Interoperability @ Microsoft

    A sneak peek at four new Nagios and Zabbix plugins for Windows Azure

    • 1 Comments

    Busy times at MS Open Tech! Today we’d like to share with the Azure community a sneak peek at our work on four new plugins for Nagios and Zabbix. It’s early days, but we care about your feedback and love working in the open, so effective today you can take a look at our github repo and see what we are working on to make monitoring on Azure easy and immediate for users of Nagios and Zabbix.

    What you can play with today is:

    • A plugin for Windows Azure Storage, that will allow you to monitor ingress, egress, requests, success ratio, availability, latency, and more
    • A plugin for Windows Azure SQL Databases, that will allow you to monitor ingress, egress, requests, success ratio, availability, latency, etc
    • A plugin for Windows Azure Active directory, that will allow you to monitor changes in user and group information (userdelta, groupdelta)
    • A plugin for Windows Azure Platform-as-a-Service (PaaS)  Worker Roles, that will allow you to monitor cpu, memory, asp.net stats, web service stats, and other compute stats

    Note that all compute plugins can be also used to monitor Windows Azure Infrastructure-as-a-Service (IaaS) Virtual Machines

    The steps for installing and running the plugins are documented in this ReadMe.

    Nagios and Zabbix have established themselves as popular choices for lightweight enterprise-class IT and infrastructure monitoring and alerting. The vibrant open source community built around Nagios has contributed hundreds of plugins (most of which are also compatible  with Zabbix) to enable  developers, IT professionals and DevOps pros to monitor a variety of entities, from servers to databases to online services. We love to help our customers that know and use those tools, and we are committed to supporting monitoring on Azure using open source technologies.

    This is a work in progress, and we’d love to hear from users to make our implementation of these popular tools the best it can be. The Plugins are available on our github repo, and we welcome your feedback and contributions. Send us a pull request if you’d like to contribute to these projects, or leave a comment/email if you have some feedback for us. See you on github!

  • Interoperability @ Microsoft

    For Backbone.js devs: easily enable new Cloud based experiences in your apps with the Windows Azure Mobile Data Service

    • 0 Comments

    Synchronizing data with the cloud has just become easier for Backbone.js developers thanks to the open source Backbone adapter for Windows Azure Mobile Data Service from Microsoft Open Technologies, Inc. Developers using the popular JavaScript framework Backbone.JS to structure their web apps now only need to add a couple values indicating the table name and location to offer their customers brand new experiences leveraging the cloud.

    About Windows Azure Mobile Services

    With Windows Azure Mobile Services, you can streamline common development tasks like structuring storage, integrating push notifications and configuring user authentication. Mobile Services fully supports Windows Store, Windows Phone 8, iOS, and Android development and are free for your first ten apps. The data service provides a straightforward way to store structured data in the cloud.

    The Backbone adapter for Windows Azure Mobile Data Service

    The Backbone adapter that MS Open Tech open sourced is for HTML apps. It overrides the backbone.sync method to make things work seamlessly with Backbone applications. Using the adapter is as simple as including a JavaScript file (in addition to the JavaScript file from the Windows Azure Mobile Data Service HTML library) in your Backbone application. Since the backbone.sync method is overrode, all restful calls to the server are intercepted and converted to the format that works with the Windows Azure Mobile Data Service.

    How about some code?

    A sample backbone collection would look like the following:

    var People = Backbone.Collection.extend({
        client: client,
        table: 'Table1',
        model: Person
    });

    var people  = new People();
    var employee = people.create(data);
    people.fetch(conditions);

    As shown in the example above, the only additional parameters that need to be added to the collection are:

    • ‘table’: indicating the corresponding table where the collection must be saved on Azure
    • ‘client’: this client object corresponds to the WindowsAzure.MobileServiceClient and typically helps with authentication when writing data to the database.

    All other operations such as create, update and fetch are like the usual Backbone operations.

    The fetch operation can also take additional parameters to filter the required data to bring it to the browser. The options for filter can specify a ‘skip’, a ‘take’, or a ‘where’ clause. For detailed information, check out the README.md file.

    Call to action

    To get started with Windows Azure Mobile Services, check out the Windows Azure portal.

    You can find the Backbone adapter for Windows Azure Mobile Services project on our GitHub page.

    Please let us know what you think commenting on this post or in the project, and do not hesitate to point us to your great web apps using Windows Azure Mobile Services!

  • Interoperability @ Microsoft

    The Updated WebSockets Prototype

    • 1 Comments

    Following hot on the heels of last week’s update to the IndexedDB prototype, I am pleased to announce that we have also updated the WebSockets prototype, a move that brings the implementation in line with the WebSockets 04 Protocol Specification.

    In short, we added a new type of masking in the protocol that is consistent with the 04 protocol specification. We also increased the maximum size for messages from the 125 character limit in the previous implementation.

    However, it’s important to note that the spec is still evolving, with the 03 version released in December, the 04 version last month and the 05 spec which just shipped yesterday. The plan is to continue to rev the code going forward and to bring the implementation in line with the just released WebSockets 05 Protocol Specification.

    WebSockets is a technology designed to simplify much of the complexity around bi-directional, full-duplex communications channels, over a single Transmission Control Protocol (TCP) socket. It can be implemented in web browsers, web servers as well as used by any client or server application.

    The WebSocket API is currently being standardized by the W3C and the WebSocket protocol is being standardized by the IETF.

    For this early WebSockets prototype we are using a Silverlight plug-in on the client and a WCF service on the server. In the future, you may see HTML5 Labs using a variety of other technologies.

    Updating the prototype is a great way to continue to test the spec as well as let users play with new features to make sure they work the way they are supposed to and to provide feedback.

    As part of the update, we are posting new demos, including a casual game that shows users how WebSockets can enable new scenarios.

    This prototype forms part of our HTML5 Labs Web site, a place where we prototype early and not yet fully stable drafts of specifications developed by the W3C and other standard organizations. We believe that the HTML5 Labs approach has advantages over placing unstable specifications directly in browser. First, developers can build on Internet Explorer 9 without worrying that their site will break as the underlying specs change. Second, we will iterate very quickly in HTML5 Labs and expect the standalone approach with prototypes to be closer to the latest specs. As an example with WebSockets, most browsers are still on the outdated versions of WebSockets-00 or older.

    Building these prototypes in a timely manner will help us have informed discussions with developer communities, and give implementation experience with the draft specifications that will generate feedback to improve the eventual standards.

    Claudio Caldato,

    Principal Program Manager, Interoperability Strategy Team

  • Interoperability @ Microsoft

    Accelerating Start-ups with open source, and Windows Azure Accelerators

    • 0 Comments

    In early 2012 Microsoft chose Tel Aviv,  as the location for its first start-up accelerator. When the team at Microsoft Research and Development, Israel asked if MS Open technologies, Inc. could speak about open source on Windows Azure at their Cloud Day event I immediately jumped at the chance since I’m fascinated by how open source can help accelerate innovation. It seemed to me that this event would attract the kinds of people who could show me a thing or two about innovation on the cloud.

    The Cloud Day event was designed to provide an opportunity for members of the local start-up community to explore the latest & hottest trends in cloud computing and to gain insights on how to get the most value out of the cloud. Speakers included representatives of start-ups at varying stages of development, Venture Capitalists, Cloud Consultants and Microsoft Open Technologies.

    My session focused on using open source software to get the most from the cloud. I discussed how Microsoft Open Technologies, Inc. work with projects and communities in order to ensure Windows Azure is an ideal platform for open source solutions. This was illustrated with a number of examples and case studies, such as how Ascribe Ltd transformed healthcare using open source big data solutions thanks to Microsoft’s contributions to Apache Hadoop and how Teletica.com used Azure and open source to manage a massive surge in web traffic. I also demonstrated how, using VM Depot makes it possible for anyone to build a video sharing site during their coffee break (more on that in a later post).

    For me though what I had to say was not the important part, it was what the attendees had to say that interested me. After my session I was able to talk to quite a few people who were both keen to tell me about their start-up and to learn how they can make the most of open source software. Almost everyone I spoke to demonstrated a hunger, energy and determination that was nothing short of impressive. It's no
    wonder that the Microsoft Accelerator here has such a high success rate.

    By the end of the day it was clear that open source is an important part of the start-up ecosystem in Israel and I, along with the rest of Microsoft Open Technologies, look forward to continuing to support the brilliant team at Microsoft Israel R&D a they continue to provide support for local innovation and business development.

  • Interoperability @ Microsoft

    SQL Database Federations: Enhancing SQL to enable Data Sharding for Scalability in the Cloud

    • 0 Comments

    I am thrilled to announce the availability of a new specification called SQL Database Federations, which describes additional SQL capabilities that enable data sharding (horizontal partitioning of data) for scalability in the cloud.

    The specification has been released under the Microsoft Open Specification Promise. With these additional SQL capabilities, the database tier can provide built-in support for data sharding to elastically scale-out the data. This is yet another milestone in our Openness and Interoperability journey.

    As you may know, multi-tier applications scale-out their front and middle tiers for elastic scale-out. With this model, as the demand on the application varies, administrators add and remove new instances of the front end and middle tier nodes to handle the workload.

    However, the database tier in general does not yet provide built-in support for such an elastic scale-out model and, as a result, applications had to custom build their own data-tier scale-out solution. Using the additional SQL capabilities for data sharding described in the SQL Database Federations specification the database tier can now provide built-in support to elastically scale-out the data-tier much like the middle and front tiers of applications. Applications and middle-tier frameworks can also more easily use data sharding and delegate data tier scale-out to database platforms.

    Openness and interoperability are important to Microsoft, our customers, partners, and developers, and so the publication of SQL Database Federations specification under the Microsoft Open Specification Promise will enable applications and middle-tier frameworks to more easily use data sharding, and also enable database platforms to provide built-in support for data sharding  in order to elastically scale-out the data.

    Also of note: The additional SQL capabilities for data sharding described in the SQL Database Federations specification are now supported in Microsoft SQL Azure via the SQL Azure Federation feature.

    Here is an example that uses Microsoft SQL Azure to illustrate the use of the additional SQL capabilities for data sharding described in the SQL Database Federations specification.

    -- Assume the existence of a user database called sales_db. Connect to sales_db and create a federation called orders_federation to scale out the tables: customers and orders. This creates the federation represented as an object in the sales_db database (root database for this federation) and also creates the first federation member of the federation.

    CREATE FEDERATION orders_federation(c_id BIGINT RANGE)
    GO

    -- Deploy schema to root, create tables in the root database (sales_db)

    CREATE TABLE application_configuration(…)
    GO

    -- Connect to the federation member and deploy schema to the federation member

    USE FEDERATION orders_federation(c_id=0) …
    GO

    -- Create federated tables: customers and orders

    CREATE TABLE customers (customer_id BIGINT PRIMARY KEY, …) FEDERATED ON (c_id = customer_id)
    GO

    CREATE TABLE orders (…, customer_id BIGINT NOT NULL) FEDERATED ON (c_id = customer_id)
    GO

    -- To scale out customer’s orders, SPLIT the federation data into two federation members

    USE FEDERATION ROOT …
    GO

    ALTER FEDERATION orders_federation SPLIT AT(c_id=100)
    GO

    -- Connect to the federation member that contains the value ‘55’

    USE FEDERATION orders_federation(c_id=55) …
    GO

    -- Query the federation member that contains the value ‘55’

    UPDATE orders SET last_order_date=getutcdate()…
    GO

    I am confident that you will find the additional SQL capabilities for data sharding described in the SQL Database Federations specification very useful as you consider scaling-out the data-tier of your applications. We welcome your feedback on the SQL Database Federations specification.

    Thanks,

    Ram Jeyaraman

    Senior Program Manager, Microsoft’s Interoperability Group

  • Interoperability @ Microsoft

    Cocos2D-X on the highway to the Windows Store

    • 1 Comments

    from:
    Adalberto Foresti - Principal Program Manager - Microsoft Open Technologies, Inc.
    Olivier Bloch - Senior Technical Evangelist - Microsoft Open Technologies, Inc.

    MS Open Tech has just published a code patch that introduces WinRT support in Cocos2D-X. This update will be welcome by those in the game development community who were looking forward to leveraging the wealth of capabilities offered by Cocos2D-X to write Windows Store games. It will be likewise welcome by publishers of existing Cocos2D-X based games on other platforms, who will find the effort of porting their code to a Windows Store app significantly reduced, thereby opening up new revenue opportunities for their previous work.

    Cocos2D-X is an open source C++ game engine aiming at extending the reach of the popular Cocos2D game engine to other OS platforms beyond iPhone. Cocos2D-X is used by many mobile gaming creators, from hobbyists to major publishers like Zynga, Konami, Glu, Gamevil and KingSoft.

    "Thanks to the big contribution from Microsoft Open Technologies, Inc., Cocos2d-x v2.1.15 is now successfully ported to Windows RT. Developers who want to publish their games on the Windows Store to extend their reach to Windows devices can take action now. I'm so glad to see Microsoft is embracing open source communities in such a way :)" - Zhe Wang, founder of Cocos2d-x.

    Here is a short demo of Cocos2D-X running on Windows 8.1.

    While MS Open Tech is collaborating with the Cocos2D-X community to integrate the changes back into the Cocos2D-X master branch in GitHub, you can already access the WinRT-enabled code on GitHub. So try it out, and get a head start on publishing your next Cocos2D-X game on the Windows Store!

  • Interoperability @ Microsoft

    Identity Interoperability scenario combining PHP, “Geneva” Server, Windows CardSpace, and Information Cards

    • 4 Comments

    At the RSA Conference 2009 in April, Microsoft’s Scott Charney included a video from a project for the Lake Washington School District in his keynote. The project features a very interesting identity interoperability scenario between the Lake Washington School District’s internal Active Directory and Intand’s Tandem for Schools SaaS application. The key challenges were to manage effectively identities while preserving the security of the users and the system.

    The project combines Microsoft code name “Geneva” (the “Geneva” Server and Windows CardSpace “Geneva”) and Intand’s PHP-based Tandem for Schools application that uses the Zend Framework’s information card support for interoperability.

    The project is based on upon the use of Microsoft code name Geneva Server, Windows CardSpace Geneva and Intand’s PHP application using the Zend Framework’s information card support for interoperability.

    To get deeper and learn more about this exciting project, watch these videos:

    Finally I wanted to point out other open source interoperability work our team has been contributing to around information cards for heterogeneous web applications. This includes information card support for Java , Ruby on Rails and a generic C module

    Jean-Christophe Cimetiere - Sr. Technical Evangelist

  • Interoperability @ Microsoft

    HTML5 Labs Prototype Update for W3C Media Capture API

    • 1 Comments

    Today, the Internet Explorer blog posted an interesting update of an HTML5Labs prototype of the W3C Media Capture API.

     A usable and standardized API for media capture means Web sites and apps will be able to access these features in a common way across all browsers in the future.

    You can read the full post on the IE blog.

  • Interoperability @ Microsoft

    Bing search helps PHP developers remedy 404 error pages

    • 1 Comments

    As many of you know, most large web sites that feature lots of content often experience traffic that is looking for pages that either don’t exist or have been moved. But did you know that the percent of traffic that causes web servers to return a generic 404 error page or sitemap is as much as 2 to 10 percent? That’s an awful lot of viewers experiencing a dead end as a result of nonexistent or relocated pages.

    However, the Bing 404 Web Page Error Toolkit for PHP, which was debuted at the Web 2.0 Expo in New York today, helps developers better manage 404 errors by dynamically creating a customizable page that contains error messages and search results that are seeded with relevant keywords from Microsoft’s Bing search engine. This page ultimately helps web site visitors move past the missing page and find the information they need.

    The Bing 404 Web Page Error Toolkit for PHP is a customizable PHP application that replaces the default error page on Microsoft IIS or Apache web servers with Bing search results that are based on keywords that have been derived from the URL requested by the user. The toolkit is available on Codeplex as an open source project, and is released under the Microsoft Public License.

    Say, for example, a user requests a page with the URL “someURLontheweb.com/interoperability/bridges,” and the URL doesn’t exist. The toolkit dynamically creates a page like this one:

    clip_image002

    The process works in this way:

    1. The web server identifies a 404 “page not found” error and executes the toolkit.
    2. The toolkit extracts keywords from the URL (“interoperability” & “bridges” in this case) and returns them, along with the error page, to the viewer's browser.
    3. The browser sends a search request to the Bing API via a JavaScript call that includes the extracted keywords.
    4. The Bing API returns the appropriate results to the browser.
    5. The browser renders the results via JavaScript in the context of the page that the developer has customized.

    You can see an overview of the architecture, the configuration steps, and a quick demo of the toolkit in the following Channel9 video:

    Get Microsoft Silverlight

    The toolkit is very easy to install and use, with very little customization necessary. Feel free to check the project site on Codeplex http://bing404php.codeplex.com. As always your feedback is welcome!

    .NET developers—note that a similar kit for ASP.NET is available for ASP.NET here.

    —Sumit Chawla, Technical Product Manager/Architect, Microsoft Interoperability Team

  • Interoperability @ Microsoft

    Binary File Format Plugfest

    • 0 Comments

    The Office interoperability team will host a Binary File Format Plugfest on October 19th and 20th in Redmond. The event will target a developer level audience. Microsoft subject matter experts from both the support organization and the product team will be onsite to answer questions about the Binary File Formats.  This Plugfest will be a great opportunity for you to test your BFF implementations and receive immediate feedback and assistance from Microsoft. The event is free, and we will cover the doc, xls, ppt, and pst formats through a combination of presentations, 1:1 discussions, and workshops.

    What to Expect:

    • Presentations on the Binary File Format Open Specifications (Word, Excel, PowerPoint, PST, Graphics, Document Cryptography etc.)
    • 1:1 Sessions with product development team members
    • Access to Office's Binary File Format validation tool for Word, Excel, and PowerPoint
    • Interaction with Microsoft Support
    • Breakfast, lunch, and dinner will be provided on both October 19th and 20th

    Space is limited, so register early. To learn more about the event or to register, please contact Michael Bowman

    Jas Sandhu

  • Interoperability @ Microsoft

    Open XML /ODF Translator: document interoperability scenarios

    • 2 Comments

    Service Pack 2 for the 2007 Microsoft Office System that has just been released includes the ability to open, edit and save documents in version 1.1 of the Open Document Format. The Open XML / ODF translator on Sourceforge will continue to be the solution for Office 2003 and Office XP users who wish to Open & Save ODF documents.

    The open source Translator project was started in July 2006, when Microsoft worked with partners (Clever Age, Dialogika & Sonata) to demonstrate pragmatic interoperability between Microsoft Office and Open Office documents. Today, after multiple releases of the project with more than 2.5 millions downloads, the translator is a mature project and version 3.0 was released in March 2009 (read the blog post).

    Version 3.0 focuses on improving the overall fidelity of the translation between Open XML and ODF as well as the performance. The previous version (2.5) of the Translator introduced ODF compatible  “Templates” intended to provide greater visual fidelity during the translation process:

    openxmlodftranslatortemplates

    Here’s a demo of the Translator created by my colleague Jean-Christophe Cimetiere with version 2.5, but from the end-user perspective version 3.0 is identical:

    Open XML-ODF Translator Demo

    From a technical perspective, the translator consists of a set of XSL transformations between the two XML formats (Open XML and ODF), along with some pre- and post-processing to manage the packaging (zip / unzip), and some advanced processing (complex transformations). The following diagram is a high level architecture of the Translator:

    openxmlodftranslatorarchictecture

    The translation engine at the core of the Translator may be used independently and hosted by a back-office server application or incorporated into hosted services or batch processing. In the latter case, Translator includes a command line interface.

    As an open source project, the Translator could be a great foundation for engineering work around document interoperability. ISVs can use the code as the basis for additional translators and programs and create a wide range of interoperability solutions that bridge Open XML and ODF. Novell has incorporated the translator into its implementation of OpenOffice for SUSE Linux, and others have taken the translator and integrated it into the Ubuntu Linux Open Office version.

    The Open XML / ODF Translator project is hosted on Sourceforge, where you can get the installers (7 languages are supported) as well the source code: http://odf-converter.sourceforge.net/

    Vijay Rajagopalan, Principal Architect, Microsoft Corp.

  • Interoperability @ Microsoft

    Open in the Cloud: Improving the Java Developer Experience on Windows Azure Platform

    • 1 Comments

    As Microsoft continues to deliver on improving the Java developer experience on Windows Azure, I am happy to tell you that today, at the Professional Developers Conference 2010 (PDC 10) held here in Redmond, we are announcing a new set of tools based on Eclipse and updated client libraries (SDK) for Windows Azure.

    This means that customers can now choose to upload the Java environment of their choice and run it on Windows Azure which, as you know, is an Open Platform that can provide language choice such as C#, PHP or Java. http://www.WindowsAzure.com/interop/

    Windows Azure & Java

    As such, I am happy to announce today the Windows Azure tools for Eclipse/Java, an open source project sponsored by Microsoft and developed by partner Soyatec, an international software company and Eclipse solution provider. We expect Soyatec to be able to release a Community Technology Preview (CTP) of the Windows Azure tools for Eclipse/Java available by the end of 2010.

    These tools allow Java developers to build, test Java applications and deploy these directly to Windows Azure. While these tools have similar features to the Windows Azure Tools for Eclipse/PHP, which we announced earlier this month, these latest tools are designed for Java developers.

    I am also demoing a preview of the Windows Azure tools for Eclipse/Java, during my session: “Open in the cloud: Windows Azure and Java” (Friday from 9:00 AM to 10:00 AM Pacific Time). You can watch the session here http://player.microsoftpdc.com/Session/6ae95ba0-c185-4546-9d66-2604ac6b6cef

    clip_image002

    I am also happy to tell you that today, at PDC 10, we announced that Soyatec is releasing the version 2.0 of the Windows Azure SDK for Java. This SDK enables Java developers easily use Windows Azure storage services in their web applications. I’m really excited about the progress we are making. As you may remember, at PDC 09, we delivered the first version of this Windows Azure SDK for Java (http://blogs.msdn.com/b/interoperability/archive/2009/11/17/windows-azure-sdks-for-php-and-java-and-tools-for-eclipse-version-1-0-released-today.aspx).

    Windows Azure & PHP updates

    I’m also pleased to share with you the news that we are continuing our work on the PHP front, and are also announcing the availability of the new November 2010 CTP of the Windows Azure Tools for Eclipse/PHP as well as a new November 2010 CTP of the Windows Azure Companion, a tool that aims to provide a seamless experience when installing and configuring PHP platform-elements (PHP runtime, extensions) and Web applications running on Windows Azure.

    In addition, we are launching a new online technical/resource website dedicated to Windows Azure and PHP. This site will be a one stop shop for PHP developers to discover, learn and get expertise on Windows Azure. A beta version of the site is available at http://AzurePHP.interoperabilitybridges.com

    And, as always, there are a number of other tools available to developers, including the Windows Azure Command-line Tools for PHP and the Windows Azure SDK for PHP.

    I have also recorded a session, which is available on demand, in which I demo the latest version of the Windows Azure and PHP tools and SDK. The session, titled “Developing PHP Applications on the Windows Azure Platform,” shows how Microsoft’s Windows Azure Platform provides a comprehensive set of services for building and running scalable PHP applications targeting cloud. The recording of the session is here: http://bit.ly/93Jgib.
    In the session I go on a coding tour using open source development tools (Eclipse, Command line), SDKs and show methods to deploy applications (like Drupal) on the Windows Azure platform.

    I’m excited about all that we announced today and look forward to updating you on lots of exciting things moving forward. Stay tuned as we will follow up shortly with more technical articles and tutorials detailing scenarios using Windows Azure with PHP and Java. As always, do give us your feedback at: http://sourceforge.net/tracker/?group_id=266877&atid=1135912

    Vijay Rajagopalan, Principal Architect

  • Interoperability @ Microsoft

    SugarCRM on Windows Azure & SSRS PHP SDK at SugarCon 2010

    • 0 Comments

    SugarCon 2010 This week I was at SugarCon 2010, the CRM conference. SugarCRM, one of my partners in the Interop Vendor Alliance (IVA), is a leading provider of open source customer relationship management (CRM) software. SugarCon, is its global customer, partner and developer conference held April 12-14, at The Palace Hotel in San Francisco, California. Microsoft along with Red Hat, Talend and Zend helped sponsor the conference. The event had a heavy cloud theme this year and the tagline “The Cloud is Open” was used.

    SugarCRM has over 6,000 customers and more than half a million users rely on SugarCRM to execute marketing programs, grow sales, retain customers and create custom business applications. There was quite a different mix of people from business to technical there, about 800 attendees or so. There was a good vibe to the show and it had a focus on the attendees and partners. There was lots of interest in different topics; CRM, Social Networking, Open Source, Cloud Computing;  private and public … and Microsoft’s presence at the event …. which brings me to why we were there …

    The keynote “Open Source and Open Clouds”  was presented by SugarCRM CEO Larry Augustin who shared new product announcements and welcomed special guests to the stage to discuss how open source software is driving the next generation of CRM and Cloud services. Rob Craft, Microsoft’s Senior Director, Cloud ISV was one of the guest joining Augustin on stage. Craft shared with attendees how Microsoft is investing strongly in cloud services. “This is a deep, substantive long term investment from Microsoft,” he said. He shared the global presence Azure, being run from six datacenters in San Antonio, Chicago, Dublin, Amsterdam, Singapore and Hong Kong, with other datacenters coming ready too. Microsoft is guaranteeing 99.9 percent uptime for Azure, with customers getting a 10 percent rebate if this falls to over 99 percent uptime or 25 percent if it falls below that figure. windows-azure-logo-lg

    Larry then went on to demonstrate a beta of SugarCRM, a PHP application, running on Windows Azure and calling data from SQL Azure. Dan Moore, Sr. Platform Strategy Advisor, and Bhushan Nene, Principal Architect, from the Cloud ISV Team gave a follow-up session, “Introducing the Windows Azure Platform”, to the keynote with an overview of the benefits of launching cloud applications on Azure. We saw excitement from the conversations we had with several SugarCRM channel partners who attended the sessions and stopped by the booth. The Windows Azure platform is receiving enormous support and excitement throughout their ecosystem!

    Along with the keynote and session, we had a booth in the exhibition area which saw quite a bit of traffic as well as a Microsoft Cloud Room where we discussed various benefits to the the Windows Azure platform and interoperating with Microsoft technologies. At the room I presented a session on “Data Tools for Microsoft and SugarCRM” where I showed our new interoperability bridge, SQL Server Reporting Services SDK for PHP: adding business intelligence and reporting features to PHP applications, and showing off an early preview of an IVA lab we will be releasing soon. This lab basically is a demonstration of SugarCRM data being called by SSRS reports using the PHP SDK and displaying results in the SugarCRM reports dashboard. The power of composing rich reports from SugarCRM data plus using the freely available SQL Server Express advanced services from Business Intelligence Studio or Visual Studio is a powerful combination. The picture below gives a glimpse of the demonstration in action. Look out for an announce on this blog shortly!

    SugarCRM Dashboard Account Types Report

    Other notable highlights of the event …

    “A Family Tree for Humanity”  where author and population geneticist, Spencer Wells of National Geographic will take us on an epic journey that spans the globe, using DNA to trace the migration routes of our ancient ancestors and revealing the incredible tapestry of human diversity created along the way. I found the science behind it and the presentation fascinating. I would recommend taking a look at the Genographic project.

    There was also a rip roaring tech talk by Newsweek reporter Daniel Lyons in “He’s Back! The Real Future of Technology with Fake Steve Jobs”.

    Best of all, the SugarCon party on day one was an evening at the acclaimed California Academy of Sciences in Golden Gate Park. If you are a geek and one who loves biology this is a must see destination. We got to wine, dine and party there, a huge plus!

     

    I would like to thank my friends from SugarCRM for welcoming us, especially Jason Nassi, Sr. Director of Product Management, who is my liaison from SugarCRM to the IVA; and Igor Spivak, Director of Product Management, Cloud Services for letting me use the live SugarCRM SQL Azure in my session demo. Thank you guys! I’m looking forward to more great interoperability stories we can tell together.

    Jas Sandhu , Interoperability Vendor Alliance manager,  @jassand

  • Interoperability @ Microsoft

    New Tutorial: Using Apache ZooKeeper on Windows Azure to Manage Solr on Linux Virtual Machines

    • 0 Comments

    Here at Microsoft Open Technologies, Inc., we’ve been working with the top open source DevOps, application and data tools to make popular open source packages easy to deploy and manage on Windows Azure. This work gives developers the ability to take combine powerful open source technologies in new and unusual ways in the cloud to build new applications and solve old problems.

    As a showcase of these possibilities, we’ve built a search engine infrastructure using Apache Solr that is managed by an external implementation of Apache ZooKeeper to ensure scalability with reliability, and consistent search results for every search, regardless of which search servers may be accessible at any time. You can find all the details in this tutorial and once you’ve completed the tutorial you will have multiple Solr instances (called SolrCores) synchronized across more than one server, with synchronization managed by ZooKeeper. 

    By default, Solr has an internal, customized version of ZooKeeper running to synchronize SolrCloud shards on the same sever, but for our ZooKeeper example, we’re show you multiple SolrCores distributed across servers.  That means that multiple cores at multiple IP addresses are made to look like one server. 

    Here’s what the Solr dashboard will show when you’ve competed this tutorial:

    image

    The tutorial configures one ZooKeeper instance and two Solr VMs as the minimum to test our configuration, but you could scale up much more than that.  With ZooKeeper managing Solr, as long as at least one SolrCloud instance is accessible anywhere that ZooKeeper is keeping things in Sync, you will still have ability to index documents and run queries.

    Try it out yourself, and let us know what you think!

     

  • Interoperability @ Microsoft

    Momentum Grows as OData v4 Achieves Standards Milestone

    • 4 Comments

    OData Industry Adoption Builds with v4 Now in Public Review in OASIS

    Based on the industry collaboration between Citrix, IBM, Microsoft, Progress Software, SAP AG, WSO2, and others, we are pleased to report that the OASIS OData Technical Committee recently approved Committee Specification Draft 01 (CSD01) of OData version 4.0 and has initiated a public review of OData v4.0 during May 3, 2013 through June 2, 2013. OData v4.0 is expected to become an OASIS Standard in 2013.

    Much of the data on the Web today lives in silos, needing different protocols, APIs, and formats to query and update the data. With the rapid growth of online information and big data sources, open data protocols and services are in demand more than ever before.

    OData is a Web protocol for querying and updating data. OData is built on a set of RESTful conventions that provide interoperability for services that expose data. It builds on standardized web technologies such as HTTP, REST, Atom/XML, and JSON. It provides an entity data model and has support for vocabularies for common ontologies such as Sales (with Customers, SalesOrder, Product, ...), Movies (with Title, Actor, Director, …), or Calendars (with Event, Venue, …), etc. OData enables the creation of REST-based data services which means that resources identified using Uniform Resource Identifiers (URIs) and defined in an Entity Data Model (EDM), can be published and edited by Web clients using simple HTTP messages.

    The OASIS OData version 4.0 specification is based on the popular OData version 3.0. OData version 4.0 defines data model changes to significantly simplify and expand how relationships are expressed and used as well as how metadata is described and partitioned, expanded query capabilities for inline collections and fulltext search, and extended functionality for change tracking and asynchronous processing.

    The OASIS Technical Committee has produced three work products; OData version 4.0 defines the core semantics and facilities of the protocol, including a set of conventions for addressing resources, query string operators for querying a service, and an XML representation of the Entity Data Model exposed by an OData service. OData JSON Format version 4.0 defines representations for OData request and response bodies using a JSON format. OData Atom Format version 4.0 defines an equivalent representation for OData request and response bodies using an Atom/XML format.

    Many organizations are already working with OData, and it has proven to be a useful and flexible technology for enabling interoperability between disparate data sources, applications, services, and clients. Here are some recent examples:

    Microsoft Research Explores OData and the Semantic Web

    Microsoft Research (MSR), in collaboration with The British Library and the Digital Enterprise Research Institute (DERI), has just published a whitepaper Linking Structured Data that explores how OData can be used to expose data within an RDF triple store through an end-user oriented model, and consumed by a broad range of consumer-oriented tools and applications. To better understand how RDF data could be exposed and consumed by OData clients in a real world example, MSR went from theory to practice by focusing on some scenarios from The British Library which publishes its metadata on the Web according to Linked Data principles.

    Join the OData Community

    If you’re interested in using or implementing the OData protocol or contributing to the OData standard, now’s the time to get involved.

    • Learn more about OData and the ecosystem of open data producer and consumer services by visiting the recently revamped OData.org web site for information, content, videos, and documentation.
    • Get the latest information for what's going on in OData by join the OData.org mailing list.
    • Get involved in the #OData discussion and contribute to the OData community.
    • Join the OASIS OData technical committee (OData TC) to contribute to the standard.
    • Send comments on OData version 4.0 to the OASIS OData Technical Committee

    We’re looking forward to continued collaboration with the community to develop OData into a formal standard through OASIS.

    Mark Gayler, Senior Technical Evangelist
    Microsoft Open Technologies, Inc.

    Ram Jeyaraman, Senior Standards Professional
    Microsoft Open Technologies, Inc. and co-Chair of the OASIS OData Technical Committee

     

     

  • Interoperability @ Microsoft

    Kerberos Interoperability Testing Workshop hosted by Microsoft

    • 3 Comments

    A few weeks ago Microsoft’s Kerberos team participated in the Kerberos Interop Workshop organized by the MIT Kerberos Consortium, being hosted here at the Microsoft campus here in Redmond. I had a chance to spend some time with the Microsoft folks (Michiko Short, Jeremy Viegas, Larry Zhu and Yi Zeng from the Microsoft’s Kerberos team) who participated in the event to discuss what happened. We thought it would be interesting to share a quick summary.

    This sort of interoperability workshop is an effort to gather developers together in a single location, to actually plug them into a network environment together and help each other work through the interoperability challenges associated with their current development efforts. In attendance were representatives from Cornell University, Centrify, Microsoft, MIT, Safe Mashups, and Sun Microsystems.

    A bit of background…

    For those of you that aren’t familiar with Kerberos, it is a network authentication protocol developed by MIT as part of a joint project with Digital Equipment Corporation and IBM designed to produce a campus wide distributed computing environment in 1983. Kerberos provides a mutual authentication system, and a high level of encryption, both designed to ensure network and data security. Kerberos was accepted by the Internet Engineering Task Force (IETF) as a standard in 1993. Since its creation Kerberos has become the most widely deployed system for authentication and authorization in modern computing networks.

    In September of 2007, MIT founded the MIT Kerberos Consortium to help establish Kerberos as the universal authentication platform for the world’s computer networks and many organizations joined since then (full list here). The consortium hopes that by opening up ongoing development of Kerberos to other interested parties, it will be possible to expand the scope of work being performed, enhance the evolution of Kerberos, and to help engage potential adopters.
    The MIT Kerberos has also a group on Facebook.
    KerberosOnFacebook

    Microsoft’s collaborative efforts regarding MIT and the Kerberos Consortium are nothing new. Microsoft was one of the original sponsors, and is represented on the board of directors by Microsoft’s Director of Development Slava Kavsan. To help standardize the testing processes for Kerberos developers, Microsoft contributed the GSS Monger interoperability testing framework to the consortium. It is now available on Codeplex using MS_PL, as an ongoing open source project.
    gssmonger

    You may not know, but Microsoft has been using Kerberos as the default authentication package since Windows 2000. You may actually be using Kerberos authentication today in your solutions without even realizing it since it is part of negotiated authentication.

    Back to the interoperability plug fest…

    How does an interoperability plug fest like this work? Each participant prepares a desired test plan based on their own current projects and challenges, but beyond that the lab is very ad-hoc. All of the participants bring systems with their code/applications to the event; then everybody hooks up to the network and starts testing out scenarios against each other’s applications using MIT realms or Microsoft domains. This collaborative environment allows participants with different implementations of the same standard to test their interoperability in a real world environment, helping to identify and solve the road blocks that might otherwise cause them problems.

    One of the scenarios for the plug fest consisted of MIT & Microsoft collaborating on testing efforts for their next release. MIT has developed an implementation of a new Kerberos RFC (jointly defined by MS/MIT, and the IETF standards body). Since it was the first implementation there were no other implementations to be tested against. So, the Microsoft team developed a second implementation for the event for validation/comparison/interoperability testing.

    Cornell University came prepared with two scenarios to investigate. The network environment that both scenarios operate under consists of a mixed MIT realm with an Active Directory domain. This results in certain complications when it comes to integrating a Single Sign-on solution. The first of their scenarios was built around integrating CUWebAuth, the open source, Kerberos based, web authentication application they have built, with key IIS services that are connected to a central Active Directory. This integrates single sign-on for Microsoft applications such as Outlook Web Access with other campus web services that require a login. The second of their scenarios centered on integrating WebDav with the Kerberos based login across their network. Complicating matters, the systems used across this network are very diverse and heterogeneous, including desktops running Windows, Linux, and Mac. The Cornell University team has had trouble implementing Kerberos with WebDav on Windows machines that are not part of a domain. Initially, they were uncertain that support for the desired functionality was even possible for Windows based systems. The Microsoft developers attending the plug-fest were able to provide the necessary insights regarding how the problem could be solved on Windows Vista and higher machines.

    Peter Bosanko of Cornell University had this to say about the event:

    “At the KC Interop we worked side by side with an impressive group of Kerberos experts from MIT and Microsoft. This was extremely fortunate for us because our interoperability issues were all about tying together Microsoft systems with an MIT KDC. By the end of our first day we had already accomplished more than we expected to accomplish over the three day Interop.”

     

    What’s in it for Microsoft and other participants?

    Interoperability is a key pillar for the Kerberos team. Knowing that many customers are going to have a heterogeneous environment, ensuring that Microsoft’s implementation of Kerberos works with other implementations is considered a key to success. By getting all the people together at events like this gives developers an opportunity to really dig into how we work together in an efficient way, solving problems in real time. Also it allows us to see how our applications interoperate with all sorts of other systems and applications that we normally don’t get the opportunity to see. Finally, it allows us to help explore, expand on, and develop standards while learning from a diverse group of experts.

    We were delighted to see the turnout for this event, and wanted to extend a thank you to the MIT Kerberos Consortium for putting this together, and to the Kerberos team here at Microsoft for sharing it with us. With any luck the collaborative efforts of the participants will enable the ongoing development work on the various Kerberos implementations to proceed unhindered.

     

     

    Jean-Christophe Cimetiere - Sr. Technical Evangelist

  • Interoperability @ Microsoft

    Windows Azure SDKs for PHP and Java and tools for Eclipse version 1.0 released today

    • 0 Comments
    clip_image002

    We’ve worked very hard to release version 1.0 of three different projects today, all timed to coincide with the availability of the Windows Azure platform, which was also announced today at the Professional Developer Conference in Los Angeles.

    This release is the culmination our team’s year-long work with our partners for bringing core PDC09 scenarios to life and a release that many of our customers & open source developers have eagerly been waiting for since our last CTP release at Eclipse Summit Europe. I want to thank our engineering partners Real Dolmen & Soyatec who have done a great job in such a short period of time to complete SDKs & tooling.

    The version 1.0 of the tools & SDKs can be downloaded from the below location.

    The Eclipse tooling & SDKs are fully compatible with Windows Azure that has just been released, so you can build services & web applications using PHP & Java in Eclipse and deploy them to the cloud today.

    I am excited to share some of the new features that we have included in this version of the Windows Azure Tools for Eclipse:

    • Improved PHP Project Migration & Portability: We have introduced a new wizard that enables PHP developers to convert their existing web applications to Windows Azure. Further, the wizard supports developers targeting Windows Azure or SQL Azure for their storage needs.

    clip_image004

    • Development Fabric & Storage Support: Eclipse tooling is now deeply integrated with development fabric & storage that offers a high-fidelity simulation of the Windows Azure hosting & storage services on the developer’s desktop or laptop to test their cloud applications.
    • SQL Azure Support: A new Management tool that allows PHP developers to setup their SQL Azure accounts and test connectivity against local (development fabric) & Cloud database. Based on the developer’s choice, the project system automatically bundles appropriate SQL Server driver and extensions.

    clip_image006

    • Service Model UI: A redesigned and significantly more complete interface for manipulating Role configuration information. To access, right mouse click on the WebRole project and click properties.

    clip_image008

    • Improvements to Storage Explorer: The Storage Explorer now supports shared & signed access signatures. The idea behind this to allow developers create signatures that are more granular than the shared key for the whole storage account and then embed these signatures directly in a blob URL instead of an authorization header.
    • Certificate Management: We have laid a solid foundation to support SSL certificates in Eclipse tooling to allow secure automated deployment of certificates to services hosted on Windows Azure. This feature will be fully completed in the upcoming milestone.
    • Updated PHP Samples & Tutorial: The samples included with Eclipse tooling enable developers to jumpstart their project targeting Windows Azure Storage or SQL Azure. Learn more here

    Finally, the many new features of the Windows Azure SDK for Java are showcased in a new tutorial that illustrates how Java developers can take advantage of Window Azure in heterogeneous scenarios, with both on-premise and cloud Java applications. The tutorial is available at: http://www.windowsazure4j.org/learn/setup/

    You may also have heard that Microsoft today announced new third-party technologies that can be run inside Windows Azure, including MySQL and  Java (we’ll come back to this later!). All of these technologies take advantage of the automated service management capabilities in Windows Azure. These developments further deliver on Microsoft’s strategy to make the Windows Azure platform open and interoperable.

    More interoperability treats are going to be announced at PDC, so stay tuned!

    -- Vijay Rajagopalan, Principal Architect

  • Interoperability @ Microsoft

    Microsoft @ OSCON 2011: We have become more open, let’s work together!

    • 0 Comments

    Gianugo Rabellino, Microsoft’s Senior Director for Open Source Communities, just finished delivering his keynote at OSCON in Portland.
    As Gianugo is now wandering around the OSCON session and expo floor, I thought it would we useful to give you a quick recap of what he just presented.

    During his keynote, Gianugo discussed how both the world and Microsoft are changing, saying that “at Microsoft we continue to evolve our focus to meet the challenging needs on the industry: we are open, more open than you may think.”

    Gianugo explained that the frontiers between open source, proprietary and commercial software are becoming more and more of a blur. The point is not about whether you run your IT on an Open Source stack or a commercial stack, the important thing is how you can assemble software components and build solutions on top of them using APIs, protocols and standards.  And the reality is that most IT systems are using heterogeneous components, he said.

    Looking at the cloud, the blur is even more opaque. What does Open Source or Commercial mean in the cloud?

    Gianugo put it this way: “In the cloud, we see just a continuous, uninterrupted shade of grey, which makes me believe it's probably time to upgrade our vision gear. If we do that, we may understand that we have a challenge ahead of us, and it's a big one: we need to define the new cornerstones of openness in the cloud. And we actually gave it a shot on this very same stage one year ago, when we came up with four interoperability elements of a cloud platform: data portability, standards, ease of migration & deployment, and developer choice.”

    Finally, Gianugo talked about how Microsoft’s participation in Open Source communities is real, and he used his keynote as an opportunity to announce a few new projects and updates.

    Gianugo Rabellino

    One way we interact with open source software is by building technical bridges, Gianugo said, giving an example on the virtualization front: announcing support for the Red Hat Enterprise Linux 6.0 and CentOS 6.0 guest operating systems on Windows Server Hyper-V (which follows this Linux Interoperability  announcement at OSBC a few weeks ago. )

    On the cloud development front, we are continuing to improve support for open source languages and runtimes, Gianugo said, announcing the availability of a new version of the Windows Azure SDK for PHP, an open source project which is led by Maarten Balliauw from RealDolmen, where Microsoft is providing funding and technical assistance.

    Maarten has all the details on the new features and link to the open source code of the SDK. This announcement also includes a set of cloud rules for the popular PHP_CodeSniffer tool that Microsoft has developed to facilitate the transition of existing PHP applications to Windows Azure. The new set of rules is available on Github.

    An on demand Webcast of Gianugo’s keynote will soon be available, and I’ll post the link to it here.

    Thanks!

  • Interoperability @ Microsoft

    Content Management Interoperability Services (CMIS) connector for SharePoint 2010 will be part of the Admin Toolkit this summer

    • 0 Comments

    AIIMExpoToday at the http://www.aiimexpo.com/conference-info/sharepoint-2010-summit-aiim-expo, Eric Swift (@eswift), General Manager of SharePoint Marketing announced that Microsoft will be shipping the CMIS Connector for SharePoint as part of the SharePoint Administrator Toolkit by the end of June 2010.

    The Content Management Interoperability Services (CMIS) specification defines a means of accessing enterprise content management (ECM) repositories independent of their platform or language. CMIS is on its way right now to OASIS for advancement through its rigorous standards development process. Microsoft, along with IBM, EMC and several other content management vendors developed the specification in response to customer requests for interoperability between multiple document repositories.

    For further details on CMIS read the announcement of the CMIS Connector for SharePoint on the Microsoft Enterprise Content Management (ECM) Team Blog.

    Jean-Christophe Cimetiere, Sr. Technical Evangelist, @openatmicrosoft

  • Interoperability @ Microsoft

    New features in the April 2011 CTP the Windows Azure Plugin for Eclipse with Java

    • 0 Comments

    In case you missed the previous announcement, the plugin adds to Eclipse a set of wizards and dialogs which guide the Java developer through the configuration of all relevant projects settings when targeting Windows Azure. The plugin builds on top of the Windows Azure Starter Kit for Java, which is primarily a command-line toolset based on a simple Windows Azure project template which includes elements required to package and deploy your Java application to Windows Azure.

    As we said in our previous blog posts this project is evolving quickly. Our goal is to use the stream of community feedback to nail down the correct experience for Java developers. So today, we’re taking the next iteration forward and announcing the April 2011 Community Technology Preview (CTP) of the Windows Azure Plugin for Eclipse with Java. Here’s the list of the features, including the new ones:

    1. Eclipse wizards to create and build new Windows Azure projects in Eclipse,
    2. Shortcuts to deploy and start the project in the Windows Azure Compute Emulator,
    3. Association of *.cscfg and *.csdef files with the Eclipse XML editor for easier XML editing,
    4. New with April CTP: Eclipse wizards to add/remove/configure Windows Azure roles for your project during project creation or project properties editing
    5. New with April CTP: Eclipse wizards to add/remove/configure role endpoints during project creation or project properties editing (ports)

    clip_image002

    The Windows Azure Plugin for Eclipse with Java is an Open Source project released under the Apache 2.0 license, and the source code is available at: http://sourceforge.net/projects/waplugin4ej.
    The best way to get started is to go through the steps explained in our updated tutorial: Deploying a Java application to Windows Azure with Eclipse .

    As always, we look forward to your comments and feedback!

    Craig Kitterman
    Twitter: @craigkitterman
    http://craig.kitterman.net

  • Interoperability @ Microsoft

    Windows Azure Supports NIST Use Cases using Java

    • 1 Comments

    clip_image001

    We've been participating in creating a roadmap for adoption of cloud computing throughout the federal government, with the National Institute for Standards and Technology (NIST) , an agency of the U.S. Department of Commerce, and the United States first federal physical science research laboratory. NIST is also known for publishing the often-quoted Definition of Cloud Computing, used by many organizations and vendors in the cloud space.

    Microsoft is participating in the NIST initiative to jumpstart the adoption of cloud computing standards called Standards Acceleration to Jumpstart the Adoption of Cloud Computing, (SAJACC).The goal is to formulate a roadmap for adoption of high-quality cloud computing standards. One way they do this is by providing working examples to show how key cloud computing use cases can be supported by interfaces implemented by various cloud services available today. Microsoft worked with NIST and our partner, Soyatec, to demonstrate how Windows Azure can support some of the key use cases defined by SAJACC using our publicly documented and openly available cloud APIs.

    NIST works with industry, government agencies and academia. They use an open and ongoing process of collecting and generating cloud system specifications. The hope is to have these resources serve to both accelerate the development of standards and reduce technical uncertainty during the interim adoption period before many cloud computing standards are formalized.

    By using the Windows Azure Service Management REST APIs we are able to manage services and run simple operations including simple CRUD operations, solve simple authentication and authorizations using certificates. Our Service management components are built with RESTful principles and support multiple languages and runtimes including Java, PHP and .NET as well as IDEs including Eclipse and Visual Studio.

    It also provides rich interfaces and functionality that provide scalable access to public, private and hosted clouds. All of the SDKs are available as open source too. With the Windows Azure Storage Service REST APIs we can use 3 sets of APIs that provide storage management support for Tables, Blobs and Queues with the same RESTful principles using the same set of languages. These APIs as well are available as open source.

    We also have an example that we have created called SAJACC use case drivers to demonstrate this code in action. In this demonstration written in Java we show the basic functionality demonstrated for the NIST Sample. We created the following scenarios and corresponding code …

    1. Copying Data Objects into a Cloud, the user is able to copy items on their local machine (client) and copy to the Windows Azure Storage without any change in the file; the assumptions are to have credential with a pair of account name and key. The scenario involves generating a container with a random name in each test execution to avoid possible name conflicts. The container uses the Windows Azure API. With the credential previously created the user prepares the Windows Azure Storage execution context. Then a blob container is created, with optional custom network connection timeout and retry policy, you are able to easily recover from network failure. Then we will create a block blob and transfer a local file to it. We will then compute a MD5 hash for the local file, get one for the blob and compare it to show there are equivalent and no data was lost

    2. Copying Data Objects Out of a Cloud, repeats what we do from the first use case, Copying Data Objects into a Cloud. Additionally we will include another scenario, where set public access to the blob container and get its public URL; we will then as an un-identified (public) user retrieve the blob using an http GET request and save it to the local file system. We will then generate a MD5 hash for this file and compare it to the originals we used previously

    3. Erasing Data Objects in a Cloud erases a data object on behalf of a user. With the credentials and data you created in the previous examples we will use the public URL of the blob and delete it by using its blob name. We will verify by using an http GET request to confirm that it has been erased.

    4. VM Control: Allocating VM Instance, the user is able to create a VM image to compute on that is secure and performs well. The scenario involves creating a Java Keystore and Truststore from a user certificate to support SSL transport (described below). We will also create Windows Azure management execution context to issue commands from and create a hosted service using it. We will then prepare a Windows Azure service package and copy it to the blob we created in the first use case. We will then deploy in the hosted service using its name and service configuration information including the URL of the blob and the number of instances. We can then change the instance count to as many roles we want to execute using what we deploy and verify the change by getting status information from it.

    5. VM Control: Managing Virtual Machine Instance State, the user is able to stop, terminate, reboot, and start the state of a virtual instance. We will first prepare an app to run as the Web Role in Windows Azure. The program will add a Windows Azure Drive to keep some files persistent when the VM is killed or rebooted. We will have two web pages, one where a random file is created inside the mounted drive, and another to list all the files on the drive. Then we will build and package the program and deploy the Web Role create as a hosted service on Window Azure using the portal. We will then create another program to manage the VM instance state similar to what we had done before in the previous use case, VM Control: Allocating VM Instance. We will use http GET requests to visit the first web page to create a random file on the Windows Azure Drive and the second web page to lists the files to show that they are not empty. We will then use the management execution context to stop the VM and disassociate the IP address and confirm this by visiting the second web page which will not be available. We will then use the same management execution context to restart the VM and confirm that the files in the drive are persistent between the restarts of the VM.

    6. Copying Data Objects between Cloud-Providers, the user is able to copy data objects from one Windows Azure Storage account to another. This example involves creating a program to run as a worker role where a storage execution context is created. We will use the container as per the first use case, Copying Data Objects into a Cloud. We will download the blob to a local file system. We will then then create a second storage execution context and transfer the downloaded file to this new storage execution context. Then as per the first use case we will create a new program and deploy it to retrieve the two blobs and compare and verify the contents MD5 hashes are the same.

    clip_image003[1]

    Java code to test the Service Management API

    clip_image005[1]

    Test Results

    clip_image006[1]

    Managing API Certificates

    For the Java examples (use cases 4-6), we need to have key credentials. In our download we demonstrate the Service Management API being called with an IIS certificate. We will take you through generating an X509 certificate for the Windows Azure Management API. We show the management console for IIS7 and certificate manager in Windows. Creating the self-signed server certificates and exporting them to the Windows Azure portal and generate a JKS format key store for the Java Azure SDK. We will then upload it to the Azure account and converting the keys for use in the Java Keystore and for calling the Service Management API from Java
    We then demonstrate the Service Management API using the Java Key tool Certificates. We will use the Java Keystore and export an X.509 certificate to the Windows Azure Management API. Then we upload certificate to an Azure account. We will then construct a new Service Management Rest object with the specific parameters and end by testing the Services Management API from Java

    To get more information, the Windows Azure Storage Services REST API Reference and the Windows Azure SDK for PHP Developers are useful resources to have. You may also want to explore more with the following tutorials:

    • Table Storage service, offers structured storage in the form of tables. The Table service API is a REST API for working with tables and the data that they contain.
    •  Blob Storage service, stores text and binary data. The Blob service offers the following three resources: the storage account, containers, and blobs
    • Queue Service, stores messages that may be read by any client who has access to the storage account. A queue can contain an unlimited number of messages, each of which can be up to 8 KB in size

    With the above tools and Azure cloud services, you can implement most of the Use Cases listed by NIST for use in SAJACC. We hope you find these demonstrations and resources useful, and please send feedback!

    Resources:

    Jas Sandhu, Technical Evangelist, @jassand

  • Interoperability @ Microsoft

    Instant Messaging Interoperability extended through XMPP and new partnerships

    • 3 Comments

    Today, Microsoft announced a new XMPP Gateway for Office Communications Server 2007 R2 that enables interoperability with Cisco Jabber/XMPP and Google Talk, along with new licensing options for Office Communications Server customers to connect with AOL and Windows Live (read the details of the announcement).

    I had a chance to seat down with Ashima Singhal (Senior Product Manager) and Albert Kooiman (Senior Product Manager) from the Communication Server team to discuss the news focusing on Instant Messaging (IM) interoperability between different networks. Here's what they have to say about how all of this works:

    Get Microsoft Silverlight

    This video is posted on the Channel9 Interoperability topic area: Instant Messaging Interoperability extended through XMPP (Jabber)

    Links:

    Jean-Christophe Cimetiere, Sr. Technical Evangelist

  • Interoperability @ Microsoft

    Open Source OData Library for Objective-C Project Moves to Outercurve Foundation

    • 0 Comments

    As Microsoft continues to deliver on its commitment to Interoperability, I have good news on the Open Source Software front: today, the OData Library for Objective-C project was submitted to the Outercurve Foundation’s Data, Languages, and Systems Interoperability gallery.

    This means that OData4ObjC, the OData client for iOS, is now a full, community-supported Open Source project.

    The Open Data Protocol (OData) is a web protocol for communications between client devices and RESTful web services, simplifying the building of queries and interpreting the responses from the server. It specifies how a web service can state its semantics such that a generic library can express those semantics to an application, meaning that applications do not need to be custom-written for a single source.

    The Outercurve Foundation already hosts 19 OSS projects and, as Gallery Manager Spyros Sakellariadis notes in his blog post, this is the gallery’s second OData project, the first being the OData Validation project contributed last August.

    “With this new assignment, we expect to involve open source community developers even more in the enhancement of seminal OData libraries,” he said.

    Microsoft Senior Program Manager for OData Arlo Belshee notes in his blog post that the Open Sourcing of the OData client library for Objective C will enable first-class support of this important platform. “Combined with exiting support for Android (Odata4j, OSS and Windows Phone (in the odata-sdk by Microsoft), this release provides strong, uniform support for all major phones,” he said.

    In assigning ownership of the code to the Outercurve Foundation, the project leads are opening it up for community contributions and support. “They firmly believe that the direction and quality of the project are best managed by users in the community, and are eager to develop a broad base of contributors and followers,” Belshee said.

    As Microsoft continues to build and provide Interoperability solutions, Sakellariadis thanked the Open Source communities for their continued support, noting that together “we can all contribute to achieving a goal of device and cloud interoperability, of true openness.”

  • Interoperability @ Microsoft

    Building PHP simple database applications for SQL Server, Windows Azure Storage and SQL Azure

    • 0 Comments
    The SQL CRUD Wizard for PHP is a wizard type application that can be used to generate a simple "Create, Read, Update, Delete" PHP application from a Microsoft SQL Server, Windows Azure Storage and SQL Azure database table. The generated PHP application supports paging, sorting and simple CSS customization. The generated PHP Application Code, generated by the PHP to SQL CRUD Wizard, includes logic for CRUD functionality between the PHP application and a SQL Server database instance on the web server. This project initiated last spring was developed by Accenture, with Microsoft providing funding.

    You can see an overview of the architecture, the configuration steps, and a quick demo of the wizard in the following Channel9 screencast:

    Get Microsoft Silverlight

    Here’s in a nutshell the logical architecture and flow of the wizard:

    SQLCRUDPHP

    You can get more details about the project and download it from here.

    --Sumit Chawla, Technical Product Manager/Architect, Microsoft Interoperability Team

  • Interoperability @ Microsoft

    Interoperability at MIX09

    • 2 Comments

     

    Well, it came as no surprise that interoperability was a big part of the discussion at MIX09… at the keynote, in the breakouts, on the blogs, on Twitter, etc. Of course interoperability is a key consideration any time that you talk about cloud computing. Let’s be clear: Interoperability between the services platforms, the identity providers, the mashable services, the social networks and so on is now an integral part of the landscape.

    MIX is a very special annual conference where Microsoft attempts to bridge the worlds of technology, design, entrepreneurship and business. Zooming into technology, we could draw much more interrelated circles, but my point is not to give a holistic view. Instead, I’ve highlighted a few sessions for you that are going deep into interoperability scenarios.

    clip_image002[4]

    I’ll start with Vijay Rajagopalan’s session
    Build Applications on the Microsoft Platform Using Eclipse, Java, Ruby and PHP!” where he presented:

    • Microsoft’s approach to Interoperability: 6-7 minutes that really helps to explain how and why Microsoft is going this direction!
    • Silverlight interoperability with the Eclipse Tools for Silverlight project, with the new Mac support (see my post Eclipse Tools for Silverlight (Eclipse4SL): now for Mac developers) and a sample integration of Silverlight and PHP
    • Azure Services Platform Interoperability and .NET Services, where Vijay demos the Java SDK for .NET Services (Jdotnetservices) and the Ruby SDK for .NET services (check also John Shewchuk’s session below for more on .NET Services/Interoperability)
      • Slide 38 at approx 31':
        clip_image004[4]
    • A prototype of PHP Tooling from Eclipse for Windows Azure, enabling developers to browse the Windows Azure Storage, and publish a PHP application that would leverage the FastCGI support in Azure (see Using 3rd Party Programming Languages via FastCGI).
      • The Azure Storage Explorer in Eclipse at approx 46' 
        clip_image006[4]

    Speaking about Azure, from the moment we kicked off our cloud computing effort, openness and interoperability stood at the forefront, we spelled it out clearly with Azure (see http://www.microsoft.com/azure screenshot below), and we mean it as this post illustrates.

    clip_image008[4]

    clip_image010[4]

    The next session I’d recommend is Shaun Hirschman & Michael Joffe’s
    Running PHP on Microsoft Servers and Services: Windows + PHP, explore the possible
    clip_image012[4]

    As Michael states in the opening, everybody is aware that PHP runs on Windows, but you don’t necessarily know all the legwork the Microsoft has been doing to enhance PHP on Windows, as well as all the interoperability touch points between PHP and Microsoft’s technologies. So in this session you’ll get the big picture. In particular don’t miss these demos:

    • Web Platform Installer: getting all you need to build your web applications in one simple and customizable installer, including popular web applications like WordPress.
    • Live Services + PHP: extend PHP applications (WordPress in the demo) by adding your Live Contacts and syncing blog content with Live Mesh

    clip_image014[4]Finally, I invite you to check out John Shewchuk’s session A Lap around Microsoft .NET Services, where he is doing “something a little wacky” as he said!

    John demonstrates interoperability scenarios with .NET Services (which is part of the overall Azure Services platform) combined with different languages and platforms. John’s demos show how to leverage the Access Control Service & the Service Bus, with an application built using Python+JQuery running on the GoogleApp engine and using Yahoo as the OpenId provider. These are great scenarios involving notifications and federated identity across firewalls boundaries and heterogeneous systems.

    clip_image016[4]

    Further down the talk, I also really liked the Facebook (PHP)/CinemaMIX (ASP.NET) application allowing users to invite friends to share (view/edit) your Netflix video queue. That’s cloud interoperability in action

    This is only a short selection of the sessions tackling Interoperability. There are many other interesting sessions to discover, so get lost at http://videos.visitmix.com/MIX09 and have fun!

    Jean-Christophe Cimetiere  - Sr. Technical Evangelist

  • Interoperability @ Microsoft

    Happy Birthday XML!

    • 0 Comments

    XML was first published as a W3C Recommendation on 10 February 1998.

    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.

    Vive XML and to its bright future!

    Jean Paoli
    President, Microsoft Open Technologies, Inc.
    Co-Creator, XML 1.0 @ W3C

  • Interoperability @ Microsoft

    A new way for iOS and Android users to access corporate resources: The Application Gateway

    • 0 Comments

    clip_image002Every CIO today has mobile VPN access sitting very high on the priority list and knows how mobile connectivity to corporate resources is an important yet complicate matter. In a quest to solve the VPN issue in a simple way, Microsoft Open Technologies, Inc. created AppGateway, an application of VPN access for Android and iOS based on the preview of a Windows Azure Application Gateway service meant to help mobile users be more productive on the go. With this app, developed in collaboration with the Windows Azure Active Directory team, Android and iOS users can experience easy connectivity to web sites behind the corporate firewall, leveraging Windows Azure authentication services.

    For obvious security reasons, connecting to resources that are behind a firewall usually requires a fairly complex infrastructure such as VPN (Virtual Private Network). The AppGateway demo app is designed to make the process simpler yet highly secured. The mobile app connects to a service on Windows Azure that acts as the proxy to an agent that is running inside the network behind the firewall. Using the Windows Azure Authentication service, the proxy can establish a trusted connection to the agent so that the application on the mobile device can browse web sites that would not be normally accessible outside the corporate network.

    clip_image004

    The demo app is available on the Apple App Store, GooglePlay and Amazon marketplaces at the following links:

    For more information on the Windows Azure Application Gateway service preview, visit http://appgportal.cloudapp.net/.

    In our best tradition, we also released the source code of the demo app. You can find the Android application code here.

    For detailed instructions and a quick ‘get started; guide is available here.

    We look forward for your feedback, comments and suggestions.

  • Interoperability @ Microsoft

    Being a polyglot developer: tools & guidance to help iPhone developers learn Windows Phone 7

    • 0 Comments

    To be honest, I used to be a developer coding for a living, and now I’d say I’m a savvy hobbyist. I’m surrounded at work by brilliant developers, and even if I write very little code, I’m still very passionate about it. So, assuming you are like me a happy coder, the joy of developing software all comes down to a few things:  

    • Building something cool that users will enjoy
    • Getting rewards from users and recognition from peers
    • Learning how to solve new challenges and build novel features.

    Even if you have a solid expertise on a particular platform/language, I think it is essential to be a “polyglot” developer. In other words, you might have a native or preferred language, but opening your mind to others can be very stimulating and will bring considerable value to your abilities and your resume.

    Jumping from one platform or language to another can introduce breaking changes in your habits, but ultimately I believe change is very healthy for any individual and as a side effect it will expand your opportunities.

    If you are a .NET developer, learning Windows Phone development is not really “change.” Instead, it is more of a continuum, where you just add new features to what you already know. If you are an iPhone developer, new to Windows Phone (and .NET), yes this is different. But don’t worry. The learning curve is not as steep as you would imagine.

    So you may ask: “how can I leverage my iPhone development expertise to build Windows Phone 7 applications?”

    imageI’d just tell you: there’s no magic wand that will do the work for you, but we have put together a great package to help you get started. It’s available at http://windowsphone.interoperabilitybridges.com/, and I’ve just posted the announcement on the Windows Phone Developer blog:
    Leveraging your iPhone development expertise to build Windows Phone 7 applications

    Feel free to pass along to your friends Smile

    Jean-Christophe Cimetiere, Sr. Technical Evangelist – Interoperability
    @jccim - blogs.msdn.com/interoperability

  • Interoperability @ Microsoft

    You’re invited to help us celebrate an unlikely pairing in open source

    • 2 Comments

    We are just days away from reaching a significant milestone for our team and the open source and open standards communities: the first anniversary of Microsoft Open Technologies, Inc. (MS Open Tech) -- a wholly owned subsidiary of Microsoft.

    We can’t think of anyone better to celebrate with than YOU, the members of the open source and open standards community and technology industry who have helped us along on our adventure over the past year.

    We’d like to extend an open (pun intended!) invitation to celebrate with us on April 25, and share your burning questions on the future of the subsidiary, open source at-large and how MS Open Tech can better connect with the developer community to present even more choice and freedom.

    I’ll be proud to share the stage with our amazing MS Open Tech leadership team: Jean Paoli, President; Kamaljit Bath, Engineering team leader; and Paul Cotton, Standards team leader and Co-Chair of the W3C HTML Working Group.

    We will share personal anecdotes about how an unlikely pairing -- Microsoft and open source / open standards – may go down in history as successful as Chocolate & Peanut Butter, Cats & the Internet, and Pirates & Ninjas.

    Come raise a toast to how far we have come as a community, and to the exciting places we’ll be headed in the next 12 months.

    Find your ticket below, and register here http://congratsmsopentech.eventbrite.com.

    Cheers,

    Gianugo Rabellino
    Senior Director, Open Source Communities
    Microsoft Open Technologies, Inc.

    image

Page 2 of 4 (341 items) 1234