Thursday, July 12, 2012

Using Maven to Integrate Flyway in an Existing Database-
Part 2

This is the second article of a two-part series on using Maven to integrate Flyway in an existing database. It addresses several key issues including using Maven profiles to manage promotion of migrations to hierarchical levels of a database as well as managing migrations across multiple disparate projects that use the same database.

Unless you are an experienced Maven and Flyway user, it is suggested you review the first article of this series, Using Maven to Integrate Flyway in an Existing Database- Part 1, as a foundation for the details presented in this article. You can find it here. We will be using the same project as an example.

Continuing Flyway’s Configuration…


As we stated in the first article, Flyway has proven to be a good tool for managing database versioning and migrations, but it lacks a “built-in” facility to manage migrations to multiple levels of the same database, e.g., development, QA, staging, and production. However, we did learn the concept of using configuration parameters to communicate database specifics such as the JDBC driver, database URL, database user name, and user password among others to the Flyway tasks.

Unfortunately, the format of the configuration medium varies depending on the method used to employ Flyway. So depending on which Flyway component(s) you use, you may need to maintain several versions of the configuration data.
  1. The Flyway Maven plugin configuration may be specified via system properties or via the <configuration> group of tags inside the definition of the plugin in the <pluginManagement> section of a parent POM or in the <plugins>section of the Maven POM for the build in which the plugin is to be executed.
  2. The Flyway Ant task configuration may be specified via system properties or via either task attributes or specific configuration tags inside the execution of the task in the Ant build file.
  3. The Flyway Command Line Tool uses a properties file in a specific location within a specific directory structure.
  4. And finally, the Java migrations may set a Properties object on the Flyway core class object or set them individually on the object.
Although system properties could be used to convey the database specifics to most of the Flyway components since they all reference the same system properties, that would preclude running the Flyway component on the same system for more than one database, unless, of course, the execution script itself sets the system properties. This would include multiple levels of the same database.

At a minimum, you should maintain at least one set of configurations for each of the levels of the database for which you are intending to automate migrations. You should also devise a methodology to use those differing configurations in executing the Flyway tasks against the different levels of your database. In this article we are going to modify the sample project we used in the first article to use Maven profiles for this purpose.

Maven Profiles to the rescue…


Again, this is not a tutorial on the purpose of or how to use Maven profiles. Suffice it to say Maven profiles can be used for a myriad of things, one of which is the setting of property values. This permits one to define properties and values in a profile and then use that profile for a given execution of Maven. Maven then substitutes the reference of the property in all POMs of the execution with the value specified in the profile.

Maven profiles can be defined in two contexts: in the Maven settings file and in a POM for a particular project. The obvious advantage of defining a profile in the Maven settings file is that it can then be referenced in any Maven execution on the system on which it is defined. However, that may be a disadvantage as well in that, generally, properties whose values are specific to a project should be defined within the project’s POM, not in a global settings file.

So we modified the parent POM for our project adding four profiles, one for each of the levels of our database: development, QA, staging, and production. Within each of these profiles, we defined properties for each of the Flyway configuration items that may differ from one database level to the next, specifically the JDBC driver, the database URL, the database schema, the database user credentials, and the database name.
NOTE: We have also employed the Maven password encryption feature to eliminate clear text passwords in our Maven POM file (see Password Encryption in the Maven Guide). When using this feature, you must encrypt a master password and define it in the Maven security-settings.xml file as well as encrypt the password for each individual database. The database passwords as well as the database user names are then specified via a <server> definition in the Maven settings.xml file. The id of the server is then specified via the <serverId> Flyway <configuration> parameter in place of the individual database user's credentials.
We added these server definitions to the <servers> section of the Maven settings.xml file:
<settings>
   . . .
   <servers>
      <server>
         <id>flyway-dev</id>
         <username>SA</username>
         <password>{QUXCK6DU8FtcS5P=}</password>
      </server>
      <server>
         <id>flyway-QA</id>
         <username>SA-QA</username>
         <password>{AXWK8jU8ob5dse#}</password>
      </server>
      <server>
         <id>flyway-staging</id>
         <username>SA-ST</username>
         <password>{MCVFo59x0#sdlk=}</password>
      </server>
      <server>
         <id>flyway-prod</id>
         <username>SA-PR</username>
         <password>{ZYpl57s2kchD3%}</password>
      </server>
   </servers>
</settings>

We added these profiles to the <profiles> section of our parent POM:
<profiles>
   . . .
   <profile>
      <id>flyway-dev</id>
      <properties>
         <database.name>flyway_dev</database.name>
         <database.driver>
            com.microsoft.sqlserver.jdbc.SQLServerDriver
         </database.driver>
         <database.url>
            jdbc:sqlserver://localhost:1433;databaseName=flyway_dev
         </database.url>
         <database.serverId>flyway-dev</database.serverId>
         <database.schemas>dbo</database.schemas>
      </properties>
   </profile>
   <profile>
      <id>flyway-QA</id>
      <properties>
         <database.name>flyway_QA</database.name>
         <database.driver>
            com.microsoft.sqlserver.jdbc.SQLServerDriver
         </database.driver>
         <database.url>
            jdbc:sqlserver://QAserver:1040;databaseName=flyway_QA
         </database.url>
         <database.serverId>flyway-QA</database.serverId>
         <database.schemas>dbo</database.schemas>
      </properties>
   </profile>
   <profile>
      <id>flyway-staging</id>
      <properties>
         <database.name>flyway_staging</database.name>
         <database.driver>
            com.microsoft.sqlserver.jdbc.SQLServerDriver
         </database.driver>
         <database.url>
            jdbc:sqlserver://stagingDB:1040;databaseName=flyway_staging
         </database.url>
         <database.serverId>flyway-staging</database.serverId>
         <database.schemas>dbo</database.schemas>
      </properties>
   </profile>
   <profile>
      <id>flyway-prod</id>
      <properties>
         <database.name>flyway_prod</database.name>
         <database.driver>
            com.microsoft.sqlserver.jdbc.SQLServerDriver
         </database.driver>
         <database.url>
            jdbc:sqlserver://prodDB:1040;databaseName=flyway_prod
         </database.url>
         <database.serverId>flyway-prod</database.serverId>
         <database.schemas>dbo</database.schemas>
      </properties>
   </profile>
</profiles>

We also changed the configuration in our plugin definitions to reference the properties.
<plugin>
   <groupId>com.googlecode.flyway</groupId>
   <artifactId>flyway-maven-plugin</artifactId>
   . . .
   <configuration>
      <driver>${database.driver}</driver>
      <url>${database.url}</url>
      <serverId>${database.serverId}</serverId>
      <schemas>${database.schemas}</schemas>
   </configuration>
</plugin>

One more note about Maven profiles. You can, if you wish, specify a default active profile so that when executing Maven for the project you do not need to specify the profile to use on the command line. If you were creating a Maven project (POM) exclusively for Flyway migrations, you might want to set the flyway-dev profile as the default using the <activeByDefault> tag so you wouldn’t need to specify it when running migrations against your dev database.

Alternatively, if you’ve modified an existing Maven project as we have you may wish to just add the Flyway properties to existing profiles you use for the differing environments. In either case, activation of the profile, either by default or explicitly via the command line -P argument, will cause Maven to use the values for the properties defined in the respective profile. In our example, we specify the profile via the -P command line argument but the results are the same.

[:flyway-test ]$ mvn flyway:history -P flyway-dev
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Build Order:
[INFO]
[INFO] MyApp :: Parent
[INFO] MyApp :: XSD :: XMLBeans Generated
[INFO] MyApp :: Domain Layer
[INFO] MyApp :: Web Application
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building MyApp :: Parent 3.15.BUILD-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- flyway-maven-plugin:1.6.2-SNAPSHOT:history (default-cli) @ myapp-parent ---
[INFO] <skip>true</skip> detected.
[WARNING] Skipping execution.
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building MyApp :: XSD :: XMLBeans Generated 3.15.BUILD-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- flyway-maven-plugin:1.6.2-SNAPSHOT:history (default-cli) @ myapp-xmlbeans-generated ---
[INFO] <skip>true</skip> detected.
[WARNING] Skipping execution.
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building MyApp :: Domain Layer 3.15.BUILD-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- flyway-maven-plugin:1.6.2-SNAPSHOT:history (default-cli) @ myapp-domain ---
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | Version | Description | Installed on | State |
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | 0 | << Flyway Init >> | 2012-06-27 08:39:40 | SUCCESS |
[INFO] | 1.0 | load-flyway test-schem | 2012-06-27 08:40:02 | SUCCESS |
[INFO] | 1.1 | add-flyway test-table | 2012-06-27 09:00:36 | SUCCESS |
[INFO] +-------------+------------------------+---------------------+---------+
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building MyApp :: Web Application 3.15.BUILD-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- flyway-maven-plugin:1.6.2-SNAPSHOT:history (default-cli) @ myapp-web ---
[INFO] <skip>true</skip> detected.
[WARNING] Skipping execution.
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] MyApp :: Parent ..................................... SUCCESS [1.002s]
[INFO] MyApp :: XSD :: XMLBeans Generated .................. SUCCESS [0.057s]
[INFO] MyApp :: Domain Layer ............................... SUCCESS [0.894s]
[INFO] MyApp :: Web Application ............................ SUCCESS [0.188s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.211s
[INFO] Finished at: Wed Jun 27 14:21:50 EDT 2012
[INFO] Final Memory: 10M/554M
[INFO] ------------------------------------------------------------------------
[:flyway-test ]$


Flyway Placeholders…


You may have noticed that there is one property we defined in the profiles that we did not use in the configuration of the Flyway Maven plugin- <database.name>. Although we have not used it as yet in our example, we have used it in the real project.

Flyway has a feature much like the Maven profile <properties> feature in that you can specify a set of property-like value pairs in the Flyway component’s configuration which it then uses for substitution in SQL migration scripts prior to actually executing the script. These properties are called “placeholders” and are specified in a <placeholders> section of the configuration like the following:
<configuration>
   . . .
   <placeholders>
      <database>${database.name}</database>
   </placeholders>
   <placeholderPrefix>$[</placeholderPrefix>
   <placeholderSuffix>]</placeholderSuffix>
</configuration>

You may also specify the delimiters which you will use when including the placeholders in your SQL scripts. In this example, we’ve added the <database> placeholder definition to our configuration and specify the $[ ] notation for placeholders in our migration scripts. When the database name is required in our migration scripts, then, we use the $[database] notation. This allows us to use the same migration script for all levels of the database.

Versioning for horizontal migrations…


One last topic which is also not addressed by the “vanilla” Flyway implementation is how to automatically maintain the “version” of SQL migrations across multiple projects that use the same database. Basically, the Flyway documentation suggests a numbering scheme for versioning which must be specified as part of the SQL migration script file name in a specific position within the name.

In fact, it’s a requirement since Flyway uses the ascending values of the version to determine which migrations should be applied to a database. When applying migrations, Flyway looks at the highest value of this version that has already been applied and only applies migrations of a higher value (see “How Does Flyway Work”).

Although this concept may be satisfactory for a siloed project with a team of developers all using the same code base, i.e., src/main/resources/database/migrations, it presents a problem for multiple teams of developers using disparate code bases, each with their own src/main/resources/database/migrations directories, but programming to the same database. You may think this is a rarity and presents additional source code management issues beyond that which we describe here, but in my consulting experience I have seen this scenario more than once and, in fact, is the case with the client whose project I used as an example.

Although the Release.Version.Modification (1.0.1) numeric algorithm works fine for most projects, we needed a more universal numbering scheme if we were to be able to automatically manage version numbers across multiple projects. The naming requirement for the version portion of Flyway SQL migration file name requires all numeric digits separated by periods (.) to denote the levels of migrations.

We chose a date-time stamp to the hundredth of a second as our version numbering template. Shell script and batch files were developed to generate a SQL migration file to the project’s database migrations source directory. The file name follows the Flyway convention of V-version__description.sql. This script is then executed by all developers of all of the projects and virtually guarantees the scripts will have unique names and be in the correct sequence.

Using this concept for our example project, we renamed the two SQL migration script files from V-1.0__load-flyway_test-schema.sql and V-1.1__add-flyway_test-table.sql to V-20120627.13.03.55_00__load-flyway_test-schema.sql and V-20120627.13.05.12.00__add-flyway_test-table.sql, respectively.

After cleaning the database and running the renamed scripts, the history of database migrations looks like this:
[INFO] ------------------------------------------------------------------------
[INFO] Building MyApp :: Domain Layer 3.15.BUILD-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- flyway-maven-plugin:1.6.2-SNAPSHOT:history (default-cli) @ myapp-domain ---
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | Version | Description | Installed on | State |
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | 0 | << Flyway Init >> | 2012-06-27 15:40:44 | SUCCESS |
[INFO] | 20120627.13.03.55.00| load-flyway test-schem | 2012-06-27 15:41:08 | SUCCESS |
[INFO] | 20120627.13.05.12.00| add-flyway test-table | 2012-06-27 15:41:08 | SUCCESS |
[INFO] +-------------+------------------------+---------------------+---------+


Handling horizontal migrations from multiple projects…


In reality, the sample project we are using in this example is one of several which use the same database, each with their own code base and, as a result, individual database migration source directories. Up to this point in our example we have been running the Flyway plugin in only the build for our domain module. We now need to add all of the projects that use the database to our Flyway migration project.

But, because of Flyway’s method of applying migrations, if we run the Flyway migrate goal in each of the modules independently, we cannot guarantee they will all be applied and in the correct sequence. Since Flyway uses the version of the last migration applied as a starting point in applying new migrations, we need to insure that ALL migrations from ALL projects are considered in the process. This means we need to maintain all migrations in the same directory that Flyway will reference in its migration algorithm. We can use a Maven plugin for this.

We will need to change our migration process. Rather than run Flyway in each of the modules that have database migrations, we will change the process to copy the database migrations from each individual module’s target directory to a parent target directory using the maven-resources-plugin. We will then add a final module to the build that will perform the Flyway tasks.

The maven-resources-plugin facilitates copying of resources from non-standard locations to a common target destination. By binding the maven-resources-plugin's copy-resources goal to the process-resources phase, it will execute after the default process-resources goal which copies and filters resources to the build output directory. We will configure the plugin to copy the database migration files from that build output directory to a top-level target/database/ migrations directory.

To do this, we added the plugin’s definition to the <pluginManagement> section of our parent POM so it is executed in each module. When additional modules are added to the parent project, their database migrations will be copied automatically since the plugin is inherited.

The plugin configuration specifies the top-level target/database/migrations directory as the output destination. The input directory, i.e., the source of the copy, is specified as a <resource>. Since this plugin is executed after the default process-resources goal, the resources to be copied, i.e., the database migrations, are in the project’s build output directory. Filtering is not required since the files would have been filtered in the default goal if requested.

The definition of the maven-resources-plugin looks like this:
<plugin>
   <artifactId>maven-resources-plugin</artifactId>
   <version>2.5</version>
   <executions>                                                                                   
      <execution>                                                                                
         <id>copy-resources</id>                                                                
         <phase>process-resources</phase>                                                       
         <goals>                                                                                
            <goal>copy-resources</goal>                                                        
         </goals>                                                                               
         <configuration>                                                                        
            <outputDirectory>
               ../target/database/migrations
            </outputDirectory>                   
            <encoding>UTF-8</encoding>                                                         
            <resources>                                                                        
               <resource>                                                                     
                  <directory>
                     ${project.build.outputDirectory}/database/migrations
                  </directory>
                  <filtering>false</filtering>                                               
               </resource>                                                                    
            </resources>                                                                       
         </configuration>                                                                       
      </execution>                                                                               
   </executions>                                                                                  
</plugin>

We test the plugin by running mvn compile flyway:history –P flyway-dev.
[INFO]
[INFO] --- maven-resources-plugin:2.5:resources (default-resources) @ myapp-domain ---
[debug] execute contextualize
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 136 resources
[INFO] Copying 3 resources
[INFO] Copying 7 resources
[INFO]
[INFO] --- maven-resources-plugin:2.5:copy-resources (copy-resources) @ myapp-domain ---
[debug] execute contextualize
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 2 resources
[INFO]
[INFO] --- maven-compiler-plugin:2.3.2:compile (default-compile) @ myapp-domain ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- flyway-maven-plugin:1.6.2-SNAPSHOT:history (default-cli) @ myapp-domain ---
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | Version | Description | Installed on | State |
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | 0 | << Flyway Init >> | 2012-06-27 15:40:44 | SUCCESS |
[INFO] | 20120627.13.03.55.00| load-flyway test-schem | 2012-06-27 15:41:08 | SUCCESS |
[INFO] | 20120627.13.05.12.00| add-flyway test-table | 2012-06-27 15:41:08 | SUCCESS |
[INFO] +-------------+------------------------+---------------------+---------+

We can see from the output that the copy-resources goal was run after the default-resources goal and copied two files. Those two files are the database migration files which were copied to the parent target/database/migrations directory.

Completing the modifications…


Next we added an additional child module to the parent POM. Like the domain child module, the services child module contains a database migration to add a new table to the database. Then we added a new module to the parent POM which we called database-migrations. The sole purpose of this module is to run the Flyway plugin.

We created the database-migrations directory under our parent project directory and created a pom.xml file in the new database-migrations directory including the Flyway plugin. This is the only file in that directory since the purpose of this module is to only run the Flyway plugin.
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.myapp</groupId>
        <artifactId>myapp-parent</artifactId>
        <version>3.15.BUILD-SNAPSHOT</version>
    </parent>
    <artifactId>myapp-database</artifactId>
    <packaging>pom</packaging>
    <name>MyApp :: Database Migrations</name>

    <build>
        <outputDirectory>../target</outputDirectory>
        <plugins>
            <!-- Flyway database versioning / migration plugin -->
            <plugin>
                <groupId>com.googlecode.flyway</groupId>
                <artifactId>flyway-maven-plugin</artifactId>
                <version>1.6.2-SNAPSHOT</version>
                <configuration>
                    <skip>false</skip>
                    <baseDir>database/migrations</baseDir>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Since Flyway looks in the runtime classpath for its migrations files, we need to override the default build output directory for this module. The build output directory is always included in the runtime classpath. The default build output directory is target/classes. We override it by specifying ../target which points to the target directory one level above this project’s build directory, or to the target directory of the parent directory. Flyway will look in the classpath, i.e., the parent target directory, for a directory named database/migrations which we specified as the value of the <baseDir> configuration parameter.

We then added the definitions of the additional child modules to the parent POM. If you do this, make sure the database-migrations child module is specified last as in the following example:
<modules>
    <module>xsd</module>
    <module>domain</module>
    <module>services</module>
    <module>web</module>
    <module>database-migrations</module>
</modules>

Our last modification is to remove the Flyway plugin definition from the child domain module POM file so the Flyway plugin is not executed. To test our modifications we will clean the database using the flyway:clean goal, initialize it with the flyway:init goal, and then run flyway:migrate to insure Flyway uses the top-level parent target directory for its migration process.

After running the migration, we can see from the output of flyway:history that all three migrations were applied to our database:

[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building MyApp :: Database Migrations 3.15.BUILD-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- flyway-maven-plugin:1.6.2-SNAPSHOT:history (default-cli) @ myapp-database ---
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | Version | Description | Installed on | State |
[INFO] +-------------+------------------------+---------------------+---------+
[INFO] | 0 | << Flyway Init >> | 2012-06-28 13:27:05 | SUCCESS |
[INFO] | 20120627.13.03.55.00| load-flyway test-schem | 2012-06-28 13:27:32 | SUCCESS |
[INFO] | 20120627.13.05.12.00| add-flyway test-table | 2012-06-28 13:27:33 | SUCCESS |
[INFO] | 20120628.13.15.52.00| add-another-flyway test-table | 2012-06-28 13:27:33 | SUCCESS |
[INFO] +-------------+------------------------+---------------------+---------+


Mission Accomplished…


Using Maven profiles we are now able to apply the database migrations to each succeeding level of the database. And via a standard naming convention using a generated file name containing a date-timestamp as a version number we are able to guarantee database migration file names are unique throughout several projects using the same database. Using the maven-resources-plugin to copy all database migrations files to a common location, we can also guarantee that all database migrations will be applied in sequence by restricting execution of the Flyway plugin goals to only one child module, the last one specified.

The only desire left is to be able to apply any migration to a database if it has not already been applied. Currently, Flyway looks at the highest value of the version that has already been applied to a database which it has recorded in the schema_version table and only applies migrations in the <baseDir> directory whose file name’s version is of a higher value (see “How Does Flyway Work”). Hopefully, a future release of Flyway will support this behavior, as it will then solve the last of our database migrations issues, namely developers committing database migrations out of sequence in multiple projects.

Monday, July 2, 2012

Using Maven to Integrate Flyway in an Existing Database-
Part 1


I was recently asked by a client to investigate database versioning / migration tools. Having had previous experience with Rails db Rake tasks and Liquibase, both of which require a DSL, I looked for a more Java-friendly tool and found Flyway.

One of the pre-requisites was to be able to integrate the tool with an existing database and SQL scripts to reduce the learning curve for application development personnel. We were also looking for a tool we could run with either Ant or Maven as the client has multiple projects using both technologies. Flyway offered that with its support of native SQL migrations including support for stored procedures and triggers as well as a Maven plugin and an Ant task. The Flyway command line tool (CLT) and Java migrations are an added bonus.
Disclaimer: This is not a testimonial for Flyway versus any other tool, just an accounting of what it took to get it working for an existing database. Although the Flyway wiki and documentation is adequate, I had a difficult time getting all the wheels turning in the same direction. In fact, I found myself doing things that were not really explained nor even touched on in the Flyway wiki pages. I thought, “What better way to communicate that than through a blog?” BUT, YMMV- use this article at your own risk.
Java migrations are Java classes that invoke the Flyway Java core classes to perform database versioning and migration. These can be useful for “on-the-fly” migrations, i.e., at application startup, to automagically bring the target database up to speed with respect to its infrastructure, etc., as opposed to requiring a DBA or whomever to execute a series of steps prior to starting the application in a production environment. There is a sample available on the Flyway Downloads page that illustrates this feature.

Wednesday, June 20, 2012

Chariot Day: Then and Now

New and Cool
  • AJAX, DWR and Spring
  • Intro to JPA
  • Spring and Groovy
  • Intro to Ruby
  • Selenium Web Testing
  • Firebug: Web Debugging Evolved
  • Spring Webflow
  • Django as a Second Language
  • Intro to Maven
  • Google AppEngine: A Simple App
  • Introduction to Asynchronous Servlets
  • Introduction to Spring Batch
  • Apache Camel
  • Intro to Lift
  • Grails Is, Knows, and Can
  • Intro to jQuery/jQuery Beyond Basics
  • Intro to OSGi
  • Spring Roo
  • Akka
  • 2012: Real-Time Web Applications
  • 2012: Griffon: Groovy Desktop Apps
  • 2012: Scala: Definitely Not Java!
  • 2012: Sencha Touch
  • 2012: Android 101
  • 2012: Scaling Batch to the Cloud
  • 2012: Roo 1.2: Let's Write Some Add-ons!
Projects
  • Test-Driven Development with Spring
  • Domain-Driven Design
  • Acceptance TDD
  • Tomcat and SpringSecurity with x509
  • Practical OSGi
  • jNetStream/Fitnesse: Testing Bytes
  • SSO with Crowd
  • Intermediate Rails
  • 2012: Hadoop in production
  • 2012: jQuery Mobile + Backbone.js
  • 2012: NoSQL: Cool vs. Real
  • 2012: Using KIF for Mobile Testing
Special Interest
  • Ning for Java Developers
  • ll(k) lexers vs. ll lexers (ANTLR 2 vs. 3)
  • Genetic Programming
  • Green Development Practices
  • Nginx: Virtual Hosting secured sites
  • JVM Memory Model
  • SW Craftsmanship: What you should know
  • TDD Hotseat
  • Networking 101
  • A Wireless Mesh Thermometer With Mina
  • 2012: Programming Kits for Children
  • 2012: ByteBuffer
  • 2012: One month with Arduino
  • 2012: CPU Caches
Chariot Day has always offered a mix of presentations: intros to what's new and cool, looking at how particular tools were used on actual projects, and special interest topics. Looking at the topics even just from the last five years (with this year's topics highlighted), you can see how some of the languages, tools, and practices that were once new and cool are now more taken for granted.

Clearly some of these have turned out to be more applicable to our projects than others.  While Rails, JPA, and Maven are now just fundamental elements of many projects, we may never again have the opportunity to work on a wireless mesh thermostat, and we have yet to actually deploy our telnet-controlled automatic Nerf weapon at a client.  (Though, there was the suggestion that with some cubicle coordinates it could target whoever broke the build...)

Looking forward, you might ask which of today's new and cool topics will be part of tomorrow's basic toolbox.  Hadoop has made the jump already. NoSQL databases have potential, but in practice have worked better for some projects than others. Mobile tools like Backbone.js, Sencha Touch, and KIF look promising, and we've already worked them into our projects, but the landscape is shifting so rapidly it's hard to know what will really have staying power.

That's one of the reasons we spent another session slot this year on the Tech Radar -- taking an inventory of the languages and tools we use, are interested in, or are waiting for, and trying to forecast what we'll be using another few years from now. It's a tricky proposition; Scala and Akka are very strong for highly-concurrent processing, but it's hard to imagine building a large, general-purpose business application in Scala. So maybe instead of a which it's more of a how -- based on our actual project experience, what's the best way to take a general-purpose business application and build in Akka for the concurrency? (OSGi has worked.)

One thing's for sure -- we'll keep working on it. And next Chariot Day, we'll see how far we've gotten.

Thursday, June 14, 2012

Scalathon update - attend discounted training from Chariot Solutions, Typesafe, around the event!

Preparation for Scalathon 2012 is well underway. In addition to the coding and social attractions of last year's successful event, this year's Scalathon provides opportunities for Scala training.

Typesafe and Chariot Solutions are offering three Scala training classes, in conjunction with Scalathon. Even better, Scalathon attendees are eligible for substantial discounts on the training fees.

The week prior to Scalathon, we are offering the Fast Track to Scala course, probably the best way to dive head-first into Scala. This will take place at our Fort Washington training center, close to the Septa R5 and just off the turnpike. Breakfast and lunch will be served both days.

The week of Scalathon, Typesafe is offering Fast Track to Play and Fast Track to Akka, two of the exciting and powerful components of the Typesafe Stack.

With the discounts, these courses are a terrific value. If you've been waiting for a good opportunity to pester your employer to send you to Scala training, that opportunity is here. See the Scalathon Training page for complete details on the training offerings, including money-saving discounts codes.

And even if you can't make the training, please join us at Scalathon 2012. Last year was fun and informative. We're hoping this year will be even better.

You can also hear more about the conference on the Chariot TechCast, episode #72, where we talk to Jamie Allen about the show and other Scala-related topics.

Friday, May 25, 2012

Read and Write NFC Tags with PhoneGap

The phonegap-nfc plugin allows you to read and write NFC tags from a PhoneGap application using JavaScript.

The plugin originally supported Android. The latest release adds support for Blackberry 7.0.

After installing the plugin into your PhoneGap app (See README) it is easy to start scanning tags.

Create a function that will handle the NFC events.

function onNfc(nfcEvent) {
    // display the tag as JSON
    alert(JSON.stringify(nfcEvent.tag));
}

Create the optional success and failure callbacks. These callbacks are for success and failure of adding the listener.

function success(result) {
    console.log("Listening for NFC Messages");
}

function failure(reason) {
    alert("Failed to add NDEF listener");
}

Register listener. When the listener is added, the plugin will generate an NFC Event whenever a tag is scanned.

nfc.addNdefListener(onNfc, success, failure);

Deploy the application and scan a tag.

Example Project

The NFC Reader example project has been updated for Blackberry.

More info

The PhoneGap NFC API is documented in the README file.

Kevin wrote Building NFC applications with Android last year. Most of that information still applies.

Wednesday, May 23, 2012

The all-new Chariot Emerging Tech site

The all-new Chariot Emerging Tech Site

We at Chariot Solutions have been working steadily on a web site that pulls together all of our media. This site, Chariot Emerging Tech, is now live, and we will be adding more content to it regularly. Currently, it contains all of our screencasts, both internally and for events such as Philly Emerging Tech. It also contains all of our podcast episodes from the TechCast, DevNews, BusinessCast, and other feeds. We're looking at importing other media as well.
We hope this will be a helpful free resource for your tech research. Soon you'll see features on various technologies, such as Big Data, Mobile Application Development Frameworks and the Spring echosystem.
Enjoy,
Ken Rimple, Director of Education Services, Chariot Solutions

Thursday, May 17, 2012

Testing Spring Roo add-ons

This is a combination of a two-part article on Spring Roo and Testing I originally posted on rimple.com, where I write about Spring Roo topics periodically around my book, Spring Roo in Action., co-authored with InfoQ's Srini Penchikala..

You may find more information about writing Roo add-ons from my recent ETE / Richmond JUG presentation, Leaping Forward with Roo add-ons.

How to test Roo add-ons

I'm working on updates to several Roo add-ons, which I am going to be pushing out to the Silly Weasel Roo repository soon. Here are some challenges and how I overcame them.

Our examples work against the Silly Weasel Coffeescript add-on, which is an extension of the one I started in the book. Over time, we'll be ramping up the features of that add-on to support the major features of the Maven Plug-In itself.