Gateway JUG

Putting Your Technical Debt Under Control with Sonar

Companies fail all the time because they accumulate more debt than they can ever repay. Likewise,  software projects fail all them time when their technical debt gets out of control.

What is technical debt and how do you measure it?

Back in 1980, Meir Manny Lehman wrote that,

"As an evolving program is continually changed, its complexity, reflecting deteriorating structure, increases unless work is done to maintain or reduce it." 

Ward Cunnigham is a renowned developer who invented the wiki and a pioneer in Extreme Programming and design patterns. He expanded on Lehman's observation in a 1992 experience report:

"Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite... The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise."

(See this Wikipedia Technical Debt article for much more on the subject.)

So how do we measure technical debt?

There are plenty of tools and APIs that help with this, but each tends to focus on a narrow part of the problem.  For instance, unit and other automated tests inform us our code is working in the areas covered by the tests. But what if we missed tests for some code? Code coverage tools like Cobertura tell us how much test coverage we have. Our IDEs usually offer some insights using code inspections to help spot bad coding practices; e.g. Flagging an empty catch block. We can also use code inspection tools like FindBugs to inform us of possible bugs.

Wouldn't it be nice if there was a tool that would would bring all of these technical debt measurements together in a consilidated view? There is. It's called Sonar.

Sonar is an LGPL licensed, open source platform hosted at Codehaus. It's what we can use to manage code quality to help us manage and reduce our technical debt. It covers the 7 axes of code quality:

 

This presentation shows how you can Sonar today to first measure, and then improve, code quality. In the presentation, I will cover

• Downloading and configuring Sonar
• The Sonar dashboard
• Code quality metrics covered
• Using The SQALE Ratings
• Alerts
• Hotspots
• Time Machine
• Cloud Views
• Design issues
• Timeline

All of these will be demonstrated with live demonstrations of this remarkable tool.

We need to know you're coming, so please be sure to RSVP using the link on the right sidebar.

Speaker: Jack Frosch

Sponsor: Modis

December 6th Meeting - Topic TBA (Tentatively, "What's New In Servlet 3.0?")

Topic: What's New in Servlet 3.0

The Gateway JUG will met on Tuesday, December 6th.  The topic was, "What's new in Servlet 3.0" and was a last minute change from our planned topic, "Tool Tips: A Survey of the 3 Leading IDEs"

Speaker: Jack Frosch

Sponsor: Advanced Resources

November 1st Meeting - Evolving JavaServer Faces

Java Web Development, you've come a long way baby!

From raw Servlet programming emitting HTML markup, to Struts 1.x, to JavaServer Faces (JSF) 1.x, Java really did advance the ball for producing enterprise-grade web applications.

JavaServer Faces became the official Java Enterprise Edition web framework and was baked into JEE5. It has evolved into JSF 2.x which is the standard web framework fro JavaEE 6.

JavaServer Faces 2.x has moved the Java web development ball even further downfield, simplifying many of the tasks developers need to do to create web applications in Java.

In this presentation, I'll walk you through the basics of JavaServer Faces development, providing an overview of the JSF Request Life-cycle and artifacts used in JSF.  We'll then take a JSF 1.x application and apply the JSF 2.x features to reduce configuration and a lot of the high ceremony code needed in JSF 1.x.

We'll then go a step farther and apply Groovy code in those places allowed in JSF 2.x (and there are many!), to whittle down the codee even more.

When we're done, the final JSF application will do everything it did before, but with a fraction of the code and configuration needed in JSF 1.x.

Don't worry if you're not familiar with JSF or using it JSF now. This presentation is for Java developers doing any web development who would like to see how JSF works, both in v 1.x and 2.x. It's also for Groovy developers looking for a way to apply their Groovy skills in enterprises already doing Java web development. While no prior JSF experience is necessary, experienced JSF developers will enjoy witnessing the evolution of JavaServer Faces!

Here's what we'll cover:

• JavaServer Faces - The Basics
• JSF 1.x Sample Application Code Review
• Morphing a JSF 1.x App into a JSF 2.x App
• Making JSF Groovy

So tell your friends and come on out to network, learn some JSF, and generally have a good time! As always, we'll have good food and drinks, and valuable door prizes!

NOTE: This presentation will be for both the Gateway JUG and Gateway Groovy Users Groups as both Java and Groovy topics will be covered.

Speaker: Jack Frosch

Sponsor: TBA

Oct 4 JUG Meeting: Change Anything with Cucumber and ATDD

 
Alright, so you’ve heard the TDD claim to fame.  Your code (…. Your functionality) is closely protected by an ever vigilant suite of tests ready to stop bugs before they are even introduced.  This sounds good, eh?

While TDD and unit testing provide numerous advantages in addition to protecting existing functionality, one shortcoming you may discover is that the scope of the unit test is too small.  Yeah, it tests how that individual class works,  but will it test the application as a whole?  Furthermore, will my unit test even be useful after a big change to the class structure?  Not likely.

Enter Acceptance Test Driven Development using Cucumber.  Test the whole application, nothing but the application, and only the application.  Allow yourself to be free to change big things and still have absolute confidence that your application still performs.  Furthermore, doing ATDD with Cucumber allows your tests to be in English (or Swedish if you like).

Whoa.  Tests in English!?  That sounds like a bad idea…  You have to see it to believe it.  It’s DRY and it’s awesome.  See you October 4^th.

Speaker: Mike Menne

Sponsor: Aurora Systems Group

Sept 6 Meeting - Concurrency in Java

 

The Concurrency in Java presentation will be a straight to the point design and
coding experience.

We'll dive into the most common problems like deadlocks,
starvation, live locks and race conditions. We'll discuss what causes them
and what patterns we can use to avoid them. We'll examine what anti patterns
can be found in existing code and how to fix them. We'll review immutable,
atomic and concurrent objects as well as synchronization. Last, but not
least, we'll see some API offered by JDK to help us write elegant code that
executes correctly in multi-threaded environment.

Presenter:  Tomasz Mozolewski

Sponsor: Experis Manpower Group

August 2nd Meeting - JSR 299: Contexts & Dependency Injection

JSR 299: Contexts & Dependency Injection

In August, we'll explore JSR 299, Contexts & Dependency Injection.

If you've been working with Spring, you can appreciate the flexibility offered by Dependency Injection and Aspect Oriented Programming (AOP). However, robust dependency injection was not available in "out-of-the-box" in the Java Enterprise Edition (JEE) until JEE 6. This capability was defined in JSR-299, once called "Web Beans", but now named Contexts & Dependency Injection (CDI).

In this presentation, we will explore the capabilities offered by CDI, not only in JEE 6, but in a servlet container (i.e. Tomcat) and even in plain ol' Java SE. Specifcially, we will discuss:

• About JSR 299
• CDI Objectives
• Relationship to Other Specs
• Sounds a Lot Like Spring …
• CDI Availability
• CDI By Example
  • CDI In Java SE
  • Producer Methods
  • Interceptors
  • Decorators
  • Events
  • Stereotypes
  • Specialization, Inheritance and Alternatives
  • Working with JEE Resources
  • JEE Integration
  • CDI In Tomcat (with JSF 2 examples)

When you leave, you should have a good idea of what role CDI can play in your current and future projects.

Be sure to RSVP via our Meetup page.

Presenter: Jack Frosch

Sponsor: Objistics

Meeting Notes: TBA

June 7th Meeting - Google Guava

  Google Guava

There are a lot of ways to learn better programming techniques. One of the best ways is to see examples revealing just what is possible. Take those examples and package them into a general purpose library and you have Google Guava!

In this presentation, we explore Guava code in the following com.google.common subpackages:

• base
• collect
• io
• net
• primitives
• util.concurrent

There's a lot in here, so I'll list 'em all, but focus on those that will give you the most value or illustrate the most interesting approaches.

From simple toStringHelper() methods to powerful immutable collection factory methods to bi-directional maps allowing look-up via value or key, you'll see plenty of ways Guava can streamline your code to make it cleaner, more elegant, and more maintainable.

By the time we finish, I guarantee you'll be devising arguments you'll make the next day to get Guava adopted into your project!

So arrive on time as we'll be starting promptly at 6:00pm to cover the bounty of goodies Google provides in the Guava library!

Presenter: Jack Frosch

Sponsor: Adaptive Solutions Group

Meeting Notes: TBD

May 3 Meeting - J90X - Transforming Flabby Code

J90X

Transforming Flabby Code

It's time to cut the flab and gain some lean, mean object oriented Java code.  That's right...90 minutes.  No gym.  No diet.  Lose 30, 60, perhaps even 120 lines of code per class.  Watch the methods melt away and be prepared to be amazed with your toned, trim objects.

Using the latest techniques developed by Robert Martin, Steve Freeman, and Nat Pryce, you can develop the software that you have always wanted.  Just read these testimonials...

"At first I was reluctant to try J90X, but even after 60 minutes, my classes were more focused and clearly defined on one purpose."

"J90X gave me the confidence to better organize my code.  Just like that, the method parameters and temporary variables disappeared.  It was easy!"

"People used to say that I had a lot of 'junk in the trunk', but since using J90X my junk is packaged neatly with matching functionality."

It can be easy for you too.  Simply attend the Gateway JUG meeting on May 3rd, 2011 and begin applying the principles that will transform your code from flab into fab.

Included in J90X is:

• Brief overview of Test Driven Development
• How to listen to your code
• Clean code gotta-knows
• A few words about Refactoring
• How to break the fules with Freeman and Pryce

Speaker: Mike Menne

Sponsor: RELAY|technology

April 5th Meething - Collaborators, I Mock Thee!

Ok, I admit it. I really like automated testing.

In the beginning, they tell us that we're meeting the requirements, at least as well as we understand them.  Along the way, they validate that nontrivial code we are writing isn't hiding a bug that will surely be found by a user at the most inopportune time.  Long after the code is created and committed, they allow us to test new features. Alas, when bugs do scurry out of the darkness into the light of our user's monitor, automated tests help us verify the bug and its fix. Most importantly, they give us the confidence to refactor code to make it better. (It's axiomatic that the first edition of code written under a tight schedule can be improved upon!)

Not all tests are equal though.

Automated functional (i.e. web) testing tends to be tedious to write and is a little fragile in a changing business environment. Of course, starting and restarting a server drains our development momentum.

Integration tests are a bit better, but still impose time-wasting server starts, Spring context loading, database preparation, etc.

Pure unit tests are a different matter altogether.

Clean and fast, they tell us right away (in under 50ms) that the thing we're testing is doing what we think it should do. No servers to start up. No Spring context to load. We're in and out after just a few minutes of test code writing and 50ms of test execution.

One testing reality we have to deal with is that classes under test usually have collaborators. We're lucky if the collaborators are even available as they are often under parallel development. If they are, maybe they're being looked up (i.e. via JNDI) or, in the worst case, are being instantiated in the middle of a method we're testing. Our class under test relies on the collaborator's behavior and resulting data so the collaborators have to be accounted for by our test. Unaware of other options, we might just give in and make our speedy unit tests into slow integration tests to give us access to the collaborators.

But we do have other options.

This presentation is all about keeping unit tests pure unit tests.

First, we'll discuss some general testing concepts and coding pitfalls that we can avoid to help us in our effort. We'll also discuss challenges when creating tests for existing code that's poorly written and difficult to test. Then we'll dive into using Mocks and Stubs, what they are, how to write them, and why you shouldn't write them. Instead, I'll show you three Java mocking frameworks you should consider, with emphasis on Mockito, one of the new kids on the block.  Throughout the presentation, I'll show you code that illustrates the concepts being discussed.  In summary, we'll cover:

• Overview of automated testing
• Creating tests for badly written code
• Coding pitfalls to avoid that also make testing easier
• Mocks and Stubs
• Using a mocking frameworks - a brief look at jMock and EasyMock
• Introduction to Mockito

Speaker: Jack Frosch

Sponsor: TransITions

March 1, 2011 Meeting: "League of Legends" - Java Programming Challenges of Online Gaming

Because of winter weather, this meeting was rescheduled from February 1st to March 1st.

Come and see just how much fun you can have with Java!

Launched in October of 2009, League of Legends has taken the online gaming world by storm.  The winner of GameSpy.com's PC Game of the Year, LoL has quickly accumulated a devoted following growing at an exponential rate.  Staying ahead of such scale challenges, while no small feat, has proven less difficult due to smart choices made during initial architecture design.  This presentation will detail the core choices and challenges of that journey.  It will include lessons learned during initial product creation such as scale testing, metrics gathering, and planning for 24/7 operation.  Key design decisions will also be explored in detail, including League of Legends’ extensive use of Oracle Coherence caching and grid computing capabilities.

Scott's presentation is sure to be an exciting and entertaining, as well as informative one.  Hope to see you all there!

Speaker: Scott Delap

Sponsor: NetEffects