Gateway JUG

August 3rd Meeting - Unit Testing Strategies

Go Ahead. Mock Me.

Mocking collaborators is the key to keeping unit tests pure and simple.

Soon after a developer has worked through simple unit testing examples, reality hits home ... testing in a production application can be much more difficult. Among the types of tests developers write are integration and unit tests.

Integration tests require implemented and working collaborators of the class-under-test (CUT). (This is also called the "system-under-test [SUT]", "object-under-test [OUT]", etc. Given all the terms, I've thought about coining a more general term, "thing-under-test" or TUT. :-) Often, a database is involved, so tables must be created, dummy data defined, and proper transaction management for testing be implemented. If you're using Spring, the Spring context has to be started. If Hibernate is used, a Hibernate SessionFactory must be instantiated. Application server services may need to be available; i.e. JNDI, JTA, servlet runner, and more. All in all, integration tests are often messy, almost always very slow, and overly fragile in a fast-changing environment.

In contrast, unit tests are supposed to be relatively simple and always fast. They are intended to focus only on the class-under-test without any assumption about the implementation and completeness of the collaborators, the Spring context, Hibernate SessionFactory, database, server services, etc.

How we deal with collaborators in unit tests is the focus of this presentation.

In this presentation, we'll have a code-based discussion on unit test development with the goal of keeping our unit tests simple and fast. Here's what we'll cover:

• Working with JUnit 4
• Test Configuration in Projects
• Unit Test Basics: Setup, Excercise, Verify, Teardown
• Testing Obstacles
• Stubs and Mocks
• jMock & EasyMock
• Using Groovy to take the pain out of testing

Presenter: Jack Frosch

Sponsor: Contegix

Meeting Notes: tba

June 1st Meeting - An Introduction to JavaServer Faces 2.0

Artist's Rendering of A Mojarra*

Friends, St. Louisans, Developers,

I come not to bury Struts, but to praise it.

Web frameworks have come a long way since we were writing HTML markup from the doGet() and doPost() methods in our custom Servlets and using distinctly non-MVC scriptlets in our JavaServer Pages.

Thank goodness, Craig McLanahan gave us Struts 1.x. With Struts 1.x we learned that MVC could be applied to web development. Struts introduced a lot of us to practical implementations of the Front Controller and Command design patterns with Struts ActionServlet dispatching preloaded (and optionally validated) Form Beans to our Struts Action command classes.

When Struts
was introduced, large and small organizations everywhere adopted it as the de facto standard Java web framework. Speakers flooded the conferences with tips and techniques on how to use Struts. Books sprang up everywhere. As of today, Amazon.com reports 150 books when searching for the keyword "Struts" in Computer and internet books.

Despite its goodness, we all sensed something was not quite right with Struts.

First, there was all of that inheritance / framework-coupling going on. Form beans weren't true POJOs; they needed to inherit from Struts' ActionForm. Our Action classes had to inherit from a Struts' Action. Action execute() methods required a Struts ActionMapping argument and had to return Struts' ActionForward objects.

Second, everything was just so coarse grained. A form bean had a single validator() method used to validate all the String fields of the form bean and one form bean was generally only useful for handling one screen. Why did we use String fields in our form beans? Craig McLanahan himself recommended type conversion not be performed in the form bean since any missing required field data or other 0th-order validations done in validate() would result in the re-rendering of the original view. He recommended type conversions and inter-field validations be deferred until the Action class processing once we knew all the data needed was present and basically sound. (I should note that validation was later improved with a separate API. Dynamic form beans improved the 1:1 ratio of form beans to screens.)

Finally, many common requirements like custom type conversion and validation had to be handled individually each time they were needed. Consider a date entry. First, we need to convert the String representation of the date to a type like java.util.Date. We need to ensure the date is a valid date (i.e. no February 29th in 2010 or June 31st ever). Finally, we need to apply our own business rule validations. Perhaps in one context, the data must be before today; in another, the date must be in the future. The latter type of validation is truly business specific, but the conversion to/from a String and basic validation is common in all cases. Yet Struts offered little for us in this regard. Want to report errors from these conversions and validations? We had to handle this somewhat mechanically.

No one recognized these deficiencies and others more than Craig McLanahan. So when he set out to redesign the next big web framework, he did so as a co-spec lead for JavaServer Faces, JSR-127, in the Java Community Process (JCP). Craig's magic touch seemed to fail when he launched the Apache Shale framework, based on JSF 1.0/1.1. Originally, he tried to call Shale Struts 2.0, but the Struts villagers gathered their rhetorical pitchforks and torches and marched on Castle McLanahan. So he moved ahead with the project as Shale. It was a bust and has since been retired. However, there is a new Struts 2.0, based on WebWork 2.2.

Despite Shale's failure, JavaServer Faces (JSF) did catch on, becoming the official Java Enterprise Edition (JEE) web framework as of JEE5. Amazon reports 43 JSF books, with several new titles out or soon to be out.

JavaServer Faces, often just called Faces, sought to correct many of the deficiencies of Struts 1.x while retaining the essential goodness of Struts' MVC enforcement and implementation of Front Controller and Command design patterns.

In JSF 1.x, we were introduced to POJO managed beans performing the combined role of Struts form beans and actions. We got a lightweight, reusable Converter API for transforming Strings to more useful object types so now we can reuse the same converters across our application. The Validator API provides a simple, reusable mechanism for doing robust field-level validation. Both the converter and validation APIs provide easy ways to register messages into Faces' built-in error reporting and localization APIs. 

Its well defined API and request processing life-cycle opened the door to an alternate implementation, MyFaces, from Apache. as well as several robust JSF widget libraries, including MyFaces Tomahawk (works with RI and MyFaces) and RichFaces, a JBoss subproject. (No JBoss server required.)

So given that JSF is here to stay...

What's Ahead In JavaServer Faces 2.0?

JavaServer Faces 2.0, available today, introduces a plethora of great enhancements. Our meeting on June 1st will highlight these improvements, comparing and contrasting JSF 2.0 with 1.x and Struts. Through code examples and live coding, topics to be covered will include:

• A Brief Introduction to JSF
• Improved navigation handling
• Multi-component validation
• Say Hello to Facelets; Good bye to JSP!
• Easy Ajax
• Managing Resources
• Improved Event Handling
• A Sneak Peek of RichFaces 4.0
• Third-party Support for JSF 2.0: Spring Faces,IDE Support, and more ...

Even if your shop is not using JSF today, you will want to attend to learn about what Faces can offer and how it solves some common problems in Java web development. So RSVP today!

Presenter: Jack Frosch

Sponsor: Adaptive Solutions Group

Meeting Notes: coming soon ...

* Project Mojarra is the code name for the JavaServer Faces Reference Implementation. Mojarra is a Caribbean fish.

May 4th Meeting - JPA 2.0

This month we will have two speakers who will tell us all about JPA 2.0 and will present an interesting demo showing how JPA works with Spring.  Below is a list of the points they will touch on during the presentation:

• JPA Overview
• ORM Mapping Strategies
• Entity Management
• Transaction Handling
• Queries
• Implementation of JPA 2.0 in an Enterprise
• JPA 2.0 integration with Spring 3.0.2
• JPA relationships
• JPA criteria API/MetaModel
• JPA Queries
• Generic DAOs

Come and learn about this exciting technology, ask questions, eat, enjoy!

Speakers: Mahesh Desai and Pradeep Chandrababu

Sponsor: modis

Meeting Notes: JPA2Presentation.zip

April 6th Meeting - Writing Meaningful Unit Tests With Ease

People write unit tests that fail to catch bugs or do not write unit tests at all because they don't know how.  This presentation will show how to write unit tests for three of the most common problems:

• testing of interfaces
• mocking dependencies
• testing DAO without a database

Also discussed will be how unit testing can speed up your development, allow for division of labor in pairwise programming, and how this approach will help you enforce good programming and design practices.

Speaker: Tomasz Mozolewski

Sponsor: Envision

Meeting Slides and Code: AprilGatewayJUG.zip

March 2nd Meeting - Code Analysis Tools and Tips

According to several studies, you can reduce defects by twice as much with techniques such as unit testing and do it in a fraction of the time.  You can improve your skills using the same techniques.  Automation is available for much of this.  These techniques can be categorized into a broad area called Code Analysis.  There are a wide variety of free, static and dynamic analysis tools to aid in code analysis.

During the presentation, you'll learn about these tools and techniques along with a couple of dashboard applications that provide a 'one-stop' overview of the health of your application.  At the conclusion, you'll see one of the presenter's favorite too.

Speaker: Darryl Parks

Sponsor: Advanced Resources

Meeting Notes: Code Analysis Presentation PDF

February 2nd Meeting - 10 Most Critical Web App Security Risks

You are cordially invited to the Gateway JUG's next meeting on February 2nd, 2010. The meeting topic will be, "The 10 Most Critical Web Application Security Risks"

In case you missed our January meeting, you need to know ...

Beginning in 2010, the Gateway JUG has teamed up with the Gateway Groovy Users Group to bring you Groovy, Grails and Java at the same place, on the same night.

Dave Klein, author the the Pragmatic Programmer's book, "Grails: A Quick-Start Guide" is heading up the Gateway Groovy Users group.

For more than a year, we at the Gateway JUG have been stressing the importance of your beginning the process of learning Groovy and Grails.

Groovy is Java's dynamic language cousin. Groovy classes compile to JVM bytecode and run in the JVM alongside Java classes. Groovy classes can call Java classes directly and Java classes can call Groovy classes directly. Of course, Java can't "see" dynamic methods on Groovy classes and can't take advantage of all of Groovy's features. Still, the interoperability between the two is very high, particularly when leveraging existing Java code and APIs in Groovy.

Grails is to Groovy what Struts and JSF are to Java; that is, Grails is Groovy's web framework. Because Grails leverages the power of Groovy's dynamic language features, it does far more elegantly than Struts or JavaServer Faces does, but in a distinctly more elegant way. However, Grails builds on a stack of proven Java technologies, like Hibernate, Spring, SiteMesh, Log4J, and more. Grails uses the best of what Java and Groovy have to offer.

Several large Java shops in town are already using Groovy in some way or another, and at least one has multiple Grails projects underway.

So starting last month, the Gateway Groovy Users group now meets from 6:00pm - 7:00pm on the first Tuesday of the month in the same location as the Gateway JUG meets. The Gateway JUG meeting will then commence at 7:00pm. We'll share the same meeting location, date, and sponsor. We'll wrap up at 8:30pm.

Learn more about the Gateway Groovy Users Group and the February 2nd meeting at http://gatewaygroovy.org/.

Now about our Gateway JUG meeting which will start at 7:00pm following the Gateway Groovy Users group meeting that starts at 6:00pm...

The February Gateway JUG meeting topic will be, "The 10 Most Critical Web Application Security Risks"

In this talk, we'll cover the new 2010 top 10 list published by the Open Web Application Security Project (OWASP). Through a combination of code, example scenarios, and demonstrations, you'll meet the top 10 web app security risks, including:

- Injection Flaws
- Cross Site Scripting (XSS)
- Broken Authentication and Session Management
- Insecure Direct Object References
- Cross Site Request Forgery (CSRF)
- Security Misconfiguration
- Failure to Restrict URL Access
- Invalidated Redirects and Forwards
- Insecure Cryptographic Storage
- Insufficient Transport Layer Protection

To RSVP, please follow the instructions at http://www.gatewayjug.org/rsvp-instructions.html which have recently changed.

The important part of the instruction update is that we're now using Meetup.com for our RSVPs. To RSVP, please visit http://www.meetup.com/GatewayJUG and register to attend. Your e-mail address will be requested so that we may contact you in the event of a meeting cancellation or important update. (This time of year, having a way to reach you is especially important.)

Note: To RSVP for the Gateway Groovy Users group meeting that precedes our meeting (and you really should attend it!), please visit http://www.meetup.com/GatewayGroovyUsers/

To Recap

The Gateway JUG meeting will start at 7:00pm on February 2nd and will immediately follow the meeting of the Gateway Groovy Users Group meeting that will start at 6:00pm. I strongly encourage all of you to attend both meetings; the extra 30 minutes over our old 2 hour format will be well worth it!

Speaker: Jack Frosch

Sponsor: TekSystems

Meeting Notes: TBA

January 5th Meeting - What's New In Spring 3.0?

You are cordially invited to the Gateway JUG's first meeting of the new year on January 5th, 2010. The meeting topic will be, "What's New In Spring 3.0?"

Before telling you about the meeting topic, I have a very important announcement to make:

For almost 10 years, the Gateway JUG has met at 6:00pm. That's changing... kind of...

Beginning in 2010, the Gateway JUG has teamed up with the Gateway Groovy Users Group to bring you Groovy, Grails and Java at the same place, on the same night.

Dave Klein, author the the Pragmatic Programmer's book, "Grails: A Quick-Start Guide" is heading up the Gateway Groovy Users group.

For more than a year, we at the Gateway JUG have been stressing the importance of your beginning the process of learning Groovy and Grails.

In case you missed it while picking the anchovies off your pizza, Groovy is Java's dynamic language cousin. Groovy classes compile to JVM bytecode and run in the JVM alongside Java classes. Groovy classes can call Java classes directly and Java classes can call Groovy classes directly. Of course, Java can't "see" dynamic methods on Groovy classes and can't take advantage of all of Groovy's features. Still, the interoperability between the two is very high, particularly when leveraging existing Java code and APIs in Groovy.

Grails is to Groovy what Struts and JSF are to Java; that is, Grails is Groovy's web framework. Because Grails leverages the power of Groovy's dynamic language features, it does far more elegantly than Struts or JavaServer Faces does, but in a distinctly more elegant way. However, Grails builds on a stack of proven Java technologies, like Hibernate, Spring, SiteMesh, Log4J, and more. Grails uses the best of what Java and Groovy have to offer.

Several large Java shops in town are already using Groovy in some way or another, and at least one has multiple Grails projects underway.

So beginning January 5th, the Gateway Groovy Users group will meet from 6:00pm - 7:00pm on the first Tuesday of the month in the same location as the Gateway JUG meets. The Gateway JUG meeting will then commence at 7:00pm. We'll share the same meeting location, date, and sponsor. We'll wrap up at 8:30pm.

We'll publish details on the January 5th Gateway Groovy Users meeting topic as soon as it becomes available.

Now about our Gateway JUG meeting

... which will start at 7:00pm

... following the Gateway Groovy Users group meeting

... that will start at 6:00pm...

The January Gateway JUG meeting topic will be, "What's New In Spring 3.0?"

Spring has become one of the "must know" frameworks used in professional Java development. From it's earliest days as a simple IoC (Inversion of Control) container, to its latest incarnation spanning a wide range of Java enterprise capabilities, Spring has consistently added a lot of value without a lot of bloat. (Well, at least relative to the full J2EE/JEE competition.) 

So let's see what's new in 3.0.

First, we'll briefly discuss the Spring framework. Next, we'll have a very brief recap of Spring 2.5 to give us a basis for comparison. Then, we'll dive into plenty of examples and code to catch you up on many new, cool Spring 3.0 features, including:

- Spring Core Updates for Java 5 Language Features
- Spring Expression Language
- IoC enhancements/Java based bean metadata
- General-purpose type conversion system and field formatting system
- Object to XML mapping functionality (OXM) moved from Spring Web Services project
- Comprehensive REST support
- @MVC additions
- Declarative model validation
- Early support for Java EE 6
- Embedded database support

To RSVP, please follow the instructions at http://www.gatewayjug.org/rsvp-instructions.html which have recently changed.

The important part of the instruction update is that we're now using Meetup.com for our RSVPs. To RSVP, please visit http://www.meetup.com/GatewayJUG and register to attend. Your e-mail address will be requested so that we may contact you in the event of a meeting cancellation or important update. (This time of year, having a way to reach you is especially important.)

Note: To RSVP for the Gateway Groovy Users group meeting that precedes our meeting (and you really should attend it!), please visit http://www.meetup.com/GatewayGroovyUsers/

To Recap

The Gateway JUG meeting will start at 7:00pm on January 5th and will immediately follow the meeting of the Gateway Groovy Users Group meeting that will start at 6:00pm. I strongly encourage all of you to attend both meetings; the extra 30 minutes over our old 2 hour format will be well worth it!

Speaker: Jack Frosch

Sponsor: ComSys

Meeting Notes: Download PDF

December 1st Meeting: Trivia and Entertainment

You are cordially invited to the Tuesday, December 1st meeting of the Gateway JUG. Doors open at 5:45pm with refreshments served at 6:00pm.

Our December 1st meeting will be a special end-of-year event featuring a Java/JVM Trivia Contest with a very special entertainment surprise.

The Trivia Contest will feature a wide range of Java and JVM-related trivia designed as a fun way to improved your knowledge of the topics covered. The trivia questions will come from these categories, (subject to change):

• Core Java
• Java WebDev
• JEE Tidbits
• Essential Associations
• Java Community and Culture
• The JVM Playground
• Certified Java Geek
• Gateway JUG History

Don't worry, you needn't be a guru to win. Many questions will be easy, some will be hard, and a few nearly impossible. Remember, this is supposed to be fun and isn't a test!

Of course we'll have plenty of prizes. There will be prizes for trivia winners, but prizes will also be awarded from a drawing of participants.

While the trivia rounds are being played, we'll have some very special background entertainment perfect for us geeks.

So come on out and let's wish this lousy year a fond farewell as we look forward to the new year!

Please RSVP so we know how much food, refreshments, and prizes we need! This would be a great time to bring a long a friend or co-worker who would benefit from joining in our community of Java and Groovy developers.

Trivia Moderators: Jack Frosch, Laura B., and other volunteers
Entertainment:       A Surprise!
Sponsor:                Modis

November 3rd Meeting: Groovy for Java Developers

You are cordially invited to the Tuesday, November 3rd meeting of the Gateway JUG. Doors open at 5:45pm with refreshments served at 6:00pm.

Our November meeting topic will be "Groovy for Java Developers." Our presenter will be Jack Frosch, our Gateway JUG Founder and President.

This will not be 75 minutes of humdrum PowerPoint slides!

Instead, after a few minutes of presentation comparing and contrasting Java and Groovy, we'll launch into an exciting game of Groovy versus Java.

Using a fun, interactive game approach, we'll explore, in code only, a wide variety of Groovy approaches to common problems we solve with Java every day. Here are just a few of the topics we'll cover:

• Java and Groovy Syntax Similarities and Differences
• Groovy Strings and HereDocs
• Groovy Truth
• Maps, Collections, and Ranges
• Working with Beans
• Metaprogramming
• Working with XML
• Accessing Web Services With Groovy
• Unit Testing with Groovy
• The Power of Scripting
• ... and more!

Volunteer game participants will have the chance to win a variety of great prizes, including books, USB drives, and gift cards. Don't worry; you won't have to do any coding! Just come and have a good time exploring "Groovy for Java developers."

We're very proud to have CDI IT Solutions as our sponsor again.

It's important for you to let us know you will attend so we can develop an accurate estimate for refreshments and door prizes. To RSVP, see these instructions. Go here for directions.

Speaker: Jack Frosch

Sponsor: CDI IT Solutions

Meeting Notes: (when available)

October 6 Meeting: Introduction to Cloud Computing

Is cloud computing all hype or is this a paradigm shift?  The presentation is an exploration of cloud computing and what it means for Java/J2EE application development.  We will explore cloud services that are offered by Amazon and Google.  We will discuss the issues facing cloud computing today.

The demonstration is a sample application that leverages Google's cloud infrastructure and Amazon's Simple Queue Service (SQS).  We will discuss how to develop an application on your local computer and then deploy it to the cloud.

Specific topics that will be covered:

    What is cloud computing?

    Cloud computing in the news

    Gartner's hype cycle for emerging technologies

    Demonstration of sample application on the Google cloud

Speaker: Sharath Sahadevan

Sponsor: NetEffects 

Meeting Slides: Intro To Cloud Computing.pdf