Andrew Powell

If you're an Atlanta area (or even Macon / Augusta / Chattanooga area) developer and want to learn more about how a developer sees user experience design, make sure you come to the Atlanta Flex User Group meeting tomorrow.  I will be giving my presentation:

It's guaranteed to make you laugh, cry, or angry.  I'd like to say it's entertaining, but that's just a bit more shameless self-promotion than I'm willing to do (at this time).  I think that this presentation is well suited to any type of developer (not just Flex) that wants to learn more about what exactly user experience design is.  I've heard, even Sledge Hammer! might be making an appearance.  

As many of you know, Universal Mind grew from the ashes of Macromedia Consulting.  At the time, there was no talk of Web 2.0, Flex, or anything like that.  We grew our business on ColdFusion.  ColdFusion is in our DNA.  It's always been a part of what we do, but lately I've heard rumblings from the community that Universal Mind has abandoned ColdFusion.  Nothing could be further from the truth.  

While people have been saying that Universal Mind has left ColdFusion behind, we have been quietly building up our ColdFusion talent with some of the strongest people in the community.  Some are names you know, some are names you do not.  Chris Scott, Dan Wilson, Laura Arguello, and Dan Skaggs are just a few of the great ColdFusion developers we have working with us.  

Yes, we build RIAs.  That includes Flex, AJAX, Silverlight, and the technologies that power them, including ColdFusion and Java.  We've got some of the best Java talent around too, but that's a post for another day.  This all means that we can build not only your RIA, but the complete solution from back to front.  When it comes to building ColdFusion back-ends for your Flex application, nobody has more experience than Universal Mind.    

So despite rumors to the contrary, our ColdFusion practice is very much alive and kicking.  What do we build?  Enterprise Class Rich Internet Applications, including those powered by ColdFusion.  After all, ColdFusion is in our DNA.

In the late 1990s, Macromedia introduced us to a term that would soon become ubiquitous with the next generation of web-based applications: Rich Internet Applications, or as we know them RIAs. At some point in the latter part of this decade, say early 2008, with the emergence of the ability to use previously web based technology to deliver desktop applications (Adobe AIR, Microsoft WPF, etc.), some people declared RIA as dead. While I disagree with that assertion, I do think that the term RIA has become a bit passé, if not overexposed.

Personally, I believe that a RIA is any application, web-based or desktop, that utilizes the resources of the Internet, to enhance the user's experience and delivers that experience in a way not commonly found in traditional desktop applications. This means that RIAs, in my opinion, are not only about the application, but the experience too. In turn, this also means that the marriage of the technology and experience of the application, not just the technology is what is going to differentiate these new applications.

As we move, ever rapidly, towards the merging of desktop and web I think it serves us to take a look at the term RIA and re-think it. The Internet is now everywhere. RIAs, as we know them, exist on the desktop, on your BlackBerry, on your iPhone, in your browser, on the television, and even in the car. With this Internet ubiquity, I want to create applications that are not just focused on the Internet aspect of the application. That's a given, a commodity. I want to focus on creating compelling, immersive, and connecting experiences that make users want to come back for more. I want experiences that users accept as part of their lives, experiences that are woven into their daily lives, but are done so unobtrusively and become people's LoveMarks.

Focusing on creating applications is too shortsighted. I want to focus on creating the experiences that will, driven by technology, make people want to have these experiences and share them with others. Twitter and Facebook did not succeed because the technology was great. No, they succeeded because they created a way for people to interact with each other and share their experiences in an unobtrusive, easy to use way. Gaining user acceptance, user loyalty, and user love are what we should be aiming for with our experiences. Create that, and I assure you, you will have created something that is far beyond an RIA.

Let's start this conversation by taking a look at what defines a "mashup". A mashup is, according to wikipedia, "a mashup is a web application that combines data from more than one source into a single integrated tool". Well, that's pretty straightforward. Eventhough it's straightforward, I must contend that, like AJAX, it's nothing new. We've been doing this for years with ColdFusion, Java, and various other languages.

One of the very first ColdFusion apps I wrote combined information from a database with information from a LDAP directory. Now, I didn't call it a "mashup", it was just the application that I needed to build. ColdFusion, that tool that we all know (and most of us love), has been able to take data from multiple sources and combine them into a single integrated tool for years. So has Java via the J2EE standards, and even Microsoft has had the ability to do this for years. So why all the hoopla over mashups in the last year or so?

Mashup, the term, is brought to you by the same marketers who tried to sell you "Web 2.0" as a new buzzword. It's a term that has been coined to describe the rise of SOA as a major player in core application functionality and interoperability. Once developers got the idea that we can merge data from these disparate sources, we started to get the idea that these new types of applications, mashups, were viable as applications that can help drive business forward.

The next phase of the mashup is to combine not only data from different SOA providers, but hardware as well. Merapi is a step in this direction. With Merapi we can send data from disparate SOA sources to hardware devices and data from hardware devices into our data service providers. Hardware mashups let us move beyond what we can conceptualize in the application and go into the physical realm of hardware. It seems to me that the next generation of mashups, let's call it "Mashups 2.0", to be constant, is the marriage of existing SOA and hardware.

Are mashups a craze created by marketers? Yes. Do they have a place and a purpose? Most definitely. I have to admit, I'm much more comfortable with mashups than Web 2.0, as a term (side note: Web 2.0 is my least favorite computing term of the last ten years, but I digress), because I think mashups fosters more creativity and forces people to create new and interesting applications which may, or may not, use technologies deemed to be Web 2.0. However, do not take this to mean that mashups and Web 2.0 are mutually exclusive. Web 2.0 needs mashups to thrive in order to stay relevant. Without the mashup, Web 2.0 is just another buzzword. However, I think that mashups will be relevant long after Web 2.0 has passed us by.

Most of us use tools like Charles or Service Capture to help debug our web applications and flex applications.  They show you the AMF data going back and forth between your browser and the server.  It's all very helpful.  However, there's a little trick if you are trying to debug traffic to a local instance of a server.  Say you're running tomcat locally and are trying to debug the calls with one of these tools.  In your browser, you would put:

http://localhost:8080/mycontextroot/myapp.html

This works to test the app, but you don't see anything in your debugger tool. If you want this traffic to show up in your debugger, you need to use the following variation on the url:

http://localhost.:8080/mycontextroot/myapp.html

This will ensure that you do not bypass the proxy settings used to route your web traffic through the debugger.  

This is the first in a series of posts in which we will address the six questions posed in The Art and Science of User Experience.

One of the first questions we have to ask in the practice of creating great user experiences (UX) is "Who Is The Audience?". At first glance, this question seems to be pretty easy to answer, but as we ponder it more, it becomes one of the most difficult and essential questions to answer in designing our UX. Not every audience is the same. If you address every audience as the same, then there's a good chance your message will miss its mark.

Understanding The Audience Will Help You Understand The Requirements

The process of learning your audience is a bit time consuming and can seem to be a waste of effort, but on the technical side, it can be quite helpful. If you take the time to learn who your audience is and how they want to tell their story, then often, the gaps that inevitably exist in a requirements document can easily be filled in if you know your audience's needs. You don't need to know your audience's business and/or needs inside and out, but a good understanding will help you fill in the gaps that will come.

Even if the requirements are well defined, there is always a chance of misinterpretation on the developer's end. Knowing your intended audience steers your clear of misinterpretation and into a faster development cycle. You have less chance of the end user coming back with bugs that are of the "it doesn't work like it should" nature because you've taken the time to learn your audience and the story that is to be told. You have a firm grasp on what the goal is and can deliver that much more effectively.

Understanding The Audience Will Help You Tell The Story

This seems pretty obvious, but sometimes we need to state the obvious to get the point across. Every application tells a story of some sort. The story it tells is not always a generalized story meant for everyone. Most applications are meant for a specific audience. If you can make these applications more engaging, help touch an emotion, then you've got the makings of a great application. In Lovemarks, it is said that "emotion leads to action while reason leads to conclusions". Understanding your audience and making that emotional connection will help lead to the application's intended goal, be it a sale, a process, or what have you. That essential understanding of what the audience wants and, furthermore, what the audience needs is essential to the telling of the application's story.

If we can't understand and know our audience, then we cannot, with any sense or accuracy, compel them to experience a story that has meaning to them. Knowing thy audience is more than just a catch phrase, it's a axiom to live by when designing and developing applications. Without a knowledge and understanding of your audience's needs and goals, then your project is doomed for failure. However, if you successfully grasp these needs and reach your audience on an emotional level, you can spur them to action and make your project a success!

I updated my bookshelf page the other day.  I added 10 more books which, as an RIA developer and consultant, I find very useful.  Click through and take a look, then buy from Amazon, or your favorite book store.

My Bookshelf

It looks as if Aptana is getting closer to rolling out Jaxer with the release of their RC "B" version. Many of you may be asking: "What the hell is Jaxer?". Well, Jaxer is billed as an AJAX server. Basically, it is a server platform that gives you the ability to write your server-side code in JavaScript. Is this really what we need, another server?

Let's see a show of hands. How many of you out there in the RIA space are only JavaScript coders and know NO server-side language? Do you really want to rely on JavaScript for your server-side code? I sure don't. We have many platforms that do the server-side really well: J2EE (I'm including ColdFusion here), .NET, Ruby On Rails, PHP, etc. Why do we want to leverage JavaScript on the server? Someone please tell me the benefit. That makes about as much sense to me as the people who want to leverage AS3 in ColdFusion. At what point do you just take the plunge into a high-level language?

We already have these great server-side solutions that do their job really well. The new middle tier's job is going to be quickly and efficiently delivering data to RIAs and less and less focused on generating HTML for the browser. It's coming. Just watch. With all the solutions we have, and where the middle tier is going, Jaxer is not going to be a viable solution. It can't handle web services well, it can't handle any sort of Flex remoting, and we still don't know how it performs under load. Jaxer is, and always will be, a way for client-side developers to get their hands into the server-side of things. I think RIA developers are looking for more. Will Jaxer be able to deliver? My guess is no.

Anyone who knows me, knows that I despise the term "Web 2.0". It's not that I think it's a bad idea, I think that people get it wrong. Web 2.0 is not about the technologies, it's about the experience.

People who say that they can develop Web 2.0 applications by simply using Flex, Flash, or AJAX are not wrong, but they're not right either. These technologies are nothing new. XML is over 10 years old. Javascript is over 13 years old. The Flash player is over 12 years old (Granted, Flex is relatively younger, but it's all Flash). These things are obviously not new to the web. Why then, are people so fascinated by "Web 2.0"? Is all just marketing hype that we've fallen victim to, or is something more substantial?

While the technology itself is not new, the way that developers are leveraging these technologies to enhance the overall experience of the user is something on a level not seen before. This is where we get Rich Internet Applications (RIA). RIAs are simply user interactions and interfaces that have evolved as these technologies have matured. What we are seeing now is the fruit of over a decade of evolution of technology on the Web. The good news is that we're only at the beginning.

That being said, where do we go from here if it's all about the experience? I think that in a few years, we will see that web browsers, as we know them, will be obsolete. Technologies such as Adobe's AIR are already breaking the RIA experience out of the browser. I also really believe that the trend we're seeing now in the rise social networks is only the beginning of a group effect on application design and execution. I think we're about to reach a point (if we're not already there) where the user community defines the experience as a collective. Application design and function is already becoming much more organic and community driven. At some point we are going to see the user communities just take over and define the experience. When that happens and catches on, you can say you're Web 3.0