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.

Friday, May 4, 2012

Camera Access from Android Browser

The browser in Android 4 is able to take pictures from a web page and display them without any plugins or server interaction. This demo uses the Device API and File API to take and display a picture on a phone using the browser.

Try it on your Android phone http://don.github.com/html-cam/.

I wrote this demo after reading David Calhoun’s post about Android implementing device APIs.

This works on my Google Nexus S running Ice Cream Sandwich (4.0.4). The Device API works on Samsung Galaxy Tab 10.1 with Honeycomb (3.2) but the File APIs do not. YMMV.

Loading images from the gallery is finicky. Images load from the device but fail to load from Picasa albums. I had to alter the image blob and change data:base64 to data:image/jpeg;base64 to get photos from galleries to display.

I kludge the photo orientation based on the device orientation, clearly there is a better solution.

It's possible to run the browser out of memory. I'm guessing this is because a huge photo is encoded into a base64 string. Maybe window.URL.createObjectURL(file) would work better than reading the image with FileReader?

Adjusting the input tag can control the input types:

<input type="file" />
Browser prompts for camera, camcorder, sound recorder, 
  music track, or gallery

<input type="file" accept="image/*" />          
Browser prompts for camera or gallery   

<input type="file" accept="image/*;capture=camera" />           
Browser goes directly to the camera

For more info see the github project.

UPDATE 2012-05-06
It looks like Facebook's mobile website allows camera access from a browser on Android.

Friday, April 27, 2012

Securing Data in iOS

There are numerous ways to secure data that you are storing on an iOS device.

The Simple/Built-in Way

The simplest way is to take advantage of the iOS Data Protection (iOS 4+). This can be accomplished by setting an attribute on a file like this:

    [[NSFileManager defaultManager] createFileAtPath:[self filePath]
                    contents:[@"super secret file contents" dataUsingEncoding:NSUTF8StringEncoding]
                    attributes:[NSDictionary dictionaryWithObject:NSFileProtectionComplete
                                                           forKey:NSFileProtectionKey]];

There are several different levels of file protection. The following was taken from the NSFileManager class reference from Apple:

  • NSFileProtectionNone - no file protection
  • NSFileProtectionComplete - file is encrypted when the device is locked or booting
  • NSFileProtectionCompleteUnlessOpen - file is encrypted and can only be opened when the device is unlocked. Once open, the file can continue to accessed even if the user locks the device.
  • NSFileProtectionCompleteUntilFirstUserAuthentication - The file is stored in an encrypted format on disk and cannot be accessed until after the device has booted. After the user unlocks the device for the first time, your application can access the file and continue to access it even if the user subsequently locks the device.

A Core Data sqlite store can also be encrypted by setting the NSFileProtectionKey file attribute to one of the above values (after you create your persistent store coordinator).

However, an important thing to realize is that this type of data protection requires the device to have a passcode set on it (http://support.apple.com/kb/HT4175).

CommonCrypto

What if you really need to insure that your data is protected regardless of whether the device has a passcode set? One way is to use the CommonCrypto libraries from Apple. This can be fairly complex. There is a great write up here from Rob Napier on what's involved. Fortunately, he has also provided a wrapper that greatly simplifies this process here. Using this library (or writing your own), you can encrypt your data and store it wherever you need. If you are using Core Data, you could write an NSValueTransformer for the Core Data entity attributes that require encryption using CommonCrypto or the RNCrypto library to encrypt/decrypt the attribute values.

SQLCipher

One more way to protect your data, specifically data that you want to store in a SQLite database, would be to use SQLCipher. SQLCipher encrypts/decrypts data at the page level and is transparent to your application code. You still use the standard SQLite APIs, with one additional method call when accessing the database (passing your key to sqlite). There are excellent instructions on setting it up for use in an iOS project here.

You can build SQLCipher as a set of static libraries by following the same iOS instructions with some modifications and additions. Here are the high level steps:

  1. Instead of creating a view based iOS project, create a static library project
  2. Follow the balance of the steps for including SQLCipher in your project
  3. Add a new "Aggregate" build target
  4. Add a "Run Script" build phase and paste the following script into it. This will build both the simulator and iOS based targets for the libcrypto, libsqlcipher, and libssl libraries.
  5. xcodebuild -project ${PROJECT_NAME}.xcodeproj -sdk iphonesimulator -target ${PROJECT_NAME} -configuration ${CONFIGURATION} clean build CONFIGURATION_BUILD_DIR=${BUILD_DIR}/${CONFIGURATION}-iphonesimulator
    
    xcodebuild -project ${PROJECT_NAME}.xcodeproj -sdk iphoneos -target ${PROJECT_NAME} -configuration ${CONFIGURATION} clean build CONFIGURATION_BUILD_DIR=${BUILD_DIR}/${CONFIGURATION}-iphoneos
    
  6. Add another "Run Script" build phase and paste the following script into it. This will merge the simulator and iOS builds into one for each library. These three libraries are what would be added to a project using SQLCipher.
  7. CRYPTO_LIB="${BUILD_DIR}/${CONFIGURATION}-iphonesimulator/libcrypto.a" &&
    SQLCIPHER_LIB="${BUILD_DIR}/${CONFIGURATION}-iphonesimulator/libsqlcipher.a" &&
    SSL_LIB="${BUILD_DIR}/${CONFIGURATION}-iphonesimulator/libssl.a" &&
    
    DEVICE_CRYPTO_LIB="${BUILD_DIR}/${CONFIGURATION}-iphoneos/libcrypto.a" &&
    DEVICE_SQLCIPHER_LIB="${BUILD_DIR}/${CONFIGURATION}-iphoneos/libsqlcipher.a" &&
    DEVICE_SSL_LIB="${BUILD_DIR}/${CONFIGURATION}-iphoneos/libssl.a" &&
    
    UNIVERSAL_LIBRARY_DIR="${BUILD_DIR}/${CONFIGURATION}-iphoneuniversal" &&
    
    
    # Create framework directory structure.
    rm -rf "${UNIVERSAL_LIBRARY_DIR}" &&
    mkdir -p "${UNIVERSAL_LIBRARY_DIR}" &&
    
    # Generate universal binary for the device and simulator.
    lipo "${CRYPTO_LIB}" "${DEVICE_CRYPTO_LIB}" -create -output "${UNIVERSAL_LIBRARY_DIR}/libcrypto" &&
    lipo "${SQLCIPHER_LIB}" "${DEVICE_SQLCIPHER_LIB}" -create -output "${UNIVERSAL_LIBRARY_DIR}/libsqlcipher" &&
    lipo "${SSL_LIB}" "${DEVICE_SSL_LIB}" -create -output "${UNIVERSAL_LIBRARY_DIR}/libssl"
    

Once completed, you can build your new aggregate target and there should be 3 libraries located in a subdirectory within your project build directory. Just add these to your XCode project as you would any other library and you are good to go.