The similarities, though, end there. Implementation varies, technology varies, scope and location and functionality varies, and all in all it ends up being a pretty difficult convoluted mess to describe. At best you can group them via complexity, and after a brief exercise of that nature we realized that a new breed of networked application was emerging. Well, alright, perhaps not emerging, but instead gaining momentum and acceptance in the mainstream. Here’s the scale, see if you agree with our reasoning.

Level 1: The Widget

At this level of RIA you are attempting to display information in context of a particular page, however you don’t care about anything but the most basic user interaction. These could be things like drop-down menus, product detail pop ups, rotation views, buttons that reveal and/or expand text content (like reviews) and so forth. They are almost always implemented in JavaScript, because to use Flash or another plug in technology would be quite a bit of overkill.

Level 2: The Functional/Interactive Widget

This level of RIA’s describes widgets that allow a user to complete a particular functional task. No longer content with simply displaying information, we’ve now added functionality or a experience that responds to user input. This could be as simple as a DHTML login form or as complex as a Flash-based page takeover, but it necessarily remains restricted to a specific, easily definable task. "Log In", "Rate This Product", "Check Convention Schedule" and so forth are good examples, as they add a richer experience that remains in context with the page itself.

Level 3: The Rich Internet Application (RIA)

The next level of complexity takes the task mentioned above and strings them together into a flow, or objective, thus defining an actual application. While previously you would have perhaps a few simple form fields to fill out, an actual RIA causes the context of the page to change dramatically via user input. User interaction is no longer restricted to a single action, but instead is intended to enable an activity, such as "Tracking your time", "Editing a Photo", or "Managing a Color Palette". This is where the bread and butter of RIA’s exist, as well as the holy grail of Web 2.0: A fully interactive and functional application contained entirely within one browser page.

Level 4: The Rich Networked Application (RNA)

The Rich Networked Application (RNA, I’m trying to coin a term here, help me out) ceases to be bound by the browser, and instead has become an experience that bridges and is uniform across all digital touch points. The service is available not only from a browser, but may also be accessed from a desktop, a mobile device, a vehicle dashboard, a kiosk, a gaming console, or any other networked or partially networked device you can imagine. The RNA reaches out to many delivery channels, and while it may provide a different experience for each it nevertheless remains connected in context across them all. Excellent examples of this are Twitter (and all its clients), Google Maps (available on Mobile, Internet, etc), Kuler (Integrated to the desktop and the entire Adobe Suite), as well as upcoming games like Spore (Share creatures across platforms). Implementation… well, lets be honest, it’s a nightmare if you go into it unarmed. You have to support many different platforms, frameworks, systems and limitations, yet even so we’re starting to see toolsets emerge that address them all (Most notably Adobe’s Flex & AIR, Microsoft’s DLR via WMF & Silverlight, and Javascript libraries like SproutCore, MooTools and Prototype).

Did that make sense to you? It does to me, and I’m really excited to see how what we have today is going to start bridging the Device Divide.

Step 1: Download and Install Cruise Control

You can download Cruise Control from Sourceforge. For the purpose of this demo I’ve used the binary distribution, though you can compile your own. Once you’ve downloaded your distribution, unzip it into a convenient directory. I’ve used the base applications directory: /Applications/CruiseControl.

Step 2: Create a User

It’s best practice to not run cruise as root, so open up your user accounts and create a new user called Cruise Control.

Step 3: Create a folder in the StartupItems directory.

$ sudo mkdir /Libraries/StartupItems/CruiseControl

Step 4: Create the Parameters File

Create a file called /Libraries/StartupItems/CruiseControl/StartupParameters.plist. This file will contain your startup launch configuration information- in other words it’s a file describing your startup task.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>Description</key>
	<string>Cruise Control</string>
	<key>OrderPreference</key>
	<string>None</string>
	<key>Provides</key>
	<array>
		<string>CruiseControl</string>
	</array>
	<key>Uses</key>
	<array>
		<string>Network</string>
	</array>
	</dict>
</plist>

Step 5: Create/Configure the launch script

The launch script needs to be command line executable with the following three options: start, stop, reset. I’ve included my sample here, but I recommend you adjust it to match your own configuration and user name.

#!/bin/sh
#
# Error out when no parameter given
if [ -z $1 ] ; then
	echo "Usage: $0 [start|stop|restart] "
	exit 1
fi

# Source the common setup functions for startup scripts
test -r /etc/rc.common || exit 1
. /etc/rc.common

###################################################################################################
# USER CONFIGURATION

# The user under which CruiseControl should run.
CC_USER=cruisecontrol

# Cruise Install Directory
CC_INSTALL_DIR=/Applications/CruiseControl

# Directory for the config.xml file.
CC_WORK_DIR=$CC_INSTALL_DIR

# Logfile Directory
CC_LOGFILE_DIR=$CC_INSTALL_DIR

# Port under which Cruise should run
CC_WEBPORT=8080

# JMX Port. It's suggested you don't change this unless the port is already in use.
CC_JMXPORT=8082

# Port for the RMI gateway, leave blank to disable.
CC_RMIPORT=

###################################################################################################
# DO NOT MODIFY ENTRIES BELOW THIS LINE

NAME=cruisecontrol
DESC="CruiseControl - continuous integration build loop"

PATH=/sbin:/usr/sbin:/usr/bin:/bin
export PATH

CC_DAEMON=$CC_INSTALL_DIR/cruisecontrol.sh
CC_CONFIG_FILE=$CC_WORK_DIR/config.xml
CC_LOG_FILE=$CC_LOGFILE_DIR/cruisecontrol.log
CC_COMMAND="$CC_DAEMON -configfile $CC_CONFIG_FILE -webport $CC_WEBPORT -jmxport $CC_JMXPORT -rmiport $CC_RMIPORT -user youruser -password supersecret"

# overwrite settings from default file
if [ -f /etc/default/cruisecontrol ]; then
  . /etc/default/cruisecontrol
fi

# does the executable exist?
test -f $CC_DAEMON || (echo "The executable $CC_DAEMON does not exist!" && exit 0)

if [ `id -u` -ne 0 ]; then
        echo "Not starting/stopping $DESC, you are not root."
        exit 4
fi

# Get the PID output from the startup script
if [ -f $CC_INSTALL_DIR/cc.pid ]; then
	CC_PID=`cat $CC_INSTALL_DIR/cc.pid`
else
	echo "No cc.pid file found.  CC process may not be controllable from this script!"
fi

StartService ()
{
	cd $CC_INSTALL_DIR
	su $CC_USER -c "/bin/sh -c "$CC_COMMAND >> $CC_LOG_FILE 2>&1"" & RETVAL=$?
	echo "$NAME started with jmx on port ${CC_JMXPORT}"
}

StopService ()
{
	if [ -n "$CC_PID" ] && ps -p ${CC_PID} > /dev/null ; then
		kill -9 ${CC_PID}
		RETVAL=$?
	else
		echo "$NAME is not running"
		RETVAL=1
	fi
}

RestartService ()
{
	RunService "stop"
	RunService "start"
}

RunService "$1"

Step 6: Set permissions

Given that the startup script will ignore anything that isn’t owned by root, and right now cruise still doesn’t have write access to the cruise install dir, we have to make a few adjustments to our file structure to make this work.

$ sudo chown -R cruisecontrol /Applications/CruiseControl
$ sudo chown -R root /Libraries/StartupItems/CruiseControl
$ sudo chmod 755 /Libraries/StartupItems/CruiseControl/CruiseControl

That’s it. I hope this was helpful

• The internet ecosystem: Ruby, Rails, AIR, Flex, and where do they all fit
• Cost: What is it going to take?
• Installing and using RubyAMF
• Overview of MXML, Actionscript, Eclipse and the SDK
• Consuming data services with Flex & Air
• Building a simple call/response architecture

The presentation was on Monday, June 16th. The files are below:

I’ve always been bothered by that question, because not only do I have a strong background in the Fine Arts, but I have 8 years of solid experience as a developer. The reason I don’t like it is that those of us who operate on the web apply both our creative and logical skills on a daily basis, and in many cases it is our creative streaks that make us so good at what we do. Problem solving skills and creative expression are absolutely inseparable: We learned this from Einstein, and Galileo, and Leonardo Da Vinci, and Thales, and Newton, and a host of other individuals who nowadays would be called the greatest minds of their time.

And yet, every single time we present ourselves professionally, we are categorized into either a logical or creative bucket: Designer or Developer. Admittedly, there are advantages to this, since one can easily quantify compensation, career advancement and project resources based on defined tracks. Furthermore, most (if not all) web production processes work on the basis of phase signoff to protect both the client and the agent, and design necessarily comes before development. Rigid classification of skill and expertise is a boon to management and customer expectations, though it is a poor representation of reality.

Truly great projects involve all hands from kickoff, and while production can perhaps not truly begin until the ideation and proposal comps have been signed it is only by the virtue of continuous collaborative progress that the possibilities begin to flourish and grow. In this kind of an environment, the terms “Designer” and “Developer” cease to have any meaning; Contribution becomes equal in value and blended along the lines of common expertise.

An example: My colleague Jeff Breckenridge (Who’s a fantastic but under-appreciated designer *hack*cough*shameless plug*) has a remarkable understanding of graphic composition, but that does not mean he doesn’t understand the opportunities of object-oriented design. I myself know how important his expertise is, and with my background in production graphics can bring my own skills to the table and meet him on mutual common ground. The end result is well composed, well designed, and is functionally robust.

Skills: Jeff Breckenridge & Michael Krotscheck

The work we did on Practical Desktop was great not because he was the “Designer” and I was the “Developer”, but because we both mingled our skills across our particular domains of expertise. In some cases, I relied on his understanding of functional implementation, while in return he provided me with comps I could easily derive interface states from. We both brought our skills to the table, and in the middle they blended to produce something great.

I have stated before, and will state again, that true genius occurs at intersections of knowledge domains. The only thing we are lacking is a way to describe our skills in a way that accurately describes these domains, and is useful in managing projects, resources and employees to achieve the greatest level of creative impact for each implementation. The following flash piece approaches a method by which the skills may be described, and even assists in managing skills for a particular project, however it may not yet be refined enough to properly define career progression and compensation.

In the end, the point I’m really trying to make is this: The terms “Designer” and “Developer” have no meaning anymore. What matters from this point forward is the blending of skills, and we need a new way of describing these skills so they may be properly blended. What remains is the management of individuals categorized in this way. How exactly does one form a team of professionals when a particular set of skills is needed? And how in the world do you compensate them?

Practical Desktop

Practical Desktop appears to be a simple timekeeping application, though in reality it’s an open source widget framework that allows pretty much anyone to build a deployable block of functionality that can start interacting with other widgets. The wrapper’s there for you, go nuts. The source is here

From a personal perspective, I use it as a beta and explorative sandbox, because there are a lot of interesting things coming out in the near future that I’d like to offer some guidance on development best practice, and to do so I will have to figure it out myself first. Rest assured that the widgets I build will be functionally complete, though perhaps limited in feature support.

Pandora

The Pandora Desktop application is really just a customized webkit browser that’s hardwired to the Pandora mini player. I’ve fixed the application so minimization works in Windows, and expanded it to include the player’s html wrapper as well. The reason I did this is because Pandora’s a free service, and I’d like to make sure that I’m not ripping them off by stripping out the ads. Optimally I’d like to help them convert their existing player to AIR, but until I have free time (or they pay me ) that won’t happen.

• Ant
  Ant macros, includes and libs
• Libraries
  The new home of the practicalflash libraries, refactored to match the Flex 3 project layout
• PandoraDesktop
  The Pandora Desktop application
• PracticalDesktop
  The Practical Desktop utility widget framework application and timekeeper
• Tools
  Miscellaneous non-actionscript tools and utilities
• build.xml
  The unified build script

Now, I’m not a big fan of Pandora. Don’t get me wrong, I love what they’re doing and have found some phenomenal music there, but the fact that I always have to keep a browser window open to make use of their service has kindof annoyed me, and now was no different. I could deal with it though for the sake of productivity…. until I realized that AIR came with its own embedded WebKit browser.

Two beers and some experimentation later (apparently Webkit doesn’t like running on a transparent window), I am now sitting on an application I shall dub “PandorAIR”, because it’s an AIR port of Pandora. There’s not much to it- there doesn’t have to be- but for what it’s worth it’s a clean little application that I’m fairly certain others would be interested in adopting. You will need to download and install the AIR runtime environment first, but once you’re done with that you’re golden. I’ll work on putting an Installer Badge here as soon as I have the time.

Note that during the install it’s going to complain at you twice: Once because this application isn’t digitally signed, and once because AIR requests unrestricted access to your desktop. To fix the former… well, if you have a spare THAWTE certificate lying around I’d be grateful: that will uniquely identify myself as the distributor. As for the latter, well, I’m afraid you’re just going to have to take my word that I’m not trying to do nefarious things to your desktop (given that my professional credibility hinges on it, that should be easy).

Caveat: It’s a bit of a memory Hog- 60MB. Trying to figure out how to fix that.

What it really means is the following:

Removing restrictions on use of the SWF and FLV/F4V specifications

This was more of a licensing restriction if I’m not mistaken, meaning any device manufacturer can now make use of these formats. In practice you might see native (or embedded) implementations of .swf or .flv, including, say, your Tivo, Streaming Video on your XBox, PSP, Nokia, etc etc etc.

Publishing the device porting layer APIs for Adobe Flash Player

Flash Player has been annoying to push to other devices, largely because of the ridiculous number of handhelds that are out there. Getting it working for so many devices has been, quite simply, impractical, so instead they’ve opened up the lower level device calls of the flash player so anyone can port their own.

This particular one I find the most compelling, because of the names that are notably not on the list of partners: Google, Apple and Microsoft. Whether they are still in talks with these companies or not I honestly don’t know, but given that between the iPhone, Google Android and Windows Mobile they have significant sway in the device industry, not having them on the list seems a little odd. Mind you, everyone else is on that list, so I’m wondering if Adobe’s trying to use the community to strongarm those three into adopting their runtime. Consider consumer A, who sees all kind of neat Flash/AIR apps on other devices, but doesn’t see them on his iPhone or his Windows Mobile device. Is he more likely to move? Would someone else be less likely to leave? I don’t know, but the strategic play by play will be very interesting to watch.

Publishing the Adobe Flash® Cast™ protocol and the AMF protocol for robust data services

We’ve heard rumors about this, but having these protocols public and formally supported by Adobe (rather than reverse engineered by the community) is a pretty big deal. Open projects like BlazeDS, AMFPHP and WebOrb can now support the entire protocol layers, and I think we’ll soon see live video streaming options for all of those platforms.

Removing licensing fees – making next major releases of Adobe Flash Player and Adobe AIR for devices free

Up until recently, Flash for a handheld device cost money. Soon, it won’t. There’s not much to this other than removal of the barriers to adoption for the consumer, and many handheld devices may come with the flash player pre-installed.

As a result I was practically giddy when I recognized a real world example of Judo Economics, a situation where a player uses the strength of their opponent against them. Consider a simple case: There exist two markets for a single product and two companies that can produce said product. The first market is large, however serving it comes with a high cost and therefore a low margin. The second market is small, but serving it is cheap and therefore comes with a high margin. The first of the companies must serve both markets, has deep pockets, while the second is considering market entry, but can only serve one of the two. Each company can only set one price against both markets. The question posed is: What will happen?

The answer is as follows: The entrant will enter the smaller, more profitable market and undercut the larger company to the point where the larger company would suffer a net loss by matching their price. Why? Well, without drawing the decision tree it turns out that net profit for the system will be larger for the big company because the entrant can continue to undercut it until the margin in the smaller market disappears entirely. Quite simply, they cannot match the entrant because they are forced to serve the both markets. Ergo: Their strength is used against them.

The Real World

Now lets take this example to the real world: Microsoft is currently serving the vast majority of the desktop market. In fact, it’s difficult to imagine a desktop computer that doesn’t run Windows, and even in the laptop market they command a substantial segment. Microsoft has gone to great lengths to solidify their position within that market, releasing their own languages, developer toolkits, IDE’s and whatnot. Buy Microsoft, by Microsoft, for Microsoft, anything you want to do on a computer you can do with Microsoft.

Unfortunately, by winning the war for the desktop market they’ve now locked themselves into serving it, and as any marketer knows you can’t really segment a market that size perfectly, at least not without severely diluting your brand. At most we’ve seen three versions of Windows, usually targeted at the Office User, the Power User, and the Home User. From both a product management perspective and from a branding perspective they’re pushing the limit of how many versions of windows they can support, especially if you take into account all the legacy versions still in circulation.

The number of versions actually doesn’t really matter- what matters is that Microsoft has to charge a price that the majority of said segment is willing to pay while at the same time accommodating for the development cost of meeting the needs of the entire market. Some consumers might be willing to pay more than they’re charging, others less, and the end result is that the margins average out to something marginally profitable.

The Competition

This is where the case for Judo Economics begins to take shape. Microsoft in the late 90’s and early 00’s could serve the entire market and did so, winning a dominant position. Since then the competition has identified users’ specialized needs and focused on them, effectively fragmenting the formerly homogenous user base of computer users into smaller segments: gamers, office workers, mobile computing, social networking, online productivity and so forth. They’ve each chosen their target market segment, have specialized their product offering for that particular segment, and are reaping the benefits of customers who are willing to pay more for a more specialized offering.

In the meantime, Mr. Gates still has to serve everyone else. The long and short is all the geeks who were angry about Microsoft’s antitrust practices vis-a-vis netscape and IE/browser integration/exclusion should have been cheering them on. A monolithic operating system and environment cannot be truly customized to the individual anymore, and they incur the massive cost of having to develop not only all the functionality they’ve supported up until now, but any new features that are identified in the market. In the world of the Long Tail their ability to meet all of a users general needs rather than all of a users’ specialized needs puts them at a significant disadvantage which their competition is busily exploiting.

So who are the competition?

Adobe: You might not think of Adobe as much of a competitor to Microsoft, however the recent introduction of Silverlight shows this is an area that Microsoft has identified as profitable (they’re good at identifying opportunity, I’ll give them that). Unfortunately Adobe has a lock on the real driving force behind the online experience: Designers. As long as they continue to focus on supporting them, the decisions of what technology to use will remain firmly in their court. Yes, purely technically designed websites and RIA’s will likely fall to Microsoft, but quite frankly I don’t think Adobe cares about serving the online accountant.

Apple: In 1999, the book on this fight seemed to have been written. Apple soundly lost the battle for the desktop, and was classified even lower than Linux, a computing platform for rabid advocates that would eventually follow the Amiga into obscurity. And now where are they? Apple is sexy. Apple is hip. Apple is targeted at a consumer segment that is affluent and to some extent image conscious, taking those users away from Microsoft. All those fat margins that could have been earned by Bill are now wandering off to the upmarket offerings provided by Apple, who doesn’t ever want to be in the position of having to serve everyone… or do they? (more on this in another post).

Nintendo: The XBox 360 is everywhere, Halo was a huge deal. We know that Microsoft was succesful here, and will continue to be so for the forseeable future. Yet this market shows some of the same signs as Apple’s position in the Desktop and Laptop market, because the XBox has become a commodity- everybody has one. Everyone does not have a Wii, and the speed at which they fly off the shelves shows a level of demand much like that of the iPod. The Wii is cool, while the XBox has become the console equivalent of a beige box. How this will play out in the long run is hard to say at this time, however given Redmond’s recent strategic moves into community gaming I feel they won’t give up their share so readily.

Google: It’s hard not to mention Google here, and even though I think they’ve jumped the shark and will lose their innovative edge in the very near future, their dominance in the search market is too big to ignore (just look at the Yahoo hostile takeover- Microsoft’s not ignoring them). Here we once again have a company that has to do everything: browser, search, ads, etc, competing with a company that’s just really, really good at one or two of those. Guess which one is dominant? I thought so.

So that’s the argument in a nutshell: Microsoft has to serve the entire market, and as a result is too crippled to actually compete for the plumb market shares. Looking forward we can already see them becoming more aware of their situation though: The next version of windows is supposedly modular and thus more customizable to individuals’ needs. They are attempting to acquire Yahoo, and opening up the XBox for community developers is a dangerously O.P.E.N. tactic. I’m calling the score tied, lets see what happens in round three.

One of my many and varied tools from my localization sandbox, the StringsProxy is a generic object proxy container intended to simplify the management of large sets of application strings with little investment from the developer. It’s effectively an implementation of the Proxy object that includes propertyChange event dispatching so that Data Binding works properly.