Chariot Solutions

Introduction to Sencha Touch

2012-01-23T18:24:00.000-05:00

Steve Smith recently looked at jQuery Mobile and Backbone using a simple application that allowed a user to track their daily exercise. I'm going to duplicate his example using Sencha Touch.

Sencha Touch is a framework for building mobile applications using HTML5, CSS3, and Javascript. This example uses the Developer Preview of Sencha Touch 2.0.

Here's what our project looks like.

A Sencha Touch application is loaded from an HTML page. The HTML loads CSS and Javascript. Sencha Touch applications typically build the UI using Javascript so the index.html is very simple.

The touch/ directory contains the Sencha Javascript and CSS from the SDK. Since this is an example, all if the application code is in one file, app.js. Larger applications will break the code up into more files and directories.

Sencha Application

Sencha Touch has a global namespace, Ext, that holds the framework and application code. The Ext.application helper function takes a configuration object where we define our application.


Ext.application({
    launch: function() {
        // define our app here
    }
});

Model

We extend Ext.data.Model to define a Model object describing our data. The data is supplied by the server in a JSON file, exercise.json. The fields in the model, match the properties in the JSON file.


Ext.define("Activity", {
    extend: "Ext.data.Model",
    fields: [
        {name: 'id', type: 'int'},
        {name: 'date', type: 'date'},    
        {name: 'type', type: 'string'},    
        {name: 'distance', type: 'string'},    
        {name: 'minutes', type: 'int'},  
        {name: 'comments', type: 'string'}
    ]
});


/* exercise.json */
[
    {
        "id":3,
        "date": "12/10/2011",
        "type": "Walk",
        "distance": "2.5 miles",
        "comments": "Shouldn't have taken the dog",
        "minutes": 45
    },
    ...
]

Store

A Store is used to load and manage data. The Activity model we created is associated with the store. We define a proxy to load the JSON data from a URL. Finally, we tell the store to automatically load the data when the store is created.


var store = Ext.create('Ext.data.Store', {
    storeId: "activityStore",
    model: "Activity",
    proxy: {
        type: 'ajax',
        url: 'exercise.json'
    },
    autoLoad: true
});

Once the store is created, we can use the Javascript console to interact with the data.

User Interface

Now we need to display the data. A NavigationView shows a navigation bar and holds the List component. The list is defined in the code using the object literal syntax. The data store we created is assigned to the list so it can display the records. The itemTmp property defines how to display each item of data. This can be a template or a string.


var view = Ext.create("Ext.NavigationView", {
    fullscreen: true,
    items: [
        {
            xtype: 'list',
            title: 'Activities',
            itemTpl: '{date} - {type}',
            store: store
        }
    ]
});

Unformatted Date

This works but the date doesn't display very well. A format can be added to the template definition. {date} in the itemTpl becomes {date:date("m/d/Y")}.


var view = Ext.create("Ext.NavigationView", {
    fullscreen: true,
    items: [
        {
            xtype: 'list',
            title: 'Activities',
            itemTpl: '{date:date("m/d/Y")} - {type}',
            store: store
        }
    ]
});

Formatted Date

Adding New Data

Let's add a button to the header to add a new row of data.


view.getNavigationBar().add({
    xtype: 'button',
    text: 'Add',
    align: 'right',
    handler: addNewRow
});

The handler property of the button defines the function that is called whenever the button is pressed. Eventually we need a form so the user can add new data. For now, let's define a function addNewRow that will create a new row and add it to the store.


var addNewRow = function() {
    // future versions should display a form for adding a record
    var fakeRecord = Ext.create('Activity', {
        date: new Date(), 
        type: 'Walk', 
        distance: '2 miles', 
        minutes: 28, 
        comments: 'Auto generated record.'
    });

    store.add(fakeRecord);
};

Now when the button is pressed a new row appears in the UI. The store notifies the list, so rows appear as records are added to the store.

Add Button

New Row

That should be enough to get you started. In future posts we'll look at features like sorting, detail views, navigation, and forms. The source code is available on github.

Spring 3.1 - Environment Profiles

2012-01-17T12:37:00.000-05:00

Spring 3.1 Environment Profiles

Profiles

Spring 3.1 now includes support for the long awaited environment aware feature called profiles. Now we can activate profiles in our application, which allows us to define beans by deployment regions, such as "dev", "qa", "production", "cloud", etc.

We also can use this feature for other purposes: defining profiles for performance testing scenarios such as "cached" or "lazyload".

Essential Tokens

Spring profiles are enabled using the case insensitive tokens spring.profiles.active or spring_profiles_active.

This token can be set as:

an Environment Variable
a JVM Property
Web Parameter
Programmatic

Spring also looks for the token, spring.profiles.default, which can be used to set the default profile(s) if none are specified with spring.profiles.active.

Grouping Beans by Profile

Spring 3.1 provides nested bean definitions, providing the ability to define beans for various environments:

<beans profiles="dev,qa">
  <bean id="dataSource" class="..."/>
  <bean id="messagingProvider" class="..."/>
</beans>

Nested <beans> must appear last in the file.
Beans that are used in all profiles are declared in the outer <beans> as we always have, such as Service classes.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="businessService"
       class="com.c...s.springthreeone.business.SimpleBusinessServiceImpl"/>

    <beans profile="dev,qa">
        <bean id="constructorBean"
          class="com.chariotsolutions.springthreeone.SimpleBean"
              c:myString="Constructor Set"/>

        <bean id="setterBean"
          class="com.chariotsolutions.springthreeone.SimpleBean">
            <property name="myString" value="Setter Set"/>
        </bean>
    </beans>

    <beans profile="prod">
        <bean id="setterBean"
          class="com.chariotsolutions.springthreeone.SimpleBean">
            <property name="myString" value="Setter Set - in Production YO!"/>
        </bean>
    </beans>
</beans>

If we put a single <bean> declaration at below any nested <beans> tags we will get the exception org.xml.sax.SAXParseException: cvc-complex-type.2.4.a: Invalid content was found starting with element 'bean'.

Multiple beans can now share the same XML "id"
In a typical scenario, we would want the DataSource bean to be called dataSource in both all profiles. Spring now allow us to create multiple beans within an XML file with the same ID providing they are defined in different <beans> sets. In other words, ID uniqueness is only enforced within each <beans> set.

Automatic Profile Discovery (Programmatic)

We can configure a class to set our profile(s) during application startup by implementing the appropriate interface. For example, we may configure an application to set different profiles based on where the application is deployed - in CloudFoundry or running as a local web application. In the web.xml file we can include an Servlet context parameter, contextInitializerClasses, to bootstrap this class:

<context-param>
  <param-name>contextInitializerClasses</param-name>
  <param-value>com.chariotsolutions.springthreeone.services.CloudApplicationContextInitializer</param-value>
</context-param>

The Initializer class

package com.chariotsolutions.springthreeone.services;

import org.cloudfoundry.runtime.env.CloudEnvironment;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;

public class CloudApplicationContextInitializer implements
  ApplicationContextInitializer<ConfigurableApplicationContext> {
    
  private static final Logger logger = LoggerFactory
    .getLogger(CloudApplicationContextInitializer.class);

  @Override
  public void initialize(ConfigurableApplicationContext applicationContext) {
    CloudEnvironment env = new CloudEnvironment();
    if (env.getInstanceInfo() != null) {
      logger.info("Application running in cloud. API '{}'",
        env.getCloudApiUri());
      applicationContext.getEnvironment().setActiveProfiles("cloud");
      applicationContext.refresh();
    } else {
      logger.info("Application running local");
      applicationContext.getEnvironment().setActiveProfiles("dev");
    }
  }
}

Annotation Support for JavaConfig

If we are are using JavaConfig to define our beans, Spring 3.1 includes the @Profile annotation for enabling bean config files by profile(s).

package com.chariotsolutions.springthreeone.configuration;

import com.chariotsolutions.springthreeone.SimpleBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
@Profile("dev")
public class AppConfig {
  @Bean
  public SimpleBean simpleBean() {
    SimpleBean simpleBean = new SimpleBean();
    simpleBean.setMyString("Ripped Pants");
    return simpleBean;
  }
}

Testing with XML Configuration

With XML configuration we can simply add the annotation @ActiveProfiles to the JUnit test class. To include multiple profiles, use the format @ActiveProfiles(profiles = {"dev", "prod"})

package com.chariotsolutions.springthreeone;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@ActiveProfiles(profiles = "dev")
public class DevBeansTest {

  @Autowired
  ApplicationContext applicationContext;

  @Test
  public void testDevBeans() {
    SimpleBean simpleBean = 
      applicationContext.getBean("constructorBean", SimpleBean.class);
    assertNotNull(simpleBean);
  }

  @Test(expected = NoSuchBeanDefinitionException.class)
  public void testProdBean() {
    SimpleBean prodBean = applicationContext.getBean("prodBean", SimpleBean.class);
    assertNull(prodBean);
  }
}

Testing with JavaConfig

JavaConfig allows us to configure Spring with or without XML configuration. If we want to test beans that are defined in a Configuration class we configure our test with the loader and classes arguments of the @ContextConfiguration annotation.

package com.chariotsolutions.springthreeone.configuration;

import com.chariotsolutions.springthreeone.SimpleBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;

import static org.junit.Assert.assertNotNull;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class, loader = AnnotationConfigContextLoader.class)
@ActiveProfiles(profiles = "dev")
public class BeanConfigTest {

  @Autowired
  SimpleBean simpleBean;

  @Test
  public void testBeanAvailablity() {
    assertNotNull(simpleBean);
  }
}

Declarative Configuration in WEB.XML

If we desire to set the configuration in WEB.XML, this can be done with parameters on ContextLoaderListener.

Application Context

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/app-config.xml</param-value>
</context-param>
<context-param>
  <param-name>spring.profiles.active</param-name>
  <param-value>DOUBLEUPMINT</param-value>
</context-param>

Log Results

DEBUG PropertySourcesPropertyResolver - Found key 'spring.profiles.active' in [servletContextInitParams] with type [String] and value 'DOUBLEUPMINT'

Environment Variable/JVM Parameter
Setting an environment variable can be done with either spring_profiles_default or spring_profiles_active. In Unix/Mac it would be export SPRING_PROFILES_DEFAULT=DEVELOPMENT for my local system.

We can also use the JVM "-D" parameter which also works with Maven when using Tomcat or Jetty plugins.

Note: Remember the tokens are NOT case sensitive and can use periods or underscores as separators. For Unix systems, you need to use the underscore, as above.

Logging of system level properties

DEBUG PropertySourcesPropertyResolver - Found key 'spring.profiles.default' in [systemProperties] with type [String] and value 'dev,default'

Summary

Now we are equipped to activate various Spring bean sets, based on profiles we define. We can use traditional, XML based configuration, or the features added to support JavaConfig originally introduced in Spring 3.0.

Philly ETE - Speaker Interview, Ken Rimple co-author of Spring Roo in Action

2012-01-12T09:26:00.000-05:00

For our first look at what’s in store for ETE 2012, we talk with our own Ken Rimple, co-author of Spring Roo in Action. Ken is Director of Education Services and is a regular co-host of Chariot’s TechCast – our monthly podcast series focusing on development and training in Spring, Rails, Scala, Hibernate, Maven and other emerging technologies in the field

Q: After last year’s tremendous following and turnout for ETE, people are really expecting this year to raise the bar. Tell us a bit about what you’ll be discussing at this year’s ETE and what people can expect from your presentation in particular.

Ken: I’ll be talking about the subject I actually wrote a book around – Spring Roo. It’s a software tool that helps people develop applications in Spring, which is a very popular Java application development platform. I’m going to talk about building Roo add-ons, which is kind of extending the features of the platform with ones that don’t exist today.

Q: So it’s all about building new features from scratch?

Ken: Exactly! For example, there are add-ons that configure different web frameworks, like Vaadin and JSF. At one point, there was an add-on for programming Flex applications [ed. note: this is currently non-functional], which are Flash-based frontends, and add-ons for other integrations to other systems.
I wrote two for the book: One to install JQuery, which is a Javascript framework, and another one that installs CoffeeScript, which is a language simplifying JavaScript. So, in my talk I’m going to go through how to write add-ons, because it’s such a new community. And I really want to boost the community’s presence so that people can start contributing to the framework.

Q: That sounds pretty impressive – it seems like Roo’s major role is to lend a real boost to the productivity developers get with Spring. With that said, how difficult is it to learn? How much of a learning curve is there for someone who traditionally programs in Java to move to Spring and then add Roo on top of that?

Ken: That’s a really good question. The thing about Spring – and let’s take a step back here to talk about some background – the thing about Java applications for about five or six years after Java became popular back in the late 90s early 00s was that there were some standard APIs for doing development and they were written by Sun.

Sun said here’s how you would do web application development, here’s how you would do business programming, etc. Those APIs were kind of limited and they had complexity issues. You ended up writing a lot of XML and extra code.

So Spring came along as a reaction to the difficulty of writing applications in Java and all the extra work we were having to do. Spring itself is a breath of fresh air for Java programmers. It levels the playing field and made it a lot easier to build applications that were easier to test and things like that. But Spring also adds its own complexity, so you shift from writing a lot of code to configuring components of a framework and ultimately writing less code.

Spring is a platform that itself is complex, but it makes your programming ultimately easier to write and understand. But to get to the point where you’re actually programming, it takes a lot more work. What Roo does is provide you a simple shell that accepts commands, and Roo does the configuration for you.

You can tell the shell to "build a web application and add a database to it" giving it simple commands to do so. It makes developing Java applications with Spring easier to get started with.

[The Roo team] are trying to give you good starting points, relatively good ways of doing things so that you can be productive right away on the Spring platform.

And the nice thing about Roo is, unlike a lot of other frameworks, it doesn’t force you to program in something different than what you’re used to. You’re still going to program in Spring, you’re still going to program in Java, so it’s just as if you were working on a Spring application or a Java application, but you’ve gotten there quicker.

Q: So basically there’s a lot less downtime with learning new classes, new syntax, etc.?

Ken: There can be. I think part of it is [that] if you’re a Spring developer, [Roo] frees you from the busywork you that have to do. I call it "doing my light work" in the book. It really takes care of repetitive tasks. But it’s not hidden from you, the code’s still there, it’s just not in your way as you’re writing your business code.
I think you still need to be aware of the platform you’re working on. So you should learn something about Spring – you can’t ignore it, because you are programming in it. But what Roo does is configure the environment and allow you to quickly create a controller, a Spring Bean, relational mappings with JPA, entities, everything you need to use for transactional programming to databases, for example. All that stuff that takes a project a week, two weeks, three weeks is done for you.

Q: That sounds like it could be really helpful for companies looking to speed up production, but with so many different layers – Roo on top of Spring on top of Java – does it make it difficult to keep everything compatible and up-to-date?

Ken: That’s a good question. Normally, Spring issues about one big release per year – but Roo is developed by a team of VMware's Spring Framework developers, and they keep Roo compatible with the latest versions of the software. Roo 1.2 uses Spring 3.1, and I understand it supports Java 7, for example.

Q: Are there any big changes that you’re excited about with these new updates?

Ken: I know that one of the major things is that Spring is starting to take into account the environment that you’re running in. You can then turn features on or off based on that environment.
For instance, in development and testing, you may want the logging and reporting turned way up so you can trace through a problem. But in production, you’re going to have that program on a server somewhere, where it’s pretty much lights out and you don’t want to fill up the disk space with lots of logging, so you will dial it back.

You could tell Spring to enable the logging only if [you are running the code] in a development environment name. That’s something that other platforms such as Ruby on Rails have had for a while and that will make it easier for Spring to play the same sort of role. I’m sure that Roo will be rolling this feature within the next few updates.

This release of Spring is also the one that officially supports the latest version of Java, so it’s making it grow up a bit more in the infrastructure it needs to remain a leader in enterprise programming solutions.

Q: So what about mobile? How do Spring and Roo fit in with the explosion of mobile applications that we’re seeing with people using apps on their phones and tablets versus in a desktop environment?

Ken: Spring and Roo can play a role in a mobile web application very easily. Of course, Spring MVC can host Javascript APIs like JQuery mobile or Sencha Touch, as can any other web application.
From the Spring infrastructure perspective, developers can serve up data back and forth to a phone in any number of formats, because it is a robust server-side infrastructure.

The challenge for Spring right now is they’ve got to find a path for what they provide to build the client side beyond just enabling Javascript frameworks and mobile web- for example iPhone apps and Android apps and how they support them.

They have an API called Spring Android that provides access to security and data from native Android applications; they also have Spring Mobile, which provides device detection, and allows users to enable a mobile or normal web application experience, but they don’t yet have in my opinion, a strong orchestrated handset or tablet strategy. They come from more of a web and server-side infrastructure play, and so the thing I want to see at ETE this year is where they are going with their mobile strategy.

Q: Sounds like you do a lot of different types of development across all platforms. What do you like most? What gets you excited?

Ken: I used to like the back-end infrastructure stuff more – like getting databases connected and such – but I’m really starting to get interested in web and mobile, mostly because it’s a new challenge for me. I’ve never been the person to write a beautiful web application. I write it so it works well [and work with web designers]. But I do think from a mobile perspective, there are a lot of toolkits you can use to put together nice, sophisticated applications and it’s more immediate.
So where do I see my focus in the next 6 months to a year? Well, I really want to spend more time on the web, web-mobile tier and even the native mobile tier with iOS and Android. That really interests me.

Q: Any advice that you’d give to people who are maybe just starting out programming in Java and who don’t know much about Spring and Roo? What would you tell someone who just wants to "jump in" and get going on the platform?

Ken: I think the best thing to do with Java [or really any] applications is to try to find sample applications that already work and plow through them. I know that it doesn’t sound exciting, but trying things more than anything else helps you learn. I think that tools like Roo can help you get started quickly. You can tell Roo to "go build me an application" and then tinker with it.

What are you going to do, burn the house down? You’re not going to break anything. I’m a firm believer in writing a lot of "throwaway" code. Get something out there, play with it, tweak a little bit of it. Try things in isolation. I think that experimentation and play is key for a developer, and if you don’t have that interest, you’re going to struggle.

You really have to put the screwdriver in the light socket and see what happens.

Ken Rimple is the Director of Education Services for Chariot Solutions. He writes about Roo and other technologies for Chariot, and also blogs about technology, photography, and music on his blog, rimple.com.

Have a question for Ken that we didn’t cover? Get in touch with us and we’ll post our answers to your questions in a follow up interview as we get closer to ETE 2012! info@chariotsolutions.com

Sign up for Philadelphia Emerging Technologies for the Enterprise by February 15 and get a special early bird rate – don’t miss out on the chance to be a part of the biggest emerging technology event on the East Coast this year.

Sorting collections with Backbone.js and jQuery Mobile

2012-01-09T09:11:00.000-05:00

In a previous post, I provided a simple example of rendering an HTML list view using Backbone.js and jQuery Mobile. The code from that example ended up rendering a list like this:

Notice that the list is presented in the order that came from the JSON.

Also, when items are added to the list, they show up at the bottom. While easy, this isn't the best. In this post, I'll add sorting to the backbone collection and make a small change to the view so that as new items are added, the list is automatically sorted.

Backbone.js makes these changes very easy. In order for a Backbone collection to be sorted, you implement a comparator method on the collection. As models are added to the collection, Backbone will make sure the sorting is maintained based on the comparator implementation. From the Backbone documentation "Comparator functions take a model and return a numeric or string value by which the model should be ordered relative to others".

We will sort our list based on the date the exercise activity occurred. Since comparators must return a number or string for sorting, we will return the time in milliseconds since 1/1/70. Our new collection definition looks like this:If we refresh our browser with the updated collection implementation, notice that the list is now sorted by date.

If we wanted it sorted descending, we would simply return the negative value of the getTime() method.

If you tried to add a new activity, you'll notice that it shows up at the end of the list. This is due to the fact that we bind a listener to the add method of the collection (line 7 below), and all this does is append the HTML to the end of the list view (line 30 below).

If you were to open a JS console in the browser and investigate the collection by entering

JSON.stringify(exercise.activities)

you would see that the collection is ordered. To fix the HTML representation of the collection all we need to do is replace the add event binding to call render. This will re-render the HTML based on the collection. We can also remove the add method in the View, as it is no longer needed. Our updated View configuration looks like this:

After refreshing the view, the list will continue to be sorted even when adding new activities. Since the code just adds an item with todays date, try typing the following in the JS console

exercise.activities.add({id:12, date:"12/01/2011", type:"Interval Run"});

This should add an item at the top of the list. Now your exercise activity will always be sorted.

The source code can be found in my git repository here. This URL will take you to the "sort" branch. The master branch represents the code from the introduction blog post found here

Introduction to Backbone.js with jQuery Mobile

2012-01-03T16:27:00.000-05:00

If you are working on a JavaScript heavy application (think jQuery Mobile, etc.), you probably will want to look at some JavaScript libraries to help add structure, consistency and convenience to your applications. One of the JavaScript libraries I've used lately is Backbone.js. To quote Backbone themselves, it provides "models with key-value binding and custom events, collections with a rich API of enumerable functions, views with declarative event handling, and connects it all to your existing application over a RESTful JSON interface.". This is really a great summary of what Backbone can provide to your application.

As an example of how to apply Backbone, I'll create a small jQuery Mobile app and use a Backbone model, collection and view to render the user interface. Through the use of Backbone's event model, the user interface will update as the model changes or new models are created.

I decided to use jQuery Mobile as the UI framework mainly because I am a mobile guy and it will provide the HTML with some reasonable style with no additional effort on my part. I know, lazy...but it works for this blog post :) Continuing on the lazy path, I will refer to jQuery Mobile as JQM from this point forward.

The following assumes you are at least a little familiar with jQuery and JQM. If not, take a look at the JQM website (http://jquerymobile.com/). They have some great documentation and even a template for creating a basic app. All of the code in this post will be available in my github repository (https://github.com/stevenpsmith/Exercise/tree/BackboneIntro).

The application we are going to make will allow a user to log exercise they have done on any given day. Please remember this is a very basic app for the sole purpose of demonstrating Backbone.js. The piece that will be developed for this post will involve pulling exercise data from a server and presenting it in a list view, a very common paradigm for mobile apps. In the end, our app will look like this:

The JSON we will be dealing with will look like this:

I like to organize my application structure a little differently than the JQM introduction shows, mainly for organizational reasons. My application structure looks like this:

All of our work will be done in index.html and app.js. In real applications I usually break down my JS files even further, but it really isn't necessary here. The list page of the application is defined within index.html. It should look like a typical JQM page definition with the only the content portion defined. We will use the Backbone View to create the list view:

If we view this in the browser, we get an empty page with an add button in the header. Since we want to populate our list view with data, we should define a Backbone model and collection in order to manipulate and store the data via JavaScript. A basic model and its collection are easily defined:

The great thing about the collection is it provides a RESTful access back to your server for data retrieval and persistence. To keep this simple, our data will be served from a static JSON file with the structure referenced earlier. Since we have no real server side in this example, we can't really save our changes anywhere but in the client's memory. But the collection will fetch the data from the server and can be used to help render our user interface. The following code will create an instance of the collection in memory, retrieve the data from the server, and parse it into a collection of models.

The exercise.initData() function can be called during initialization of the application (or wherever else might be appropriate) to load the data. Now it is time to render the view. Backbone views depend upon Underscore.js. Underscore is a utility library that includes a lot of great features, one of which is view templates. Backbone can be used with many view template frameworks (e.g. Mustache, Handlbars, etc.), but here we will stick with Underscore templates as they meet our needs. For our exercise activity items, we need a very basic template like this:

Giving the template a unique id will let us access it using typical jQuery selectors. The data driven parts of the template are surrounded by

<%= %>

As you can see in line 2, we are using the id, date, and type attributes of whatever model is supplied to the template to fill in the HTML accordingly. While the "identifier" attribute is not a real HTML attribute and not required by any of the frameworks, it would be used to determine what activity the user selected in the list so the appropriate data could be retrieved and displayed on a subsequent page.

The next step is to define the Backbone View that will render the list view. Backbone views can be defined and set up numerous ways, and the documentation does a great job explaining the options, etc. I like to define my views so that they are as self contained as possible. So, rather than allowing Backbone to create the HTML within a DIV (the default behavior), I define the appropriate properties to create a JQM list view as shown in lines 2-4 below:

From the Backbone site: "The default implementation of render is a no-op. Override this function with your code that renders the view template from model data, and updates this.el with the new HTML. A good convention is to return this at the end of render to enable chained calls". The $(this.el) refers to the containing element, in this case the ul element. There are standard attributes that are accessible from within the Backbone View including collection and model. Lines 17-20 iterate over the collection of activities, fills in the template placeholders with the data from the model, and appends the resulting HTML to the containing element.

If you need to pass arbitrary data to your view, it can be accessed via the options object as shown on line 11 of the code snippet. As mentioned earlier, I like my Backbone Views to be as self contained as possible, so I provide the containing HTML element for this view (as a jQuery object) when constructing the View instance. Line 20 sets the HTML of the containing element to the Backbone View and line 21 tells JQM to style things appropriately.

The next step is to instantiate and render the view with the appropriate collection and HTML container. Since this is the "home" page in our application, this is done after JQM initializes the page.

Now we have a list view that renders a JQM list based on data in a Backbone collection. To take advantage of the real power of Backbone models/collections, we can add listeners for changes to the collection that will update the view based on those changes. The beauty of this is the additional code to accomplish this is minimal. By adding

this.collection.bind('add', this.add, this);

to the initialize method of our Backbone View and providing an add() method.

Here we are just grabbing the list view and appending the new model to the view (and refreshing it so JQM does its magic). By adding a click handler to the "Add" button, we can test that adding a model to the collection updates the view.

There are other methods on which to bind, but this provides a quick example on how Backbone can be used to assist with view rendering and data handling in JavaScript based client applications.

The entire code base is available here. It can be deployed on any web server. For OS X, I use the built in web server, but feel free to use the server of your choice.

Spring Roo 1.2.0 released - it's growing up...

2011-12-19T11:25:00.001-05:00

On Saturday, 12/17/11, SpringSource/VMware released version 1.2.0 of Spring Roo, the Spring rapid application development platform, to the public.

There are a lot of good changes in this release to make Roo quite palatable to Enterprise developers, such as:

Multi-POM projects - now you can create web, service, database, and functional tiers and tie them all together with a parent POM. You can even scaffold web interfaces based on models from other projects.
Scaffolded service support and repository support - now, instead of using the Active Record pattern (entities contain their own persistence methods) you can write your own services and repositories. Or, let Spring scaffold them for you. As usual, all scaffolded service and repositories will automatically contain the proper base methods, but you can then extend them and add your own, or push the code in and work with it yourself.
A cleaner add-on API - the Roo team has been working toward cleaning up the add-on internals and making it more consistent. Expect more add-on developers to appear after this release, it's really a straight-forward process to develop them.
JSF support - while this is the initial version of the add-on, it is rather feature-rich. Roo supports either Oracle Mojarra or Apache MyFaces, and theming, and uses composed UIs. In some ways, developing user interfaces with JSF may be easier for newer developers. Unlike earlier efforts, though, Roo is not mounting JSF via the WebFlow integration. Scaffolding is supported, as are rich widgets via PrimeFaces (www.primefaces.org).

There is more, including enhancements to GWT and some shell usability enhancements (you can now do a OS escape with the exclamation point and a space such as roo> ! ls). We're waiting on an updated blog entry from Alan Stewart to detail everything. For now, though, you can download Roo 1.2.0 from springsource.org/spring-roo. Srini Penchikala and I have wrapped up writing chapters for Roo in Action, and are readying it for print in early April. The book covers Roo 1.2.0, and will be helpful for those just starting out. You can purchase the MEAP online at http://www.manning.com/rimple.

Ken is a writer, podcaster and trainer/mentor at Chariot Solutions. He teaches Spring, Maven, and other subjects, and you can see training courses offered by Chariot at chariotsolutions.com/education.

OpEd: Yammering about Scala, Java, and Winning

2011-12-16T01:29:00.000-05:00

This is an opinion piece that represents the views of the author, and does not represent the official stance of Chariot Solutions. But sometimes it is fun to weigh in on the news of the day.

There has been quite a dust up in the blogosphere about Yammer's decision to switch from using Scala to Java. Google "yammer switching to scala" and you'll get a sampling. You can read it for yourself, but the gist of story seems to be that Yammer, the self described "enterprise social network" e.g. private label Twitter, decided to move their development from Scala to Java. The Scala guys at Typesafe heard about this (disclosure: Chariot Solutions is a Typesafe partner), and privately asked Coda Hale, infrastructure architect at Yammer, the reasoning behind the move. Coda responded in another private-but-soon-made-public email. It is a very long and detailed email, but in summary:

"The essence of it is that the friction and complexity that
comes with using Scala instead of Java isn't offset by enough productivity
benefit or reduction of maintenance burden for it to make sense as our default
language."

Then Hale clarified the purpose of his email and Yammer clarified their official position on Scala. Yammer's decision has (re)ignited the debate over whether Scala is better or worse than Java. If you read the comments section of this blog post from Stephen Colebourne, you get the general gist but here is a sampling that I can reprint and still keep this blog "family friendly":

In favor of Scala:
Some pretty serious masochists out there at Yammer. I wonder if their investors now about it.

Not in favor of Scala:
The code and build process was a rat's nest of pain and people should avoid using scala at all costs on any commercial project where these things can become a big issue.
I've used and learned lots of different languages but can't recall anything more painful than scala. Cross compiling and maintaining c codebases with native ui on different Linux/winblows envs was easier and less traumatizing than this. It's fine for academic pursuits and personal projects but you're smoking some serious crack to try and justify it commercially.

Opinion #1: Java is winning (like Tebow not Sheen)

The biggest thing that I take away from this whole incident is that Java is winning. I don't mean Java is winning vs Scala or that Java is better than Scala. I mean that Java is, in my opinion, an aging language with many quirks, with a fairly dysfunctional governing body in the JCP, and a yet-to-be-fully-trusted new caretaker in Oracle, full of the baggage of vendor compromises which nearly ruined JEE, and faces many very strong competitors on the JVM itself like Scala, Groovy, and Clojure, and yet -- against all odds and in very Tim Tebowesque form -- is winning over highly skilled engineering shops like Yammer.

I've been a Java programmer for 10+ years and there are many things about Java that irritate me like the slew of boilerplate code that you need in every single class. But while innovation in the language itself can only go so far while still maintaining backward compatibility, innovation in the wider Java community is still thriving. Java may not be the best language out there, but the battle tested JVM runtime combined with the countless mature open source tools and frameworks make the Java ecosystem as a whole arguably the richest one on the planet.

For a while I was convinced Java was the new Cobol: a language past its prime which due to its huge popularity will never die out completely, but not on the short list of candidate languages for a green field project. Now I've changed my mind. Java has its warts but there is value in maturity, and it still can compete head to head with any language ecosystem out there.

Opinion #2: Scala is winning too

Yes, Yammer moved from Java to Scala, but they make explicitly clear that they like Scala too. It is just that Java make more sense for them and their specific business needs. Yammer was able to build an impressive high volume system with a small engineering team using Scala. One shop moving away from Scala does not constitute a trend. Scala has a relatively young ecosystem but already some very impressive open source projects like Akka. I expect the combination of Jonas Boner and Martin Odersky together in a single company to provide a real boost to Scala.

I've never used Scala on a real project but I'm in love with the syntax and what you can do with the language. I know people who use it all the time and love it as well. Scala is undeniably more complex than Java but with the complexity comes more power. Scala isn't better or worse than Java. It is just different.

Opinion #3: Polygot is hard

I really like the idea of polygot programming: pick the programming language that fits your problem space. I worked with many large clients that solve every problem with the same Java stack even when it is obviously a bad fit. But one of the things that Hale mentioned in his email was that the choice for Yammer wasn't between Scala and Java, it was between Scala/Java and Java. The context switching caused by thinking in multiple languages was a drag on the team. When you think about it, a programmer is required to know many languages just to build a basic web app using a Java stack: Java, SQL, HTML, Javascript, and CSS. Adding more languages to the mix makes things that much more complex. Then you also include build tools, language idioms, and the ecosystem of libraries and frameworks.

I work in both Java and Groovy, and I find those languages similar enough to minimize the difficulty of context switching, but I can imagine switching between diverse languages like Java and Clojure might make my head explode.

Opinion #4: Coda Hale is a humorous writer

Not everyone can write about techie stuff and make it humorous and informative. Here is a quote from his blog post that made me chuckle:

"The Scala community needs another giant blog post about ways in which someone doesn’t like Scala like I need a hole in my head, and I’d rather suck a dog’s nose dry than lend a hand to the nerd slapfights on Hacker News."

I was pleasantly surprised to find that Hale is speaking at my company's annual technology conference Philly ETE. That's one session I'll be attending.

And I might just ask him if Scala is better than Java :-)

Groovy Algorithms: Shunting Yard

2011-11-07T03:00:00.000-05:00

Groovy's sugary syntax makes coding algorithms -- dare I say it -- fun. The shunting yard algorithm, invented by Dutch computer scientist Edsger Dijkstra, is used to parse mathematical expressions. You might have picked up on this already, but computers and people think differently. We commonly use infix notation to write mathematical expressions. It is what you learned in school. For example: "3 * (2 + 3)". Makes sense to you, but it is inefficient for a computer to process. Things like operator precedent and nested parenthesis make infix rather messy. A more efficient format is postfix or Reverse Polish notation. In postfix, the operands are listed first, and then the operator. For example: "2 3 + 3 *". This eliminates the need for parenthesis, and allows you to calculate the expression using just a single stack to hold operands and intermediate results. Why didn't we learn this in school? I don't know. Why aren't we using the metric system yet? Why doesn't Siri on my iPhone understand anything I say even though it works great in the commericals? Life's little mysteries. Back to shunting yard. Here is my Groovy implementation of it.

The main class is ExpressionSolver. The computePostfix method (line 7) shows how easy it is to calculate a postfix expression with a single stack and single pass through the tokens in the expression. It delegates the work of converting from infix to postfix to the appropriately named ShuntingYardAlgorithm class (line 21).

1:  package org.jadcon.expression  
2:  def infixExpression = '5.5 + ((6 + 2) * 4) - -3 * 1.5'  
3:  def postfixExpression = '5.5 6 2 + 4 * -3 1.5 * - +'  
4:  def expectedResult = 42  
5:  assert computePostfix(postfixExpression) == expectedResult   
6:  assert computeInfix(infixExpression) == expectedResult  
7:  def computePostfix(postfixExpression) {  
8:       def stack = []  
9:       postfixExpression.split().each { token ->  
10:            if (token.isNumber()) {  
11:                 stack.add(token)  
12:            } else {  
13:                 def b = stack.pop().toBigDecimal()  
14:                 def a = stack.pop().toBigDecimal()  
15:                 stack.add(Operator.valueFrom(token).calculate(a, b))  
16:            }  
17:       }  
18:       stack.pop()  
19:  }  
20:  def computeInfix(infixExpression) {  
21:       computePostfix(ShuntingYardAlgorithm.convertToPostfix(infixExpression))  
22:  }

The ShuntingYardAlgorithm class coverts an expression from infix to postfix. It requires two stacks: an output stack and a working stack. The main logic is in the processToken method (line 14) which loops through each token. Operands go directly on the output stack. Operators and parenthesis are placed on the working stack to get correctly ordered when placed on the output stack.

1:  package org.jadcon.expression  
2:  class ShuntingYardAlgorithm {  
3:       def static convertToPostfix(infixExpression) {  
4:            def output = []  
5:            def stack = []  
6:            evenSpaceAroundParens(infixExpression).split().each { token ->  
7:                 processToken(token, output, stack)  
8:            }  
9:            while (!stack.isEmpty()) {  
10:                 output.add stack.pop()  
11:            }  
12:            output.join(' ')  
13:       }  
14:       def static processToken(token, output, stack) {  
15:            if (token.isNumber()) {  
16:                 output.add token  
17:            } else {  
18:                 switch (token) {                           
19:                      case "(":  
20:                           stack.add token  
21:                           break  
22:                      case ")":  
23:                           while (stack.last() != "(") {  
24:                                output.add stack.pop()  
25:                           }  
26:                           stack.pop() // pop the left paren and ignore it  
27:                           break  
28:                      default:  
29:                           def operator = Operator.valueFrom(token)  
30:                           while (!stack.isEmpty() &&  
31:                                     stack.last().is(Operator) &&  
32:                                     operator <= stack.last()) {  
33:                                output.add stack.pop()  
34:                           }  
35:                           stack.add operator  
36:                 }  
37:            }  
38:       }  
39:       def static evenSpaceAroundParens(string) {  
40:            def output = []  
41:            string.each { letter ->  
42:                 if (!output.isEmpty() && letter != ' ') {  
43:                      def last = output.last()  
44:                      if (isParen(letter) && last != ' ') {  
45:                           output.add ' '  
46:                      } else if (isParen(last)) {   
47:                           output.add ' '  
48:                      }  
49:                 }  
50:                 output.add letter  
51:            }  
52:            output.join()  
53:       }  
54:       def static isParen(letter) {  
55:            letter == '(' || letter == ')'  
56:       }  
57:  }

The final class is Operator which is an enumeration of operators. Groovy makes this code pretty tight using closures. Even threw in a spaceship comparison operator for good measure (line 24).

1:  package org.jadcon.expression  
2:  enum Operator {  
3:       PLUS('+', 0, { a, b -> a + b }),   
4:       MINUS('-', 0, { a, b -> a - b }),   
5:       MULTIPLY('*', 1, { a, b -> a * b }),   
6:       DIVIDE('/', 1, { a, b -> a / b })  
7:       String value  
8:       int precedence  
9:       Closure calculate  
10:       private Operator(String value, int precedence, Closure calculate) {  
11:            this.value = value  
12:            this.precedence = precedence  
13:            this.calculate = calculate  
14:       }  
15:       def static valueFrom(string) {  
16:            for (operator in Operator.values()) {  
17:                 if (operator.value == string) {  
18:                      return operator  
19:                 }  
20:            }  
21:            throw new IllegalArgumentException("invalid operator ${string}")  
22:       }  
23:       def int compareTo(other) {  
24:            precedence <=> other.precedence       
25:       }  
26:       def String toString() {  
27:            value  
28:       }  
29:  }

Coding the shunting yard algorithm was fun exercise in Groovyness.

Spring Roo 1.2 will be tipping point for RAD Java

2011-10-26T15:38:00.000-04:00

I'm going to make a bold statement: Spring Roo is about to do for Spring developers what Ruby on Rails did for Ruby developers - make developer agility, and not mechanical, rigid architectural structures, the focus of daily developer productivity.

There. I've said it. But I have to step back for a minute and disclaim a few things. First, as some of you may know I've been working with Spring and Spring-related projects for a while. I'm also the education director here at Chariot, and Spring has been a mainstay of many of our Java-based consulting projects and course materials - we're also VMware Training Partner. Finally, I'm an author on Spring Roo in Action by Manning, which is undergoing the transformation from draft to publication by early 2012.

With the disclaimers aside, let's dig into my treatise. First, a bit about what, exactly, Roo is...

Roo in a nutshell

Roo is a developer productivity tool that uses a simple command-line shell to configure projects, install features, and create various objects such as JPA entities, controllers, services, repositories, and tests. Conceptually, it is similar to Rails, Grails, or even JBoss Seam, in that you use it to bootstrap a project.

Unlike these other frameworks, which lean heavily on dynamically generated code, Roo is a compile-time framework - no "Roo Runtime" exists to interpret your code. The shell adjusts your code and configuration, based on changes made to annotations in source code (either by the Roo shell, or by the developer). Roo even generates setters, getters, JPA code, transaction logic, scaffolded controller views, and a lot more.

Here is a typical Roo JPA entity:

@RooJavaBean
@RooToString
@RooActiveRecord
public class Employee {

  @Max(length = 20)
  private String firstName;

  @NotNull
  @Max(length = 30)
  private String lastName;
}

You may be saying "where are the getters, setters, IDs, constructors? Isn't this just another strange "hide my code in some unaccessible place" framework?

Well, yes, and no. It turns out that when you create this entity (via a set of Roo shell commands or just by saving it in the source directory structure), Roo generates some special files, known technically as Aspect-J Inter-Type Declarations, or informally as mix-ins. These files contain the boilerplate methods, such as setters and getters, JPA code, the default primary keys and versioning, even a default toString() method.

You can use this entity directly from a controller or Spring bean:

Employee e = new Employee();
e.setFirstName("Joe");
e.setLastName("Smith");
e.persist();

As an aside, the @ActiveRecord annotation generated our persist() method. It also generated others, such as getEmployee(Long id), update(), and delete() to name a few... That's the Active Record pattern at work.

Is that all it can do?

No, Roo isn't just a persistence layer development tool. Roo is also a development productivity platform. Every feature in Roo is implemented as an add-on - there are pre-installed add-ons to set up Spring MVC, GWT, MongoDB, various JPA containers such as Hibernate, OpenJPA and EclipseLink, text searching with Solr, JMS with ActiveMQ, Email, Selenium integration tests, and a lot more.

The real power of Roo will come when developers begin embracing and writing their own add-ons. Since they install in the shell itself, you can essentially provide pre-configured versions of the Roo environment for your developer team, and give them all the same, consistent productivity tools.

So, that's Roo in a nutshell. But here's what I think is going to make the upcoming version a break-out tool for 2012.

Spring 3.x is dominant

For all the JavaOne bombast, let's face it : a large number of developers are using Spring to get things done. Why? Because it simplifies every day development tasks. Spring makes things [replace next word with your favorite explitive] stink less. If you've ever needed to write JDBC code, you know the Roo Jdbc Template is a godsend. Spring MVC has gotten so flexible and powerful that it's trivial to expose RESTful web services and MVC forms. And with projects like Spring Integration and Batch, both also open source efforts, you can wire in service-based architectures, messaging and batch operations without paying tens of thousands of dollars just for a single CPU license.

Spring projects are Open Source

Just like Ruby on Rails, Spring is an open source platform. Even Spring Integration source code can be downloaded and reviewed. Except a few sub-projects, such as the monitoring core of Spring tc Server, you can debug right into source on just about anything. Spring Roo is yet another project by this team. They put Roo on GitHub (github.com/springsource/spring-roo) and have a public JIRA and forum.

But Spring moves complexity to configuration, right?

Ah, good thinking. If you've done anything with a significantly complex Spring application, you'll see those configuration files, the setup of frameworks such as Spring MVC, Web Flow, JMS, and others, as tasks you'd rather not do. Sure, Spring has evolved over the past decade - from just XML to annotation-driven bean definitions and auto-wiring, to the new JavaConfig feature, which allows you to specify configuration in Java classes.

This is the Spring adoption price of entry. We've got to configure Spring to do what we want. Inexperienced Spring developers have quite a time learning the ropes. And the Java EE community, with tools like TomEE that do Java EE out of the box require zero configuration.

So, Java EE to the rescue?

Well, yes and no... Java EE has evolved. Now you can install a Java EE application into a web profile container and be off and running - without installing or downloading additional frameworks.

However, I look at Java EE and Spring as two different philosophies - as alike and yet different as Nutella and Peanut Butter. Bear with me here...

While Java EE is a standards-based platform, with input from a wide variety of organizations, it has consistently evolved, but at a slow pace. Java EE is geared toward running on web and application servers, has specific component types, and vetted frameworks such as JPA, JSF, and the dependency injection of JSR-299. Nutella.

However, Spring, since it evolves due to developer needs, actually can adapt every 12-18 months or earlier, adding features including the JSR-250 Spring annotations, not specifying a single ORM tool or vendor, and generally abstracting and simplifying a pluggable configuration strategy. If you want to use JPA with Hibernate to start your project, then find the database is much too difficult to map, you can always switch to MyBATIS, NoSQL stores or even Spring JDBC without worry.

Likewise with web frameworks - you can start with Spring MVC, and if your team needs web workflow, give them Spring Web Flow, or if they want container-driven programming, install JSF on Web Flow or the ajaxy GWT. Even Flex clients are easy to bolt on.

Peanut Butter.

Ok, I'm completely biased, that is true. And there are others diametrically opposed to my viewpoint. They say Spring is just too complex to configure, and is a "third party framework."

Enter Roo

Roo's goal is to get configuration tasks out of your way, and remove the boilerplate code so that you can focus on getting things done. Just like any other RAD framework such as Grails, Rails, or Django, it automates the mundane.

Roo takes commands that can be bundled in a script file. Here is a sample file that creates a voting application:

 project --topLevelPackage com.springsource.vote
 
 jpa setup --provider HIBERNATE --database HYPERSONIC_PERSISTENT
 
 entity jpa --class ~.domain.Choice --testAutomatically
 field string namingChoice --notNull --sizeMin 1 --sizeMax 30
 field string description --sizeMax 80
 web mvc setup
 web mvc scaffold ~.web.ChoiceController
 
 entity jpa --class Vote --testAutomatically
 field reference choice --type Choice
 field string ip --notNull --sizeMin 7 --sizeMax 15
 field date registered --type java.util.Date --notNull --past
 web mvc scaffold ~.web.VoteController
 
 web mvc controller ~.web.PublicVoteController --preferredMapping /public
 
 web mvc language --code de
 web mvc language --code es
 
 logging setup --level WARN --package WEB
 
 security setup
 
 finder list --class ~.domain.Vote --depth 2 --filter reg,betw,IpEq
 
 logging setup --level INFO

What do we get by running this script?

A Spring MVC Web application
JPA based persistence, backed by the latest Hibernate API
Validation provided both server and client-side via the Java EE Bean Validation Framework and Dojo, respectively
Two entities, Choice and Vote, and backing form web pages for create, read, update, delete and list for each
Language support for both English and German
Spring Security

So, in short, quite a lot. And Roo has over 30 commands built in, including embedding of content such as twitter and facebook feeds, exporting JSON data from controllers, and much more. Things you'd need to spend a few hours to research now take literally minutes to install and test.

How does Roo separate the business code from the mundane?

Roo configures the project for you, as we discussed above, but it also builds business-level objects for each thing you create. Just to show you the correlation between the commands above and the objects they create, let's look at the Vote entity and the VoteController MVC controller:

Vote.java

@RooJavaBean
@RooToString
@RooDisplayString
@RooJpaActiveRecord
public class Vote {

    @ManyToOne
    private Choice choice;

    @NotNull
    @Size(min = 7, max = 15)
    private String ip;

    @NotNull
    @Past
    @Temporal(TemporalType.TIMESTAMP)
    @DateTimeFormat(style = "M-")
    private Date registered;
}

See how the Vote object doesn't have setters, getters, constructors, equals methods, or anything else that can be mechanically generated? Unlike dynamic language frameworks, Roo generates actual Java-based AspectJ files to hold these artifacts, such as:

Vote_Roo_ToString.aj
Vote_Roo_JpaEntity.aj
Vote_Roo_DisplayString.aj

Here is VoteController.java:

@RequestMapping("/votes")
@Controller
@RooWebScaffold(path = "votes", formBackingObject = Vote.class)
public class VoteController {

}

Remember, Roo then generates the real code to manage all of the CRUD operations in an Aspect-J ITD file, VoteController_Roo_Controller.aj. It also scaffolds a set of views.
When you save this file, the Roo shell will rip the method out of the Aspect, so they won't conflict. Easy, isn't it?

You are in control

Ok, you decide, you want to change the behavior of the Roo controller or forms. Maybe you want to go right back to the grid when you're done. Just pluck the method out of the ITD and put it into the class (it's not literally that simple, you'll have to convert the syntax, but close).

For example, you take the code from the controller aspect method:

@RequestMapping(value = "/{id}", method = RequestMethod.GET)
public java.lang.String VoteController.show(

                              @PathVariable("id") java.lang.Long id,

                              Model uiModel) {

    addDateTimeFormatPatterns(uiModel);
    uiModel.addAttribute("vote", Vote.findVote(id));
    uiModel.addAttribute("itemId", id);
    return "votes/show";
}

The syntax is slightly different; you have the class name prefixed to the method name, and spelled-out classes such as java.lang.String. However, with a little cleanup, you can paste this into your controller class, and modify the return value (changes bolded):

@RequestMapping(value = "/{id}", method = RequestMethod.GET)
public String show(@PathVariable("id") Long id, Model uiModel) {
    addDateTimeFormatPatterns(uiModel);
    uiModel.addAttribute("vote", Vote.findVote(id));
    uiModel.addAttribute("itemId", id);
    return "votes/list";
}

And that's it! In general, you are in control of your Java classes, Roo is in control of the Aspects. If you don't like the code in the aspects, remove the annotation (which will remove the aspect file) or push in the methods you want to customize.

On the web side, each web framework has different things you can and can't change. In Spring MVC, Roo devised a set of high level tags such as containers for various actions (create, update, list) and component tags for dates, rich text and the like. In Roo in Action I go into detail on how to customize these web pages, and even skip the scaffolding altogether and roll your own web or Ajax interface.

The Roo team listens

The Roo team is in contact with developers and is open to discussions about features. I know I've contributed a number of JIRA issues that have become new features. In that way, the team is listening to the developers and acting in their interests - they recently added service-and-repository support, so that Roo developers don't have to explain to their wincing staff architects that Roo works more magically, like a Rails application. Now those teams will get the productivity Roo brings to the table. Another big (upcoming) addition is multi-project (POM) support, so enterprise developers who have to deploy EARS or separate projects into multiple POMs can benefit as well.

The add-on API is powerful

One of the issues with writing Roo add-ons was the stability of the add-on code. Each release broke the code of the prior release. The changes I'm seeing with Roo 1.2 seem to be focused on making the add-on API more useful and perhaps more stable. I hope the team will provide easy upgrade paths, including deprecating rather than removing and renaming classes, with follow-on releases. What can you do with an add-on? Well, pretty much anything. For example:

You can manipulate files such as Spring configurations, POM files, servlet.xml, etc, thereby making it easier for them to work with a given API by setting it up for them.
You can use a built-in type parser system to generate and update the annotations and code attached to Java types (classes), thereby activating your add-on's class watcher (which can generate boilerplate code in your own Aspect-J ITDs).
You can add commands to the Roo shell, and specify a method for each command to determine whether it should be exposed (why expose web-based commands when you haven't set up your web engine yet, for example).
You can gain access to the OSGi console and stop/start other bundles, or detect if bundles are installed.

Roo is NOT a Runtime Platform

Remember, for all of the smartness involved in assembling features for the Roo shell, it's a compile-time platform that uses Aspect-J to weave code into classes at compile-time, not run-time. With SpringSource Tool Suite or IntelliJ IDEA, you can set breakpoints in Aspect-J ITDs, and debug your application in every line of code, even if generated by Roo. Since everything is compile-time, the platform is capable of being faster than typical dynamic language platforms (someone ought to run a benchmark!).

Important features coming in Roo 1.2

Up until this point in time, the goal of the Roo team has been to stabilize the Roo platform and add-on system. They've added things like a public add-on registry, support for publishing your own company-level add-ons via the OSGi OBR (OSGi Bundle Repository) protocol, and improving overall shell features and performance.So, what is on deck for Roo 1.2? Here are some highlights:

JSF support - including automatic scaffolding of JSF pages for models you specify. The JSF module seems to be using PrimeFaces at this time.
Multi-POM support - a big improvement - will contain the ability to specify POM projects, and WAR, JAR projects. An example already exists in the GitHub project page - look for multimodule.roo and see the commands to set up your own web and repository project.
Support for Spring Data APIs, which simplify CRUD-based application writing by providing (wait for it) proxy-based, generated methods using an interface you provide. This is an extremely powerful API.
Support for NoSQL databases. The MongoDB database is included in the first milestone snapshot.
Support for Spring services - these are automatically marked transactional and delegate either to Roo entity methods, or if repositories exist, delegate to the repository backing an entity.
Ability to switch between service-and-repository or Active-Record implementations of your persistence model just by switching annotations on the JPA entity.

As with other versions, pre-release upgrades may be a bit tricky - we will have to see whether Roo can upgrade a project in place. The Roo documentation provides help once a version is released.

Resources

Spring Roo project website
Manning's Spring Roo in Action, Rimple, Penchikala, Dickens, pub date est Jan 2012. MEAP available now, all chapters available in November 2011.
Spring Roo JIRA forum
Spring Roo Message Boards
Spring Roo in Action Author Forum
Twitter: @SpringRoo, @RooInAction, @TechCast (the Chariot TechCast covers Roo), and @krimple (that's me)
My Blog: I speak about a wide variety of topics, technical, musical and photography based, at rimple.com

Akka Scheduler: Actors with Heartbeats

2011-10-17T16:20:00.000-04:00

Akka is an excellent platform for writing concurrent applications using the Actor model. Chariot architect Anatoly Polinsky describes the Akka scheduler and how you can use it to create a heartbeat for an actor. From Anatoly's blog:

AKKA Scheduler: Sending Message to Actor’s Self on Start

Akka has a little scheduler written using actors. This can be convenient if you want to schedule some periodic task for maintenance or similar. It allows you to register a message that you want to be sent to a specific actor at a periodic interval.

How Does AKKA Schedule Things?

Behind the scenes, AKKA scheduler relies on “ScheduledExecutorService” from the “java.util.concurrent” package. Hence when AKKA Scheduler needs to schedule “a message sent to an actor, given a certain initial delay and interval”, it just wraps the task of sending a message in a “java.lang.Runnable”, and uses a “ScheduledExecutorService” to schedule it:

service.scheduleAtFixedRate( createSendRunnable( receiver, message, true ),
                           initialDelay,                         
                           delay,                             
                           timeUnit).asInstanceOf[ScheduledFuture[AnyRef]]

“Heartbeat” Actor

Let’s look at the example of scheduling a message that should be sent to an Actor’s “self” as the Actor on start. Why? Because it is a cool use case : )
“Heartbeat” would be an ideal example of such use case => “When a ‘Hearbeat Actor’ starts, it should start sending heartbeats with a given interval (e.g. every 2 seconds)”

Creating a Message

First we need to create a message that will be scheduled to be sent every so often. We’ll call it a “SendHeartbeat” message:

sealed trait HeartbeatMessage 
case object SendHeartbeat extends HeartbeatMessage

Read the full post at: AKKA Scheduler: Sending Message to Actor's Self on Start

PhoneGap 1.0 Android Plugin updates

2011-09-27T10:36:00.000-04:00

Kevin Griffin has been working with PhoneGap for some time now. In this new blog post, Kevin discusses new features in PhoneGap 1.0.

With the upcoming release of PhoneGap 1.0 I thought I would point out a couple of nice additions coming for PhoneGap (Android) Plugin developers (and eventually PhoneGap as a whole).
The first addition is the propagation of lifecycle events (onPause, onResume and onNewIntent) to plugins. Plugin developers are now responsible for reacting appropriately if the app has multitasking turned on, but also have access to the lifecycle of the application. Developing the NFC plugin (https://github.com/chariotsolutions/phonegap-nfc) we found this an absolute necessity, so it’s great to see it added in.
Ah the power of Open Source software :)
The second is a new method of loading plugins. To register a plugin now you just need to add your plugin name and class to the plugins.xml (located in res/xml/)

Read more...

Isobar Create 48 - A Solution to Parking Hassles Using NFC

2011-09-22T13:05:00.000-04:00

Recently, Chariot's Director of Consulting, Don Coleman, participated in the Isobar Create 48 NFC Hackathon in Boston. Below is an excerpt from his blog about his experience and his team's second place finish.

My friend Chris Bernardi invited me to join his team for the Isobar Create 48 NFC Hackathon along with April DiMartino and Marc Neuwirth. The event kicked off on Tuesday around 3 PM at Space with a Soul. Before the hackathon there were some general Near Field Communication (NFC) presentations by Isobar, Nokia and ICS. After the NFC intro, they kicked out the people who came for the presentations so we could get started.
None of us came to the hackathon with the killer application idea. We brainstormed for a while, discarding lots of half-baked ideas and ended up deciding to build an NFC solution to make parking better. We came up with a bunch of scenarios, but decided to limit our initial implementation to garages with entrance and exit gates, so it was easier to track inventory.
April does an excellent job describing our application:
The working title of the app is “I Got Your Ticket Right Here” and is best understood when said with a Brooklyn NY accent ;-) We haven’t worked out a shorter and more appropriate title for it yet. So for purposes of this I will simply refer to it as the Parking app.

Read more...

Checklists and Document Inspections

2011-09-01T11:01:00.000-04:00

John Shepard, one of our architects, blogged some interesting thoughts on what makes a document inspection. Most developers will tell you that code reviews are good, and also tell you they aren't done regularly in their organization. But John goes beyond the scope of code to reviewing other documents such as requirements and technical specifications as well.

"While there is an ongoing debate on whether or not document inspections are useful, my experience is that on larger projects, they are very useful. They help maintain a minimum level of quality and help disseminate information among team members. Rather than continuing that debate here, I'm going to provide a starting point for checklists for those who have decided to use document inspections. While the checklists do end up being different for each project, I find it helpful to have an obvious place to start."

Read the full post here.

Full-Text Search For Relational Data

2011-08-09T09:57:00.000-04:00

Thanks to internet search engines like Google, Yahoo, and Bing, everyone has become accustomed to searching their data effortlessly. Consequently, as developers of web-based applications, we increasingly find that our customers' requirements include being able to search their application's data in a "Google-like" way.

For a very small subset of applications that only need to do full-text search on a few database columns, there a some very simplistic solutions, ranging from using a SQL 'like' clause on every column to database-vendor supplied full-text search functionality for designated columns.

Frequently, however, these simplistic approaches are not enough, either because the data to be searched is large and complex, because the approach's search functionality is limited, or because database neutrality is desired. For these situations, a more advanced solution is needed. Fortunately, there are now a number of solutions available for all of the most popular platforms, languages, and frameworks, and several hosted solutions that are development stack-neutral.

Lucene and Compass
One of the most popular full-text search projects is Apache Lucene, a Java-based, open-source indexing and searching solution. Lucene itself targets indexing and searching of 'documents', but several other projects, most notably Compass, have adapted Lucene for indexing and searching relational data via integration with Object-Relational Mapping libraries such as Java's JPA, Hibernate, and others.

The combination of Lucene and Compass provides Java developers with an easy way to implement Google-like searching of their relational data, including fuzzy searching (spell-check / 'Did you mean...'), stemming ('fishing', 'fished', 'fish', and 'fisher' all match 'fish'), wildcards, and boolean logic.

For users of the Java JPA ORM, usage of Compass is fairly straightforward. For users of the Grails framework, the Grails Searchable Plugin makes implementation of full-text searching almost effortless. I recently added this plugin to a Grails application with a moderately complex data model, and had my full-text search functionality up and running in a few hours, with fine-tuning taking only a few more hours. As the application's data model has grown, very little time has had to be spent on keeping the search functionality up to date.

There are many other programming languages and platforms in use besides Java, so not surprisingly, Lucene has been ported to many of them, including C, C++, .NET, Objective-C, Python, Perl, and Ruby. The most popular of these, due to the popularity of the programming languages, are Lucene.net, which is a C# port targeted at the .NET runtime, and Ferret, which is a Ruby port targeted at the Ruby on Rails framework.

While Lucene and its variants currently dominate the open-source full-text search landscape, there are other well-known projects, including Xapian.

Hosted Solutions
There may be situations where it makes more sense move your full-text search functionality 'to the cloud'. Several hosted solutions are available, some based on Lucene or other open-source technologies, as well as other, proprietary offerings.

Websolr is a hosted version of Apache's Solr which is itself built on Lucene. Other offerings include Flying Sphinx for Rails (which uses the Sphinx search engine), and IndexTank, which is a proprietary offering.

Both Flying Sphinx and IndexTank are available as add-ons for the popular EngineYard and Heroku Ruby-based hosting platforms.

I recently tried out IndexTank on Heroku. IndexTank itself targets indexing and searching documents, but the Tanker gem does a great job of integrating IndexTank with Rails' ActiveRecord ORM. IndexTank's documentation doesn't mention it, and while not available "out of the box", IndexTank does support both fuzzy searching and stemming. All you need to do is send an email to their customer support address, and ask to have it turned on.

If your application can benefit from full-text search, there are plenty of interesting choices, regardless of your platform or programming language.

Groovy Script to Tame Gmail Attachments

2011-08-03T14:09:00.001-04:00

I like Gmail but it has a big short coming: you can't sort mail by attachment size. This means that if you are running out of space in your Gmail account, you can't easily find large attachments like that 25MB video that your friend sent you of his kid's graduation or other large attachment that you really would like to get rid of. There are sites like findbigmail.com that will help you find large attachments, but the downside is that you have to trust them and allow them to read all of your email. I'm a little paranoid so that wasn't something I was willing to do.

I also like Groovy and so I wrote a little Groovy script that finds large attachments in Gmail and gives them a custom label so you can easily find them. The script uses JavaMail which depends on the JavaBeans Activation Framework (activation.jar). Both jars need to be in the classpath along with the Groovy jar.

The first part of the code makes a connection to Gmail.

import javax.mail.*
import java.util.Properties
def emailAddress = "you@gmail.com"
def password = "password"
def server = "imap.gmail.com"
def port = 993
def OneMB = 1024000
def FiveMB = 5120000
def props = new Properties()
props.setProperty("mail.store.protocol", "imaps")
props.setProperty("mail.imaps.host", server)
props.setProperty("mail.imaps.port", port.toString())
def session = Session.getDefaultInstance(props,null)
def store = session.getStore("imaps")
store.connect(emailAddress, password)
println "connected to Gmail"

Then we define the labels that we want to add. Labels in Gmail are called folders in JavaMail.

def bigAttachmentFolder = store.getFolder("1MB+ attachment")
if (!bigAttachmentFolder.exists()) {
   bigAttachmentFolder.create(Folder.HOLDS_MESSAGES)
}
def hugeAttachmentFolder = store.getFolder("5MB+ attachment")
if (!hugeAttachmentFolder.exists()) {
   hugeAttachmentFolder.create(Folder.HOLDS_MESSAGES)
}

Next the script iterates through all of the emails looking for attachments. If a large attachment is found, it is copied into a folder which in Gmail adds the appropriate label to it.

def folder = store.getFolder("[Gmail]/All Mail")
folder.open(Folder.READ_ONLY)
folder.messages.each { msg ->
try {
    def content = msg.content
    if (content instanceof Multipart) {
        for (i in 0..(content.count - 1)) {
            BodyPart bodyPart = content.getBodyPart(i)
            if (Part.ATTACHMENT.equalsIgnoreCase(bodyPart.disposition)
                    && bodyPart.size > OneMB) {
                println "big attachment: ${bodyPart.fileName} = ${bodyPart.size}"
                folder.copyMessages([msg] as Message[], bigAttachmentFolder);
                if (bodyPart.size > FiveMB) {
                  folder.copyMessages([msg] as Message[], hugeAttachmentFolder);
                }
            }
        }
    }
} catch (Exception ignore) {
    println "error processing message, no big deal, moving on"
}
}
println "-----------done------------"

That's it! If you modify the script with your email address and password, and then run it, your Gmail account will get 2 new labels: "1MB+ attachments" and "5MB+ attachments" that will allow you find and delete big attachments quickly. The code is pretty concise, and the JavaMail API looks better in Groovy in my opinion.

Roo In Action Corner - Testing Entity Validations With A Mock Entity

2011-07-25T11:21:00.000-04:00

This article references the Manning book Spring Roo in Action, which Ken Rimple is currently authoring. It is available as a Manning MEAP.

I've been working hard on the more advanced chapters of Roo in Action, and as part of this I've amassed some background material that didn't make it into the book. This topic, using Spring's Mock Entity support, was one of those topics that didn't get a lot of attention.
In Spring Roo in Action, Chapter 3, I discuss how Roo automatically executes the Bean Validators when persisting a live entity. However, when running unit tests, we don't have a live entity at all, nor do we have a Spring container - so how can we exercise the validation without actually hitting our Roo application and the database?

The answer is that we have to bootstrap the validation framework within the test ourselves. We can use the CourseDataOnDemand class's getNewTransientEntityName method to generate a valid, transient JPA entity. Then, we can:

Mock static entity methods, such as findById, to bring back pre-fabricated class instances of your entity
Initialize the validation engine, bootstrapping a JSR-303 bean validation framework engine, and perform validation on your entity
Set any appropriate properties to apply to a particular test condition
Initialize a test instance of the entity validator and assert the appropriate validation results are returned

The concept in action...

Given a Student entity with the following definition:

@RooEntity
@RooJavaBean
@RooToString
public class Student {
  
  @NotNull
  private String emergencyContactInfo;

  ...
}

The listing below shows a unit test method that ensures the NotNull validation fires against missing emergency contact information on the Student entity:

@Test
public void testStudentMissingEmergencyContactValidation() {
  // setup our test data
  StudentDataOnDemand dod = new StudentDataOnDemand();

  // tell the mock to expect this call 
  Student.findStudent(1L); 
  // tell the mocking API to expect a return from the prior call in the form of
  // a new student from the test data generator, dod
  AnnotationDrivenStaticEntityMockingControl.expectReturn(
     dod.getNewTransientStudent(0)); 

  // put our mock in playback mode
  AnnotationDrivenStaticEntityMockingControl.playback(); 

  // Setup the validator API in our unit test
  LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
  validator.afterPropertiesSet(); 

  // execute the call from the mock, set the emergency contact field
  // to an invalid value 
  Student student = Student.findStudent(1L);
  student.setEmergencyContactInfo(null);
  
  // execute validation, check for violations
  Set<ConstraintViolation<Student>> violations = 
    validator.validate(student, Default.class);

  // do we have one?
  Assert.assertEquals(1, violations.size());

  // now, check the constraint violations to check for our specific error
  ConstraintViolation<Student> violation = violations.iterator().next();
  
  // contains the right message?
  Assert.assertEquals("{javax.validation.constraints.NotNull.message}", 
    violation.getMessageTemplate());
   
  // from the right field?
  Assert.assertEquals("emergencyContactInfo", 
    violation.getPropertyPath().toString());
}

Analysis

The test starts with a declaration of a StudentOnDemand object, which we'll use to generate our test data. We'll get into the more advanced uses of the DataOnDemand Framework later in the chapter. For now, keep in mind that we can use this class to create an instance of an Entity, with randomly assigned, valid data. We then require that the test calls the Student.findStudent method, passing it a key of 1L. Next, we'll tell the entity mocking framework that the call should return a new transient Student instance. At this point, we've defined our static mocking behavior, so we'll put the mocking framework into playback mode.
Next, we issue the actual Student.findById(1L) call, this time storing the result as the member variable student. This call will trip the mock, which will return a new transient instance. We then set the emergencyContactInfo field to null, so that it becomes invalid, as it is annotated with a @NotNull annotation. Now we are ready to set up our bean validation framework.

We create a LocalValidatorFactoryBean instance, which will boot the Bean Validation Framework in the afterPropertiesSet() method, which is defined for any Spring Bean implementing InitializingBean. We must call this method ourselves, because Spring is not involved in our unit test. Now we're ready to run our validation and assert the proper behavior has occurred.
We call our validator's validate method, passing it the student instance and the standard Default validation group, which will trigger validation. We'll then check that we only have one validation failure, and that the message template for the error is the same as the one for the @NotNull validation. We also check to ensure that the field that caused the validation was our emergencyContactInfo field.
In our answer callback, we can launch the Bean Validation Framework, and execute the validate method against our entity. In this way, we can exercise our bean instance any way we want, and instead of persisting the entity, can perform the validation phase and exit gracefully.

Caveats...

There are a few things slightly wrong here. First of all, the Data on Demand classes actually use Spring to inject relationships to each other, which I've logged a bug against as ROO-2497. You can override the setup of the data on demand class and manually create the DoD of the referring one, which is fine. They have slated to work on this bug for Roo 1.2, so it should be fixed sometime in the next few months.
Also, realize that this is NOT easy to do, compared to writing an integration test. However, this test runs markedly faster. If you have some sophisticated logic that you've attached to a

@AssertTrue

annotation, this is the way to test it in isolation.

About this post

Did you find this post useful? Ken and Gordon both teach courses in Spring, Hibernate, Integration, Maven, Rails and more for Chariot Solutions. Visit our Education Services page for details on upcoming courses, including August's Hibernate with Spring.

The Ultimate Power of Spring Batch

2011-07-18T07:10:00.000-04:00

Chariot architect Anatoly Polinsky has created an interactive Prezi presentation about the power of Spring Batch. It is an animated blog post because Anatoly is not just a software developer, he's an artist. It is a cool way to get familiar with what Spring Batch does for you and a lot of fun to watch.

http://prezi.com/6mnfrgjuh3dp/the-ultimate-power-of-spring-batch/

Growing Up with Jenkins/Hudson, Nexus, and Sonar, Part 1

2011-07-10T21:45:00.000-04:00

In my previous post I explained why I think you should use Jenkins (or his twin Hudson), Nexus, and Sonar to super-charge your Maven builds. To summarize, Jenkins is a continuous integration server that runs your builds, Nexus is an artifact repository that versions and stores your jars/wars/zips/etc, and Sonar is a metrics server that gathers code metrics and produces nice reports to help you improve code quality. All 3 products are free OSS and really useful. But scaling anything is hard. In this post I'll talk about some of the challenges that you might face when you scale up a Jenkins infrastructure from a few builds a day to thousands of builds a day, and some tips to help overcome those challenges. In the following post, I'll cover Nexus and Sonar tips.

The Demo Went Well, But Now The Honeymoon Is Over

When you first introduce any new piece of infrastructure, your biggest challenge is generally just getting it installed and working at all. That is surprisingly easy with the Jenkins/Nexus/Sonar stack. They install easily. They have good-looking, intuitive UIs and demo really well. They play nicely together. You figure, "Setting up this CI (continuous integration) thing is a slam dunk. I'll be done by lunch." And then you introduce your beautiful new system to the users. Uhhgg. The users. Everything worked fine until they showed up and started breaking it. In this case, the users are the various development teams within your organization that want to #1 build their code with Jenkins, #2 store their artifacts in Nexus, and #3 gather code metrics with Sonar.

Jenkins runs all of your builds so obviously it requires a lot of CPU for compilation, running tests, and static code analysis. You will quickly need multiple boxes to handle the daily load of CI builds. Fortunately Jenkins has support for building a server farm quite easily by running a "master" instance that distributes builds to many "slave" instances. In practice this works very well. Some tips:

Tip 1: Partition your master/slave clusters by something logical like development organization. Don't put all of the builds on a single cluster unless you work for a very small organization. This is important for 3 reasons:

It isolates development organization from each other so you can, for instance, restart or upgrade one cluster without effecting others and keeps "problematic" development organizations isolated (you know how you are...the kind of developer who put infinite loops in your unit tests and stuff like that).

It allows you to configure security differently for each cluster which you may need to do if the groups within your company don't like each other. Hey, you're a DevOps, not a psychiatrist so just go with it.

The Jenkins UI will get very messy very quickly with hundreds of jobs to wade through. It does have filtering features, but it is still slow to render in browsers. IE, I'm looking at you.

Tip 2: Early on, come up with a strategy to automate the creation of new master and slave instances. Two good options are using a provisioning tool like Puppet or Chef, or cloning a VM. One bad option is setting things up manually from memory.

This kind of automation is important because if you are scaling up (adding more and more development teams to your infrastructure) most likely you'll end up: #1 adding more master/slave clusters, and #2 making global changes across your master/slave instances. For example, Jenkins has an awesome plugin community so it is likely you'll be finding new and useful plugins often. Say you have 5 Jenkins clusters partitioned by development organization (a good choice for partitioning). You'll have to install the plugin on all 5 master instances manually. And say you need to change something in the environment. Assume your 5 master instances each have 2 slaves also. Now you've got to make a change in 15 places. Your chances of fat-fingering a change goes way up plus who wants to do all of that typing? So get on board with the DevOps movement, and automate so your infrastructure becomes code.

Problem 1: You configure Jenkins' security permissions to allow the development teams to create / manage their own jobs. This is a problem because if you want any uniformity at all in your builds, then 500 developers all changing their jobs willy-nilly creates a mess in Jenkins. This makes any kind of global changes to Jenkins jobs using a script very difficult, and doesn't allow you to use Jenkins to do any kind of enforcement of standards or provide a software "chain-of-custody" from source repository to production which can be a very big deal in a big company. Just having standards for Jenkins job names is actually very useful, and in a "free-for-all" model no standards can be enforced.

Problem 2: The reverse. You configure Jenkins' security permissions to restrict the development teams from creating / managing their own jobs. Instead only a select number of Jenkins admins can do that task. The Jenkins admins now have new full time job which is very un-fun: manually create jobs all day.

Solution: The crux of the issue is that you want developers to be able to change some fields in a job like the source code URL to their project, but not other things like mandatory builds steps such as quality gates or auditing steps. You also probably want to prevent developers from using Jenkins' cool-but-dangerous feature of allowing a job to run arbitrary script code on the server which obviously could do all kinds of mischief. Jenkins security permissions allow you to either create / manage a job in its entirety or not at all. What you really need is to set permissions on a field by field basis.

I don't have the perfect solution for this problem. For some of you out there, the whole "Jenkins job management" problem isn't a problem at all: just let the developers own their jobs and be done with it. I was on that side of the argument for a while, but experience has beaten me to down to the realization that some controls are actually a good thing.

There are 2 solutions I can think of. One is to create a Jenkins plugin that creates a new job type that is customized to your needs. I don't really like that one.

My suggested solution is to create a simple "Jenkins job management" web application in your favorite rapid application framework (Rails, Grails, etc) that is used by developers to create jobs. This application only allows them to set the fields that are "safe" and behind the scenes does the job creation / maintenance via Jenkins easy-to-use REST API. This is the best of both worlds: self-service creation of jobs but with a measure of control.

Problem 3: The builds run really slow

Solution: There are many, many reasons why this would be true, but there are 3 things I've found helpful aside from just buying bigger hardware.

The 1st thing is to profile your build. I wrote a simple AspectJ aspect (using load time weaving) to profile Maven builds and give timings for each Maven plugin that ran. That helped break down a 45 minute build into the different steps and help explain why it was taking so long.

The 2nd thing is to take all of the build steps that can be deferred until later and process them asynchronously. A CI job needs to run compilation and it needs to run tests to provide immediate feedback. You can't defer those steps. But there are many others that you potentially can defer. For example, Maven site generation is slow. Running Sonar metrics can also be slow. So instead of running the Maven site and Sonar stuff during your build, run them asynchronously. This takes a little engineering but you are a software engineer, right? You could write a simple Jenkins plugin that puts a message in a queue after each successful build. Then have a process outside of Jenkins -- potentially on a different server -- read the queue, and run things like Maven site and Sonar. You can potentially make your builds much faster using this technique, and I've used it successfully.

The 3rd thing is to pay attention to the build time trend information that Jenkins provides, and automatically email developers if their build takes X% more than it used to. I've often see the root cause of a suddenly slower build is that a slow unit test was introduced. Fixing the test improves the build times, and it is much easier to find the offending test if you notice the slow down right away. You can get the build times via Jenkins REST API, so you can write a little script (Groovy anyone?) that is scheduled to run every night and checks the build times to provide rapid feedback if a job suddenly gets much slowers.

Problem 4: No one pays attention to failing Jenkins builds

Solution: This is a real problem. Developers face a barrage of emails daily, and sometimes the job failure email is just one more to ignore. Obviously peer pressure is the main way to make people care about failing CI jobs. There are many Jenkins plugins that provide build notification, but my personal favorite way to get people to care is to bridge the virtual world into the physical world by building a CI orb. A CI orb has both a visual representation (some kind of light -- traffic light, lava lamps, glowing orb) and an audio output ("Joel has broken the build"). Instructions for a cool one that I've personally seen can be found here. The CI orb is not just a gimmick -- it really does work. It is easy to ignore 1 or 2 failing Jenkins jobs out of 50. But it is much harder to ignore a large pulsating red orb next to your boss's cube, or your name being read on a loudspeaker. A CI orb helps your team realize the purpose of CI which is to respond to failures quickly.

In the next post, I'll give you some tips for Nexus and Sonar.

Learnings from Actor Development

2011-07-01T13:43:00.000-04:00

I spent a fair amount of time developing actor-based systems recently, specifically with the Scala Actor library. Regardless of whether you are implementing actors with the Scala library, Akka, Lift or Scalaz, some basic gotchas can present themselves until you get a feel for what you're doing. Here are some of them that I've learned the hard way.

Never Refer Directly to Other Actors
Actors are fragile and can die easily. While you typically create a supervisor with a strategy for how to recreate that actor, any other class with a direct reference to that actor that died now has an invalid reference. If you absolutely must have actors with references to others that do not have a supervisory relationship, use a proxy reference instead - if the actor behind the proxy dies, you only have to replace it in the proxy, not in every actor with that reference. Akka solves this problem nicely with ActorRef, where the reference behind it can be recreated without updating anyone holding the reference.

If You Do Have an Actor's Reference, Avoid Synchronous Method Calls Between Actors
Regardless of whether your actors are event- (shared thread pool) or thread-based (each actor has its own dedicated thread), avoid having actors make direct method calls on another actor. It introduces concurrency into classes that are designed to avoid that very situation - the receiving actor can be operating on a thread handling a mailbox message at the same time it is dealing with your call. Use blocking or future-based message sends instead, which allows the receiving actor to handle the request through its mailbox on its own thread. Not to harp on the virtues of Akka too much, but the ActorRef type also prevents this kind of behavior.

Write Business Logic in External Idempotent Functions
Testing actors is difficult, particularly those with side effects. If you are in a supervisor hierarchy, the receipt of a message may lead to the creation of child actors that have their own side effects which may be difficult to account for in a test environment. The goal of unit tests is not to test whether actor interaction works, but that the business logic that the actor performs is sound. Externalize your business logic into functions and partial functions that can be tested outside of actors, and use integration tests to prove only that the actors executing that logic behave as expected as part of an end-to-end functional test.

Beware the Thundering Herd
When you start creating structures of actors such as supervisor hierarchies, it can seem simplest to send generic messages that are passed through the tree. However, as actors react and send their own messages, this can lead to event "storms". This can be addressed using two strategies - 1) use granular messages that target specific events for specific actor instances, and 2) ignore messages of the same type with the same parameter data for a given time period. You can even implement a common trait for all of your actors that gives them the ability to not handle the same message for an externally-configurable period of time. Be judicious in how you use this, though - tune it for the loads of your system.

Garbage Collection
In the case of a supervisor hierarchy that is responsible for configuring servers in a cluster, you may want to implement garbage collecting actors that ensure that each server is pruned of configuration that it currently has but is no longer relevant. The actors in the supervisor hierarchy will take care of that if one was created to represent that particular configuration item, but if no actor already existed to represent that state, only a garbage collector whose role is specifically to clean up a dirty environment can take care of clearing bad data from the target server.

Always Pass Copies in Immutable Messages
Copy any object instance that will be passed in a message, so as to avoid accidentally sharing any state. In almost all cases, you should ensure that your messages themselves are immutable. Dean Wampler and Alex Payne make this point specifically in their book, Programming Scala. This, combined with very granular messages, can seem expensive in terms of resources. But it is worth the cost in memory and performance to ensure that your actor behavior is what you expect at design time.

Semantic Logging
Debugging actors isn't easy. Typically, you have multiple instances of the same class with asynchronous behavior, so it is difficult to discern flow. Create trace level log output for each actor type that displays specific information about it in a clearly-visible manner. Use line breaks and tabbed indentation to make it readable, but note that doing so can make your log files even larger than they already are. This has an unfortunate side effect of forcing you to be very granular in your log configuration as to what logging level is used - package-level logging may be too much information. It may help to put a timestamp into a message, so you can grep the log for specific messages as they flow through actors. Also, log the timestamp of when the actor received and handled it.

Deteriorating Retry
If your actors have side effects where a required resource (network connection, database access) may not be available or may fail, use deteriorating retry logic to allow the actor to send itself a message to try again in an increasingly longer interval. For a good example of this, go to Gmail, disconnect from all networks and watch as it tries to reconnect in longer and longer timeframes.

Instrument via JMX for Runtime Clarity
Register every actor instance with the JVM's MBeanServer, and have their supervisors clean up the instrumentation when they die. Yes, this comes at a performance cost, but you can make the registration asynchronous through a future while you perform other tasks in initialization and startup. While you'll still need to profile the threads involved to find threading issues, having the ability to view actor existence and state in JConsole or VisualVM is a wonderful help in knowing what is happening in your system in production.

Prepare for Race Conditions
As with any asynchronous programming, the timing of actor interactions can be unpredictable. Make your actor interactions recheck state they depend on so that they can reflect an appropriate state of their own. If Actor A needs Actor B to have a specific value for its own state to be appropriate, it should not send only one message to Actor B and assume that the value returned is correct that one time. Keep checking the value (again, possibly with deteriorating retry) until you can be certain you have a correct representation of Actor B's state.

Associative Arrays in Bash 4

2011-06-30T11:08:00.000-04:00

John Shepard, one of Chariot's architects and newest bloggers, just recently posted this on his blog.
A little different from our more focused software dev posts, we hope you will find this information useful.

I recently switched my work machine from OS X to Fedora. One of the first programs I noticed was missing was Time Machine. After being unable to get any of the backup software for Linux to behave as desired, a project emerged.

Ignoring most of the details of the backup scripts (all the scripts are available at the end of this post), I'm going to focus on the part working with associative arrays.

The backup program would need some way to keep only one backup per day for previous days. The obvious way to determine which days are affected is to keep a key value pair of dates and backup counts per day. Key value pairs have a few different names such as maps or dictionaries. In bash key value pairs are called associative arrays.

To declare an associative array use -A
declare -A MY_VARIABLE

To access the value just reference the variable as an array element
KEY="some value"
MY_VARIABLE["${KEY}"]

To access the value, or use zero if there is no value, use a default value
${MY_VARIABLE["${KEY}"]:-0}

And to set a value (here the value for the key is being set to two)
MY_VARIABLE["${KEY}"]=2

For looping, to access all keys
${!MY_VARIABLE[@]}

The entire set of backup scripts is available on github. cleanup_day.sh contains the associative array code.

HTML 5 Offline Applications with JQuery Mobile

2011-06-21T13:03:00.000-04:00

I can't believe it is a month since our last post. Vacation got in the way, but our consultants have been blogging on various topics. There is some catching up to do over the next week.

New to the blogsphere is John Shepard. John recently posted around JQuery ad HTML5, and what he has been doing with his spare time.

I was recently playing around with JQuery Mobile and was wondering how easy it would be to create an HTML 5 offline application. I'm not very familiar with HTML or JavaScript, so I figured this would be an interesting project.

A simple application was required, so a calculator was semi-randomly selected. (The source for the calculator is available at the end of this post.)

The first step in creating the calculator was to add some HTML that had a text area and some buttons. jQuery Mobile handles a resizing display area and can put buttons in a grid. The hooks into jQuery Mobile seem to be through data-roles and classes. Putting the textarea ....read more

Debugging PhoneGap and JavaScript

2011-05-20T12:36:00.000-04:00

This is a "reprint" of a guest blog post on the PhoneGap blog, by our resident PhoneGap expert, Hiedi Utley. Hiedi tackles debugging JavaScript on PhoneGap.

If you have ever written any JavaScript and tried to get it working on a mobile phone then spent hours banging your head against the wall because it just doesn’t work, this post is just for you. Today, we will be looking at ways to troubleshoot, diagnose, and debug your mobile web project. While I will be focusing on debugging interactions with PhoneGap, the strategies outlined here are really applicable to any JavaScript or mobile web project. Since I have been focusing mainly on iOS development, this post will discuss the debugging of JavaScript and PhoneGap within an iPhone application but the same ideas should work for Android and other platforms as well.

Read more..

Spock It Like You Mean It!

2011-05-16T14:55:00.000-04:00

This post was just put up on the blog of one of our architects, Anatoly Polinsky. Anatoly has a playful take on Spock, a Groovy testing framework, and specifically, abotu connecting Spock with Spring and DbUnit.

So here we go.. Yesterday night we hacked our way into The Ancient Database where besides the data about ancients themselves, we found incredible stats about many different living species of all the planets ancients traveled to.
So what do we do now? Well, we need a way to query/read this data. So we asked Sam to develop a reader ( ancients called it a ‘DAO’ ) to find a number of living species on each planet since the “beginning of time”.
So she did, and called this “species reader” a ‘SpeciesDao’.
We, of course, trust Sam. But in ancient technology, trust is always based on challenging the assumption by testing all the possible permutations. So we are calling Mr. Spock to help us out…
Sam of course used a well known ancient technique ( code name: Spring Framework ) to create a “species reader”, so Mr. Spock will use all the goodies of this technique to inject all the dependencies ( e.g. data source, a reader itself, etc.. ) for a test.

Read more...

Digital Philadelphia: A vision of Philadelphia as a regional technology center

2011-05-01T22:10:00.001-04:00

Here's how to make ithappen, says former CTO Allan Frank

By Todd R. Weiss

PHILADELPHIA – (Editor's note: Allan R. Frank, the former CTO of the City of Philadelphia, was scheduledto speak here last Thursday at the 6^th annual Emerging Technologies for theEnterprise Conference (ETE). A sick child at home, however,canceled his plans for the day. Frank was kind enough, though, to talk with meby telephone to describe his vision for technology in Philadelphia – which was to have been thesubject of his talk. Here are his thoughts.)

From July 2008 to this past February, Allan R. Frank workedas the City of Philadelphia'sfirst-ever Chief Technology Officer(CTO). Yes, the city has maintained a separate Chief Information Officerpost for a long time, but the CIO is in charge of the city's IT systems andstaff and running IT for its government agencies and processes.

Instead, Frank was brought in to help find ways to usetechnology to make the city a better place to live, work and do business. Hisvision, he said, was to find ways of using technology in the city to bringbusiness people, educators, residents and other movers and shakers together inthe common good.

Frank tookthe CTO post after talking with Mayor Michael Nutter and convincing Nutterthat someone was needed to help connect the area's technological capabilitieswith the issues that were central to the mayor and the city. To Frank, thatmeant showing Nutter how a technology-focused CTO could help the city solve itsmost pressing problems, from economic development to solving poverty toimproving education and more.

Frank said he explained to Nutter how technology could havean impact on a wide range of issues, but that someone was needed to lead theeffort.

"I started explaining to the mayor that I saw a tremendousopportunity for the city to take its place as a cornerstone of a regional technologycenter," he said. By bringing Frank in as CTO, he told Nutter that themayor would finally have someone "sitting at the table to focus on all ofhis goals."

"The mayor obviously shared my vision around theopportunity for how technology plays a role in everything in a city,"Frank said. "He saw the importance of that outside role."

Frank's vision was to continue what Philadelphia has always been – a city offirsts. Since the 1600s, the first library was set up here, as well as thefirst hospital, bank, library, medical school and computer – ENIAC.

With that history in mind, Frank said he envisions the cityas the "ground zero" for the next wave of technological innovation inthe U.S.

"My vision of what I call 'Digital Philadelphia' isasking the question, 'what should it be and what should it look like? This citymust be the national model for urban transformation to the 21^stcentury knowledge economy."

The tools are here in the region to make it happen,including such things as an urban core that has been again attracting youngpeople to move downtown and work in the city, he said.

"We're also the home of Comcast," he said."We could be the next Silicon Valley."

Much of Frank's ideas for the city were born, he said, afterPresident Obama took office, nurtured by Obama's ideas of creating broadbandstimulus efforts to help cities expand their technological infrastructures andabilities.

"In the 1960s, Philadelphiawas manufacturing textiles," Frank said. "Today we should be talkingabout putting in fiber networks and technology parks."

There are 154,660 people employed in IT occupations in the Philadelphia region,employing 7.4% of the area's total workforce, he said. That gives the area the6th

largest concentration of IT workers in the U.S.

Adding to the region's allure as a burgeoning tech centerare the world-class universities here that train qualified technical people, hesaid.

"What about developing tech economic development zonesaround the city, buildings that are pre-wired for 1-gigabit networks and many moreinnovations?" he said. "I was trying to frame this vision of Philadelphia as this zoneof network incubators, and setting up better ways to work with local techcommunity."

All of these things have been part of the regionaldiscussion after he joined the city in 2008 and they will continue to bepursued evenafter he departed from his post to head back into private industry, hesaid.

"Government can't make all of this happen," Franksaid. "It takes the community at large. And it takes the government to besupportive. Digital Philadelphianeeds to have executives, citizens and tech companies involved."

Now all of those ideas will be the responsibilities ofothers. Frank, who has more than 35 years of experience in technology andbusiness leadership, left his CTO role in February to return full-time to The AKA Group LLC, a strategic consultingfirm that he founded.

Frank remains, however, on a steering committee to helpcontinue these efforts and he believes in the city and the area, he said. Hispassions and energy will continue to help push for these changes, he said.

"Over the last couple of years, you can feel the energyhere," he said. "Our kids should be staying here in Philadelphia to create for technologycompanies" so we need to help create a vibrant tech community here toemploy thousands of people. "The future of the world is cities."

The power to make it all happen here is right in theregion's hands, according to Frank. "What we really have to do is create afreaking wave."

Todd R. Weiss is a longtime technology journalist whoworked as a staff writer for Computerworld.com from 2000 to 2008. Now afreelance tech journalist, Weiss contributes regularly to Computerworld,PCWorld.com and other publications. He has also written extensively forLinux.com, ForecastingClouds.com and TechTarget on a wide range of enterpriseIT topics from Linux and open source to disaster recovery, cloud computing,virtualization, application development, IT education and mobile and wirelesstechnologies. He began writing about computers in 1996 after a newspaper editorhe worked for told him that "no one cares about technology."Apparently, the editor was wrong. Follow him on Twitter.com @TechManTalking orcontact him at toddrweiss at gmail dot com.

Meet your future bosses: Meet the girls of TechGirlz.org

2011-04-28T16:16:00.001-04:00

By Todd R. Weiss

PHILADELPHIA – Yes, the halls here atthe 6^th annual EmergingTechnologies for the Enterprise Conference (ETE) arefilled with software developers, business people and technologyvisionaries.

But if you looked a little deeper, youmight have met your next boss – and she could still be inelementary school.

In a conference room here this morning,nine girls – ages eight to 15 – met with two visionary womenin technology who delivered the keynotes for the event – StormyPeters of Mozilla and Molly Holzschlag of Opera Software – to getadvice, encouragement and

support in pursuing their youthfulinterests in computers.

The girls were invited to visit byTechGirlz.org,a Philadelphia-area non-profit group begun two years ago to encourageyoung girls to explore their love of technology even when they thinkit's too geeky to pursue.

So who are the girls of TechGirlz?

They are young women like Eliana, 12,who one day decided she wanted to create a video game. First shebegan creating a site for the game using HTML, then she realized sheneeded to use a programming language to build it correctly. She chosePython after attending several technology camps and talking withothers to gaining their expertise.

"I started by teaching myself HTMLthen I started learning Python," said the bright-eyed girl withbraces, hot pink pants and long, curly dark hair. "What got meinvolved was that ever since I was really little, I was alwaysattracted to video games and computers."

Since then, she's been working hard tofurther develop the game and continue to add features. She's evenexploring the idea of releasing it as an open source project, but shesaid she's not sure she wants to give up control of the project.

Yes, I did say she's 12.

And those code camps that Eliana's beengoing to? They're with students who are in high school and college,yet there she is coding with the best of them. "I'm still kindof more like an amateur," she said.

Yeah, right.

I know of companies out there who aredesperate today to find and hire good Python coders and here isEliana, a 12-year-old who is building her own video game fromscratch.

Classic.

Then there's Olivia, 12, in a pinkshirt and ponytail, who loves to do art and design work on hercomputer, "making it go from clunky to smooth and shiny."

There was Megan, 13, who said she'dlike to find ways of helping to add emotional context to online chatand other electronic communications. The problem, Megan said, is thatit's hard to know what people are feeling when they are communicatingusing chat – are they mad at you or are they happy with you, shewondered? That's a great problem to solve.

Ten-year-old Kayla had another concern– she created a Web site for her business - making healthy homemadedoggie treats (www.kaninekookies.webs.com)– and sometimes the technology overwhelms her, she said.

Haley, 8, is on her school's roboticsteam and likes to use computers.

Meanwhile, Logan, 15, also likesrobotics and learning about how to make the devices operate. "Itcan be frustrating figuring out how to make them do something,"she said.

So what advice did Peters andHolzschlag have for the girls?

First, Peters said, if the girls feeloverwhelmed by the technology, she reminded them that it's not due toany shortcomings of their own.

"It's not you," Peters said."It's the way that the people who are telling you about it aretalking about it. I always think it's the fault of the person who'strying to tell you about it [if they can't explain it better]."

Asking lots of questions is a great wayto learn, Peters added, lauding Olivia for asking what CSS Zen Gardenis all about in the field of Web design.

"If you're brave enough to askwhat CSS is at a technology conference, then I guarantee that 80% ofthe other people in the room are also wondering what CSS is,"Peters said with a laugh.

Whatever they choose to do as theycontinue their educations, Peters encouraged the girls to follow whatthey are interested in and not give up on their dreams of pursuing atechnology career.

"What frustrates me is that womenare missing opportunities in a fantastic field," she said. "Istarted in technology because I really liked what computers could do.Now we have computers that can help blind people read, that helppeople find a movie, that enable people to get jobs and more. I justfound computers fascinating and being able to make … them do what Iwanted to do was another part of that."

Holzschlag got involved with computers by accident, she said. She was studying Spanish and linguistics atthe University of Arizona when she suddenly had to drop out of schooldue to a long-term illness. For 10 years she was home-bound.

One day, a cousin send her an oldCommodore 64 computer and a friend sent her a 300

baud modem. She hooked it all togetherand went online using an ancient dial-up service back in 1988.

Suddenly she went from home-bound andbeing isolated to joining a global community, years before theInternet ever appeared, she said.

"It was in that moment that Ilogged on and saw people from around the world," Holzschlagsaid. "I didn't know what I was looking at, but I knew that was'it.'"

She's been involved in technology eversince.

"My life changed … because ofthat Commodore 64 and a 300 baud modem that somehow came into mylife,"she said.

Those are the kinds of messages thatTechGirlz.org is working to bring to young girls in the area, saidTracey Welson-Rossman, director of marketing and sales at ChariotSolutions, the Fort Washington, Pa.-based software developmentconsulting company that hosts the annual ETE event.

Welson-Rossman, the founder ofTechGirlz.org, said the group's work started last September whengroups of 15-20 girls would come to participate in lectures,discussions and demonstrations of technology so they could gainexposure and increase their curiosity about high-tech topics.
Theidea is to expose tech-minded girls at a young age to women who areworking in technology so they can be inspired and empowered,Welson-Rossman said.

"We've seen research that saysthat the reason that girls drop out of pursuing technology interestsstarting in ninth grade in high school is because they think it'sgeeky," she said. "They think it's not creative. Theythink you're working in a cubicle and not talking to anybody."

To battle those stereotypes, TechGirlzstrives to get to them early and show them how exciting, gratifyingand worthwhile technology jobs can be. "One of the other issuesis that they think it's not cool for girls to be in technology. Andbecause of that they feel that they can't actually express that theyactually like technology."

"So one of our goals is to createa safe place for them to be able to express this part of theirpersonalities, of their interests," through TechGirlz.

About 100 girls are involved in theprogram so far. TechGirlz is growing its program by makingconnections with teachers and schools in the metropolitanPhiladelphia area and through communications with home-schoolingorganizations, Scouting groups and others.

Men in technology are also welcome tovolunteer and help with the TechGirlz program, Welson-Rossman said."We also want men to be involved because we need to show alltypes of role models. These girls are going to be working with men."

Todd R. Weiss is a longtimetechnology journalist who worked as a staff writer forComputerworld.com from 2000 to 2008. Now a freelance tech journalist,Weiss contributes regularly to Computerworld, PCWorld.com and otherpublications. He has also written extensively for Linux.com,ForecastingClouds.com and TechTarget on a wide range of enterprise ITtopics from Linux and open source to disaster recovery, cloudcomputing, virtualization, application development, IT education andmobile and wireless technologies. He began writing about computers in1996 after a newspaper editor he worked for told him that "noone cares about technology." Apparently, the editor was wrong.

If you hold an Emerging technologies for the Enterprise conference in Philadelphia, people will come

2011-04-28T10:54:00.001-04:00

Here's why they do attend – forlearning, for new ideas, for meeting peers

By Todd R. Weiss

PHILADELPHIA – Almost 500 attendeesfrom all over the U.S., and some from as far away as India andSweden, are here at the 6^th annual EmergingTechnologies for the Enterprise Conference (ETE).

What attracted them to attend thisyear's two-day conference?

And what have they taken away so far?

For Michael P. Redlich, a seniorresearch technician for a U.S.-based petrochemical researchorganization, this is his fourth year in a row as an attendee.

"It's basically just the wealth ofinformation that's out there, especially in the area of emergingtechnology," he said. "I never heard of the Akkaplatform until today so I went to see what it was about. Itturned out to be about cloud computing. There's just so much to keepup with that it's hard to keep current."

That's where conferences like this oneare a boon, he said. Redlich, who runs a Java user's group and usesthe enterprise open source Springdevelopment platform, said he also attended a session on Spring andcame out with useful new ideas.

"There were some new things inthere that I wasn't even aware of," he said.

Amir Tahvildaran, manager of systemsand applications for Drexel University's Math Forum and GoodwinCollege, said attending the show helps him stay connected to thelatest enterprise software developments.

"It's good to keep up on thenewest things and technologies that you don't have time to keep upwith at work," said Tahvildaran, who is here for his fifth ETEconference. "I hadn't heard of several mobile technologies, suchas PhoneGap, or the Arquillianintegration testing [tools]."

As Drexel looks at getting involved inmore mobile projects in the future, these kinds of technologies couldbe very useful to explore, he said. "It was nice to come inhere. People talk sense about why you would get into mobile."

Linda Kaiser, a IT manager for aPhiladelphia-based investment company, was at ETE for the first time.

"I'm here because in my role [asthe leader of a small R&D group] I'm generally interested inemerging technologies," Kaiser said. "We are veryinterested in the mobility topics that they have here at theconference."

One of the best sessions she attended,she said, was about "intentional emergence" and what large,monolithic enterprises can learn from the Web and from open sourcecommunities.

Presentedby JimStogdill, a senior director of architecture innovation withconsulting firm, Accenture, the session dove into the visible shiftsin organizational structure as our society continues to move from theIndustrial Age to the Information Age.

Stogdilltalked about "how it impacts real organizations that are used todoing things from the top down" instead of in the reverse,Kaiser said. "We have been using Agile software developmentmethodologies for several years now with varying degrees of success.Some of that has to do with the need for the organization to shift.There are definitely some interesting sessions here."

Steve Gass, a Web developer forArmstrong World Industries in Lancaster who is attending his thirdETE show, said he's already learned some intriguing things to takeback to work.

"I got a lot of insights into themobile platform" and how businesses can find ways to connectwith customers, Gass said. "It's something I'm just startingwith" in his job.

One of the best things he comes awaywith, he said, is the wide range of ideas he hears from presentersand fellow attendees from a wide range of companies.

"I come for a lot of bothtechnical insights and philosophical insights," he said.

Bruce Momjian, a database architectwith EnterpriseDB, saidhe's been coming to the ETE conference for four years from his homein nearby Newtown Square, Pa., because the topics covered here arethings he doesn't deal with every day in his work.

"What's neat for me is that thisis a conference that is not in my specialty," he said. "WhenI come here, I learn about new things, like [the programminglanguage] Erlang and about howto write mobile apps in a Web browser. The cool thing for me is thatI get more out of this conference than I do just about anywhere else.It's a different stack."

Another key benefit of the ETEconference, Momjian said, is that it truly highlights some of thebest technology innovations being developed right here in hisbackyard in Philadelphia.

"I learn about what everyone elseis doing plus I get to develop working relationships with tech peoplein the area," he said. ""This gives me a chance toreally be visible and to get to know a lot of the movers and shakersin our area. We have a lot of tech people here in Philadelphia, butwe didn't have anyone to bring us together until now. That's why Ithink this is a core conference. I get so much out of this."

What were your reasons for attendingthis year's conference?

And what did you get out of it?

Please share your stories and lessonslearned here in the comments section of the blog below.

Todd R. Weiss is a longtimetechnology journalist who worked as a staff writer forComputerworld.com from 2000 to 2008. Now a freelance tech journalist,Weiss contributes regularly to Computerworld, PCWorld.com and otherpublications. He has also written extensively for Linux.com,ForecastingClouds.com and TechTarget on a wide range of enterprise ITtopics from Linux and open source to disaster recovery, cloudcomputing, virtualization, application development, IT education andmobile and wireless technologies. He began writing about computers in1996 after a newspaper editor he worked for told him that "noone cares about technology." Apparently, the editor was wrong.

In a new world of tablet computers and smartphones, on-screen buttons are passé

2011-04-27T14:29:00.000-04:00

Design expert: Pay attention to thenew rules of designing for touchscreens

By Todd R. Weiss

PHILADELPHIA - As software developersdesign how the next generations of apps will look and work, they needto transform their ideas about how to best put useful content on theshrinking device screens being used by consumers.

That's because tablet computers,smartphones and other handheld mobile devices dramatically change howconsumers can view content on screens that are much smaller thantraditional desktop displays. Those differences call for a move awayfrom traditional desktop on-screen buttons that simply don't workwell on smaller screens.

What's needed instead, says JoshClark, an iPhone app consultant and founder of app design firm GlobalMoxie, is for app designers to carefully focus on the contentitself so they can visualize and truly find the most relevant ways todisplay it.

In a thought-provoking presentationhere today at the 6^th annual EmergingTechnologies for the Enterprise Conference(ETE), Clark described why "Buttons Are A Hack: The New Rules ofDesigning for Touch."

"When you remove the mouse andkeyboard … all that remains is you and the device," he said.That approach gets to the core of the connections between users andtheir touchscreen devices because they must use the tactile emotionsof touch to find what they are seeking. The problem, though, is thatnot all touchscreen apps today allow users to truly explore touchnatively, he said.

One example of this, according toClark, is the ABC News app forthe iPad, which features an Earth globe that can be "spun"with a fingertip to move from story to story for viewing. The problemis it's built for show and doesn't make it easy for users to find thecontent they are seeking, he said, partly because it only displaystwo stories at a time in the main screen and there's no usable index.

"It's actively upstaging thecontent," Clark said. "Whiz-bang graphics don't help usfind information. More attention is given to the contraption than tothe content."

A better, more intuitive and cleanerapproach comes from TheNew York Times Editor's Choice app for the iPhone, which favorsfunction over form. Instead of trying a flashy, tech interface, theapp displays New York Times content in a form that appears like anewspaper page. Critics, of course, panned the interface as boringand traditional, Clark said, but experiments by other designers foundthat too much change can also be a turn-off for consumers.

Because the New York Times' onlinebrand has been around now for more than 15 years, it's instantlyrecognizable as a brand to online readers, Clark said. And ratherthan rework it with an entirely new look and feel, research foundthat that connection is a boon because it keeps the Times familiarand comfortable for readers.

The lesson learned?

"Don't underestimate the power ofhum-drum as you go out and design interfaces," Clark said. "Oldideas are not necessarily old-fashioned."

Another key for app design is to matchthe touchscreen capabilities to the content you are producing, hesaid. If the app is for displaying the content of a print magazine,then keep the tactile feel of the paper magazine in mind –visualize how the pages turn and feel so you can keep your users"connected" to the physical magazine as they explore itsonline content. Automated "page flips" can be a goodfeature to use, as they allow the user to "see" the pagesturning as they read the content, but make the pages turn quickly soyou don't lose readers, he said.

"Page flips are window dressingfor sure, but they reinforce that you are reading a newspaper ormagazine or book," which provides context, connection andfamiliarity, Clark said. "And familiarity and intimacy invitetouch. If you're going to make it look like a book [or magazine] thenyou have to make it act like one."

That's not always done in app designs,and it needs to happen more, he said.

Even Apple's own calendar app for theiPhone isn't intuitive enough due to its design, according to Clark.Where a user should be able to "swipe" a finger across thecalendar screen to turn a page, it's not possible. Instead, they haveto click an arrow to move a page ahead or backward.

That's just not right withtouchscreens, he said, because they invite intuitive actions such astouching, tapping, swiping – at the expense of those outmodedbuttons. "You see this [disconnect] all over the place" inrecent app designs, he said.

"Just enough is more," Clarksaid, accentuating the idea that design just for the sake of designis not enough. The content delivery of today's apps need to focus onthe users and how they want to access information throughtheir fingertips and touch.

"Watch a toddler use an iPad,"he said. "They just use it. So design for humans. Design fordirect interaction. Design for toddlers. Think about how kids woulduse the app."

All of this is still evolving, Clarksaid, as touchscreen app development remains in its infancy today."We're only a year into mainstream tablet app design. Don'tassume that anyone else has it nailed yet, especially the big guys."

That means it's great to watch whatother app developers are doing, but don't immediately jump in tofollow them – they could have gotten it all wrong.

"It's very early and it'sdangerous to lock in on half-baked convention" just because yousee others doing certain things so far, he said."Understand thatyou won't get it right the first time and don't give up."

Todd R. Weiss is a longtimetechnology journalist who worked as a staff writer forComputerworld.com from 2000 to 2008. Now a freelance tech journalist,Weiss contributes regularly to Computerworld, PCWorld.com and otherpublications. He has also written extensively for Linux.com,ForecastingClouds.com and TechTarget on a wide range of enterprise ITtopics from Linux and open source to disaster recovery, cloudcomputing, virtualization, application development, IT education andmobile and wireless technologies. He began writing about computers in1996 after a newspaper editor he worked for told him that "noone cares about technology." Apparently, the editor was wrong.

Welcome: A Guide to What's in Store for you here at the 6th annual Emerging Technologies for the Enterprise Conference

2011-04-27T08:31:00.000-04:00

By Todd R. Weiss

In the next two days, prepare to beinspired, educated, challenged, informed and entertained by a cast ofdiverse IT experts who are here to share their insights andexperiences on a wide swath of software development topics.

I'm technology journalist Todd R.Weiss, and I'm a regular contributor to Computerworld, PC World andTechTarget, writing about enterprise IT and the challenges it bringsdaily to businesses and their busy IT staffs.

I'm here on behalf of Chariot Solutionsto help cover this conference and bring some of its key highlights totheir customers and attendees at this 6^th annual EmergingTechnologies for the Enterprise Conference (ETE) in Philadelphia.

Among the software development notableshere for this information-packed event are:

*Mobile application consultant JonathanStark, who is the author of O’Reilly Media’s Building iPhoneApps with HTML, CSS, and JavaScript.Jonathan will talk about his alternative approaches to building appsfor iPhone and iPad using only HTML, CSS and JavaScript.

*David Kaneda, thedeveloper of jQTouch,a Javascript framework for iPhone development and creative directorat Sencha. David will talk aboutSencha Touch, a mobile web app framework that allows developers tocreate rich mobile apps which look and feel native.

*Josh Clark, a designer who specializesin mobile design strategy and user experience. Josh is the author of “Tapworthy: Designing Great iPhone Apps” and “BestiPhone Apps” from O'Reilly Media.

*Eduardo Jezierski, theCTO of InSTEDD,a non-profit that helps communities around the world use, design anddevelop information tools for their health, safety and development.Eduardo will lecture about "Architecture and Agility With Livesat Stake."

*Jonas Boner, the creator of the Akkadevelopment framework, who will describe Akka in detail and show howit can be used to solve hard scalability problems.

*Mark Chadwick, the chief architect atGoogle subsidiary Invite Media, who will describe how Invite Mediaserves up millions of advertisements to targeted consumers every hourin his lecture, Doingthe Mundane a Million Times a Minute.

This year the ETE conference is part ofthe first "Philly TechWeek" being organized in Philadelphia across a wide range ofsites in the city. Philly Tech Week is a first-time event that'sbeing promoted to showcase the bustling technology community in theregion.

This is the biggest year yet for theETE conference, which is hosting almost 500 attendees in 2011, saidTracey Welson-Rossman, director of sales and marketing for softwaredevelopment consulting firm Chariot Solutions of Fort Washington, Pa.

"We really feel that this is atipping point and that we're going to let people outside the areaknow that there's hidden high-tech gems in the Philadelphia area,"Welson-Rossman said. "Were really fortunate to have this levelof talent that comes to us here at the conference."

"We know that the Philadelphiacommunity has an incredibly strong tech community," she said."That’s why were able to have this show. We wouldn't be ableto attract the speakers if the area didn’t have this reputation."

Todd R. Weiss is a longtimetechnology journalist who worked as a staff writer forComputerworld.com from 2000 to 2008. Now a freelance tech journalist,Weiss contributes regularly to Computerworld, PCWorld.com and otherpublications. He has also written extensively for Linux.com,ForecastingClouds.com and TechTarget on a wide range of enterprise ITtopics from Linux and open source to disaster recovery, cloudcomputing, virtualization, application development, IT education andmobile and wireless technologies. He began writing about computers in1996 after a newspaper editor he worked for told him that "noone cares about technology." Apparently, the editor was wrong.

PhoneGap Tutorial Series – #6 Writing Your Own Plugin

2011-04-21T18:27:00.000-04:00

This is the last of the series Hiedi Utley has written on PhoneGap. I hope you have found the series helpful. We hope to have more of this type of blog post in the future to help with developing mobile applications.

How to Create Your Own PhoneGap Plugin

Today’s topic is about creating your own PhoneGap plugin for iOS development. PhoneGap provides a whole array of built in features to access all sorts of things on a device but what if you want to do something that is not already supported and has not already been provided by a third-party plugin? Stop fretting, just like adding a third-party plugin, if you can write a little Objective-C then you can add your own plugin to PhoneGap as well. In order to create your own plugin you will have to be somewhat familiar with JavaScript as well as Objective-C. This tutorial assumes that you are familiar with JavaScript, Objective-C, the iOS SDK, and the XCode development environment. This post also assumes that you are familiar with the PhoneGap project structure and the PhoneGap plugin architecture, so you may want to peruse some of my earlier posts before continuing on if you haven’t already.

Read more..

PhoneGap Tutorial Series – #5

2011-04-19T15:45:00.000-04:00

Extending the PhoneGap API – Third-Party Plugins (NativeControls)

Continuing on down the path of using third party plugins, today we will look at a little more complex example and use the NativeControls plugin to display a UIActionSheet to allow the user to select whether they want to take a photo using the camera or pick one from the photo library by utilizing the PhoneGap Camera API.
If you haven’t read my previous post on Third-Party Plugins (ChildBrowser) you may want to peruse that to understand the structure of a plugin and how to go about installing one before continuing on.

Read more...

Extending the PhoneGap API – Third-Party Plugins (ChildBrowser)

2011-04-15T14:36:00.000-04:00

As we are preparing for Emerging Technologies for the Enterprise, I did not want to forget the rest of the series on PhoneGap API that Hiedi Utley has been penning. Here is part 4.

Extending the PhoneGap API – Third-Party Plugins (ChildBrowser)

So the last post was all about editing PhoneGap classes to add a little something extra, today it’s about using a third-party plugin that you may have downloaded from somewhere or gotten from someone.
The plugins that we will be using today are from Jesse MacFayden (aka @purplecabbage on twitter). The original source code for the plugins can be downloaded from github here: https://github.com/purplecabbage/phonegap-plugins.git
You can also get the entire source for my sample project “HelloPhoneGap” from github here: https://github.com/hutley/HelloPhoneGap.git

Read more..

Extending the PhoneGap API

2011-04-08T14:19:00.000-04:00

Here is the third installment of Hiedi Utley's series on PhoneGap. We hope you are finding this series helpful as you learn more about developing for mobile applications.

Extending the PhoneGap API
If you’ve had a chance to play with PhoneGap a bit, chances are you have wanted it to do something that it doesn’t already do. Alas, don’t worry! You don’t have to put in a ticket and hope that the PhoneGap developers agree with you and implement it in some future release, if you can write a little Objective-C then you can do it yourself and use it in your own iOS project.
The topic at hand is all about extending the PhoneGap API whether it’s by editing existing PhoneGap classes, downloading a third-party plugin from somewhere, or by writing your own plugin from scratch. For this post I will concentrate on editing the PhoneGap classes, in later posts I’ll give step-by-step instructions on using a third-party plugin and how to create your own plugin.
If you haven’t already had a chance to read my earlier posts on PhoneGap internals and using the PhoneGap API – you may want to peruse them before reading on.

Read more...

Using the PhoneGap API

2011-03-31T11:26:00.000-04:00

We are a little behind in posting Hiedi Utley's PhoneGap Tutorial Series. Or she is a very fast writer.
In this post, Hiedi discusses the features of PhoneGap API.

Using the PhoneGap API

Welcome to the second installment of my PhoneGap Tutorial Series! This post is a continuation of PhoneGap Project Structure and Internals so if you haven’t already, you may want to peruse that post before continuing on.
We already know that PhoneGap is an open source framework for writing applications using typical web technologies like HTML, CSS, and JavaScript and that the PhoneGap architecture supplies JavaScript wrappers to access native phone features. What you may NOT know is how extensive those features really are or how to actually use them.
This article is all about getting familiar with the current features of the PhoneGap API and how to use them with the iPhone iOS.

Read more..

What is in my Spring Context?

2011-03-21T09:44:00.000-04:00

When we are learning Spring, there are times we are not sure which beans are in the Spring context. Especially when we use convenient features of Spring 3 such as <context:annotation-driven/> or <context:component-scan/>. As developers, we want to inspect the classes that are automatically registered providing the opportunity to look at the source code and javadocs to see what each class does.

JUnit Tests get Application Context

Our JUnit tests have the ability to inject the Application Context. This is one of the many benefits of @RunWith(SpringJUnit4ClassRunner.class)


@ContextConfiguration(value = "/META-INF/spring/test-app-context.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class BeansInContextTest {

     @Autowired
     ApplicationContext applicationContext;

Simple Code

Let's loop through all the beans that are defined or discovered with the following code.


@Before
public void setup() {
  logger.debug("********************");
  String[] beans = applicationContext.getBeanDefinitionNames();
  for (String o : beans) {
    logger.debug("________________________");
    logger.debug("BEAN = " + o);
    logger.debug("\tType = " + applicationContext.getType(o));
    String[] aliases = applicationContext.getAliases(o);
     if (aliases != null && aliases.length > 0) {
       for (String a : aliases) {
         logger.debug("\tAliased as: " + a);
       }
     }
  }

  logger.debug("********************");
  logger.debug("*** Number of Beans = {} ***",
    applicationContext.getBeanDefinitionCount());
  logger.debug("********************");
  }
}

What is the Alias?

We can define beans with "id" which by XML law requires it to be unique per file. This restricts us in the ability to use special symbols for the name should we want to. I recommend using "id" unless absolutely necessary. However, should we what to refer to the bean with multiple names or use special symbols, we can use the "name" attribute. By comma separating the tokens, we have the opportunity to refer to a bean with any of the tokens provided.

<bean name="mailServer/default, mailServer" class="..."/>

If no, "id" is provided, the first token becomes the primary and the subse quent tokens become aliases. Does this matter in the usage of the beans? No. But to find "all" the names of the beans, we would display the aliases in addition to the bean names.

The Full Test Code

package com.chariot.sample;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ContextConfiguration(value = "/META-INF/spring/test-app-context.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class BeansInContextTest {
  private final Logger logger = LoggerFactory
    .getLogger(BeansInContextTest.class);

  @Autowired
  ApplicationContext applicationContext;

  @Before
  public void setup() {
    logger.debug("********************");
    String[] beans = applicationContext.getBeanDefinitionNames();
    for (String o : beans) {
      logger.debug("________________________");
      logger.debug("BEAN = " + o);
      logger.debug("\tType = " + applicationContext.getType(o));
      String[] aliases = applicationContext.getAliases(o);
      if (aliases != null && aliases.length > 0) {
        for (String a : aliases) {
          logger.debug("\tAliased as: " + a);
        }
      }
    }
   
    logger.debug("********************");
    logger.debug("*** Number of Beans = {} ***",
      applicationContext.getBeanDefinitionCount());
    logger.debug("********************");
  }
}

Sample Bean Context


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-3.0.xsd">

  <context:annotation-config/>

  <bean id="myBean" class="MyCoolBean"/>

</beans>

Experiment and Have Fun

Add beans to the config file. Import other config files and see what happens.

Wanna Learn More?

Learn more about what goes on Spring Context by attending a Core Spring Training class at Chariot.

Chariot Education Calendar

PhoneGap Tutorial Series – #1 Project Structure and Internals

2011-03-17T09:22:00.000-04:00

Heidi Utley, one of the members of our mobile practice, has been working with PhoneGap for one of our clients. She decided to create a series of posts focusing on using PhoneGap for iPhone development.

This first one discusses the project structure. Future posts will review the PhoneGap API, installing a third party plugin, and last building your own PhoneGap plugin.

What is PhoneGap?

PhoneGap is an open source framework for writing applications using typical web technologies like HTML, CSS, and javascript. The PhoneGap architecture supplies javascript wrappers that allow a developer to access native phone features (like contacts, GPS, and the camera) by writing their app against the PhoneGap javascript API.
The basic gist is that the typical web developer will be able to write a standalone HTML/CSS/javascript application that runs in a WebKit browser with access to native functions just by calling the PhoneGap javascript. PhoneGap aides the developer by abstracting the complexities of native development by allowing the developer to write the app in well-known technology without having to learn the intricacies of each mobile platform and thereby hiding the complexity of writing the same application multiple times in various native languages (like Objective-C for the iPhone or Java for Android).

Read more...

Stay tuned as we have more discussions around mobile development. Our team continues with their research, for Chariot's own projects (our conference app for Philly ETE) and for our clients.

Xcode3 – Debugging iOS Unit Tests

2011-03-10T09:24:00.000-05:00

A recent blog post by Hiedi Utley (no, she is not related to our knee challenged second baseman), Chariot's newest team addition. Hiedi has been working in our mobile practice. She reviews some of the challenges of being a Java developer and moving to an iOS environment.

Here is an excerpt from this post:

So you have some unit tests (yeah!) and they are failing …. now what?

Over the course of my career these past few years, I have become a developer that writes more test code than production code in an effort to never have to spend the wee hours of the morning debugging a horrible production issue. As a java developer turned mobile developer, there are several things that I miss about coding in Java but the number one thing is unit tests.
Don’t get me wrong – I know what you are thinking – probably something along the lines of: “Do a little research dummy! Xcode has a nice Unit Test Bundle target that we can use to run unit tests! All you have to do is write them!” Right…..
Or maybe after a little more googling around you may even point me to this excellent Apple documentation that explains the process of setting up and running my newly created unit tests but there is a huge section missing from this guide…

Mobile Design Part 3

2011-03-07T09:48:00.000-05:00

The next installment of Kevin Griffin's blog on Mobile Design.

Cognitive Effort.

In this installment of my thoughts on mobile design, I thought we would take a look at the concept of ‘cognitive effort’. I think I first heard that term used in reference to design from William Van Hecke (@fetjuel) when he spoke at Voices that Matter in Philly. When a guy from The OmniGroup talks to be about making great apps, I tend to shut up and listen.
We have all thought about cognitive effort at some point:

“Does this screen look too busy?”
“We should move this functionality out of this screen” are signs you thinking about it.

What increases cognitive effort?
Every question, action, dialog, gesture, tap, shake, voice communiqué we ask the user ultimately ends in some kind of effort be it physical, cognitive or verbal. Sometimes we intentionally make these things progressively harder, games for example. Sometimes we unintentionally make these things progressively harder, continually adding functionality to a screen.

Read more...

JUnit & Spring – What You Don’t Know

2011-02-17T07:50:00.000-05:00

Gordon Dickens, Chariot architect and one of our education trainers, recently wrote this blog post on JUnit and Spring.

When using JUnit in Spring there are several features added that many developers are not aware of.
First, if you are including the Spring Context in your tests, it becomes an Integration Test, no longer a Unit Test.

1. Default Searching of Context File(s)

To instruct Spring to load beans for the tests in the class, we annotate the class with @ContextConfiguration

1a. No File Specified

@ContextConfiguration – with no parameters, (by Default) looks for the config file as the same name as the class with the suffix “-context.xml“. For example,

Using

package com.gordondickens.sample;
@ContextConfiguration
public class UtilsTest {
  ...
}
...

Is equivalent to

  ...
@ContextConfiguration("classpath:/com/gordondickens/sample/UtilsTest-context.xml")
  ...

What's Coming in Spring 3.1

2011-02-10T21:14:00.000-05:00

Spring 3.1.0 M1 is expected to be released on Feb 10, 2011. There are many exciting new features expected for the final release which is scheduled for June 2011.

Environment Profiles

Many times we want separate configuration for different environments such as development, qa, production. Also, we may want to provide different bean configuration for traditional or cloud environments as well.

Beans can be configured in XML with the additional "profile" attribute
Activate 1..n profiles in code or with java arg -Dspring.profiles.active="dev,qa"
ParamName for DispatcherServlet "spring.profiles.active"
Integration Tests Class GenericXmlApplicationContext
Nested "beans" in other words, <beans/> tag can have other <beans/> tags within allowing multiple bean sets for different profiles in the same config file
The variable “environment” is already registered for SpEL


@Profile(“development”)
public class MyClass() { ... }


<beans profile=“development” … />


#{environment[‘prop.key’]}
public String myProp;

The "c" Namespace

Much like the existing "p" namespace, the "c" namespace supports constructor arguments. This has the additional benefit of allowing us to reference the constructor arguments by name.


<bean class=“…” c:age=“35” c:amount=“50000”/>

Cache Abstractions

Cache Abstractions will be available – not just EHCache, also for Gemfire, Coherence
Package: org.springframework.cache
Annotation Package: org.springframework.cache.annotation
<cache: &/gt; namespace


<cache:annotation-driven> //referencing "cacheManager"


@Cacheable  //field or method

@Cacheable(condition=“name.length < 10”) //conditional

@CacheEvict // remove field from cache
public void clearMyField() { ... }

Servlet 3.0

ServletContainerInitializer – XML Free config (no web.xml)
package org.springframework.web.context.support.AnnotationConfigWebApplicationContext
Async request processing
Standard file upload support

HTTP Session Improvements

Share information across multiple browser instances
Uses Shared Cookie
package org.springframework.web.bind.support.SessionAttributeStore
Conversation "scope"
Useful for MVC & JSF, Web Flow

Groovy Support

Groovy/Grails BeanBuilder inclusion
<lang:groovy>
Groovy based template files (alternative to Velocity and Freemarker)

Feature Configuration

For Bean @Configuration - To support applications with Java based configuration.

package org.springframework.context.annotation
Picked up via AnnotationConfigApplicationContext // Standalone application context, accepting annotated classes as input
Allows scanning for @Configuration classes
@FeatureConfiguration // class level - specify the name of the Spring bean definition
@Feature // Method w/i @FeatureConfiguration Class

Customizable @MVC

Custom @ExceptionHandler support for @Controller methods
Custom @ExceptionHandler support for @RequestBody & @ResponseBody
You can write a BeanPostProcessor to change AnnotationMethodHandlerAdapter after construction
Auto-detection of custom HttpMessageConverters - for example custom MyMappingJacksonHttpMessageConverter
Support for custom message codes resolver with <mvc:annotation-driven/>


<mvc:annotation-driven>
  <mvc:custom-web-argument-resolvers>
    <bean class="org.example.MyWebArgumentResolver"/>
  </mvc:custom-web-argument-resolvers>
</mvc:annotation-driven>


<mvc:annotation-driven>
  <mvc:message-converters>
    <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
    <bean class="org.springframework.http.converter.ResourceHttpMessageConverter"/>
    <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"/>
  </mvc:message-converters>
</mvc:annotation-driven>


<mvc:annotation-driven message-codes-resolver="org.example.MyMessageCodesResolver"/>

REST Enhancements

Interceptors for RestTemplate
ClientHttpRequestInterceptor
bufferRequestBody property to the SimpleClientHttpRequestFactory to handle large payloads with RestTemplate
New WebRequest.checkNotModified(String) // only had long support previously
New @ResponseEntity
To support OAuth with ClientHttpRequestInterceptors

Summary

Many of the items included here are specific features for 3.1.0.M1, there are many more improvements coming for MVC customization and REST improvements in M2.

Sending Beans as XML with JmsTemplate

2011-02-07T13:30:00.000-05:00

Introduction

We often want to send XML via web services. We may already have the schema or annotated JAXB2 classes configured in our application. What if we want to send the same format via JMS? By default Spring JMS is configured to send & receive objects serialized. How can we switch to using JAXB2 (or any other OXM marshaling strategy)?
The following example assumes we are going from annotations first instead of from XML Schema.

Quick Overview

Annotate Bean with JAXB2
Configure OXM Converter
Integration Test
Visualize Results
Logging Configuration
Maven Configuration

1. Annotate Bean with JAXB2

Use JAXB2 annotations for our bean

package com.gordondickens.jmswithoxm;

import java.math.BigDecimal;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "account")
@XmlAccessorType(XmlAccessType.FIELD)
public class Account {
     @XmlElement(required = true)
     private String name;

     @XmlElement
     private String description;

     @XmlElement
     private BigDecimal balance;

     public String getName() {
          return name;
     }

     public void setName(String name) {
          this.name = name;
     }

     public String getDescription() {
          return description;
     }

     public void setDescription(String description) {
          this.description = description;
     }

     public BigDecimal getBalance() {
          return balance;
     }

     public void setBalance(BigDecimal balance) {
          this.balance = balance;
     }

     @Override
     public String toString() {
          return "Account [name=" + name + ", description=" + description
                    + ", balance=" + balance + "]";
     }
}

2. Configure OXM Converter

Define our Marshalers - We see <oxm:jaxb2-marshaller ...> defines JAXB2 as our marshaller for the Account class
Register our MarshallingMessageConverter - We register the MarshallingMessageConverter to use the JAXB2 marshaller for both inbound and outbound data
Register our Converter - In the JmsTemplate, we register our oxmMessageConverter as the messageConverter. This replaces the default SimpleMessageConverter which will relies on Serialization
Notice the ActiveMQ namespace?

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
     "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:oxm="http://www.springframework.org/schema/oxm"
     xsi:schemaLocation="http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-3.0.xsd
          http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core-5.4.0.xsd
          http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

     <amq:broker persistent="false" useJmx="true">
          <amq:transportConnectors>
               <amq:transportConnector uri="tcp://localhost:61616" />
          </amq:transportConnectors>
     </amq:broker>

     <amq:connectionFactory brokerURL="vm://localhost" id="jmsFactory" />

     <!-- Spring JMS Template -->
     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
          <property name="connectionFactory" ref="jmsFactory" />
          <property name="defaultDestination" ref="oxmTestQueue" />
          <property name="messageConverter" ref="oxmMessageConverter" />
     </bean>

     <amq:queue id="oxmTestQueue" physicalName="oxm.test.queue" />

     <bean id="oxmMessageConverter"
          class="org.springframework.jms.support.converter.MarshallingMessageConverter">
          <property name="marshaller" ref="marshaller" />
          <property name="unmarshaller" ref="marshaller" />
     </bean>

     <oxm:jaxb2-marshaller id="marshaller">
          <oxm:class-to-be-bound name="com.gordondickens.jmswithoxm.Account" />
     </oxm:jaxb2-marshaller>
</beans>

3. Integration Test

Populate the Account bean
Calls convertAndSend on the JmsTemplate to marshal & send the Account
Includes a postProcessor callback to log the XML data
Calls receiveAndConvert on the JmsTemplate to get & unmarshal the Account
Asserts end state

package com.gordondickens.jmswithoxm;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.math.BigDecimal;
import javax.jms.BytesMessage;
import javax.jms.JMSException;
import javax.jms.Message;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessagePostProcessor;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class JmsWithOxmTest {
  private static final Logger logger = LoggerFactory
      .getLogger(JunitWithOxmTest.class);
  private static final String TEST_DEST = "oxmTestQueue";

  @Autowired
  JmsTemplate jmsTemplate;

  @Test
  public void testSendingMessage() {
    Account account = generateTestMessage();
    jmsTemplate.convertAndSend(TEST_DEST, account,
        new MessagePostProcessor() {
          @Override
          public Message postProcessMessage(Message message)
              throws JMSException {
            if (message instanceof BytesMessage) {
              BytesMessage messageBody = (BytesMessage) message;
              // message is in write mode, close & reset to start
              // of byte stream
              messageBody.reset();

              Long length = messageBody.getBodyLength();
              logger.debug("***** MESSAGE LENGTH is {} bytes",
                  length);
              byte[] byteMyMessage = new byte[length.intValue()];
              int red = messageBody.readBytes(byteMyMessage);
              logger.debug(
                  "***** SENDING MESSAGE - \n\n{}\n",
                  new String(byteMyMessage));
            }
            return message;
          }
        });
    Account account2 = (Account) jmsTemplate.receiveAndConvert(TEST_DEST);
    assertNotNull("Account MUST return from JMS", account2);
    assertEquals("Name MUST match", account.getName(), account2.getName());
    assertEquals("Description MUST match", account.getDescription(),
        account2.getDescription());
    assertEquals("Balance MUST match", account.getBalance(),
        account2.getBalance());
  }

  private Account generateTestMessage() {
    Account account = new Account();
    account.setBalance(new BigDecimal(12345.67));
    account.setDescription("A no account varmint");
    account.setName("Waskally Wabbit");
    logger.debug("Generated Test Message: " + account.toString());
    return account;
  }
}

4. Visualizing Results

Run: mvn clean test
See Account XML between the block  & 
Output has been Formatted for clarity


-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.gordondickens.jmswithoxm.JmsWithOxmTest

INFO  o.s.o.j.Jaxb2Marshaller - Creating JAXBContext 
  with classes to be bound [class com.gordondickens.jmswithoxm.Account]
  
DEBUG c.g.j.JmsWithOxmTest - Generated Test Message: 
  Account [name=Waskally Wabbit, description=A no account 
  varmint, balance=12345.670000000000072759576141834259033203125]

DEBUG o.s.j.c.JmsTemplate - Executing callback on JMS Session: 
  ActiveMQSession {id=ID:Technophiliac-61135-1296856347600-2:1:1,started=false}

DEBUG c.g.j.JmsWithOxmTest - ***** MESSAGE LENGTH is 213 bytes

DEBUG c.g.j.JmsWithOxmTest - ***** SENDING MESSAGE -
<!-- MSG START -->
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <account>
    <name>Waskally Wabbit</name>
    <description>A no account varmint</description>
    <balance>12345.670000000000072759576141834259033203125</balance>
  </account>
<!-- MSG END -->

DEBUG o.s.j.c.JmsTemplate - Sending created message:
  ActiveMQBytesMessage {commandId = 0, responseRequired = false, messageId = null, originalDestination = null, originalTransactionId = null, producerId = null, destination = null, transactionId = null, expiration = 0, timestamp = 0, arrival = 0, brokerInTime = 0, brokerOutTime = 0, correlationId = null, replyTo = null, persistent = false, type = null, priority = 0, groupID = null, groupSequence = 0, targetConsumerId = null, compressed = false, userID = null, content = org.apache.activemq.util.ByteSequence@b364dcb, marshalledProperties = null, dataStructure = null, redeliveryCounter = 0, size = 0, properties = null, readOnlyProperties = false, readOnlyBody = true, droppable = false} ActiveMQBytesMessage{ bytesOut = null, dataOut = null, dataIn = java.io.DataInputStream@1a2d502d }

DEBUG o.s.j.c.JmsTemplate - Executing callback on JMS Session:
  ActiveMQSession {id=ID:Technophiliac-61135-1296856347600-2:2:1,started=true}

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.276 sec

5. Logging Configuration

Logback is very similar to Log4J
Logback patterns use Log4J characters also
See: Logback Pattern Layout Documentation

<configuration>
  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
      <pattern>%-5level %logger{5} - %msg%n</pattern>
    </encoder>
</appender>

  <logger name="com.gordondickens" level="DEBUG" />
  <logger name="org.springframework.jms" level="DEBUG" />
  <logger name="org.springframework.oxm" level="DEBUG" />
  <!--<logger name="org.apache.activemq" level="DEBUG"/> -->

  <root level="WARN">
    <appender-ref ref="STDOUT" />
  </root>
</configuration>

6. Maven Configuration

Using Logback to support Log4J, SLF4J, Apache (JCL) & Java Util Logging
Included IDE builders for STS/Eclipse & IntelliJ IDEA

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.gordondickens.jmswithoxm</groupId>
  <artifactId>spring-jms-oxm</artifactId>
  <version>1.0.0.CI-SNAPSHOT</version>
  <packaging>jar</packaging>
  <name>JMS to OXM Spring</name>
  <url>http://gordondickens.com</url>
  <description>Sample JMS with OXM Message Conversion</description>
  <developers>
    <developer>
      <id>gordon.dickens</id>
      <name>Gordon Dickens</name>
      <email>gordondickens@gmail.com</email>
      <roles>
        <role>Author</role>
      </roles>
      <organization>http://www.gordondickens.com</organization>
    </developer>
  </developers>

  <properties>
    <spring.version>3.0.5.RELEASE</spring.version>
    <junit.version>4.8.1</junit.version>
    <jms.version>1.1.1</jms.version>
    <slf4j.version>1.6.1</slf4j.version>
    <activemq.version>5.4.2</activemq.version>
    <logback.version>0.9.27</logback.version>
    <log4j.version>1.2.16</log4j.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.test.failure.ignore>false</maven.test.failure.ignore>
  </properties>
  <profiles>
    <profile>
      <id>quick</id>
      <properties>
        <maven.test.failure.ignore>true</maven.test.failure.ignore>
      </properties>
    </profile>
  </profiles>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jul-to-slf4j</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>${logback.version}</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-core</artifactId>
      <version>${logback.version}</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-access</artifactId>
      <version>${logback.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.apache.activemq</groupId>
      <artifactId>activemq-core</artifactId>
      <version>${activemq.version}</version>
      <exclusions>
        <exclusion>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
        </exclusion>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging-api</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.apache.xbean</groupId>
      <artifactId>xbean-spring</artifactId>
      <version>3.7</version>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jms</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.xml.bind</groupId>
      <artifactId>jaxb-api</artifactId>
      <version>2.2.2</version>
    </dependency>
    <dependency>
      <groupId>org.apache.geronimo.specs</groupId>
      <artifactId>geronimo-jms_1.1_spec</artifactId>
      <version>${jms.version}</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.7.1</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-eclipse-plugin</artifactId>
        <version>2.8</version>
        <configuration>
          <downloadSources>true</downloadSources>
          <downloadJavadocs>true</downloadJavadocs>
          <wtpversion>2.0</wtpversion>
          <additionalBuildcommands>
            <buildCommand>
              <name>org.springframework.ide.eclipse.core.springbuilder</name>
            </buildCommand>
          </additionalBuildcommands>
          <additionalProjectnatures>
            <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
          </additionalProjectnatures>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.6</source>
          <target>1.6</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-idea-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <downloadSources>true</downloadSources>
          <downloadJavadocs>true</downloadJavadocs>
          <dependenciesAsLibraries>true</dependenciesAsLibraries>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

6. Getting the code

Code is in my Git Repo:
https://github.com/gordonad/core-spring-demos/tree/master/demos/JmsOxmDemo

Conclusion

Using Spring, it is very easy to configure projects to send/receive data from XML formatted beans. This simplification allows us to focus on the message payload using Spring JMS. If our solution was to serialize the data, the default JMS message conversion would suffice.

This implementation focussed on annotated JAXB2 beans without an XML schema. Many projects have existing XML schema, and with Spring JMS this is not difficult to configure. Even though the example above focussed on JAXB2 as our marshaling strategy, we could have chosen others such as JiBX, XMLBeans, XStream, Castor with relative ease.

Philly ETE 2011 mobile line up!

2011-02-04T08:24:00.000-05:00

This post is via Kevin Griffin, Chariot Architect and committee chair of the Mobile tract for ETE:

Philly ETE 2011 mobile line up!

Just thought I would post an update on the current lineup for Philly ETE.
I've been involved in helping get the mobile track lineup sorted out and so far we have confirmed the following:

Josh Clark - my favorite 'Tapworthy' author.
Johnathon Stark - He literally wrote the books on making mobile apps with HTML, CSS and JavaScript.
Ted Neward - If you are lazy, and want to write Android apps, he has the talk for you!
Jay McGavren - If you want to write Android apps, in Ruby (Oh yeah!) This is the talk for you (personally, I can't wait for this one!).
Terry Ryan - Philly Evangelist from Adobe who will use Air, to build Playbook apps. Magic!
David Kaneda - Although technically on the Frameworks track. Go build your mobile apps in Sencha Touch, seriously go now! That way you can thank him at ETE!

With one super secret invite still pending :D

Web Application Security

2011-02-01T16:19:00.000-05:00

The recent news that the popular dating site Plenty Of Fish was hacked and that passwords and other user information was stolen truly disheartened me.

It was just the latest in a seemingly endless list of such hacks over the years, recently including Gawker Media (Lifehacker, Gizmodo), McDonald's, Walgreen's and Pizza Hut.

Apparently, Little Bobby Tables is alive and well.

What is disheartening to me is not so much the security breaches themselves. No site is completely secure. The operators of these and other sites may have been able to do more than they did to prevent the breaches, or maybe they had really good (but not good enough) security. But security breaches will happen. I think that every site has to assume that it is possible that their site will be hacked and their database stolen.

I'm not suggesting that they just accept the inevitable, and give up. I'm suggesting that everyone that builds a website that collects information from their users (that's every site that has user accounts) should care enough to do their best to ensure that when the site is compromised, the damage is as minimal as possible. That's why the Plenty Of Fish hack was so disturbing. Passwords were apparently stored in the database in clear-text. Once the database was stolen, passwords were readily available, with no further work on the hacker's part.

I had thought that clear-text passwords were such a well-known evil that no-one was doing it any more, but apparently I was mistaken. Web developers who don't know any better apparently still store plain-text passwords so that they can implement the even less-secure feature of emailing it to you if you forget it (or even sometimes even if you don't).

So, what's the right thing to do? Obviously, the most important prerequisites are being aware of the problem, and caring enough about your users to do something about it. If you've read this far, I'll assume that you have those two covered.

The next thing is to not store passwords. Let me repeat that - do not store your user's passwords. By that, I do not mean that you should encrypt the passwords before you store them, though that would be a huge improvement over plaintext. The problem with storing encrypted passwords is twofold. The first, as previously mentioned, is that it may tempt you to decrypt it for some reason (like sending it to the user in an email). The second problem is that unless you are really careful with your encryption, the data thief may very well have the resources to decrypt the passwords.

Instead of storing a user's password, store a cryptographic hash of their password. A cryptographic hash is also known as a one-way hash, and cannot be "decrypted". For authentication, take the user-entered password, run it through the same hash function, and then compare the result to the hash stored in the database. Provide users with the means to securely re-set their password (choose a new one) in the event that they forget it, rather than attempting to send them the old one.

There are still some issues to be aware of when using cryptographic hashes. If there are collisions (two different passwords hash to the same value), and the thief possesses one of the clear-text passwords by some other means, then they can substitute the known password for the one in the other account. Of course, there's always the possibility that two or more users will pick the same password. For example, in the Gawker Media case, the password data was published on the web, and it was revealed that thousands of users had chosen the same few passwords, with '123456' and 'password' leading the list. If you use a simple hash function, then it seems likely that you will have lots of collisions. This makes several attack vectors, like a dictionary attack, or other brute-force attack much more likely to be successful.

The answer to collisions is random salt. By appending random bits to the password before hashing it, you can make the hashes much more likely to be unique. A common method is to generate a new, random salt value for each user, and to store the salt in an additional column in the password table. Making the salt available to a hacker does not make the hashes more susceptible to a brute-force attack if no two of the salt values are the same. One thing to be careful of is using the username for salt - unless you intend to never let a user change their username.

All hash functions are not created equal. As time goes on, and more and more computing power becomes available at relatively low cost, once-unbreakable hash functions become breakable. For instance, SHA-1, apparently still the most widely used cryptographic hash function, was broken in 2005, and the National Institute of Standards and Technology has recommended that federal agencies stop using it. SHA-2, the recommended replacement for SHA-1, while not yet broken, has already been recognized by NIST as potentially insecure, and there is already an effort under way to develop SHA-3.

One-way, randomly-salted SHA-2 (or eventually SHA-3) hashes should solve your password security issues, but what about other user data? What about email addresses, credit card numbers, and the like? I'd like to suggest that the first line of defense is collecting as little sensitive information as possible. Storing credit card information (where legal) is generally unnecessary and provides the potential attacker with substantial incentive. In short, unless you are a credit card company, you probably shouldn't store credit card information.

Other user information should be treated just as carefully - stored only if absolutely necessary, and stored with encryption as secure as possible if it must be stored. Assume from the start that your database will be compromised, and make it as difficult as possible for the data to be used.

There are many other security issues to be concerned about, and I encourage you to research them, but if you care about your users and your reputation, then the least you can do is stop storing sensitive user information in the clear.

Executing JavaScript from Objective-C in an iOS App

2011-02-01T08:25:00.000-05:00

New blog post from Steve Smith, one of the Chariot architects working in our mobile practice. Steve is currently working on updating the mobile app for our Emerging Technologies conference and will be posting articles from time to time as he finds challenges or discoveries.

Here is an excerpt:

The other day, I found the need to execute some JavaScript from a native iOS application. After doing a little research, I discovered that the UIWebView has a stringByEvaluatingJavaScriptFromString method. So I decided to create a quick little proof-of-concept to see how to invoke some JavaScript using this. I am not going to walk through all the details of creating a project, etc. and will cut right to the important aspects of making the JavaScript call from the objective-c code.
We are going to need a JavaScript function to call and a UIWebView to evaluate the JavaScript. It would be nice if the JavaScript function took a parameter as well, so we could also prove out the passing of values. Here is the JavaScript function that I will use:

1var area = function(diameter) {
2     var radius = diameter/2,
3     area = Math.PI * radius * radius;
4     return Math.round(area*100)/100;
5};

Android Development: Best Practices

2011-01-24T15:29:00.000-05:00

Thanks to Anatoly Polinsky for another blog post

I got introduced to an Android application development during Philly ETE conference by listening to “A guided tour of the Android ETE mobile application” talk, where Andrew Oswald ( a Java Architect from Chariot Solutions ) talked about creating an Android app for the conference, which was a cool introduction to “what it takes” to write one of those apps from scratch. I am looking forward to more talks around mobile development this year at Philly ETE conference as well.

Meanwhile I rely mostly on Android’s Developer Guide whenever I seek answers to my questions or/and best practices. Here are my notes on such practices I picked up listening to “A Beginner’s Guide to Android” Google I/O 2010 talk:

Read More....

Enterprise Integration with Spring Training

2011-01-18T17:13:00.000-05:00

Are you a Spring Developer?

Do you have Enterprise solutions to develop or architect?

Chariot Solutions, a Spring Training Partner and Philadelphia leader in Spring Training, Mentoring and Consulting can help you take your Spring skills to the next level - Enterprise Integration!

There are many Spring developers who have learned by experimenting, reading documentation and maybe code dives into an existing application or two. But with the knowledge you gain from Official SpringSource training at Chariot from our certified SpringSource instructors, you can be more equipped to chose the right tools for your complex integration solutions.

The Enterprise Integration with Spring (EIwS) course is not only extremely valuable to any Spring developer it should be REQUIRED for anyone architecting Spring applications.

What is cool in the EIwS course?

Synchronous & Asynchronous Processing
Messaging with Enterprise Integration Patterns
Messaging with JMS
Exposing Services with RMI, HTTP
Web Services with SOAP, REST and WS Security - and why REST is cool!
Spring Local and Distributed Transaction Management - JTA/XA - Open Source distributed transactions without a JEE Server
Service Integration with SMTP (email), File, JMS, FTP, JDBC, TCP/UDP, XMPP, etc.
Polling and Triggering
Tasks and Scheduling of Processes
Message Filtering, Routing, Transformation, Splitting, Aggregating, Bridging and Chaining
Creating Batch processes for inline or offline execution
Monitoring Batch process exceptions
Unit and Mock testing of application layers
Modifying Integration processes without recompiling... AWESOME Right?

One of the key take-aways from this course is knowing which tools are available to choose from and why.

What does Gordon teach?

When I teach the Core or EIwS classes, I go through the common Spring project application layers, and their respective roles and responsibilities. We discuss the tools you have within Spring and which to use to solve integration concerns. In EIwS, the course builds from common concurrency, tasks & scheduling, Messaging with JMS to the flexible power of Spring Integration and Spring Batch tool sets. I teach layering your applications focussing on the power and flexibility of Service POJOs exposing your processes in a Service Oriented Architecture (SOA) manner and keeping your POJOs - Pure business objects, un-compromised by framework or infrastructure java objects.

I am teaching EIwS February 22-25, 2010 in Philadelphia! If you come you will receive:

A shiny new course book
An Official Spring USB thumb drive with SpringSource Tool Suite, Course Documentation PDF, all the labs & solutions
The secret meaning of the acronym "SOA"
Bad humor from your instructor (if I teach you can count on it)
Demo's that Gordon creates (if taking my class)
Lunch, Coffee, Tea & soft drinks

Q&A

Q: What if I have not taken the Core Spring course?
A: It is highly recommended that you attend the Core Spring Course first. Click here to see the Course Schedule

Q: What if I am not using Spring 3 yet?
A: No problem, although the course focuses on 3.0 features, you will still get usable information for your applications.

Q: What will I learn?
A: Scroll up.

Q: What if I already have used some of the topics covered?
A: Relax during those chapters or, even better, provide your "in the trenches" experience with the class.

Q: How can I get management to pay for the class?
A: This course is Essential to my skills, to provide you with better tools to choose the right approach to solving our complex integration needs. Check Here for possible Early Bird Discounts.

Q: Where do I find out about the Enterprise Integration course?
A: Click here for SpringSource Training Site

Q: When is Gordon teaching the class?
A: Click here for the next scheduled course on February 22, 2011

Q: Is there certification for Enterprise Integration Specialist?
A: Check here for the status on Enterprise Integration Specialist Certification

Memorable Quotes:

"Wow, I just learned in 5 minutes what it took me 2 weeks to do in the past"
"A Spring Developer without
"Understanding the layered design of Spring applications really helps me best architect my solutions."
"I really needed to provide file processing into my database, glad I took this class for those implementation discussions"

So, what are you waiting for? Register NOW for Enterprise Integration with Spring!

Simple Spring Social for Twitter Friends

2011-01-17T15:17:00.001-05:00

The Spring Social project provides us developers with an easy way to interact with Twitter, Facebook, LinkedIn & TripIt via the familiar Template objects we have used. Spring has provided Templates for convenient interaction with JDBC, REST, Hibernate, JNDI, and more.

One of the simplest social media calls is to lookup someone's Twitter friends with the TwitterTemplate.

1. Add the Spring Social project dependency to the pom.xml file

<dependencies>
<dependency>
    <groupId>org.springframework.social</groupId>
    <artifactId>spring-social-core</artifactId>
    <version>${spring.social.version}</version>
</dependency>
  ...
</dependencies>

2. Add the Spring Milestone Repository repository to the pom.xml file


<repositories>
  <repository>
    <id>spring-maven-milestone</id>
    <name>Spring Maven Milestone Repository</name>
    <url>http://maven.springframework.org/milestone</url>
  </repository><
  ...
</repositories>

3. Create the TwitterTemplate, and ask for friends

TwitterTemplate twitterTemplate = new TwitterTemplate();
List<String> friends = twitterTemplate.getFriends("chariotsolution");
for (String friend : friends) {
  System.out.println("Friend: " + friend);
}

4. Use the code above anywhere in your application

In the next blog, I will cover how to use Open Authentication (OAuth) to perform more Twitter operations.

Simple Spring Social for Twitter Friends

2011-01-17T12:01:00.000-05:00

Gordon Dickens recently posted on his blog some thoughts on the Spring Social project.

The Spring Social project provides us developers with an easy way to interact with Twitter, Facebook, LinkedIn & TripIt via the familiar Template objects we have used. Spring has provided Templates for convenient interaction with JDBC, REST, Hibernate, JNDI, and more.
One of the simplest social media calls is to lookup someone’s Twitter friends with the TwitterTemplate.
Read more..

An Introduction to Mobile Device Detection

2011-01-10T15:22:00.000-05:00

One of our architects, Steve Smith, recently posted this on his blog:

These days, there are many ways to browse the internet. There are desktop browsers, mobile phone browsers, tablets, tablet/phones (e.g. Dell Streak), etc. all with different screen sizes, resolution, and capabilities. How do you render an appropriate view optimized for the device accessing your site? The answer is device detection.
The two main approaches for device detection are server-side detection and client side detection. Server side detection involves determining the device at the time of the request and then presenting the appropriate view. Client side detection involves manipulating the view after the content has been sent to the browser.

Read the full post..

Build and Release Management With Apache Maven

2010-12-31T07:58:00.000-05:00

More than ten years ago, Joel Spolsky of "Joel on Software" fame wrote The Joel Test: 12 Steps to Better Code. It was a great set of 12 yes/no questions, all of which you should be able to honestly answer "yes" if your team is to have any hope of producing good software in a timely and efficient manner.

The Joel Test stands up pretty well even today. Joel's first two questions, "Do you use source control?" and "Can you make a build in one step?" are a good start at addressing the need for build automation. With the tools available today, however, I suggest that build management (not just automation) and release management should be added to the "must have" list for productive software development teams.

Since I mostly work in Java, I'll talk about Java build and release management. There are a few comprehensive tools for Java build and release management (actually many more build management tools than release management tools), but the most popular by far is Apache Maven.

Maven started in 2001 as a part of the Apache Alexandria project, moved to be a part of the Apache Turbine project in 2002, became a top-level Apache project in 2003, and had its first milestone release, v1.0, in October of 2005. Version 2.2.1 has been in wide use since its release in August of 2009. Version 3.0 was released in October of 2010, and the current version, 3.0.1 was released in November 2010.

Maven bills itself as a "software project management and comprehension tool". Its most basic use is as a build tool, commonly as a replacement for Apache Ant, but it does several other things, which taken together, really do form a useful software project management and comprehension tool. Maven is certainly not an absolute requirement for a good software development team, but the issues that it addresses must be addressed somehow. If your Java development team is not currently addressing these issues in a satisfactory way now, Maven is a good way to get started addressing them in a coherent way.

As a build tool, Maven takes the now-common "convention over configuration" approach that seems to have started around 2004 with the Ruby on Rails web framework. As such, Maven was designed to be a highly opinionated tool, giving structure to the free-for-all that Ant usage had become in many projects. Maven is based on the Project Object Model, an XML configuration file that specifies what goes into a project, but unlike Ant, generally not how to build it. This is where the convention over configuration comes in - you put your source code and other build artifacts in a directory structure that Maven expects, and then Maven can build it with no further configuration. This results in both simplified build management (no build script to write and maintain), and a project that anyone familiar with Maven can build. There is a well-defined build lifecycle, with well-defined targets: "mvn install" builds, tests, and packages any project built with Maven, and installs the resulting artifact in a local repository (more about repositories later). This is a great improvement over Ant, where the names of the build targets, and what they do are up to the whim of the person writing the Ant build script.

Maven is much more than just a build tool. It has many more features, but to me, the most important are Dependency Management and Release Management.

Dependency Management is all about dealing with the libraries (jar files) upon which your project depends (direct dependencies), and those jar files' dependencies (transitive dependencies). With Ant or any other build system that does not manage dependencies, this is left as a manual exercise for the developers. Typically, all of the dependencies are resolved manually, and all of the jar files are put into the project's 'lib' directory. This frequently means that multiple projects using the same third-party libraries will each need to keep a copy of them.

Maven's paradigm is to have the developer declare the project's direct dependencies in the POM. Maven then resolves the transitive dependencies, and pulls the required jar files (direct and transitive dependencies) from a Maven Repository at build time. Jar files are not kept within the project, just the specification of which jar files to use at build time. There is a "standard" external repository (the "central" repository) that is web-based, and hosted by maven.org, and a local repository in the filesystem on the developer's machine. Jar files are pulled from the central repository, or other external repositories that may be configured, and cached in the local repository.

This arrangement works well for small, one-off development efforts, but many shops have reusable jar files of their own that are used by multiple internal projects. Historically, many development teams have distributed these reusable in-house developed jar files by either putting them on a shared network directory, or by checking them into the source code version control system. This results in a process that is more manual and cumbersome than it should be, and generally violates the DRY principle.

Using Maven instead of Ant or a home-grown build system, and managing dependencies through it are a good first step, but for reusable code, Release Management becomes important, and again, Maven can help. Maven, through its release plugin, supports a well-defined release lifecycle, and allows teams to store their reusable code in a centralized Maven repository, just like the "standard" jar files that are kept in the central repository. Teams (or whole companies) can set up their own internal, web-based repository that either enhances or replaces the central repository. Using Maven, they can then "release" their jar files to this repository. Projects using Maven can then declare these jar files as dependencies the same way that they do for jar files in the central repository, and they will be resolved by Maven. No need for shared directories, or placing binaries in the source code version control system. The release plugin takes care of incrementing version numbers and updating them in the version control system, in a standard way.

The features that have been presented here are just the most prominent ones - Maven is capable of much more, especially with its extensive list of plugins. If your team is not using Maven (or something like it), or is only using Maven as a build tool, I encourage you to spend some time learning more about Maven. It will be time well spent. There are the Maven project's own "Getting Started" guides and a series of books by Sonatype (the commercial company behind Maven) for starters.

Sonatype provides online, instructor-led training courses, and here at Chariot Solutions, we offer public, on-site training in our Ft. Washington, PA facility, as well as custom private courses.

Painless Java Desktop Application Development with Griffon, MigLayout, and IntelliJ

2010-12-28T12:37:00.000-05:00

As Java consultants and developers, a very large percentage our projects are web applications.
We have become accustomed to depending on MVC web frameworks, and almost take for granted that at some level, we will be handling HTTPServletRequests, providing HTTPServletResponses, and deploying our applications to either a servlet container or a full J2EE server.

Every once in a while, however, the need arises to write an old-fashioned, desktop, thick-ui, non-web-centric application. If you have ever written a Java Swing application, you may have painful memories of dealing with things like BorderLayouts, GridBags, Event Listeners and Event Dispatching Threads, JFrames, and the like.

As a web developer, when you think about building your desktop application, you might start to think about how you will structure your application, and how you will build and package it. Will you have to re-package your code and all of your dependencies in one giant uber-jar?
Will you make it a web-start application? Fortunately, some folks have been thinking about, and working on these issues.

Griffon is a Groovy-based MVC framework for writing desktop applications. It is written by the Groovy Swing team, and is heavily influenced by Grails. If you have worked with Grails, then Griffon will be a very familiar environment. Griffon answers all of the above questions, and more.

Using the convention-over-configuration and command-line-driven scaffolding paradigms made popular by Ruby on Rails, Django, and Groovy on Grails, among others, Griffon generates the project structure, the model, view, and controller objects, and all of the configuration for you. You then customize these to produce your application.

Working in Groovy, of course, makes this a much more pleasurable experience, dispensing with the ceremony of Java development, and letting you write high-level, fairly terse, yet expressive code, and enabling you to accomplish quite a bit very quickly. The prime example of this in the Griffon framework is the SwingBuilder object - a Groovy Builder that provides a DSL for building Swing user interfaces. Views in Griffon are SwingBuilder scripts, and greatly simplify the task of creating Swing UIs.

Griffon uses the Gant build system (as does Grails), and by default, packages your application with all its dependencies as an uber-jar (with the correct manifest entries to make it 'executable'), as an applet, and as a java-webstart application.

When working with Swing, even with the SwingBuilder, one potentially still has to deal with the frustration of laying out the user interface by using a LayoutManager. GridBagLayout is flexible (too flexible?), but about as complicated as it can get. BorderLayout is fairly simple, but the simplicity comes at a cost - you typically wind up nesting lots of BorderLayouts in other BorderLayouts to get the desired behavior. Over the years, alternate layout managers have appeared, and some are quite useful, most notably the JGoodies Form Layout and RiverLayout. I tried MigLayout with my Griffon project, and found it to be very flexible and easy to use.

Here is a screenshot of the main UI of my application:

As mentioned previously, the View is a Groovy SwingBuilder script. The first part of the script sets up an 'application' - the application's "MainFrame", which Griffon interprets according to the runtime environment - for a stand-alone application, it will build a JFrame, and for an applet it will build a JApplet:

package servicetester

import java.awt.FlowLayout
import net.miginfocom.swing.MigLayout

application(title: 'Service Tester', minimumSize: [297, 200], maximumSize: [297,200], location: [50, 50], pack: true, locationByPlatform: true) {

Note that minimumSize, maximumSize, location, etc. are set as properties here. In straight Java Swing code, these would have been at least one line of code each, and several would have involved building Dimension objects.

Next is setup of the actions and the menu bar that uses the actions, in this case, a simple 'File' menu with a 'Quit' menu item to exit the application.
Note the use of Groovy closures for associating the Action object with implementation of the action.

actions {

    action(id: 'exitAction',
            name: 'Quit',
            closure: { System.exit(1) },
            mnemonic: 'Q',
            accelerator: shortcut('Q'),
            shortDescription: 'Quit'
    )
  }

  menuBar(id: 'menuBar') {

    menu(text: 'File', mnemonic: 'F') {
      menuItem(exitAction)
    }

  }

I chose to use the MigLayout for the main panel of the view. There are lots of ways to initialize a MigLayout, I used the "fill" parameter to the constructor, which tells it to grow to occupy all available space, which makes sense here because it is the top-level component in the frame.

panel(border: emptyBorder(12), layout: new MigLayout('fill')) {

As you can see in the screenshot, there are three groupings of controls - the group of fields above the separator (the input fields), the group of fields below the separator (the output fields), and the "button bar" at the bottom (only one button). To achieve these groupings, I added two panels, each with MigLayout initialized with "fill", as with the main frame, and a third panel with a FlowLayout for the button bar.
These MigLayouts are given constraints of "growy" and "wrap":

panel(layout: new MigLayout('fill'), 
          constraints: "growy, wrap") {

"growy" means "grow vertically", and "wrap" means that the next component should be placed below, instead of to the right.
With this configuration, the MigLayout in the main frame gives the button bar it's preferred size, and resizes the other two panels as the main window is resized, giving equal weight to them.

The two MigLayout panels are very similar. Each has sets of label / input field pairs, which look like:

label(text: 'AMQ Broker URL:')
      textField(
              id: 'brokerUrl',
              columns: 40,
              text: bind(target: model, targetProperty: 'brokerUrl', value: model.brokerUrl),
              enabled: bind {model.enabled},
              constraints: 'wrap'
      )

The "text:bind" property binds the value entered in the textField to a property in the model - the value entered by the user is placed into the model.

One big "gotcha" here is that bi-directional binding is not supported. It is possible to bind in each direction, but not both directions at the same time. As one might expect, lots of people are asking for this capability, so I wouldn't be surprised to see it show up soon. I ran into this when trying to set the initial value of the field from the value in the model. The answer for this case is to use the "value" property as shown above - it gives the field it's initial value, and does not participate in the binding mechanism, so it doesn't present the same problem as bi-directional binding. If you do truly need bi-directional binding, at the moment, you'll have to roll your own.

Here is the full source code for this View.

Due to its highly-developed sense of structure and general lack of need for configuration, working on a Griffon application using the command line and a text editor is very straightforward. However, IDE support is always nice. Eclipse does not directly support Griffon, but does support Groovy. Both NetBeans and IntelliJ have direct support for Griffon projects. IntelliJ 9 and 10 have direct support for creating, importing, testing, running, and debugging Griffon applications, and I found these features to work quite well.

I found the combination of Groovy, Griffon, MigLayout, and IntelliJ to be an extremely productive environment for creating Swing applications, providing much of the application infrastructure, allowing me to dispense with ceremony and concentrate on writing the parts of the application that make it unique. Before embarking on a large or mission-critical Griffon project, however, you do need to be aware that Griffon is still in Beta (0.9.2-beta-3 was just released on Dec. 21st, 2010), and so is still in a bit of a state of flux.

If you are interested in reading about Griffon, there's documenatation at at the Griffon home page, and the Griffon In Action book is available from Manning.

Nielsen: Android makes huge gains in US smartphone marketshare, RIM takes a backseat, Apple leads in desirability -- Engadget

2010-12-01T14:03:00.001-05:00

via engadget.com

Spring into Mobile Application Development

2010-11-24T13:13:00.001-05:00

Spring into Mobile Application Development

Posted on November 19th, 2010 by Keith Donald in Spring.

At SpringOne2gx we announced exciting new initiatives in the areas of social media and mobile application development. A few weeks ago, Craig Walls released Spring Social. Today, Roy Clarkson released Spring Mobile and Spring Android. In this post, I'd like to highlight these projects and share how Spring aims to simplify mobile application development.

Choices in Mobile Application Development

If you attended SpringOne2gx this year, you've seen Greenhouse, an app we built for our community that also serves as a reference and driver for Spring technology. Craig showed you some of the social elements of Greenhouse, such as the ability to connect your account with Twitter and Facebook. There are also a number of mobile elements. Specifically, Greenhouse doubles as a mobile web app, and sports native Greenhouse for iPhone and Android clients.

Like many organizations today, we had to answer the basic question of "what mobile platforms to target?" In the end, we chose to invest in a native experience for iPhone and Android users, while also developing a cross-platform mobile web app. Our decision to go native was driven by the fact the app is consumer-oriented, and a large number of prospective consumers (application developers) own iPhone and Android devices. At the same time, the mobile web app aims to provide a good baseline experience that works cross-platform, something that's possible today with the rise of WebKit and HTML 5.

From our development work, grew Spring Framework contributions: first, a Spring Mobile project that provides extensions to Spring MVC for developing mobile web apps; and second, a Spring Android project that supports the development of native Android clients that communicate with Spring-based back-ends. I'll take you through each of these projects in turn.

Spring Mobile

The first problem we tackled was designing a web app that was pleasant for mobile visitors to use. While a smartphone may have a capable web browser, it still has a small screen and that needs to be accounted for. There are essentially two approaches to dealing with this problem:

Detect the device that originated the web request and serve a separate site to mobile devices.

Serve a single site, but progressively enhance it for desktop users by using CSS 3 media queries and JavaScript.

You can find examples of both techniques in the wild today; for example, the conference site Lanyrd enhances through client-side detection, while SpeakerRate uses server-side detection that redirects mobile visitors to a separate site (see for yourself by installing the Firefox User Agent Switcher and setting your user agent to iPhone).

In Greenhouse, we started with server-side detection. Specifically, we aimed to apply a different page layout if the device was a mobile device. Out of this grew a general purpose "Device Resolver Abstraction", which is the defining feature of Spring Mobile 1.0.0.M1. Some highlights of this feature include:

A HandlerInterceptor that uses a DeviceResolver to detect the Device that originated the current HttpServletRequest.

The ability to inject the detected Device into @Controller methods and view templates to vary logic by device type.

Below are some usage examples from the Greenhouse codebase. First, have a look at the interceptor definition from /WEB-INF/spring/appServlet/servlet-context.xml:

view source
print ?
1 <interceptors>
2 
3 <beans:bean class="org.springframework.mobile.device.mvc.DeviceResolvingHandlerInterceptor" />
4 </interceptors>

Now, a JSP template that conditionally renders some content if the device is not a mobile device:

view source
print ?
1 Please try again<c:if test="${!currentDevice.mobile}"> or <a href="<c:url value="/signup" />">sign up</a></c:if>.

Finally, a Tiles-based page layout that changes if the device is a mobile device:

view source
print ?
1 <definition name="page" templateExpression="/WEB-INF/layouts/${currentDevice.mobile ? 'mobile/' : 'standard/'}page.jsp" />

In addition to these features, Spring Mobile 1.0.0.M1 ships:

A HandlerInterceptor that redirects mobile visitors to another URL. This is useful if your mobile site truly is a separate application. Consider Flickr, for example, which will redirect you to m.flickr.com if you access www.flickr.com from your phone.

A DeviceResolver implementation that delegates to WURFL for device detection. WURFL provides a large database of devices and their capabilities. It is useful when you need to know more about the Device that originated the request, such as its specific screen size, manufacturer, model, preferred markup, or other capabilities.

Recently, we have also begun exploring the use of CSS 3 media queries with JavaScript to perform client-side detection. This approach has the advantage of not requiring special server-side handling unless you aim to vary the semantic content you send to the device, and not just optimize the style. Not all browsers support media queries, so they may not be an option for you, but if you're targeting smartphones with WebKit-based browsers you should be fine. In general, the approach of first designing your app for mobile, then progressively enhancing it for desktop feels quite elegant to me.

Spring Android

For the Android client, a different set of challenges emerged. We needed to exchange data with the server over HTTPS via REST, and since that data is user-specific we require the user to sign in. Rather than use Basic Auth, where we would need to store username and password credentials on the device itself, we opted for OAuth.

OAuth is an emerging standard that provides a token-based authorization scheme. Essentially, a username and password is traded for an access token, and the access token is used to make requests for protected resources. This means you only need to store the access token with the device for "remember me" functionality. Furthermore, we chose to implement the sign in process whereby the client takes you to the server's web site for connection authorization. In this way, the client never sees your username and passsword, which is important if you allow third-party clients to be developed against your API (which we also want to encourage). Finally, in the event a user's phone is stolen or otherwise compromised, an access token can be invalidated without the risk of username and password compromise.

Out of this work, came the desire to get specific modules of the Spring Framework working in an Android environment. Specifically, we aimed to use RestTemplate for the REST API calls, and Spring Security for the OAuth client.

I'm pleased announce that the first milestone of Spring Android ships an "Android-ready" RestTemplate. We're using it in Greenhouse, and we encourage you to use it as the REST client in your own Android applications. Check out the example usage below:

view source
print ?
1 RestTemplate restTemplate = new RestTemplate(new CommonsClientHttpRequestFactory());
2 Event event = restTemplate.getForObject("https://myapp.com/event/{name}", Event.class, "springone2gx");

In future milestones, you can expect more of the Spring Framework to be supported in an Android environment, such as the Spring Security OAuth client.

Getting Started

The best way to get started is to see it live by walking through the Greenhouse app in your own local development environment. As a reference, Greenhouse uses the Spring Mobile and Spring Android projects, as well as Spring MVC, Security, Social, and Integration. The project page provides a guide that shows you how to get the web app, iPhone client, and Android client all running in your local environment in minutes.

If you have questions about features, roadmap, or just want to have a discussion with the development team, please do visit our community forums. We value your feedback.

Summary

I'm very excited about all the new initiatives we've got going, and especially what we're doing in the social and mobile space. The first milestones of these projects are just the beginning. I encourage you to get involved in the projects that are useful to you and help us make them the best they can possibly be.

via blog.springsource.com

Need to check this out for some old Spring stuff I have worked on :)

NFC. What does it all mean?

2010-11-16T22:55:00.001-05:00

NFC: Near Field Communications: a short-range high frequency wireless communication technology which enables the exchange of data between devices over about a 10 centimeter (around 4 inches) distance (via Wikipedia).

Well that's great, but what does it mean, especially when mentioned in conjunction with Gingerbread?

As you may (or may not) have heard this week at the Web2.0 Summit Eric Schmidt talk about Android 2.3 and its support for NFC. This could indeed lead the way for mobile payments on devices. NFC will allow for the transmission of credit card data over a defined radio frequency (13.56 MHz).

This isn't new, Japanese handsets (Keitai) have had this type of technology for a while (I want to say up to 10 years, but I can't back that up right now). Go google Osaifu-Keitai/keitai credit.

However this *is* all exciting news. There is potential for integrating it with conferences, museums, travel, healthcare, payment systems, and countless other things. Lets not forget though, some of these things already exist already:

Exxon SpeedPass
Debit cards with Visa PayWave.

Now we have another new way to gain information about our surroundings. #mobilefirst anyone?

Some interesting articles to peruse at your leisure.

RFID in Museums - Another Growing Market

Who Will Win the Mobile Payments Battle: Gadgets, NFC or Apps?

Intuit Squares Off In Mobile Credit, With A Little Help From Apple

Future Credit Cards: Electronic and RFID?

Web 2.0 Summit 2010: Eric Schmidt, "A Conversation with Eric Schmidt"

Configuring LogBack in Roo

2010-11-11T12:38:00.000-05:00

Gordon Dickens, one of our trainers and architects, recently posted this on his Technophile Blog, on Roo.

LogBack is the more versatile logging strategy created by the same person that created log4j. Use the following steps to configure your Roo 1.1 project to use LogBack.
See Also: Reasons to Switch to LogBack

1. Create a `logback.xml` file in `src/main/resources`

`Cont. here for the remainder of the post`

Post Presentation Thoughts from our Mobile Seminar

2010-11-10T15:34:00.000-05:00

Kevin Griffin was one of the presenters at our first Mobile Seminar Breakfast. Below is a recap of his thoughts after he finished his presentation.

Yesterday I presented at the first in a series of events for Chariot Solutions, the topic was 'Mobile Design Concepts'.

My goal was to try present things that I had learned/seen/been shown/done over the last couple of years, and try to get the audience out of the 'desktop browser' mind set when developing for mobile.

I drew from a lot of people that I have seen/meet including Luke Wroblewski (@LukeW), Josh Clark/Tapworthy (@globalmoxie), Mike Lee (@bmf) William Van Hecke (@fetjuel) and Brian Fling's book 'Mobile Design and Development' which I still think is the first book anyone planning on a mobile project should read. I was probably influenced by many more folks than that, but they are the obvious ones to me at the time of writing.

Cont. reading..

Grails Validation Constraints Quick Ref

2010-11-08T09:51:00.000-05:00

This is an excerpt from a blog post by Gordon Dickens, Chariot Architect and Trainer (via Technophile Blog)

After several iterations of Grails, we have to go to 17 (seventeen) pages to see all the validation constraints? I wanted to see them on one page.

Grails 1.3.5 – Validation Constraints

blank – To validate that a String value is not blank

creditCard – To validate that a String value is a valid credit card number

cardNumber(creditCard:true)

email – To validate that a String value is a valid email address.

Click here for the rest of the article

Monthly Mobile Musings from September

2010-10-04T19:10:00.000-04:00

Firstly I should apologize for being a few days late, September was a busy month!

I had the privilege and pleasure of joining a top notch panel discussion at 'Mobile Monday Mid-Atlantic' talking about mobile strategy. For anyone in the Philadelphia area interested/participating in mobile development, Mobile Monday is a must attend event, they have some great topics coming soon and we had a great attendance for the panel discussion again. My thanks again to MOMO-MA for the opportunity to speak and to the audience for the great questions which drove our discussions. I posted my morning after thoughts on my blog.

So back to the mobile news, September saw an interesting trend in rumors regarding new Android Markets, both Verizon and Amazon(!?) were floated as potentially offering alternatives, perhaps fueling the fragmentation. Legit news about Android Market expansion has them now featuring submissions from 20 new countries and taking paid markets up to 32 countries.

In a month where I got excited (yet again) over a new handset, the Nokia N8 supposedly launching next month (running Symbian 3) coupled with the Nokia and AT&T developer competition got us thinking finally Nokia would get the respect they deserve here in the US. Then Samsung spoiled it all by announcing it's plans to drop support at the years end, presumably to big up some WP7 love.

Speaking of WP7 love, I attended a Windows Phone 7 Fire-starter event here in Philly this month. My thoughts on that can be found on my blog. They are also having a launch event this month (October 11th) which engadget will be live at, check the details here.

Time for some Chariot house keeping, we have been hard at work getting ready for ETE 2011 (oh yes, already) and we have some *outstanding* mobile speakers already which will be announced soon, along with the rest of the line up. We are starting a mobile seminar series here in Philadelphia, starting on November 9th featuring a variety of talks and discussions, aimed at helping business identify their mobile needs and how to fulfill them.

Setting up TeamCity CI w/ Cucumber, Flex, FunFX, and Firefox in a Headless Environment: Part Two

2010-09-16T11:40:00.000-04:00

Recently I had the “opportunity” (read: challenge) to setup a continuous integration build for a project with a Flex frontend and a Ruby/Rails backend. The project had been converted from Java-Hibernate-Tomcat to Ruby on Rails. Cucumber was introduced for GUI testing using the FunFX adapter. It was my first experience with Cucumber, so the combination of Cucumber, FunFX, Flex, and Firefox was a little daunting at first. But we got through it and actually, it turned out to be quite an effective tool in our testing suite.

But the fun really started when I was tasked with building the TeamCity CI server for our project. And after it was all over, I felt I needed to document the trip so others might benefit from it, if not just for posterity. This is the second part of the two-part series on that journey.

Continuing…

In the first part we installed the open source software we are using: Java, Ruby, Rails, and all the required Ruby Gems, as well as the Flex 4.1.0 SDK, Firefox, FlashPlayer, and the Git client. The FunFX adapter for Cucumber uses JSSH to communicate with Firefox, so we configured and built Firefox with JSSH to run in a headless environment. We installed the latest Flex 4.1.0 SDK and the FlashPlayer 10.1 plugin for Firefox.

So what we have left is the installation and configuration of TeamCity itself as well as the setup of the build process for our Cucumber, Flex, and FunFX sample project.

So let’s get started.

Install TeamCity

Download the latest version of the Professional TeamCity software from the TeamCity web site for the appropriate platform. The Professional version is free but is limited in number of projects, build configurations, and users. We will only define one project and are well within the limit for build configurations.

We will be executing the installation instructions detailed on the TeamCity web site to install TeamCity bundled with the Tomcat servlet container on a Linux platform. They are relatively simple and are documented here. If you wish to install TeamCity to an existing Tomcat servlet container or on a different platform, please refer to the instructions for your specific environment.

We will be using the default admin user that we’ll define during installation. We will also be using HSQLDB and the default build agent. Most of the defaults will suffice for our installation.

Copy the TeamCity tar.gz file to the TeamCity server. SSH into the TeamCity server as yourself. Copy the TeamCity tar.gz file from /home/teamcity to /usr/local, unpackage the tar.gz file, and create a symlink to the TeamCity install directory. You will also need to change the owner of the TeamCity install directory to the 'teamcity' user.

$ cd /usr/local
$ sudo cp /home/teamcity/TeamCity-5.1.3.tar.gz .
$ sudo tar -xzvf TeamCity-5.1.3.tar.gz
$ sudo ln -s TeamCity teamcity
$ sudo chown -hR teamcity TeamCity

Logout as yourself and SSH into the TeamCity server as the ‘teamcity’ user. We will run the TeamCity CI server under this ‘teamcity’ user.

Since there is no physical display device attached to the TeamCity server, we need to indicate to TeamCity it will be running in headless mode. This is done by setting TeamCity’s java.awt.headless Java options property to true. You can either create a setenv.sh file in the bin directory or add the statement to the catalina.sh file. If you are installing TeamCity to execute in an existing Tomcat servlet container, add the statement to the catalina.sh file in its Tomcat installation’s bin directory.

$ cd /usr/local/teamcity/bin
$ echo 'JAVA_OPTS="$JAVA_OPTS -Djava.awt.headless=true"' > setenv.sh
$ chmod +x setenv.sh

You should also set the TEAMCITY_SERVER_MEM_OPTS and TEAMCITY_AGENT_MEM_OPTS environment variables as described in the instructions for the TeamCity startup options. Although these values may vary according to your build requirements, we set our values as follows:

TEAMCITY_SERVER_MEM_OPTS	-Xms512m -Xmx1024m -XX:MaxPermSize=1024m
TEAMCITY_AGENT_MEM_OPTS	-Xms512m -Xmx1024m -XX:MaxPermSize=1024m

Start the server with the following command:

$ sh /usr/local/teamcity/bin/runAll.sh start

Then bring up the TeamCity application in a local browser (http://localhost:8111). When the application is initialized for the first time, you are presented with the licensing and conditions of use page. After agreeing to the license, you are prompted to create an administrator account. Fill in the fields as appropriate and create the account. If you log out of TeamCity, use the credentials created here to log back in.

Create a CI Project

After creating the administrator account, you are presented with the Projects page. Select the Create Project link. Enter the appropriate values in the respective fields of the resulting screen:

Name:	FC Converter
Description:	Fahrenheit to Celsius Conversion project

Press the Create button.

Next we will associate the project with a version control system. Select the VCS Roots tab and then the +Create VCS root link.

Enter an appropriate VCS rootname and select the type of VCS from the dropdown.

The remainder of the screen is refreshed with the fields for the respective VCS. We are illustrating Git here. Enter / select as appropriate for the respective fields:

VCS rootname:	fc_converter-root
Type of VCS:	Git (Jetbrains)
Fetch URL:	git://github.com/landerson/FC-Converter.git
Push URL:	(leave blank to use Fetch URL)
Branch name:	master
Clone repository to:	checkout
User Name Style:	Userid(jsmith)
Submodules:	Checkout
Authentication Method:	Anonymous
User name:	(leave blank)
Path to git:	/usr/bin/git(or as appropriate)
Clean Policy:	(as appropriate)
Checking Interval:	(as appropriate)

Press the Test Connection button to test the SSH handshake with github. The test should succeed. The test must succeed in order for the TeamCity build configuration to work properly. After the test succeeds, press the Save button.

Select the General tab to return to the main project page. It is from this page that we will create the build configuration for this CI project.

We will create the following build configuration steps:

checkout the project from the source repository and update the Ruby gems,
compile the Flex source modules,
restart the webserver, and
run the Cucumber FunFX tests.

First we will create a build step to gather the sources and update any required Ruby Gems. Select the +Create build configuration link. Enter the following in the respective fields of the resulting General Settings screen:

Name:	Step 1- Collect Sources
Description:	Checkout sources and update gems.
Fail build if:	check ‘an error message is logged by build runner’

Leave the remaining fields blank or checked as-is to accept the defaults.

Press the VCS Settings button and enter the following in the respective fields of the resulting Version Control Settings screen:

+Attach existing VCS root:	fc_converter-root
VCS checkout mode:	Automatically on server
Checkout directory:	checkout
VCS labeling mode:	Do not label
Choose VCS roots to label:	(leave blank- do not check)

The “Automatically on server“ selection will cause the project source to be checked out of the source repository into the TeamCity project working directory.

Press the Choose Build Runner button and enter the following in the respective fields of the resulting Build Runner screen:

Build runner:	Rake
Rake tasks:	gems:install

Uncheck any Attached reporters that may be checked and leave the remaining fields blank.

Press the Save button to create the build configuration. The screen is refreshed and should show the following message:

Build configuration "Step 1- Collect Sources" has been created successfully.

Select FC Converter Project in the Administration > FC Converter Project > Step 1 ... banner line just under the tabs at the top of the page to return to the main project page. If you named your project differently, your project ‘s name will appear in the banner line.

Next we will create a build step to compile the Flex source modules. Select the +Create build configuration link. Enter the following in the respective fields of the resulting General Settings screen:

Name:	Step 2- Flex Compiles
Description:	Compile the Flex source modules.
Fail build if:	check ‘an error message is logged by build runner’

Leave the remaining fields blank or checked as-is to accept the defaults.

Although we are not checking out the sources in this step (or any subsequent step), we still need to specify the VCS settings to tell TeamCity where the sources are, e.g., in the checkout directory. Press the VCS Settings button and enter the following in the respective fields of the resulting Version Control Settings screen:

+Attach existing VCS root:	fc_converter-root
VCS checkout mode:	Do not checkout files automatically
Checkout directory:	checkout
VCS labeling mode:	Do not label
Choose VCS roots to label:	(leave blank)

Press the Choose Build Runner button and enter the following in the respective fields of the resulting Build Runner screen:

Build runner:	Rake
Rake tasks:	flex:compile

Uncheck any Attached reporters that may be checked and leave the remaining fields blank.

Press the Save button to create the build configuration. The screen is refreshed and should show the following message:

Build configuration "Step 2- Flex Compiles" has been created successfully.

Under the right hand column titled Configuration Steps, select 6 Properties and Environment Variables. On the resulting screen, select +Add new variable under Environment Variables. Enter the following in the respective fields of the resulting screen:

Name:	FLEX_HOME
Value:	/usr/local/flex_4_sdk

and press the Save button.

Again, select FC Converter Project in the Administration > FC Converter Project > Step 1 ... banner line just under the tabs at the top of the page to return to the main project page. If you named your project differently, your project ‘s name will appear in the banner line.

Next we will create a build step to restart the Rails web server. Select the +Create build configuration link. Enter the following in the respective fields of the resulting General Settings screen:

Name:	Step 3- Restart the Web Server
Description:	Stop and start the Rails web server.
Fail build if:	check ‘an error message is logged by build runner’

Leave the remaining fields blank or checked as-is to accept the defaults.

Although we are not checking out the sources in this step we still need to specify the VCS settings to tell TeamCity the sources are in the checkout directory. Press the VCS Settings button and enter the following in the respective fields of the resulting Version Control Settings screen:

+Attach existing VCS root:	fc_converter-root
VCS checkout mode:	Do not checkout files automatically
Checkout directory:	checkout
VCS labeling mode:	Do not label
Choose VCS roots to label:	(leave blank)

Press the Choose Build Runner button and enter the following in the respective fields of the resulting Build Runner screen:

Build runner:	Rake
Rake tasks:	webserver:stop webserver:start
Additional Rake command line parameters:	RAILS_ENV=cucumber

Uncheck any Attached reporters that may be checked and leave the remaining fields blank.

Press the Save button to create the build configuration. The screen is refreshed and should show the following message:

Build configuration "Step 3- Restart the Web Server" has been created successfully.

Finally, we will create a build step to run the Cucumber FunFX tests. Select the +Create build configuration link. Enter the following in the respective fields of the resulting General Settings screen:

Name:	Step 4- Run Cucumber Tests
Description:	Run the Cucumber FunFX Tests.
Fail build if:	check ‘an error message is logged by build runner’

Leave the remaining fields blank or checked as-is to accept the defaults.

+Attach existing VCS root:	fc_converter-root
VCS checkout mode:	Do not checkout files automatically
Checkout directory:	checkout
VCS labeling mode:	Do not label
Choose VCS roots to label:	(leave blank)

Press the Choose Build Runner button and enter the following in the respective fields of the resulting Build Runner screen:

Build runner:	Rake
Rake tasks:	ci:features

Uncheck any Attached reporters that may be checked and leave the remaining fields blank.

Press the Save button to create the build configuration. The screen is refreshed and should show the following message:

Build configuration "Step 4- Run Cucumber Tests" has been created successfully.

Name:	DISPLAY
Value:	localhost:1.0

and press the Save button.

Again select +Add new variable under Environment Variables. Enter the following in the respective fields of the resulting screen:

Name:	CUCUMBER_FORMAT
Value:	progress

and press the Save button.

Select the Projects tab in the top left of the screen to display the build configuration steps for the FC Converter project.

Perform First Build

We’re now ready to execute our first build. We will use the first build configuration step we created to clone the project source for the first time.

To run the first step, press the Run button to the left on the Step 1- Collect Sources line. This will add the step to the build queue and it should begin executing immediately. You should see the 'Running:...' message underneath the step title line within seconds. When the step has completed, 'Running:...' should be replaced with 'Success'.

To view the output of the build step, hover the mouse pointer over the down arrow adjacent to the 'Success' label and select the 'Full log' choice in the resulting drop down menu. Take note of the checkout directory in the log - we will reference this later.

[10:19:14]: Checkout directory: /usr/local/TeamCity/buildAgent/work/fc_converter
[10:19:14]: Updating sources: server side checkout...
[10:19:14]: [Updating sources: server side checkout...] Will perform clean checkout. Reason: Checkout directory is empty or doesn't exist
[10:19:14]: [Updating sources: server side checkout...] Building clean patch for VCS root: fc_converter-root
[10:19:14]: [Updating sources: server side checkout...] Repository sources transferred: 2.59Mb total
[10:19:14]: [Updating sources: server side checkout...] Removing /usr/local/TeamCity/buildAgent/work/fc_converter
[10:19:14]: [Updating sources: server side checkout...] Updating /usr/local/TeamCity/buildAgent/work/fc_converter

This is the directory that contains the source for the FC Converter project. Press the browser's back button to return to the FC Converter project page.

The remaining steps of the build process can be setup to automatically run after successful completion of the immediately previous step. We’ll describe how to do this using the second step as an example. Then you can repeat the process for the third and fourth steps, selecting the appropriate preceding step in each.

Hover the mouse pointer over the down arrow immediately following the title of the second step, Step 2- Flex Compiles, to expose the dropdown menu. Select Edit Settings from the dropdown menu and the General Settings page for the step is displayed.

Select Build Triggering from the list under the Configuration Steps heading on the right margin of the page. We are going to add a build dependency trigger. Select the +Add new trigger link and then select Build Dependency Trigger in the Trigger Type dropdown of the pop-up window. Select Step 1- Collect Sources from the Build Configuration drop down and press Save.

Select the Projects tab at the top of the page to return to the FC Converter project page. Repeat the steps above starting with hovering the mouse pointer for the remaining two steps, selecting the previous step as a build dependency.

When you have finished setting the dependencies, press the Run button in the right margin of the Step 2- Flex Compiles step to launch the remainder of the build process. Each step will execute upon successful completion of the previous step. You can view the results of an individual step by hovering the mouse pointer over the down arrow immediately following the ‘Success’ status label under the step title and selecting either ‘Short log’ or ‘Full log’.

Points of Interest…

Referencing the checkout source directory of the FC Converter project (/usr/local/TeamCity/buildAgent/work/fc_converter)…

In the features/support directory you will notice two files: env.rb and firewatir_firefox_patch.rb. Files in the support directory are loaded by Cucumber prior to running features. The purpose of env.rb is to set up the environment for running features. The purpose of firewatir_firefox_patch.rb is as its name indicates: a patch for the FireWatir::Firefox class. The patch is to support a headless Firefox environment by pre-pending DISPLAY to the command that invokes Firefox.

The features/step_definitions directory contains the fc_converter_steps.rb file which defines the templates for the Cucumber steps used in the features/fc_converter.feature file.

Some things you may want to investigate on your own:

Setting a build trigger for the first step dependent on SCM updates.
Adding more features and Cucumber steps to support them.
Generating some reports from the TeamCity server.
Setting up email notifications on successful and / or failed builds.

Conclusion…

Although our project is a very simple example of using Cucumber, Flex, FunFX, and Firefox, the purpose of this article is to illustrate the setup of the server environment to support a remote, headless, continuous integration environment. And although it’s a little complex, it’s a once-and-done thing. Setting up TeamCity is relatively simple.

Hopefully the log of this journey has helped you in your quest to get Cucumber FunFX tests running in a remote CI environment.

Oh, and if you’re inclined, Chariot Solutions is running a CI event this fall.

In the future, look for a sister post to this one where we’ll use Hudson as our CI server.