Andrew Powell

There are only two weeks until FlexCamp Miami.  Are you registered?

Brian Rinaldi recently did an interview with me to help promote FlexCamp Miami.  Click here to read it, then go and register for FlexCamp today.  

During the move to my new hosting provider, Slicehost, I hosed the Weight Watchers Mobile Point Calculator.  Well, it's fixed and there are two versions, one that should work on the iPhone and one that should work on WML browsers (regular cell phones). 

It should auto-detect your device type and send you to the appropriate application, but if not here are the links:

Mobile Point Calculator:  http://www.infoaccelerator.net/wwCalc/wap.cfm

iPhone Compatible Mobile Point Calculator:  http://www.infoaccelerator.net/wwCalc/

Spring has been, is, and will continue to be the easiest way to deploy enterprise class services with your Java applications.  There is a common pattern to the way Spring lets you expose your beans as services.  What this means is that the methodology for exporting a bean as a Hessian service, a Burlap service, a WebService, or now, an AMF Service (via BlazeDS) is consistent.  This consistency is what BlazeDS needed to be accepted into the Spring world.

Until the release of the Spring / BlazeDS integration by Spring Source, Spring has always been a bit of an interloper when it comes to BlazeDS.  Sure, Jeff Vroom's SpringFactory has served many of us well for a long time, but it was always something extra that had to be added on to the BlazeDS configuration.   To make it work, the services-config.xml file had to be modified and you had to specify special properties within the remoting destinations of remoting-config.xml.  It was a lot of steps to make something that makes things simple work with BlazeDS. 

Using the Spring/BlazeDS integration, it is no longer necessary to touch anything in the services-config.xml (unless you're changing the channels) or the remoting-config.xml files.  It just works out of the box by exporting your spring beans just as you would for any other remote services.  This consistent methodology will make it easier for teams to choose to use BlazeDS, and in turn, Flex for projects.   It means that teams will get the benefit of AMF with, possibly, no refactoring of the service layer.  All one would need to do is generate the AS classes to match the resulting datatypes (XDoclet can help a ton here) and you're done with the middle tier.  This allows for more development time to be focused on the Flex layer instead of being mired in getting the middle tier setup.  

By becoming more like other remoting methodologies in Spring, it appears that AMF and BlazeDS are ready to become prime-time players.

Recently, I've been playing around with ideas of how to improve site performance.  One of the things we've done in the past, to improve performance, is move all static content to a separate server, on the same network, so that your application server (ColdFusion, etc) is focused on only processing your application pages.  All static content is served from the "static" server and can be configured with things like content expiration and caching to help speed up site loading.  Recently, however, Amazon has made great strides with their Simple Storage Solution (S3) platform.  More directly, they have introduced CloudFront which can distribute your content to their edge servers from a S3 bucket.  What does this really mean for you?  Well, much like Akamai, CloudFront makes sure that your users are pulling the content from the server that is closest to them.  CloudFront uses the following edge locations:

United States

• Ashburn, VA
• Dallas/Fort Worth, TX
• Los Angeles, CA
• Miami, FL
• Newark, NJ
• Palo Alto, CA
• Seattle, WA
• St. Louis, MO

Europe

• Amsterdam
• Frankfurt
• Dublin
• London

Asia

• Hong Kong
• Tokyo

So, no matter where your users are, there is probably a CloudFront location near them, which means faster content delivery.

Getting your content up on CloudFront is pretty easy too.  You can use the Manager For Amazon CloudFront to help you create CloudFront distributions from your S3 buckets.  Just a note, there are CloudFront limits you to 1,000 Mb per second of transfer and 1,000 GET requests per second.  If you expect your application to go over that, then you've got a pretty popular application, but Amazon can accommodate you.  

So, what is the difference between S3 and CloudFront?  S3 sets you up in one of two locations:  United States or Europe.  CloudFront distributes your content to edge servers around the world.  While S3 is fast, it is not as distributed as CloudFront.  I have, recently, switched all the static assets of this site to be hosted on CloudFront.  Take a look at the activity when you load this site and you will see a dearth of images coming down from "static.infoaccelerator.net", which is my CNAME to my CloudFront distribution.  

CloudFront is a very cost effective and reliable way to help improve the performance of your web applications.  It scales itself for you, and, it costs less than a new server to deploy.  If you're looking for a low-cost, fast and reliable hosting provider for static content, go take a look at CloudFront.

Need I say more?  Want to see it in person, come to Flex Camp Miami, cf.Objective(), or 360|Flex Indy

About a year ago, it seems like parts of the ColdFusion community really took to my idea of running Spring and Hibernate inside of ColdFusion (see this link for the materials). Some people, like Joe, took the concept to heart and really ran with it. Some very cool things have been done with the concept, like Groovy integration, etc. That's all well and good, but shortly after I gave that presentation at cf.Objective() last year, I got to thinking: "If ColdFusion is just a J2EE app, why am I even using ColdFusion in this setup and not straight-up Java?".

Since that time, I've been focused on creating Flex/AIR apps with BlazeDS, Java, Hibernate, and Spring all in the mix. ColdFusion, though, still has a place in the core application stack. I've not abandoned it, totally. Why? Well, ColdFusion still easily provides services and functionality that are, quite frankly, a pain in the ass to leverage in Java, even with Spring. I have come to realize that while CFML is not the greatest application of pure OO principles and CFCs really just irritate me more than anything else (more on that in another post), it is still pretty handy for other things like:

• PDF functionality
• Exchange Server integration
• Image Manipulation
• Presentation Generation
• Report Writing
• Email Services

Granted, there are some things on that list that Spring makes easier than Java without Spring, but at the end of the day, it's still not as simple as doing it with CFML. That being said, I try to keep all of my data persistence, and other business logic within my Java app, but at the same time, make ColdFusion available to Flex (via AMF) for those "special services". At the end of the day, it's not a matter of building your application in ColdFusion vs. building your application in Java, it's simply finding the balance of what works best from both environments.

I'm not anti-ColdFusion in anyway, nor is ColdFusion "dead", like some have suggested. ColdFusion's role in the modern web application stack has just changed, for me. Adobe makes it possible for you to use ColdFusion as your only platform, but also enables you to use it as a provider of specialized services to your application. I don't like to think that I am only limited to ColdFusion as my application platform. I like to think of ColdFusion as another piece of the total puzzle for my solutions. It's just not the same piece it was for me 18 months ago.

Register For cf.Objective()

The past two years, I have spoken at cf.Objective() on mostly ColdFusion topics with a little JavaEE and AJAX thrown in for good measure.  This year however, is different.  I'm going to be speaking on a topic near and dear to my heart:  Merapi.  For those of you who don't know, Merapi is a bridge that lets you talk to Java applications running on the desktop via AIR or Flex.  These presentations aren't really slide heavy, but they're very demo heavy.  So, if you want to see, amongst other things, JoJo the Merapi robot, come to this session.  Other demos I will show include:

• AIR & GPS
• AIR & RFID
• AIR & MS Office
• AIR & Hibernate
• AIR & Text To Speech
• AIR & Translation Engine

Register For cf.Objective()

Flex Camp Miami, that is.  Yeah, I know it's all Miami Vice'd up on the site, but I couldn't help using the awful Will Smith reference.

Register Now

I will be speaking at Flex Camp Miami on March 6th, 2009, along with a list of other, better known, names.  This really isn't so much a Flex 101 type event as they have been in the past, but will touch on a wide array of skill-levels and give you a good feel as to what you can do with Flex and AIR.  Among the speakers slated, other than myself, are:

• David Tucker
• Maxim Porges
• Brian LeGros
• Laura Arguello

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.