A large percentage of outsourced, onshore and offshore resources, are skilled in XML, Java and other Internet-based languages and development techniques, meaning their ability to tinker with and add features to 3GL/4GL applications is limited at best and that cost savings of such as model is neutralized. Adding to the conversation is the acknowledgment that more than 200 million lines of COBOL code are currently in use while another five million are being written each year. This presents a challenge given the waning number of students studying computer science and the shrinking number of experts in legacy applications.

According to Gartner, “interviews conducted with IT sourcing managers across the Gartner client base hint at what’s to come: Many have seen price hikes of 10% to 15% in certain skills during the past year.”

Still, the dwindling, expensive legacy expert community is not the only IT population that needs to be addressed.  The rise of the millennium generation should also be top of mind.  Gartner research reports: “College students and 20-somethings are heading toward IT-related work in film, music, multimedia, gaming and Internet companies” and that “students enrolling in science, technology, engineering, and mathematics — the STEM disciplines – have declined in developed countries and risen in other countries.  In the United States for instance, computer science enrollment has dropped 39% since 2002.

The costs and reduction in the workforce of experienced legacy IT professionals combined with a shrinking pool of Internet IT resources is a significant issue, but so too is it an opportunity — an opportunity to re-structure IT as a business-driven function. CIO’s, IT executives, and business leaders must identify the roles and competencies that understand how information, processes, and relationships drive business effectiveness and who can lead the development of solutions to support LOB demands. These roles include business process designers and developers, enterprise architects, information modelers, business analysts, and IT financial analysts.  While there is not an overabundance of these resources either, an IT group organized around these roles will require fewer bodies which equates to less operational overhead.  The effect of such a transition however will leave a gap in the more traditional IT roles such as application development, programming, infrastructure and services.

“In China, India and other countries, the IT curriculum attracts enrollment.  Chinese universities graduate about 500,000 IT and high-tech students every year.”  Developing countries such as China and others are quickly becoming part of the workforce solution, but as it relates to Internet-oriented technologies such as Java, .NET, XML and others. Thus, it comes back to application modernization.  There is a tremendous demand among business leaders that IT become business driven.  This requires that IT resources are more business-minded, but such a transition in resource skill set requires growing the IT department and incurring more costs, or focusing the IT organization on these skills and leveraging outsourced resources for development and programming.  To adopt that outsource model effectively however requires that applications and the architecture that supports them exist in a format familiar to that pool of outsource
resources.

Pursuance of an application modernization initiative, regardless of size or scope, is paramount to better utilization of offshore resources.

While working on an application for a client, I encountered some issues with Java’s MessageFormat. In particular, I needed to pass MessageFormat a string that contained single-quotes and curly braces that would be treated literally. This is an issue, because single-quotes and curly braces are special characters in MessageFormat land.

MessageFormat is designed to allow you to dynamically create a string based on a static pattern and a set of inputs. For example, this is from the MessageFormat JavaDoc:

 Object[] testArgs = {new Long(3), "MyDisk"};

 MessageFormat form = new MessageFormat(
     "The disk \"{1}\" contains {0} file(s).");

 System.out.println(form.format(testArgs));

 // output, with different testArgs
 output: The disk "MyDisk" contains 0 file(s).
 output: The disk "MyDisk" contains 1 file(s).
 output: The disk "MyDisk" contains 1,273 file(s).

Seems pretty straight forward. However, say you wanted to format a string that contained curly braces, such as “{ Hello {0}! I’m inside curly braces }”. Of course, to support this, MessageFormat uses single-quotes to specify strings that should be treated literally. So, naively, one might think to format

{ Hello {0}! I'm inside curly braces }

with the following output where {0} = “Joel”

{ Hello Joel! I'm inside curly braces }

We would come up with something like

'{ Hello {0}! I'm inside curly braces '}

This would work, if single-quote were an escape character like many of us are accustomed to using, for instance in regular expressions, and in Java literal strings, backslash “\” is an escape character. Of course, if single-quote were like an escape character, the above example would work and I wouldn’t be writing this post. But the single-quote isn’t an escape character.

The rules for MessageFormat escaping are most easily understood like this:

1. Strings inside single quotes are treated literally
2. Two single-quotes next to each other will be interpreted as a single single-quote, rather than an empty literal string

The understanding of single-quote as an escape character comes from the second rule. In this case, it is similar to “\\” in Java, C, Perl, etc, where to get the literal character “\” rather than an escaped string to be interpreted specially (e.g., “\n” for new line, “\u2297″ for a special Unicode character), you type the escape character twice, i.e., “\\”. However, the two single-quotes in a row are a special case, and most of the time you will use a string inside a set of single-quotes to represent a set of characters that should be ignored by the MessageFormat parser as it searches for placeholders (e.g., {0}, {1}, …).

Following these rules, to format

{ Hello {0}! I'm inside curly braces }

where {0} = “Joel”, i.e.,

{ Hello Joel! I'm inside curly braces }

We really only need to tell the parser to ignore the start and end curly braces. To do this, we will use the following pattern:

'{' Hello {0}! I'm inside curly braces '}'

And that actually works!

Now, let’s look at the problem I was trying to solve, and see if these rules can help us out. The string I was trying to format looked like this:

<label text="{ bind('dataSource=joelDS; select=text; type=ONE_WAY') }" />

I was using this string in an XModify Macro, however, such as this:

<macro:macro xmlns:macro="http://openxal.org/core/macro"
	name="addTradingTab">
	<xm:modifications xmlns:xm="http://openxal.org/core/xmodify">
		<xm:append select="id('container')">
			<label text="{ bind('dataSource={0}; select=text; type=ONE_WAY') }" />
		</xm:append>
	</xm:modifications>
</macro:macro>

Notice that the string to be appended contains a {, a }, and two ‘, all of which need to be escaped, without smothering the {0} from the parser. First lets tell the parser to ignore the first { and last }:

<macro:macro xmlns:macro="http://openxal.org/core/macro"
	name="addTradingTab">
	<xm:modifications xmlns:xm="http://openxal.org/core/xmodify">
		<xm:append select="id('container')">
			<label text="'{' bind('dataSource={0}; select=text; type=ONE_WAY') '}'" />
		</xm:append>
	</xm:modifications>
</macro:macro>

Next, lets escape the single quotes inside the parens:

<macro:macro xmlns:macro="http://openxal.org/core/macro"
	name="addTradingTab">
	<xm:modifications xmlns:xm="http://openxal.org/core/xmodify">
		<xm:append select="id('container')">
			<label text="'{' bind(''dataSource={0}; select=text; type=ONE_WAY'') '}'" />
		</xm:append>
	</xm:modifications>
</macro:macro>

We can test the above string using the MessageFormat demo provided by Sun, which runs in an applet. Entering the

<label text="'{' bind(''dataSource={0}; select=text; type=ONE_WAY'') '}'" />

line in the Pattern field, and entering “joelDS” in the 0 argument, we get:

<label text="{ bind('dataSource=joelDS; select=text; type=ONE_WAY') }" />

Wahoo, it works!

To review:

1. While MessageFormat single-quotes act like escape characters, it is much easier to think of them as a string-literal syntax
2. When in doubt, test your Macro patterns using the MessageFormat demo provided by Sun.

Here are some considerations when you want to modernize your enteprise application to Enterprise Web 2.0.

Everyone,

Last night we finally got all the pieces to the dojo.E release finished and it is now online. There is quite a few things new in this release of dojo.E. We are also now making it possible to get the dojo.E code with the IMB, EDS and Nexaweb Server right from the dojo.E site.  This is exciting because you can get started with dojo.E and IMB by download a simple zip file.

This version of dojo.E includes many new features that expand it beyond the XML UI and UI manipulation features:

• Internet Messing Bus support including interval polling, one-time sync and long-polling.  Over the previous implementation of the IMB there are tons of improvements and has been written from the ground up.  dojo.E can have a full Comet support using the Nexaweb Server.

   //create the session.
   var imbSession = new nexaweb.imb.Session();
   imbSession.createSession();

   //Subscribe to the chat topic.
   imbSession.getMessagingService().subscribe("chat", function(topic, message){
       dojo.byId("latestChat").innerHTML = message;
   });

   //publish the message.
   imbSession.getMessagingService().publish("chat", dojo.byId("chatBox").value);

• EDS support - developers can pull data out of data base and use it as a dojo data store.
• Templating - We have upgraded the templating capabilities of dojo.E.  Now macros can use dojo.string.substitute and dojox.dtl.  I got real excited about the dtl support after watching Alex show what the it could, an extra three lines of code and BAM it is integrated into dojo.E.

<dojoe.Macro id="dtlMacro" format="dojox.dtl._Templated">
  <dojoe.Include query="#contactTable" blendMode="append">
      {% for item in contacts %}
      <tr id="{{ item.firstName }}-{{ item.lastName }}">
         <th>{{ item.firstName }}</th>
         <th>{{ item.lastName }}</th>
         <th>{{ item.email }}</>
    	 <th><dijit.TitlePane title="Button" style="width:110px">
         <dijit.form.Button onclick="dojoe.macros.remove.execute(['{{ item.firstName }}-
             {{ item.lastName }}'])" label="Remove"/> </dijit.TitlePane> </th>
    </tr>
    {% endfor %}
   </append>
 </dojoe.Xmodify>

• Form Support - Adding a “form” attribute to a Marco will automatically connect the Macros execution to the form submittal.
• Mashup widgets - We now have a WebTop (think iGoogle), Fusion Charts support (Comes with the free version and easy to add the full version of the Gadgets). Tag Cloud, Iterator and an Paging Bar.
• Dynamic UI improvements - We have added dojoe.includeRequest, includeString, includeDocument that give developers a easy way to interact with HTML, dojoML or XML UI universally.
• Lots of bug fixes overs the previous release of dojo.E
• Support for both Dojo 1.1 and Dojo 1.2
• Experimental XBL processor - XBL is an great spec that makes creating reusable components; dojo.E has the ability turn an XBL document into a dojo widget.

A new version of dojo.E is online as of last night and with many improvements to the site:

• Updated Verbiage on home page. Now site talks about the things that dojo.E improves and less about XML
• Updated Hero Spot - Highlights all of the new features in the release.
• New Samples for the Mashup Widgets.
• Improved downloads tracking now tracking the exact downloads dojo.E
• Possible to download the dojo.E with Nexaweb extensions from the dojo.E site
• Updated documentation in the documents and reference area.
• Nightly builds and the dojo.E code repository is now online - http://source.nexaweb.com/projects/dojoe/

Take a look and send feedback on anything out of place. We have also launched dojo.Everywhere in an effort to get more information and feedback to more people.  Under dojo.Everywhere you can use the Google Group or subscribe to the Pownce feed to give feedback or get the latest updates.

Screencast:

Running your first dojo.E Project from Bob Buffone on Vimeo.

Bob (Buffone)

Legacy applications have architectural limitations that prohibit their ability to support large scale deployments. They often necessitate servers and technicians at each location with continuous client software maintenance and service, all creating redundant headcounts, resources and costs.

Application modernization toward an open, web architecture can address these technology limitations as they relate to the demands of globalization and will create new opportunities in terms of people and delivery. First, regarding the architectural limitations of legacy technologies, modernization toward an open, web architecture supports centralized deployments and zero-client installation which significantly lessens the need for local technicians, eliminates client software maintenance needs, and supports a reduction in hardware and infrastructure –consequently lessening energy requirements. From a pure software development perspective, adopting a loosely coupled architectural Web approach can reduce the time to execute a change request by 90 percent.

Secondly, modernization with Internet-based technology creates new methods of delivery and new ways to carve the resources pie. In terms of people, transformation toward an open, standardized application platform allows better utilization of a global workforce, especially from countries such as China and India. In terms of delivery, the lack of skilled IT resources against the demand will drive innovation and investment in new delivery models such as SaaS, IT process automation, and Internet-based service offerings that lessen reliance on human resources to resolve issues that can be solved in other ways.

I just presented a tutorial on Friday on using Direct Web Remoting, Hibernate and dojo.E.  It’s a very simple demo, but demonstrates the power of these three technologies combined to create simple, dynamic Java applications very quickly. The tutorial is available on SlideShare.

Note that there is a bug that obscures the URL for the SVN project.  The URL is http://source.nexaweb.com/svn/repos/trunk/tutorials/ajax/DWRExample/.

You can check out the project via SVN using this URL.

Also, to copy and paste the code snippets, download the document and open directly in PowerPoint. When copying and pasting, watch out for “smart quotes”. Some of the quotation characters in the PPT have been replaced with “smart quotes”, which are not recognized by XML parsers.

This will get even more exciting with the new features of DWR 3.0, which will add a RESTful layer to DWR’s remoting.  To learn more about DWR 3.0, I recommend Joe Walker’s presentation from The Ajax Experience last week.  He’s the lead developer for DWR.

Joel Barciauskas

Over the weekend the dojo.E team spent some time at the Dojo Foundation’s Boston Dojo Developer Day and then at The Ajax Experience with some cool swag in tow. For those who missed these events, we’re giving away free stickers along with a limited number of t-shirts at the dojo.E website. Hurry up, though, as supplies are limited.

Google Chrome is only about three weeks old and is already an Internet phenomenon. To sum it up, Google Chrome is all about making web browsing safer, faster, and easier. While some might see a fierce competition between Google Chrome and Mozilla Firefox, I see harmony.

Here is some background to better understand this point of view. There has been a somewhat valid belief stating that the un-typed and interpreted nature of the JavaScript language was a major limitation for building demanding client applications. Consequently, to overcome this challenge, the browser technology providers had the following two options:

1. Re-invent the language by “upgrading” the JavaScript language to a more a traditional typed and object-oriented language, such as Java or C#, allowing the runtime to just focus on running the code.
2. Re-invent the runtime by creating novels ways for the JavaScript virtual machine to parse and interpret the JavaScript code, making the language as robust and reliable as more traditional languages.

Conforming to the EcmaScript’s Harmony decision, which focuses on not reinventing [or forking] the language (i.e., not doing #1), Google and Mozilla are actually genuinely working on the same goal, which is to make the current JavaScript faster and more reliable in a completely transparent way to the web developer. So, from a language point of view, Mozilla and Google are actually in complete harmony in pursuit of the Open Web vision.

Here are a few Q&As to summarize my take on Google Chrome from a developer’s perspective.

Which one is faster?

It does not matter as long as they keep fighting it up. Google Chrome got a good PR head-start, but, Mozilla Firefox 3.1 is back in the race with TraceMonkey.

What’s the good news?

JavaScript has become a safer bet for developers. With Google, Mozilla, and Apple seriously investing in JavaScript, from applications to runtimes, developers can rest assured that the language has a bright future. I also think this will be a factor in forcing Microsoft to react aggressively, assuming it does not want to see the Internet slipping way (again).

What’s the bad news?

The caveats (and there are always some) are that developers will have yet another browser to test against and the market will have yet another browser to adopt.

So, at the end, I think that Google Chrome is a good thing for the Open Web in general, and my hope is that it will be a forcing hand to get Microsoft to update its Web strategy.

For example, given that Microsoft Internet strategy seems to be mostly focused on the plug-in front (i.e., SilverLight vs. Flash), it might be interesting for Microsoft to just re-use the Mozilla or Google JavaScript virtual machine. Why not?  Developers will be happy, and Microsoft would be able to fully focus on SilverLight and Net.

As you might have heard, harmony has been found in the ECMAScript working group ECMAScript Harmony (see also EJohn Resig’s post and thegreat Harmony podcast with Brendan Eich and Arun Ranganathan).

To sum it up, the ECMAScript, responsible for standardizing JavaScript, has had pretty intense discussions over the years about the future of the language. One side wanted to evolve JavaScript into a more typed and traditional compiled language (ECMAScript 4), while the other wanted to keep JavaScript’s dynamic nature a core feature of the language (ECMAScript 3+).

Theoretically, from a language perspective there are pros and cons for both sides. However, the bigger question was and is “what is the best direction for the web?”

To better answer this question, a quick look at the different application architecture designs would be helpful. There are two main architecture designs for client applications.

1. Client Oriented Architecture in which application logic resides on the client machine and data are loaded and synchronized from a local or remote internet destination. This approach is currently the best, if not the only, way to build desktop applications (i.e. Outlook, Photoshop and Skype). While it can also work and be useful in a web environment via plugins such as SilverLight, Java and Flash, it often finds itself at odds with standard web assets.  
2. Web Oriented Architecture in which application logic is distributed across client and server and data can be downloaded or synchronized as part of the application flow. The distributed nature of this approach requires the client runtime (i.e. browser) to have a more programmable interface (i.e. html, css, and JavaScript) than the traditional client centric approach. A unique attribute of this web architecture is the capability for the server to completely reprogram the client within an application flow. This architecture attribute is probably the single most important design concept behind the web we know today.

In the client centric approach, the benefits of having a typed and compiled language provides undeniable benefits as it facilitates client applications to fully take advantage of the local device’s resources. Platforms such as Java, .Net and others provide great versatility and client side capabilities.

For the web centric approach, dynamic languages and architecture such as html/css and JavaScript have proven to be robust and scalable design principles for internet based applications.  These include consumer sites such as YouTube, Facebook and eBay as well as enterprise mission critical applications such as SAP, Oracle Ebusiness, and SalesForce.com.

So the real debate was “do we bring the ‘client/server’ application model back to the web, or do we continue to improve the current dynamic nature of the web which allows clients and servers to fully participate in all aspect of the application?”

Luckily, a conclusion has been reached and the decision has been to keep the Web dynamic and to abandon parts of the ECMAScript 4 concepts that could have had a negative or backward impact on the dynamic nature of the web.

Some might call harmony a victory for Microsoft, who despite their SilverLight effort were lobbying to keep JavaScript more incremental and dynamic, others might say that it dismisses Adobe’s ActionScript, which was paving the way for a more a traditional object oriented language for the Web. However, the real winner is the Web as we know it today as this event ratifies its design principles and consolidate its resources for building a better and brighter future. Harmony is a great milestone for the future of the web, and in many ways it has already reinvigorated the industry interest about the web technology discussions and directions. The ECMAScript team did a fabulous job at reaching consensus and articulating the decisions in an objective and informative way.

For enterprises, this is a huge step forward as it ratifies open Web technologies and design principles as the future-proof building blocks for creating the next generation of internet enterprise applications.

Now, the next two big milestones for the web are going to be how fast Microsoft will catch-up on its JavaScript implementation, and when the web will be able to leverage the next iteration of the web markup language (HTML 5).

Note: if you are getting confused with all these names and version, Alex Russell made a nice name soup.

Just finished checking in the last of the updates (minus bug fixes) for the new Ajax IMB Client, after a week of straight coding and little else. The new version has been completely rewritten from the ground up. This coincides with Nexaweb’s upcoming release (in a month or so) of an updated version of the Ajax Client. The Ajax Client codebase will be completely updated and run over dojo 1.2. All the coding for these updates follow six principles:

• Small
• Flexible
• Fast
• Simple
• Easy
• Robust
• Add Value

Applying these rules to the IMB code produced some great improvements in both size as well as functionality. Comparing the metrics between the old codebase and the new one shows considerable improvement.

• Number of Classes - old 30 vs. New 10 - 67% savings.
• Size - old 27KB vs. New 17KB - 37% savings. I had it down to 14KB before adding in the new features.
• Complexity, if I were to measure it, would be 1/10 of the old codebase.

New Features:

The numbers tell only half the story. Developers will benefit from the simplified usage and increased functionality of the IMB codebase. Below are the features new to this version of the codebase:

1. long-polling support - This is a huge benefit over the first version’s interval-based polling. Reading a lot about Comet techniques and looking through tons of code last week, I was able to get “long-polling,” as it’s known, into the codebase. WIkipedia has a good article on Comet as does Comet Daily. Opening the “push” connection is done as follows: imbSession.getSynchronizationService().openPushConnection();
   
The great thing about long-polling is that it’s a very clean client-side implementation and works well in all the browsers. Most of the work for dealing with the complexity is done on the server-side. Our server already had all the infrastructure to handle long-polling and just needed some client-side love.
2. Server Controlled - You can specify the synchronization mechanism for the IMB using a server configuration file; when the IMB is started, the server tells the IMB Client how it should configure its synchronization service: interval-polling (interval), long-polling or nothing. Again, the server was already sending the client the right information, I just needed to read it and configure the synchronization layer. In the WEB-INF/nexaweb-client.xml file you can configure the client to start a push connection (long-polling in Ajax) or start interval polling at startup.
   
<default-session-configuration>
<configuration>
<polling-interval>2 seconds</polling-interval>
<begin-polling-on-startup>false</begin-polling-on-startup>
<establish-push-connection-on-startup>
true
</establish-push-connection-on-startup>
</configuration>
</default-session-configuration>

   The configuration can be customized for more advanced behavior such as starting a push connection for IE and a ten-minute polling interval for all other browsers.
3. Events - Developers can now manage all common events that occur in the Ajax client. This allows developers to handle session time outs, polling errors, and more.
   
dojo.connect(myIMBSession, "onSessionTimeOut", displayRestartDialog);
4. Policy based management of the transport: Nexaweb’s server infrastructure has always been a very well thought out piece of code. Developers or Administrators can control every aspect of the IMB to get just the right balance of performance and client throughput. The WEB-INF/nexaweb-client.xml file can configure how data is sent up the push connection. Originally intended to more effectively manage complex network topologies, the IMB policies allow the configuration of data pushes to the client. The following piece of XML from the nexaweb-client.xml demonstrates this capability:
   
<policy>
<configuration class="com.nexaweb.server.pushconnection.
flushpolicies.ThroughputFlushPolicy">
<flush-size>1 bytes</flush-size>
<is-stream-closed-on-flush>true</is-stream-closed-on-flush>
<measurement-period>2 seconds</measurement-period>
<minimum-throughput>500 bytes</minimum-throughput>
</configuration>
</policy>

   This tells the server to use the throughput policy, whereby data being sent up the push connection waits either 2 seconds or until the payload is 500 bytes before it’s sent to the client. Why would this be a good configuration? Maybe you know that data comes in very short bursts and want to wait until the end of the burst before sending the data. Setting the policy to 1 millis and 1 bytes would mean that the server would send the data and cut the connection for every message. Although this might send the data quicker initially, the data would be choppier. Also more resource requests would be made resulting in poor performance and higher resource consumption.
5. Robust error handling: One thing we are trying do throughout the codebase is to introduce better error handling to warn developers about issues or things that they should not do, and prevent them from happening. Below are some examples of this in the IMB code.
   • Developers can no longer start up two polling tasks
   • Can’t subscribe to a topic with the same handler twice
   • The codebase notifies developers if the session is invalid when they try to use any of the services…

Existing Features:

The IMB already had some cool features in it, which have now been recoded following the rules above to hopefully make them easier and more robust.

• Automatic request proxying: Say a developer wants to load an RSS file from digg.com - they can use the following code to do so:
  
session.getRequestService().retrieve("http://digg.com/rss/index.xml");
session.getRequestService().retrieveAsynchronously(
"http://digg.com/rss/index.xml", {
requestCompleted: function(request, response){
},
requestFailed: function(request, response){
}
});

  The IMB will detect this is as a cross-site request and proxy it via the server. This means that the client never needs to open up cross-site requests and developers can manage it from the server-side.
• Simple Resource retrieval: The IMB “RequestService” can be used to access server-side resources with either a synchronous or asynchronous connection. The API is the same as shown above, but if the resource is within the application, the IMB retrieves the resource as any other Ajax framework would.
• Automatic Resource Processing: dojo.E and the Nexaweb platform allow developers to use Xmodify syntax to change the HTML DOM or dojo Widgets. Using the following methods, developers can simplify this by telling the IMB to automatically process the results of the request:
  
session.getRequestService().retrieveAndProcess("login.jsp");
session.getRequestService().retrieveAndProcessAsynchronously("login.jsp", {
requestCompleted: function(request, response){
},
requestFailed: function(request, response){
}
});

• Pub/Sub is the metaphor for how the IMB handles its real-time messaging. Any “node” (Client or Server) within the application can subscribe to a topic and no matter where the message is published from, all subscribers receive a copy of it.
  
session.getMessagingService().subscribe("chat-with-me", {
onMessage: function(topic, message){
var div = dojo.byId("last_"+topic);
div.innerHTML = message;
}
});

  New to this version, developers can supply a function to be called when a message is received for a topic.
  
session.getMessagingService().subscribe("chat-with-me",
function(topic, message){
});
• Clustering: The IMB is fully clusterable, which gives applications unlimited scalability. The clustering has been in production deployments for fours years now and proven in large scale deployments such as Tokyo-Mitsubishi UFJ. Clustering the IMB is necessary for mission critical applications like MUFJ’s FOREX Trading Platform. When dealing with millions of dollars, messages must be delivered no matter the circumstance. Clustering removes any single point of failure in the back end, allowing machines to crash or be taken off-line without interruption to the service.

Sample Applications:

I have created two sample applications that demonstrate the functionality of the improved IMB.

• Tic-Tac-Toe - A simple, single player Tic-Tac-Toe game with the Artificial Intelligence (it’s all relative) embedded into the server. When the user moves or sends a message, the server initiates the AI to respond to the messages and moves by publishing a response message.

• IMB Dashboard - This application allows users to control every facet of the IMB functionality through a simple to use UI. To see what the new push connection does, open up two browsers and have them talk to each other by subscribing to the same topic.

That’s It:

Can’t think of anything else to mention about the new or old IMB code so I’ll end it here. Oh wait, one last thing, a sample application. Been trying to think of a cool app, something simple yet useful or at least fun for a couple minutes, but haven’t settled on one. I will create the super awesome chat application but want something a little more engaging. Any ideas, add them via the comments.

Bob (Buffone)