Ajax Library Smackdown: Prototype vs jQuery

The Art of Messaging • Unit Testing in Grails

Polyglot Programming: The Basic Nuts and Bolts

Issue VII | September 2009

Make Your Training Dollars Go Further In 2009NFJS brings a high-quality technical conference to your city... no travel required.Many of our speakers are the same people you will see speaking at JavaOne andother national events.

Develop Your SkillsStaying up-to-date can be overwhelming. NFJS helps developers: improve skills,solve problems, and be productive. The best developers possess many talents. NFJSevents deliver a select body of technical knowledge and hands on training. During anevent, there are always interesting sessions available to you.

Learn How Agile Teams WinSoftware is a difficult industry with very high rates of failure. NFJS emphasizes Agilepractices such as: Test Driven Development, Continuous Integration, Code QualityMeasures, and Team Building methods to stabilize your processes and improvequality. Do your work better and faster!

Exchange Knowledge with Your PeersDo you want to solve a problem? Get a fresh opinion. Few developer problems aretruly new! NFJS is a great opportunity to interact with your peers and exchange ideas.

Save Big with NFJS Discounts1) Earlybird Rates - register early to get the best rate2) Group Discounts - NFJS makes it practical to bring your team3) Alumni Discounts - Have you attended before? Watch your email for alumni rates. * Be sure to check nofluffjuststuff.com early to get the best rate available.

Topics for 2009Most NFJS events offer 5 concurrent sessions. Throughout the duration of an event,there are sure to be sessions of interest available to all developers. Our content isupdated frequently. Check nofluffjuststuff.com for current session details.

Agile PracticesCore JavaEnterprise Java : EJB3 & JMSArchitecture & ScalingGroovy and GrailsSecurityDynamic LanguagesFrameworks: Hibernate, Spring, JSFAJAX, Flex, RIA, REST

For more tour dates and information please visithttp://www.nofluffjuststuff.com/ or emailjzimmerman@nofluffjuststuff.com

Neal FordApplication Architect atThoughtWorks, Inc.

Ted NewardEnterprise, VirtualMachine and LanguageWonk

Venkat SubramaniamFounder of AgileDeveloper, Inc.

Scott DavisAuthor of "GroovyRecipes" & TDD Expert

David GearyAuthor of Graphic Javaand co-author of Core JSF

Ken SipeTechnology Director,Perficient, Inc. (PRFT)

Tour ScheduleSalt Lake City, UT Jul 17 - 18Phoenix, AZ Jul 24 - 26Des Moines, IA Aug 7 - 9Orlando, FL Aug 21 - 23Raleigh, NC Aug 28 - 30Boston, MA Sep 11 - 13Seattle, WA Sep 18 - 20Calgary, Alberta Sep 25 - 27Minneapolis, MN Oct 2 - 4Cincinnati, OH Oct 9 - 11Atlanta, GA Oct 23 - 25Reston, VA Nov 6 - 8Chicago, IL Nov 13 - 15Denver, CO Nov 20 - 22

Featured Speakers

No Fluff Just Stuff, the Magazine | 3

Greetings!

September is upon us and we are in the home stretch for the 2009 NFJS tour. It is hard to believe we will be finishing up the 9th year on the NFJS tour. Wow the time has flown by! I find myself thinking back to all of the great people I have met on tour through the years. It has been a very rewarding experience for speakers and attendees alike. Real time encounters will always trump the virtual world. My hope is that each of you will join us at one of the many NFJS tour stops and learn why the unique experience of NFJS is not to be missed!

Mark your calendar as we have two destination events for you to enjoy this fall. First up is

SpringOne 2GX show a collocated event coming to New Orleans on October 19-22nd. SpringOne will cover the latest developments in the Spring ecosystem, including Spring 3. The Groovy/Grails Experience will provide in-depth coverage of Groovy, Grails, and Griffon. So whether you’re a Spring enthusiast, Tomcat user, Groovy/Grails fan, or just interested in open source development, you’ll find valuable content in sessions presented here. Go to www.springone2gx.com for additional details and registration information. Early Bird discount ends Friday, September 18th – Register today!

The second event is the Rich Web Experience 2009 coming December 1-4th to Orlando.

RWE 2009 focus is on the convergence of web development and design looking at JavaScript, all of the Ajax frameworks, web security, web standards, etc… We have a unique program for RWE 2009 called the all-inclusive. The all-inclusive is one fee for your registration, airfare and hotel. RWE 2009 is an event not to be missed! Make sure and go to www.therichwebexperience.com for additional details. See you in Orlando!

We thank each of you for your support of NFJS, the Magazine. It is a pleasure to bring you excellent technical content each and every issue. As always, your feedback is appreciated as well. Have a great month!

Until next month,

Jay Zimmermanjzimmerman@nofluffjuststuff.comPublisher: NFJS, the MagazineTwitter: @NoFluff

{september2009}

4 | NoFluff JustStuff .com

Contributors

Publisher: Jay Zimmerman

Editor in Chief: Andrew Glover

Technical Editor: Nick Watts

Layout/Design: Alicia Weller

Author Contributors for Issue VII:

Scott Davis

Nate Schutta

Mark Richards

Robert Fischer

Table of Contents

The Art of Messaging 5 - 10

Unit Testing in Grails

12 - 16

Ajax Library Smackdown: Prototype vs jQuery

18 - 22

Polyglot Programming: The Basic Nuts and Bolts

24 - 30

Letter from the Editor

Eat your own dog food. And everything else too.

As I was reading through this month’s motley articles, I was struck by the notion of what it means to be a polyglot. Indeed, not only does Robert address the term head on, but each remaining article does too (in an indirect manner) -- Mark with JMS and Java, Scott with Groovy, and Nate with JavaScript. In fact, I found myself looking for a broader term; not only do the articles address different languages, but they address different aspects of how varied languages are leveraged. It seems from this broad assortment of articles the word that comes to mind to me is omnivorous. Yes, as in the definition of “avidly taking in everything as if devouring or consuming.”

You see, not only do different languages change the way you address certain problems, but certainly different solutions address how you think about problems. Take for instance, Grails -- yes, it is written, for the most part, in another language and in order to use it, you’ll end up writing Groovy code; however, Grails is a solution that addresses the speed of web development. Or JQuery, for instance -- another tool that leverages a different language and which addresses the issue of interactivity (or the lack thereof in much of the web today). Both aspects can and have been solved with other languages, by the way. What’s important though isn’t just that each article uses a different language, but that each article addresses a different subject altogether. In fact, that’s the beauty of this magazine -- each month is a cornucopia of topics that demonstrate different languages, tools, platforms, and consequently, solutions.

While being a polyglot programmer is certainly important (and I’m willing to bet that broadly speaking, you already are one -- you do know SQL, right? HTML? And of course, Java. There’s arguably three languages (generally defined) you know, right?) -- I think what’s even more important, if you want to be successful in your career, is omnivorousness. If you want to go places and see things, you’ll need to know and understand multiple languages, multiple tools and platforms, and the solutions and related problems that tie everything together.

With that in mind, I hope you’ll enjoy devouring this month’s issue -- Scott, Mark, Nate, and Robert have written some fabulous articles that span the gamut of technology today. And while you’ll certainly be a polyglot programmer if you end up using the various languages demonstrated this month, you’ll also be quite sated by all the varied content. Bon appétit!

Andrew Glover

The Premier Java Event of 2009

SpringSource and No Fluff Just Stuff Symposium Series are pleased to presentSpringOne 2GX.

SpringOne 2GX will include a technical exploration of the Spring ecosystem alongwith the latest developments in the Groovy/Grails space. As a participant, you willhave the opportunity to attend two great events at one venue. Whether you're aSpring enthusiast, Tomcat user, Groovy/Grails fan, or just interested in open sourcedevelopment, you'll find valuable content in sessions presented here.

This year's event will be held at the recently restored Roosevelt Hotel in New Orleans.Now a part of the prestigious Waldorf Astoria Collection, this landmark hotel combineselegant guest rooms, historic dining, and a luxurious spa, all in the heart of thisfabulous city.

Save Big with Discounts1) Earlybird Rates - register early to get the best rate2) Group Discounts - Register 4 individuals and receive 1 additional pass free3) Alumni Discounts - Have you attended before? Watch your email for alumni rates. * Be sure to check springone2gx.com early to get the best rate available.

Topics for 2009SpringOne 2GX will offer 8 concurrent sessions. Throughout the duration of the event,there are sure to be sessions of interest available to all developers. Checkspringone2gx.com for session details.

Spring 3.0Spring WebflowSpring BatchWeb OperationsGroovy / GrailsGriffonAgile PracticesArchitecture & ScalingSecurityDynamic Languages

For more information please visit http://www.springone2gx.com/ oremail jzimmerman@nofluffjuststuff.com

Rod JohnsonCreator of Spring & BestSelling Author of J2EEwithout EJB

Keith DonaldLead of Spring Web andCreator of Spring WebFlow

Graeme RocherHead of GrailsDevelopment forSpringSource

Adrian ColyerCTO of SpringSource

Rob HarropCore Spring developerand author of the bestseller Pro Spring

Guillaume LaForgeHead of GroovyDevelopment forSpringSource

Ben AlexCreator of Spring Security(Acegi) & SpringSourcePrincipal SoftwareEngineer

The Roosevelt New Orleans123 Baronne StreetNew Orleans, LA 70112

18 | NoFluff JustStuff .com

Ajax Library Smackdown:Prototype vs jQueryby Nathaniel Schutta

Introduction

Creating a modern web based application requires that we develop a rich interactive user interface that takes advantage of all the techniques in the Ajax toolbox. When these approaches were first introduced, many pundits insisted you needed to be a rocket scientist to pull it off - while not trivial today, high quality frameworks have helped our cause. In this article, we’ll take a look at how popular libraries like Prototype and jQuery have simplified the life of today’s JavaScript developer. We’ll talk about why we should use a library in the first place, how to choose between libraries and then we’ll look at some specific examples from Prototype and jQuery.

Why Should I Use a Library?

Back in the Paleolithic Web era known as the late 90s, those of us doing front end development had things pretty rough. Our monitors had lower resolution than today’s coolest smartphones, the browser wars were in full swing giving us a variety of incompatible behavior and our toolbox was only slightly better than that guy that insisted on using punch cards. And we walked to work uphill in the snow both ways. Getting JavaScript to work properly across browsers was a Herculean task (akin to cleaning the Augean stables.) On one early project, ran into so many issues the manager laid down the “thou shalt use only the bare minimum JavaScript required to make the application work.” I do not miss those days.

Though things have greatly stabilized, browser issues are still with us today (IE 6, I’m looking in your direction.) In addition to an awesome toolbox, today’s JavaScript developer can take advantage of a veritable plethora of libraries to ease the burden of developing cross browser front end code. In fact, we face a paradox of choice in our effort to select just the right framework to make our lives easier - but that sure beats long nights debugging that weird issue with the Foo browser on the XYZ operating system! Today’s JavaScript programmer should be looking to a library to create a baseline for their coding efforts. You can think of a toolkit as a virtual machine of sorts that sits between the various browser implementations and the code you’re trying to write.

In addition to smoothing out browser differences, toolkits give us a ton of leverage in our day to day coding efforts. Though each library is different, there are several common themes. Most toolkits provide:

• a wrapper around the XMLHttpRequest (XHR) object

• cross browser CSS selectors• simplified event handling• various animations, effects and widgets• sundry utility functions

Some libraries are minimalists that do one thing and only one thing while others are all encompassing kitchen sink sized toolkits that seek to rectify shortcomings in all things web.

How do you pick one library over another? Coding everything by hand - not using any library - is the only wrong answer. It can be a bit daunting to pick a library, but it’s nothing compared to trying to do everything yourself. Before you panic and think you have to choose just one library, most of them will work fine together (within reason) and sometimes mixing and matching is the best option. Regardless, here are some questions to consider when picking a library:

• What do you want out of a toolkit? Are you looking for a complete replacement of nearly all UI elements on your page or are you just looking for something to take a bit of the suck out of JavaScript programming?

• How easy is the code to read? Despite massive improvements in documentation over the last few years, odds are you will have to dig into the code at some point. Before committing to a library, spend some time knee deep in the source. Is it easy to understand or does even the original author have trouble with it?

• How good is the documentation? Clean and readable code can make up for a less than stellar docs, but nothing helps you get started quite like tutorials and examples. Poke around the wiki or the website and see what they have to offer. Are the examples clear and easy to follow? Does a quick Google search bring you to the proper part of their material?

Issue VII

No Fluff Just Stuff, the Magazine | 19

• What’s the community like that surrounds the library? Check out the mailing lists; is there a lot of traffic? Are new people treated with respect or derision? Has the code been updated recently or was the last release before the previous presidential election cycle started?

• Can I get help? While this is related to the previous bits about community, it’s always valuable to look around the development community and see who’s using what. Check out the job boards to get a sense of what libraries are showing up frequently on resumes.

Before pulling the trigger, be sure to spend some time playing with the finalists. Some libraries have a certain flavor - for instance, Prototype brings a strong dose of Ruby to JavaScript. If you think Ruby is the language to end all languages, this is a feature, if reading Ruby makes your eyes hurt, Prototype might not be the best choice. Reading code and following tutorials is fine, but until you actually try to solve some of your pain points in a given library, it’s hard to know which one is right for you.

Why Prototype and jQuery?

In this article, we’ll compare and contrast two popular frameworks: Prototype and jQuery. Both libraries are solid choices in what I call the “make JavaScript suck less” camp. Unlike Dojo and YUI they don’t come with a side of widgets (at least out of the box.) They do, however, provide solid foundations for building better JavaScript based applications.

How are they similar?

Prototype and jQuery are both small (each weighs in around 4300 lines of code) well written libraries. If you have never used either of them, simply reading through the code would make you a better JavaScript developer. Both have similar features: XHR wrappers, CSS selectors, event handlers and a number of features that make JavaScript easier to work with. Each has excellent documentation (both online and in print) and thriving communities. As the code has matured, releases have slowed somewhat but the respective mailing lists are quite active.

How are they different?

Though very similar, Prototype and jQuery have some fundamentally different philosophical underpinnings. Prototype grew out of the Rails project and is heavily influenced by that style of coding. jQuery was, in some regards, a reaction to what some perceived as shortcomings in the Prototype approach, especially when it comes to extending core JavaScript objects. They also have very different uses for $ - in Prototype, $ is a convenience method that replaces the tedious task of typing document.getElementById while in jQuery, $ is core to everything you’ll ever do, nearly every expression you’ll write is based upon the humble $. Let’s take a look at some high level pros and cons of the two libraries.

Some of Prototype’s pros:• brings a strong Ruby flavor to JavaScript• adds functionality to HTML elements and

JavaScript base classes• additional features (such as widgets and visual

effects) found in extensions like script.aculo.us• widely used on a variety of projects

Some of jQuery’s pros:• focused on HTML elements - acting on elements

found via CSS selectors is core• doesn’t pollute the global namespace• makes manipulating the DOM a snap• extensive plugins that provide a wealth of

functionality• widely used on a variety of projects

Some of Prototype’s cons:• doesn’t ship with a minified version• performance hasn’t always been a top priority• pollutes the global namespace

Some of jQuery’s cons:• some APIs can be a bit clumsy to use (parameter

order isn’t always intuitive)• functionality beyond DOM manipulation is often

relegated to plugins• some functions change what this binds to

{ajax}

20 | NoFluff JustStuff .com

It’s important to note that the libraries have influenced each other. Good ideas introduced to one library often find their way into the other and members of both communities have contributed to the other. In some cases, if you squint a bit, it can be hard to tell just which library you are using!

Getting Started

Getting started with either Prototype or jQuery is very straightforward. Simply go to their respective websites and download the latest and greatest version. Add the respective JavaScript files to your project and you’re off and running.

Ajax The Easy Way

While the XHR object itself isn’t very complicated, there is just enough nuance to doing it right that you’ll soon come to appreciate the abstraction layer that you’ll find in virtually all of today’s Ajax libraries. Prototype and jQuery are no exceptions and each provides a simple-to-use wrapper. Though there are a variety of ways to skin this proverbial cat, there are common themes you’ll find when working with XHR via a library. At a minimum, you’ll have a way of doing to following:

• provide the URl of the resource to call• a way of passing URL parameters• a method of specifying the HTTP method (e.g. get,

post) to use to make the call• a callback technique to handle the result of the call

Prototype’s Take on Ajax

Prototype’s Ajax.Request provides a simple yet very powerful way of interacting with a server. The basic signature may seem spartan: new Ajax.Request(url, [options]) but that simple constructor gives you access to fully configure the underlying XHR instance. The optional second argument is a hash of configuration options that allows you to set:

• the HTTP method to use• parameters• content type• a variety of callbacks aligned with various XHR

object states such as onComplete, onFailure and onSuccess.

A typical invocation might look something like the code in Listing SCH-1.

In this case we’ve passed in some configuration parameters - we’ll use the get method, we’re passing some values from the page ($F is a convenience method that returns the value of the specified field) and when the call is complete we’re replacing the innerHTML of the messages element with the response text from the call. Not bad for less than 10 lines of code!

jQuery’s Take on Ajax

jQuery has an equally straightforward Ajax wrapper defining a variety of APIs to solve this problem. From the low level $.ajax(options) to more specific calls like

YSlow is an excellent tool that can help you speed up your pages and using a content delivery network (CDN) is one of the recommendations to improve page performance. If your company doesn’t have it’s own CDN and doesn’t use a CDN service provider, you can take advantage of the Google AJAX Libraries API. Google has data centers all over the world and they provide hosting for the major players in the Ajax library space (including Prototype and jQuery.) Google stays up to date on the latest stable version (though you can easily bind to a specific version is you wish) and hosts previous releases indefinitely. You can leverage Google’s load API or directly load a library via a script tag.

new Ajax.Request(‘/fooApp/validate’, {

method: ‘get’,

parameters: { zip: $F(‘zip’), city: $F(‘city’), state: $F(‘state’) },

onComplete: function(request) {

$(‘messages’).update(request.responseText);

}

});Listing SCH-1

Typical AJAX Request in Prototype.

Improving Web Page Performance

Issue VII

No Fluff Just Stuff, the Magazine | 21

$.getJSON(url, [data], [callback]), jQuery has your Ajax needs covered. A typical call might look something like the code in Listing SCH-2.

Looks pretty similar doesn’t it? First off, you’ll notice that all jQuery methods are bound under $ which can be a bit confusing at first but overcomes JavaScript’s lack of namespaces - in this case, it keeps jQuery code separated from your own. In this case, we’ve used the get convenience method to call our server side validation passing in the same parameters as before with nearly identical syntax. Also, as before, we’re replacing the innerHTML of the messages div. Once again, a few short lines does an awful lot for us!

The Power of CSS Selectors

CSS selectors are an amazingly powerful tool in the web developer’s toolbox but as with JavaScript itself browser support isn’t universal. Luckily for us, today’s libraries step into the void giving us the full power of CSS selectors.

CSS Selectors in Prototype

Prototype gives us CSS selectors via the function $$. For instance, if we wanted to get every element that had the header style applied to it, we’d do something like the example in Listing SCH-3.

$$ returns an array of elements that match the selector rules which we then iterate over via the each method. We’ll talk about the observe function in the next section, but whenever someone clicks on a header element, the toggleSection method will be fired.

CSS Selectors in jQuery

CSS selectors are one of jQuery’s strongest features; their support is top notch, including a variety of helpful convenience methods. Performance is outstanding, relying on native browser support instead of code where possible. The previous example rewritten in jQuery looks something like the example in Listing SCH-4.

In this example we’ve actually coded the toggleSection method right into our CSS selector code and, as before, this code will be invoked on a click. Again, a couple of lines of code yields a huge return.

Event Handling

Event handling is especially common in the era of unobtrusive JavaScript but as we’ve come to expect, browsers aren’t entirely consistent. Luckily for us, library designers have taken it upon themselves to simplify our lives once again. In the previous section, we saw two ways of binding to the click event - Prototype uses the observe function while jQuery defines a series of APIs including event helpers like click. In both cases, we’re asking to be notified when an event happens so we can take some action - in our examples that involves toggling a section (that is hiding it if visible or making it visible if it’s hidden.) We could have added event handlers directly to our markup but using an abstraction as we have here is much cleaner, it separates our business logic from our presentation.

Animations and Effects

Prototype and jQuery don’t stand alone, they both support additional libraries that combine together to help us provide polished interfaces. Script.aculo.us builds on top of Prototype to provide animations, widgets and more. Not to be outdone, jQuery UI provides a number of effects, widgets like dialog and interactions like draggable.

The jQuery selector example shows the use of the blind effect in conjunction with the toggle. When the header is clicked, the section doesn’t just instantly hide or become visible - it gradually slides up or down. jQuery UI relies on a number of plugins that can all be used independently as the need arises, keeping your page weights trim.

$.get(“/fooApp/validate”,

{

zip: $(“#zip”).val(),

city: $(“#city”).val(),

state: $(“#state”).val()

},

function(message) {

$(“#messages”).html(message);

});Listing SCH-2

Typical AJAX Request in jQuery.

$$(‘.header’).each(function(el) {el.observe(“click”, toggleSection)});

Listing SCH-3

CSS Selectors Example in Prototype.

$(‘.header’).click(function() {

$(this).next().toggle(“blind”,

{ direction: “vertical” }, 500);

});Listing SCH-4

CSS Selectors Example in jQuery.

{ajax}

22 | NoFluff JustStuff .com

Let’s return to the validation example from the Ajax section to see how an effect could spice up our Prototype example. By including script.aculo.us in our page, we add a highlight effect to draw attention to the message returned from the server. Thanks to chaining, we can tack a highlight on to the end of our update call so it looks something like the code in Listing SCH-5.

This default behavior will give us a very handy yellow fade that subtly lets our users know something has changed.

Getting HelpBoth libraries offer extensive online documentation. If you can’t find the answers there and Googling doesn’t enlighten you, try the mailing lists. URLs for Prototype’s and jQuery’s API documentation and mailing lists are listed in the References section.

Conclusion

We’ve covered a lot of ground in a short space but you should have some ideas of just what a well written framework provides. Whether you prefer Prototype or jQuery, each greatly simplifies the life of a front end developer and both libraries have vocal proponents. Each has pros and cons but you can’t go too far wrong adding either one to your application.

$(‘messages’).update(request.responseText).highlight({duration: 1.0});

Listing SCH-5 Script.aculo.us Highlight Effect.

References – Prototype

http://www.prototypejs.org/ http://www.prototypejs.org/api/ajax/options http://www.prototypejs.org/api/utility/dollar-f http://www.prototypejs.org/api/utility/dollar-dollar http://www.prototypejs.org/api/enumerable#method-each http://www.prototypejs.org/api/event/observe http://www.prototypejs.org/api/ http://www.prototypejs.org/discuss http://blog.thinkrelevance.com/2009/1/12/why-i-still-prefer-prototype-to-jquery

References – jQuery

http://jquery.com/ http://docs.jquery.com/Ajax http://docs.jquery.com/Selectors http://docs.jquery.com/Events http://docs.jquery.com/Events/click http://docs.jquery.com/UI/Effects http://docs.jquery.com/UI/API/1.7/Dialog http://docs.jquery.com/UI/API/1.7/Draggable http://docs.jquery.com/UI/Effects/Blind http://docs.jquery.com/Main_Page http://docs.jquery.com/Discussion

About the Author

Nathaniel T. Schutta is a senior software engineer focused on making usable applications. A proponent of polyglot programming, Nate has written two books on Ajax and speaks regularly at various No Fluff Just Stuff symposia, universities, and Java user groups. In addition to his day job, Nate is an adjunct professor at the University of Minnesota where he teaches students to embrace dynamic languages.

References – Other

http://en.wikipedia.org/wiki/Augeas http://en.wikipedia.org/wiki/XMLHttpRequest http://www.javaworld.com/javaworld/jw-05-2009/jw-05-javascript-tools.html http://www.ted.com/index.php/talks/barry_schwartz_on_the_paradox_of_choice.html http://www.dojotoolkit.org/ http://developer.yahoo.com/yui/ http://developer.yahoo.com/yslow/ http://developer.yahoo.com/performance/rules.html http://rubyonrails.org/ http://code.google.com/apis/ajaxlibs/ http://code.google.com/apis/ajaxlibs/documentation/#googleDotLoad http://www.alistapart.com/articles/behavioralseparation http://www.37signals.com/svn/archives/000558.php

References – script.aculo.us

http://script.aculo.us/ http://wiki.github.com/madrobby/scriptaculous/combination-effects-demo http://wiki.github.com/madrobby/scriptaculous/controls http://wiki.github.com/madrobby/scriptaculous/effect-highlight

NFJS One provides access to the top technical talent in the industry. Our services include: in-depth

public and private training sessions, project consulting engagements, team mentoring, and on-

site private events.

Investing in your people should be your number one priority

The benefits of keeping your folks sharp and ahead of the curve are endless:

Increase your organization's productivity Reduce development costs Accelerate employees' learning curves

The NFJS One Model:

NFJS One takes pride in ensuring a recognized expert is matched to your organizational strategies and initiatives. Whether it be a private 3 day training class on a specific tool, an organizational assessment, a project coach, etc. Our first goal is to get a grasp on your environment today.

What are your strengths/weaknesses (toolset, process, initiatives, etc)? What challenges are preventing you from meeting your goals?

Once we come to an agreement on services and benefits, NFJS One will align you to one of our 75+ experts – ensuring this person is a 5 star resource on the subject matter at hand.

Training:Our courses range from beginner to expert on various tools, process, frameworks, languages and more. We align our courses to your environment, and don’t come in for a lecture – be prepared to get your hands dirty and leave ready to use what you’ve learned tomorrow.

Mentoring/Consulting:We have various models to meet our customer requirements, including organizational assessments, agile coaching, and technology evaluations

Private Events:NFJS One is an entity of the No Fluff Just Stuff Software Symposium. If you are ready to host a professional conference with the best speakers in the industry – NFJS One is your provider.

NFJSOne.com877-825-0663 ext. 2

contact@nfjsone.com

Issue VII

No Fluff Just Stuff, the Magazine | 31

Coming up next month

Next month’s issue features articles on JSF 2.0 by David Geary, Lucene by John Griffin, Easyb by

Andrew Glover and part 2 of the Collections article written by Ted Neward. Another can’t miss read!