Douglas Purdy

Dewitt Clinton (who I am running into more these days) posted an article (“People love Apps”) asserting that Web apps will be the dominant application model in the mobile space (as they have in the PC market).

There’s still a functionality gap right now, but there is no technical reason that mobile web apps won’t catch up. And when they do, all the advantages of being able to target multiple platforms with one codebase, all the advantages of sharing a single stack between desktop web and the mobile web, and all the advantages of HTML5 itself, will push the balance back in favor of the web.

Incidentally, the browser is already my most-used app on my Android device, but I may be an early adopter / leading indicator rather than the norm.)

Native mobile apps may be bigger and better than mobile web apps today, but they won’t be tomorrow.

Mark my words.

We’ve seen this all before.

I mostly agree with DeWitt; it is very difficult for native platforms to stay ahead of the “Web platform” (such as it is) over the long term.

But the operative phase in the above is “long term”…

One of the key factors at play between native and Web platforms is access to new hardware capabilities.

The Web platform catches up eventually (note all the mobile hardware device support in “HTML5″), but the native platform will always have “first mover advantage” to give developers access to these capabilities.

In short, the most innovative apps leveraging new hardware will be written to the native platform.

Of course, a device vendor could adopt the Web platform as their native platform (read WebOS), but apps written to this platform are not really a Web app as defined by Dewitt or as I would define it (Web app ~= works on > 1 OS && > 1 browser).

Also note, that you even see Palm creating a native platform layer for developers (mainly for games).

When Apple releases the iPhone 5 with the iNeuron connector kit, I envision the following sequence playing out:

1. Apple releases the “Cocoa Thought” framework that you can program in Objective-C
2. In 6-12 months, Apple will have Javascript/HTML extensions that work in Safari only
3. In N months, some of the other mobile browser vendors support a variant of #2
4. In N+24 months, the W3C, IETF or some other standards body agree on some variant of #3
5. The neuron interface is now part of the “Web platform”

Net:  Hardware matters.  Native apps will support new hardware sooner.  Ergo, native apps will continue to be important.

I do think that the most apps will be Web apps, but native apps are like waves cresting over that vast ocean.

“Declaring variables”

| aString aNumber aBoolean anObject |

“Assigning values to variables”

aString := ‘HelloWorld’.

“Sending a unary message”

aNumber := aString size.

“Sending a binary message”

aNumber := aNumber + 0.

“Sending a keyword message”

aBoolean := aNumber isDivisibleBy: 2.

“Writing the all important ‘Hello World’”

Transcript show: aString.

“Working with loops, conditionals and blocks”

aBoolean ifTrue: [ Transcript show: 'even' ] ifFalse: [ Transcript show: 'odd' ].

1 to: aString size do: [:number | Transcript show: (aString at: number) ].

[ aBoolean ] whileTrue: [ Transcript show: 'looping'. aBoolean:= false ].

“Creating a class. Notice that this is keyword message to Object. The IDE makes this look better.”

Object subclass: #Person

instanceVariableNames: ‘name’

classVariableNames: ”

poolDictionaries: ”

category: ‘Samples’.

“Adding two methods. Note the use of the ‘^’ to return from a method. The IDE makes this look better.”

Person compile: ‘name

^name’.

Person compile: ‘name: aString

name := aString’.

“Creating an instance of an object”

anObject := Person new.

“Calling our methods”

anObject name: ‘Bodhidharma’.

Transcript show: anObject name.

“Removing the reference to the object. Not needed, but I wanted to show nil.”

anObject := nil.

“Everything in this post is valid Smalltalk.  You can download Squeak (http://www.squeak.org) and run it without changing anything.  I left out a few things, but this should be enough to get you going with the world’s greatest language.”

At the NOLA airport preparing to move on to the next leg of the OData Roadshow after TechEd North Amercia 2010.

I enjoyed the conference, particularly doing the keynote with Bob Muglia and the “Open Data for the Open Web” session with Jonathan Carter.

One of the things that we announced in our session was some work that we have been doing with Facebook:  the Insights OData Service.

Facebook Insights provides FB application developers and page authors access to a wealth of information about how FB users interact with their applications and pages.

We started working with Facebook just before F8 on an implementation that would bring this dataset into the OData ecosystem.

Our primary goal is to make this information accessible in a first class way within Microsoft’s BI tools, like Excel.

TechEd seemed like a good place to talk about our progress to date.

The service is still in “preview” mode, as we are still adding features and we are likely to change the URL, etc.

Nevertheless, if you have a Facebook application or page, I encourage you to check it out.

In 2000 (if memory serves), I had the privilege of watching Alan Kay present at Microsoft Research.

As a Smalltalker, I had a tremendous amount of respect for his work, but I was completely blown away by him and his presentation (all done in Squeak).

He chastised us (Microsoft and the industry) for all the unfulfilled promise that he had outlined years before.  We deserved it.

Alan turned 70 on May 17.

His friends and co-workers (including Gordon Bell, Chuck Thacker, and Butler Lampson) have written him a book.

It is available online (donations welecome) at http://vpri.org/pov/

It is worth reading.

We still have a lot of work to do.

We all wear masks.

We wear a mask at work.  A mask that tells people we are serious, intelligent and worth whatever we are being paid (or more).

We wear a different mask when having drinks with our friends.  A mask where we want to be carefree, free from the weight of the mask worn at work.

We wear a different mask when we are all alone with our partner(s)/spouse(s).  A mask where we can sometime share our deepest desires and fears (and often a mask where we cannot).

We even wear a mask when we talk to ourselves.  The mask that says we are simultaneously both the greatest and worst person that has ever lived (the subject for a much longer post).

When I read about privacy on social networks, I can typically unwind the issue to really be about what projections of self (a mask) that the network supports.

Most only support a few masks (public and/or friends) and often poorly.  This causes people to “under share”, use a different network for that mask, or just opt-out completely.

An interesting observation is that these masks are often (roughly) organized in a subset/superset relationship.

This observation could help make this problem more tractable, although I do believe that a network needs to enable the same level of control that I have today — essentially the ability to construct a mask for each individual in the network.

I could spend several years talking about why these masks exist in the first place (religious, cultural, biological, etc.), but social networks like Facebook or Robert Scoble are not going to make them go away.

What we need is a social network that understands these masks and supports them in a first class way.

The first one that does will become the essessial platform (a utility) for the next generation of applications.

Miguel has called for us to open source our .NET OData Server implementation.

It is something we have talked about doing in the run up to MIX and something we continue to discuss.

Broadly, I agree with much of Miguel’s argument.  Expect to hear more on this topic from us.

As we explore open sourcing our .NET OData server code, the question that I am pondering is if that would be enough to kick-start an ecosystem of OData services on Unix.

Do we need to have an OData implementation for PHP &| Python as well?

What if we both open sourced our .NET implementation and also spooled up a PHP &| Python project?

If we did decide to do something like this and we could only pick one other language/runtime beyond .NET, which one should it be?

Interested in any and all thoughts on this topic.

At MIX, we showed off “Houston”, a Web-based database development/administration tool for SQL Azure, that will CTP “soon”.

The development team is interested in getting feedback about some aspects of the tool before we release it on the Web.

If you would like to help us determine the right set of features, etc. for “Houston”, please take a couple of minutes to answer a few questions at http://www.surveymonkey.com/s/SKYDFBS.

If you have seen the MIX Day 2 keynote, you know that we showed off OData on a Palm Pre.

Several of us (myself, JCar and Pablo) had a chance to write code for webOS as part of the demo work — and we really liked the runtime (effectively HTML5) and the device.

If you haven’t done so, it is really worth checking out the webOS SDK and most importantly, Ares, which I consider a herald of things to come.

BTW: I want to personally thank Palm (in particular Mike Abbott) for being supportive of this work.

The “checkbox” to expose a SQL Azure database as OData service is now live.

https://www.sqlazurelabs.com/

You can see a quick demo of this functionality in the MIX Day 2 keynote.

I want to personally thank Mike Pizzo, David Robinson, and Jack Greenfield for their work on this service over the last couple of weeks.

Great work guys!

If you have every designed an API, you know that it is not a trivial process.

From naming, to versioning, to security, the number of things you have to get right is quite large.

Creating a Web API introduces more complexity; security writ large, versioning writ large, subscriber management, reporting, billing, etc.

At MIX, we will talk about the things that can help you build out Web APIs, including  OData and “Dallas”.

There are also some interesting startups that provide services to help you kickstart your Web APIs.

One of which is WebServius, which I call out because I know one of the founders (they are also part of our BizSpark program).

They provide both free and paid services to enable you to focus on the Web API itself (still not an easy task), while letting them worry about security, monitoring, etc.

It is exactly these sorts of services that will help get more and more Web sites to offer Web API.

Over time, more and more developers will realize that it is the Web API, not the Web site, that truly captures and exposes real value.

The Twitter API is one of the first evidence points of this movement.

I long for the day when I can pivot and access any piece of information on the Web in tools like Excel or DabbleDB.

If you run a Web site, why not start today?

I was asked this question based on my Emacs.NET (2010) post, so I thought I respond with a screenshot from the current CTP.

“Intellipad” is a .NET application that is used to write a .NET application: (large portions of) itself.

Most of the commands are in IronPython.  Further, the tests are in IronPython.  You can run them from the command buffer in the tool (>>>Test(“TestName”)) and they ship in the CTP.

Beyond IronPython, “Intellipad” supports “modes” for “M”, T-SQL, and lots more.  Of course, since the tool is completely extensible, you can add whatever language you want, as I did with MUrl.

BTW:  In case it is not clear, this is all still in CTP, the team is still working on it, so stuff can change.  I know the “M” and “Intellipad”/”Quadrant” teams believe strongly in text as a core way of “modeling” software, so you can expect that principle to be honored.

At the end of 2007, we started hiring for a project that we referred to internally as “Emacs.Net”.

I often get asked about this project and it is a recurring search leading to this blog, so I thought I would give an update on what happened since we staffed up that team.

The short story is that we gave this project an official unofficial name: “Intellipad”.  This tool was included in the first “Oslo” CTP and continues to ship in the latest SQL Server Modeling CTP.

We designed “Intellipad” to work standalone as a lightweight companion to “Quadrant” and VS.  In addition, a core scenario was in situ use within “Quadrant” itself.

You can see three “Intellipad” views in “Quadrant” below (from the current CTP).  One shows “M”.  Another shows the T-SQL generated from the “M”.  The last shows “Intellipad” as the query editor in the table view.

The ‘Quadrant” integration is something we debuted at PDC this year, but the fact that we were going there shouldn’t have been a surprise.  First, I told anyone that asked and second the name is the best clue.  “Intellipad” is short for “Intellisense Workpad”.  A workpad is the name that we give for a view inside of “Quadrant”.

BTW:  One of the main developers of “Intellipad” and “Quadrant” has an impressive side-project that you may want to check out: SmallBasic.

[Update:  If you want to see what you can do with “Intellipad”, check out how we extend it for MUrl.]

The title of this post is not mine.

It is Bret Taylor’s.

Bret, of Google Maps and more importantly FriendFeed fame, is now at Facebook working closely with some of the best Microsoft alums I know.

Back in 2008, he was on to something, something important.

How do you discover a given dataset, particularly a common dataset that should be like “air” for developers?

Once you find it, what are the legal requirements to access it?

Once you can legally access it, what is the mechanism to access it?  Do you have to screen scrape it?  You would be surprised at the amount of screenscraping you need to do for even datasets you pay for.  Jon Udell captured some of my personal frustration around this in 2006 here.

Of course, if you are a dataset provider, you have the inverse of these questions.

Bret called his solution to these problems, DataWiki.

I call it “Dallas”.

There is, however, a key difference between Bret’s concept of the DataWiki and “Dallas” that is best highlighted by a Steward Brand quote:

Information Wants To Be Free. Information also wants to be expensive.

I do not think you can ignore this tension and any “data as a service” like “Dallas” needs to internalize this deeply in both its technical architecture and business strategy.

With that said, I think of “Dallas” as an important example and (I hope) success story of the Open Data vision that many of us at Microsoft share.

Maybe Bret will get his DataWiki after all…

The below diagram highlights all the products that have shipped or announced that support OData.

This is a very impressive list and there are more in the pipeline.

One of the questions I often hear is “That is great, but what is the scenario?”

I’ll admit that I tend to think the scenario(s) should be self-evident, but I am very close to the technology.

In order to answer this question, Pablo put together a video of a concrete, real-world scenario that should resonate well with even the most jaded cynic.

Watch OData: The Movie Now

BTW:  One of the things that we are looking at going is adding support in SQL Azure for OData.  Create a database and get a non-code OData service that you can access from any platform/language over HTTP.  If you are interested in this feature, please let use know:  Vote for OData Support in SQL Azure.

As noted on the OData.org site, WebSphere eXtreme Scale uses the OData protocol.

Billy Newport, an IBM Distinguished Engineer, was interviewed recently on why they selected a RESTful data service as the API and how OData helped.

The article: http://searchsoa.techtarget.com/news/article/0,289142,sid26_gci1379765,00.html

More product details: http://www.ibm.com/developerworks/websphere/downloads/xs_rest_service.html 

It is great to see that developers, regardless of platform/language, have a simple way to consume these services.

I’ll make one interesting note about this implementation.

As near as I can tell, Billy’s team implemented OData without ever talking to anyone at Microsoft.

I suspect they used the protocol documents we have online (these define the protocol with even greater precision that many standard specifications I have seen) and a HTTP trace tool.

Having been involved in distributed computing/protocol integration work for a long time, that is quite an achievement.

It could speak to simplicity of the protocol (it is just conventions/extensions over HTTP/AtomPub), the quality of the documentation or the intelligence/patience of the IBM team.

Likely it was all of these.

I am spending a lot of time on the Open Data Protocol (OData).

Many of us at Microsoft that believe that this protocol can help usher in a more open and programmable Web.

A protocol like this is a prerequisite for the broader “Infobus” and “Information Liberation” vision that I often talk about.

Envision a world where every application/Web property exposes its data (actually your data) in a way that you can easily query it in rich tools like Excel/Numbers or write your own mash-up/custom application.

A world were government data is transparent, queryable and accessible to any citizen.

A world where you can you can ask a question and know: “There’s a feed for that”.

We are just starting, but we (Microsoft) already has an impressive list of OData producers/consumers coming online (including SharePoint, SQL Server 2008, IIS/ASP.NET, etc.) and there are more in the pipeline that we will announce this year.

We are working as hard as we can to get OData support on as many platforms (both client and server/service) as we can, so a developer on any platform can both consume and produce these feeds.

We are begin to engaging partners, consumers and even competitors in a more structured way to see how we can work together to build up an ecosystem of open data services.

To make this vision a little more concrete, let’s look at a couple of screenshots.

Below is a third-party tool called LinqPad.  LinqPad recently added support for OData, which is demonstrated below.  The most interesting thing is the data service that I am accessing.  The City of Edmonton, Canada is exposing datasets as OData feeds at http://data.edmonton.ca/.  That lets tools that understand OData, like LinqPad, access this information in rich ways.

Also, notice the two other data services in the tool.  These point to District of Columbia and New America Foundation data at http://ogdisdk.cloudapp.net/.

This next screenshot is of Excel (via the PowerPivot plug-in) accessing the same data service.

Just to prove that this is all open, accessible and available to non-Microsoft clients/tools, see the below.  This is the same query that we are executing in LinqPad, but in Chrome and on the address bar.

Of course, you can access all this information using PHP, Java, JavaScript or .NET language using our OData clients.

Further, we are beginning to have conversations with key technical leaders in other companies/organizations about adding support in other platforms/languages/products.

We are excited about the possibilities here and think there is a real opportunity to usher in a world where open data is not only possible, but pervasive.

As you may know, my vision is all about giving people the power to create, access and share their data as they will.

Although I work at Microsoft, I love to see other companies making progress on technologies that I believe soundly support this vision.

Recently, I have been using a product by FileMaker (owned by Apple) called Bento.

There is both a Mac and iPhone version.  You can sync your “database” (called a library in Bent0) between your Mac and iPhone.  You can also share your libraries with any Mac on your local subnet – like iTunes – via Bonjour.

I could nitpick features I want and lament what I consider a powerful platform play Apple could execute on, but in general I have nothing but praise, great praise, for this product.

If you own an iPhone or a Mac, I really encourage you to check it out. 

Great work Bento team!

Before we gave “M” an official external codename, we called it “D” internally.

Back in the “D” days, our team started working with MSR on a number things related to the language.

We recently released some of that work on the MSR site: Dminor.

Dminor is a data-modeling language based on M, the data-modeling language of Microsoft Oslo. Dminor provides extended compile-time checking of code, making use of an SMT (Satisfiability Modulo Theories) solver.

You can read more about it at http://whigmaleerie.spaces.live.com/blog/cns!C6149B019D236BF5!846.entry.

You can download it at http://research.microsoft.com/en-us/downloads/cd60cdb0-353f-48b3-81d7-177621eba1bf/default.aspx.

Congrats to Andy and company…

WCF Data Services supports two data sources out of the box:  an EF data source and a CLR data source.

This lets you expose an OData service from any database that supports EF as well as arbitrary CLR objects.

There are many reasons to need more than this, particularly if your data is not relational or you can’t afford to have CLR types floating around all over the place.

A canoncial example of this scenario is the SharePoint data model.

In order to support SharePoint, we adedd a dynamic data source provider model that we call IDSP internally.

This provider model consists of a number of interfaces that you can use to expose any data source as an OData service.

One of the PMs on the WCF Data Services team, AlexJ, is blogging about this at now.

http://blogs.msdn.com/alexj/archive/2010/01/04/creating-a-data-service-provider-part-1-intro.aspx

Worth checking out…

The (WCF) Data Services team just released the an update to .NET FX 3.5 for the OData.

New features in this release are:

· Projections: This ADO.NET Data Services URI format has been extended to express projections (i.e. you can now work with a subset of the properties of an entity).  This release includes both server and client library (including LINQ support) support for projections.  We’ve done a fair amount of work in this space to support roundtripping projected values, working with anonymous types, etc.  We’ll create a subsequent series of posts to describe this feature.

· Data Binding:  The data services client library for the .NET Framework 3.5 SP1 has been extended to support two-way data binding.

· Row Count: One scenario we heard a ton of feedback on after shipping V1 of ADO.NET Data Services in the .NET Framework 3.5SP1 is the ability for the a client of a data service to determine the total number of entities in a set without having to retrieve them all.  To address this need, we have extended the data services addressing scheme to allow a client to obtain this type of information without having to download all the entities in a set.

· Feed Customization (aka “Web Friendly Feeds”): A common ask we have received is to provide the ability to customize how entities are mapped into the various elements of an AtomPub feed.  This feature does just that by providing a data service author declarative control over how the data service runtime maps the properties of an entity (e.g. a Customer, Order, etc) to the elements of a feed.

· Server Driven Paging (SDP): This one is best described by example.  If you had a data service that exposes photos, you likely want to limit the total number of photos a single request to the service can retrieve because the total collection of photos may be very large.  This feature allows a service author to set per collection limits on the total number of entities returned for each request.  In addition to limiting the number of photos returned per request, the server provides the client a “next link” which is simply a URI specifying how to continue retrieving the rest of the entities in the collection not returned by the first request.  For those familiar with AtomPub, this feature adds support for AtomPub <link rel=”next” …> elements to the data service runtime.

· Enhanced BLOB Support: This feature enhances the BLOB support provided in V1 to enable data services to stream arbitrarily large BLOBs, store binary content separate from its metadata, easily defer the loading of BLOB content when its metadata is requested, etc.

· Request Pipeline: We have started to expose events throughout the data services server request processing pipeline.  For this release we’ll expose request level events and in future we’ll look to expose more fine grained events based on your feedback.  The goal of exposing our processing pipeline is to allow services further transparency into a data service such that a service author can do things such as setting HTTP response cache headers, wrapping interceptor processing and data service request processing in a single transaction, etc.

· New “Data Service Provider” Interfaces for Custom Provider Writers: As the data services runtime has evolved, so has the number of ways people want to plug data into the data service framework.  In V1, two methods (Entity Framework and arbitrary .NET classes) were supported to enable a data service to interact with various diverse data sources.  To address another class of environments and data sources we have introduced a way to write a “custom” provider for those cases when the previous two provider models don’t meet your needs.