September 29th, 2008

Busy week for Microsoft: Silverlight and jQuery

Posted by Ryan Stewart @ 5:59 am

Categories: Ajax, Microsoft, Rich Internet Applications, Silverlight

Tags: Developer, Microsoft Silverlight, Microsoft Corp., Silverlight.net, Silverlight 2 RC, AJAX, Strategy, Internet, Software/Web Development, Web Development

I’m traveling so I wasn’t able to chime in on the availability of a Silverlight release candidate. One of the most important thing for developers is that it sounds like this will be the last round of API tweaks so there will be no more updating your applications. Silverlight.net has some information about what those API changes are. In addition to the API changes, there are some new controls to play with. Silverlight 2 RC includes a progress bar, a password input, and a combo box. The new controls are also included in a new service pack for Blend 2.0. Finally, there are some changes to the skins as well as some changes in how the skins render which will make Silerlight applications look cleaner in some cases.

We keep getting closer. As ScottGu says, it’s not that far off, and I’ve heard rumors to that effect. Microsoft recently had a bunch of independent developers in Redmond to go over the Sivlerlight roadmap, so I expect big things once Microsoft ships Silverlight 2. I think in general most developers are happy with the level of innovation that Adobe and Microsoft have been throwing into their respective projects. Eventually, however, I wouldn’t be surprised to see Flash Player and Silverlight diverge a bit. I think they’ll always compete at a basic and feature level, but I think it’s pretty obvious that the larger strategy of the two companies is different and I think Flash and Silverlight play a core role in those respective strategies. As each runtime becomes more driven by a larger strategy, innovation may start to happen in different areas. I just hope that everyone keeps swapping ideas.

Microsoft has also been busy on the Ajax front. They announced today that they’re incorporating support for jQuery into Visual Studio. I’m a big fan of what Microsoft has done with Ajax going back to the way they supported it in Silverlght 1. What’s really interesting is seeing the support for ADO.NET Data Services, which is a very, very big deal. Now more JavaScript developers have an easy, native entry point for writing apps that include Microsoft’s Data Services stack. That’s going to be significant.

September 2nd, 2008

Google Chrome: A browser for RIAs and a Firefox Killer

Posted by Ryan Stewart @ 9:57 am

Categories: Ajax, Google, Mozilla, Rich Internet Applications

Tags: Google Inc., Mozilla Firefox, Rich Internet Application, Web Browser, Web Browsers, Internet, Ryan Stewart

Google announced Google Chrome yesterday with a slick little comic and a bunch of good ideas about how to improve the browser. Even though I think everyone agrees that the shine of Google has worn off, if you picturd all of the things that should be in a Google browser, this pretty much covers it. We’ve got much better memory management, we’ve got a new JavaScript engine. Some are calling it a Windows killer, and it’s easy to see why. It’s has operating system-like features and it’s built from the ground up to run very complex Ajax appliations. In that sense, it’s very much a browser specifically for RIAs. It will include Gears support so that it can handle the offline/online problem for you. I love the feature that keeps each tab in its own memory space so that rouge applications can’t crash your entire browser. It also adds a memory inspector so you can see exactly which plugins or applications in the browser are taking up memory. Anyone who uses Windows should be familiar with this feature.

So it has everything you’d expect from a browser-based operating system and gets right to the heart of the problems. By making the browser more stable and more usable for long periods of time, they’ve created something very, very interesting, and something that should be a huge win for RIA developers everywhere - even Flash or Silverlight developers. So the easy answer is “Windows Killer”. But I didn’t see anything in the comic about device drivers. I didn’t see anything about hardware acceleration. In an extra bit of irony the beta is only available on Windows. So who’s in trouble? Firefox, even if they don’t acknowledge it.

Firefox has become synonymous with memory leaks and an antiquated code base. Despite a very good, lucrative arrangement for both sides, Google started from scratch and used WebKit as the HTML renderer. Firefox’s market share is still somewhere in the 25% range, while IE controls the bulk of the rest. So while it’s making inroads, it still appeals most to the hard-core geek crowd. And add-is are a major selling point over Safari right now. With Google Chrome you get the WebKit engine, you get add-ins, and you get a ton of more useful features in your browser. That same crowd that flocked to Firefox is going to embrace Google Chrome with open arms. The crowd of folks who just use whatever comes with their operating system? Not so much. Google will make more inroads than Firefox can, but it’s still going to take a ton of market-share from everyone’s feel-good open source browser.

I’m very, very excited about Google Chrome. This is a big day for RIA developers because Google started from scratch. They’re building a train that will actually be able to run on the high speed tracks of the internet. We’ve been pushing and pushing and pushing for a long time, but the browsers just haven’t been able to keep up with demands. Google Chrome should be a big leap forward.

August 22nd, 2008

Gears' new GeoLocation API is very slick

Posted by Ryan Stewart @ 2:34 pm

Categories: Ajax, Google

Tags: Mobile, API, AJAX, GPS, Advertising & Promotion, Internet, Software/Web Development, Web Development, Web 2.0, Consumer Electronics

Dion Almaer blogged this morning about the new GeoLocation API in Gears. As a Geo-nut, I’m pretty impressed with how well it’s implemented. The API is clean, and as Dion notes, with the community working on the W3C Geolocation spec, we could see a lot more geolocation on the web soon.

The mobile version appears only to work on Windows Mobile devices but the API uses a combination of GPS, cell towers, and WiFi/IP information to get a fix on where you are. It works anywhere that you’ve got Ajax as Dion’s example shows.

The release comes as part of Gears 0.4 which in addition to the Geolocation API, also provides onprogress events for HTTP downloads and uploads and some localized dialogues. the onprogressevent will be a big deal for anyone doing large uploads in the browser.

July 15th, 2008

Using Flash and Silverlight to move web standards forward

Posted by Ryan Stewart @ 11:24 am

Categories: Adobe, Ajax, Flash, Microsoft, Rich Internet Applications, Silverlight

Tags: Innovation, Web, W3C, Microsoft Silverlight, Standards, Alex Russell, Channel Management, Marketing, Ryan Stewart

Via John Carroll I saw a blog post by Paul Ellis in which he talks about the shortcomings of open standards, or more specifically, standards bodies, and how that affects the open web. In short, it’s led to the innovation and widespread adoption of proprietary technologies like Flash and Silverlight. If you really step back and look at it, despite all of the amazing things people are doing inside of the browser, real, ground-level innovation just isn’t happing unless it comes from companies like Adobe or Microsoft.

People are definitely doing innovative things with Ajax, but they’re taking the same basic set of technologies and rearranging it in different ways with varied results. All of the Ajax frameworks? Great stuff, but there’s not much in the way of core technology innovation going on. Flash and Silverlight on the other hand are pushing the boundaries when it comes to video, cross-domain security, offline/desktop access, deep zoom technologies, manipulating sounds, file access, filters and effects, and more.

I’m not trying to disparage the open web. I think if the open web could move at the speed of a private company, we’d all be better off. But it can’t, and really, the W3C wasn’t made for innovation and people are starting to realize that. Alex Russell realizes it, and more importantly Google realizes it. And they realize that lack of innovation is actually starting to hold them back as a company that relies very heavily on the browser. That’s one reason you’re seeing so much going into Gears. Google needs to move the open web forward but the W3C is too slow, so they’re coming up with their own solution.

In the end, I think the web is pretty robust and it’s self-healing. The W3C and other open web advocates should look to technologies like Flash and Silverlight as a way to see what works on the web and what doesn’t. If there’s a genuine threat, then hopefully that causes people to get up and help fix a broken standards process. The open web is in a good position. It’s still the best solution but now it has a bunch of companies fighting to innovate around it. The community can pull good ideas from that battle and move everyone forward.

July 2nd, 2008

WordPress, Gears, and the converging browser/desktop

Posted by Ryan Stewart @ 3:19 pm

Categories: Ajax, Google, Rich Internet Applications

Tags: Wordpress, Blogging, Web Browser, Desktops, Web Browsers, Hardware, Internet, Ryan Stewart

I had a good conversation today about the browser/desktop hybrid and where the converging is going to happen. Will it be more on the desktop side or will it be more on the browser side? I think we’ve seen the original browser-based development model win out as more and more people are learning HTML and JavaScript to build applications. But what about how the actual applications behave? Well today on the WordPress blog they explained to their users how they’re converging - by using Gears.

They’re using Gears to enable their “Turbo” link. What the Turbo link does is stores some data from the admin console - things like the images and HTML data - on the local machine so it’s accessible right off the hard drive instead of having to download it over and over again. It’s a small difference but it can have a big impact on the end user experience by speeding things up and providing more instant feedback. WordPress is basically making part of the internet faster by storing it on a local machine.

I think blogging is one of the more interesting examples of the browser/desktop melding. There are still a ton of desktop-based blog editors out there. People use them for all kinds of reasons including it’s easier to edit posts, they can craft posts offline, and it’s easier to drag and drop files/images/videos onto a desktop application. But I’d imagine that most people use the web-based blogging admin interface and find it perfectly adequate (I do). So can browsers evolve enough to remove the “market” for desktop blogging software or will there always be something better about using a full-fledged desktop client for some people?

June 17th, 2008

Apple finally goes RIA

Posted by Ryan Stewart @ 7:41 am

Categories: Ajax, Apple, Rich Internet Applications

Tags: Rich Internet Application, Apple Inc., SproutCore, Ryan Stewart

I shouldn’t say finally. The writing has been on the wall forever but most people couldn’t figure out what the writing said. It turns out it has a name, SproutCore, an open source Javascript framework that has been getting some buzz because it may be powering the Mobile Me suite of applications from Apple soon.

There’s a big, long, sometimes hard to read post on RoughlyDrafted that dives into a bunch of Apple vs Adobe vs Microsoft vs Sun vs Google scenarios with the central topic being that SproutCore is Apple’s Flash killer. So what is SproutCore?

There are a couple of demos that actually ran pretty terribly on my Mac in Camino. Most of the news and following blog posts seem to come from a single session at WWDC that talked about SproutCore. The RoughlyDrafted post seems to imply that Apple will be supporting the SproutCore project. Could we see something like we have with WebKit? The SproutCore blog doesn’t mention anything like that which I can see. But the creator, Charles Jolley, was hired as part of the .Mac team so I guess that means that Apple has acquired the framework.

So Apple now has a bunch of pieces to put together a real HTML/Javascript RIA push. They have the platform: Safari (Mac/iPhone/Windows), the framework: SproutCore, the multimedia: Quicktime/H.264, and the tools. If you want to start delivering RIAs and you want people to start building RIAs on your platform, that’s pretty much what you need. But I’m not fully convinced this is a platform play for Apple. They don’t seem to want massive developer adoption (note the miniscule 1.5% acceptance rate for the iPhone dev program) but rather a way to deploy online applications that can mesh with the Apple brand.

I think we’re at a very interesting time in RIA. I’ve long considered Javascript and HTML a part of the RIA stack, but the places we’re seeing Javascript and HTML have become more prevalent. I think we’re reaching a point where the issue isn’t so much “who wins the RIA war” as “who can deliver the best stuff on their platform”. RIA is a big, big deal. It’s arguably the future of application deployment. Flash used to be the only technology that could really meet user expectation as we moved from the desktop to the browser. But it’s scary for companies like Microsoft, Google, or Apple to be tied to a technology like Flash that they don’t own. So everyone saw the end goal - RIAs - and took different paths. There’s still some wrestling for developer mindshare but we’re quickly moving into a world of “what can I build” which I think is a great state to be in for RIA enthusiasts everywhere.

May 30th, 2008

Google's plugin craze

Posted by Ryan Stewart @ 3:05 am

Categories: Ajax, Google, Rich Internet Applications

Tags: Google Inc., Web Browser, Plug-in, Web Browsers, Internet, Ryan Stewart

Google is a company that prides itself on being a web company and helping to move everything into the browser. They created services like Google Maps and GMail which heavily relied on Ajax and helped usher in the idea of a much greater user experience inside the browser. In a lot of ways they brought the original idea of RIAs, which was to move away from the page model, into the main stream. And along the way they became big supporters of the browser as an entity and supporting standards. So the past couple of days have been interesting because it seems like Google has moved beyond what the browser can offer alone and has started leveraging plug-ins to add functionality where needed.

Gears
The first and best example is Gears. Google saw that there were some things the browsers just couldn’t do - including provide offline access - and decided they had to provide a solution. Enter Gears, a plugin which allows offline functionality and looks like it will become a core part of what Google is doing as it continues to require functionality beyond the browser. It seems like Google has rightfully come to the conclusion that standards bodies and browser vendors move slowly. It’s tough to innovate on the web when you’re depending on those two things to come together. So with Gears, Google is claiming to provide a standards implementation that the browsers can follow. At the Google I/O conference a few ideas were thrown out for what Gears might support:

• Being able to create a shortcut icon on the desktop.
• Notifications outside the browser.
• Drag and Drop file access.
• Blog data type in the database.
• Webcam and Microphone support.

Google has always had big ambitions, but it seems like they’ve finally realized that the the browser is broken in a lot of ways. It can’t keep up with the speed of the web.

Google Earth
The more interesting example for me was the Google Earth plugin. Currently Windows-only, it provides Google Earth functionality right in the browser. I took it for a spin tonight and I’m pretty impressed. It’s snappy, fast, and seems full featured. They also have exposed a JavaScript API so developers can use JavaScript to write directly to the plugin. Trying to get something like this natively in the browser would have been insanity. You couldn’t do this with SVG or anything that allows you to do animations and vector art in the newer browsers, so a plugin had to be created. I’m not sure how important Google Earth is to the overall Google strategy, but seeing it ported to the browser means that Google thought it was valuable enough to spend resources on.

So is this the start of a trend? Ask yourself if a year ago you would have expected Google’s conference to be very plugin heavy and I think you’ll realize that this is a big deal. Google is outgrowing the web browsers just like Adobe did, just like Microsoft did, just like Sun did, and just like a lot of other companies. I think in the long term Google hopes that Gears becomes a core part of any browser and that may still happen, but for now it’s one more plugin to download and one more thing to program with or around. But all of this is good for RIA developers. We now have a lot of tools to play with and more and more people are realizing that the browser by itself can’t keep up with our imaginations.

May 28th, 2008

More information on Yahoo's BrowserPlus

Posted by Ryan Stewart @ 7:42 pm

Categories: Ajax, Rich Internet Applications, Yahoo

Tags: Web, Google Gears, Yahoo! Inc., Web Browser, Web Browsers, Channel Management, Internet, Marketing, Ryan Stewart

There have been small bits of information trickling out about Yahoo’s BrowserPlus, but today in a blog posting on the Yahoo Developer Network we got some more information about what Yahoo’s planning and it’s a good development for RIAs. In their own words, Yahoo is building a platform to extend the web:

BrowserPlus is a platform for extending the Web: an end-user installs it and a developer uses its features through a small JavaScript library. Some of the features that exist in the platform today include:

• Drag-and-drop from the desktop
• Client-side image manipulation (cropping, rotation & filters)
• Desktop notifications

Clint Boulton makes the comparison between Gears and Adobe AIR, which is sort of correct. It really looks like it’s more competition for Google Gears as it will run inside the browser and expand the capabilities of the browser. It also doesn’t seem to be a one-plugin fro everything model. In the case of Yahoo BrowserPlus, users would download a plugin, and then websites could call different web services supported by BrowserPlus and BorwserPlus would load those into the browser when they’re called. That means it’s very easy for Yahoo to add functionality to the platform as they go instead of having to worry about distributing a new version of the plugin every time.

Some of the new functionality parallels the new features and roadmap of Google Gears that was announced today and it’s interesting to see two big web companies continue to try and expand on what the browser can do by offering their own functionality. If you look at Mozilla Prism, Adobe AIR, Google Gears, and BrowserPlus, there does seem to be a lot of interest in moving beyond the browser and there is plenty of choice for how each developer makes that happen.

April 30th, 2008

Tibco planning to use Silverlight

Posted by Ryan Stewart @ 1:50 pm

Categories: Ajax, Rich Internet Applications, Silverlight

Tags: TIBCO Software Inc., Microsoft Silverlight, Rich Internet Application, Dojo, AJAX, Internet, Software/Web Development, Web Development, Web 2.0, Ryan Stewart

Tibco Software is planning to support Silverlight according to an announcement at TUCON, the Tibco User Conference, in San Francisco today. The guts of the announcement mean that Tibco will use Silverlight where customers require audio, video, or other rich user experience elements where Ajax can’t be used. I’m not fully up on what differentiates Tibco from a host of other JavaScript vendors out there but I think this is a very interesting trend.

As demand for richer user experience grows are we going to see more Ajax-centric companies align with a RIA framework that enables more functionality? According to Tibco they chose Silverlight because they could leverage existing skills in C# and that Microsoft and Tibco have a lot of joint customers.

We’re seeing a lot of RIA adoption across a number of verticals including the enterprise, where I think Tibco has a lot of strength. Dojo has been pushing the envelope for animations in it’s Framework and added some support for Silverlight recently.

I’m not sure how significant the Tibco announcement is by itself, but it may be the start of a trend. Getting the RIA vendors closer to a number of Ajax frameworks is always a good thing because I think it gets the communities talking and sharing ideas which makes all RIA platforms, Ajaxy and not, better.

April 18th, 2008

The ever-changing definition of RIAs and how people are killing it

Posted by Ryan Stewart @ 3:58 pm

Categories: AIR, Adobe, Ajax, Curl, Flash, Flex, JavaFX, Microsoft, Mozilla, Prism, Rich Internet Applications, Silverlight, WPF, Windows Presentation Foundation

Tags: Desktop, Microsoft Silverlight, Adobe AIR, Rich Internet Application, Web Browser, Mozilla Prism, Ryan Stewart

There’s a long and mostly good article about various RIA technologies over at eWeek. I say mostly good because the author, Jim Rapoza, gives a pretty unbiased view of a lot of technologies. It’s a rundown that we (the entire space) needs more of and that I don’t feel qualified to give (for obvious reasons). But the problem is that Jim limits the term RIA to primarily desktop technologies with the exception of Silverlight which is included in the desktop RIA roundup and Curl, where I can’t tell if he’s using the browser plugin for Curl or the desktop version.

Defining RIA
Let’s first bite off the question of what desktop applications constitute RIAs. In general, I’m pretty broad with this definition. I think things like Mozilla Prism, Adobe AIR, Curl Nitro, and Microsoft WPF are all examples of desktop RIAs. WPF is the hardest to place because it’s the most “native” of those examples seeing as it’s the next generation of Microsoft’s .NET framework for building Windows applications. In general, I think RIAs as a whole should be:

• Cross-platform
• Using web technologies
• Have a focus on both performance/data as well as very usable, next generation user interfaces (the “Rich” part of RIA).

I also think that the best RIA platforms should have:

• A good designer/developer workflow story
• At a technical level business logic and user interface should be very cleanly separated so that the UI can easily be enhanced.

It’s the last two that I think pushes WPF over the top.

Coding for the desktop in the browser
So with that definition of RIAs, we get a bunch of technologies. Some are RIAs on the desktop, like the ones included in the eWeek article. But the longer term, older, and some would say more future-compliant are the RIAs inside the browser. That’s what Web 2.0 was built around and that’s what continues to get a lot of attention. As a result it’s VERY, VERY important to differentiate between browser RIAs and desktop RIAs and to compare apples to apples instead of apples to oranges (browser RIAs to desktop RIAs). This is where people seem to confuse Silverlight the most.

The eWeek article starts off like this with regards to Silverlight:

However, while Silverlight’s browser and operating system support is impressive, as an RIA platform, its scope is much more modest. In tests, Silverlight proved to be a fairly basic and even old-school approach to building and using RIAs. In fact, Silverlight can’t be considered a direct competitor to more advanced RIA platforms such as AIR. If anything, Silverlight is more of a direct competitor to Flash.

That’s both semi-accurate and completely misses the point. Actually, it’s kind of scary that the newest entrant into browser RIAs is being called a “basic, old-school approach to building and using RIAs”. Are browser RIAs that boring? While I’m a huge advocate of desktop RIAs, I think the browser should still be getting a bunch of the attention. And in fact, the browser is still where most of the energy is and as a result a really good RIA platform will build on what they know in the browser and leverage that in their desktop clients.

Look at Adobe. We’ve got the Flash Player in the browser and you can use ActionScript as well as the Flex Framework to build browser RIAs. Then you can take that exact same knowledge/code and start building a desktop application on AIR. Look at Microsoft. You can build a C# and XAML application in Silverlight then take that code and start building a desktop application in WPF. Look at Java. You can write Java code along (soon) with JavaFX and run it in the browser or as a regular Java app. Seeing a pattern? Same thing with Curl. You can use the Curl language to build a Curl application in the browser and now with Nitro you can take that code and build a desktop application. Mozilla Prism is the most basic example because all you’re basically doing is taking a browser application written in Ajax and turning it into a desktop application. The browser space is also where a lot of the Ajax frameworks exist and where companies like OpenLaszlo exist, so there’s room for all of those to grow.

Ajax
The way all of these technologies incorporate Ajax has also been interesting to see. Silverlight allows you to use JavaScript to program RIAs with it. AIR supports the full HTML stack so you can create desktop applications with Ajax. Prism is obviously all about Ajax. So as a core RIA technology, JavaScript and HTML are still doing very well and should continue to get attention whenever anyone mentions RIAs.

It’s a big, big world and it’s only getting bigger. And yeah, maybe it’s a pain that RIAs have started to fragment a lot. But in the end, competition is good and each of these technologies within both the browser niche and the desktop niche have their own strengths and weaknesses. It’s how those evolve that will be the most interesting and because of the close relationship between the browser RIAs and the desktop RIAs, we need to keep an eye on both.

So that’s my take on the RIA space. What did I mess up? Talkback away.