No Fluff Just Stuff

No Fluff Just Stuff http://www.nofluffjuststuff.com The best value in the Java/Open Source conferencing space hands down Michael Nygard - ITIL and Extreme Programming http://www.michaelnygard.com/blog/2007/05/itil_and_extreme_programming.html Esther Schindler asked if I'd be willing to post my earlier article on <a href="http://www.michaelnygard.com/blog/2007/05/itil_and_xp.html">staying agile in the face of ITIL</a> at CIO.com.  How could I say no?  The piece is <a target="_blank" href="http://advice.cio.com/mtnygard/itil_and_extreme_programming">here</a>.   Mon, 21 May 2007 08:00:00 CDT Jason Rudolph - GSwG Source Code Now Updated for Grails 0.5 http://jasonrudolph.com/blog/2007/05/19/gswg-source-code-now-updated-for-grails-05/ Grails 0.5 was a huge release, and you’re bound to come across some of its many enhancements in any app you build. If you’ve installed 0.5 and you’re using it as you work through Getting Started with Grails (GSwG), there are a few new resources to assist you in that endeavor. First up, [...] Sun, 20 May 2007 16:00:00 CDT Venkat Subramaniam - It's not the languages, but their idioms that matter http://www.agiledeveloper.com/blog/PermaLink.aspx?guid=47615df9-fcfe-45db-8fe9-cc5714834699 Some things that you can say eloquently in one (human) language, may not sound as nice when you translate to another language. Idioms add spice to conversations in a language (and when overused they turn into cliches). Idioms don't take the aggregated meaning of the words that make them. Their meaning's shaped by culture, tradition, and history. Idioms make learning a language interesting, tricky, and fun. One of the challenges of picking up a language is learning the idioms. The same applies to computer languages as well. Their "idioms" make them fun to learn. You may accomplish a task in a number of ways in a language. When you're new, you may try out some ways you're used to in other languages. Learning that "language way" of doing things is, however, exciting. We need to take the time to learn the idiomatic differences and there in lies the fun. Here is a little swing code in Java (I can reduce this to one method and use anonymous inner classes for the event handler, but Groovy would choke on that, so I decided to keep the code like below for the purpose of this example). import javax.swing.*; import java.awt.event.*; import java.util.Date; public class SwingIt implements ActionListener {     JLabel myLabel;     public void actionPerformed(ActionEvent ae)     {         myLabel.setText(new Date().toString());     }     public void showExample()     {         JFrame frame = new JFrame();         frame.setTitle("Swing It");         frame.setLayout(new java.awt.FlowLayout());         frame.setSize(300, 200);         frame.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);                 myLabel = new JLabel("Test");                 JButton myButton = new JButton("Click Me");         myButton.addActionListener(this);                 frame.getContentPane().add(myLabel);         frame.getContentPane().add(myButton);                 frame.setVisible(true);     }     public static void main(String[] args)     {         new SwingIt().showExample();     } } [ Like I said above, I can eliminate the actionPerformed method in SwingIt class and replace the event listener code as: myButton.addActionListener( new ActionListener()     {         public void actionPerformed(ActionEvent ae)         {             myLabel.setText(new Date().toString()); // This will require myLabel to be declared final in showExample         }     } ) ] The above code pops up a frame with a label and button. When you click on the button, it displays the current date and time in the label. Almost all Java code is Groovy code. So you can literally copy the above file to SwingIt.groovy and type groovy SwingIt.groovy to execute the code in Groovy. But, that's no fun. We've not really seen the Groovy way of doing that. So, let's start by stripping out code that's not needed, after all, Groovy is a light weight language with high signal-to-noise ratio. Also, we will make some slight changes to the way we will write the event handler addActionListener. So, here is the modified code SwingIt2.groovy: import javax.swing.* import java.awt.event.* JFrame frame = new JFrame() frame.setTitle("Swing It") frame.setLayout(new java.awt.FlowLayout()) frame.setSize(300, 200) frame.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE) myLabel = new JLabel("Test") JButton myButton = new JButton("Click Me") myButton.addActionListener( { myLabel.setText(new Date().toString()) } as ActionListener ) frame.getContentPane().add(myLabel) frame.getContentPane().add(myButton) frame.setVisible(true) The code that catches my eyes is myButton.addActionListener( { myLabel.setText(new Date().toString()) } as ActionListener ) Here the code block within {} is treated to implement the ActionListener interface. Can we do better? Groovy provides markup builders and there's one for Swing (think of this as DSL for Swing in Groovy). Here's SwingIt3.groovy: bldr = new groovy.swing.SwingBuilder() frame = bldr.frame(     title: "Swing It",     layout: new java.awt.FlowLayout(),     size: [300, 200],     defaultCloseOperation: javax.swing.WindowConstants.EXIT_ON_CLOSE) {     myLabel = label(text: 'Test')     myButton = button(text: 'Click Me', actionPerformed: { myLabel.setText(new Date().toString()) } ) } frame.setVisible(true) I was chatting with <a href="http://memeagora.blogspot.com" target="_blank">Neal</a> this afternoon, and he mentioned <a href="http://www.paulgraham.com/power.html" target="_blank"> Paul Graham's discussion on Language Succinctness</a>. Groovy code is more succinct than Java code. How would the code look like in JavaScript (With Java 6 and JSR 223, you can write Java-platform code in one of several different languages including JavaScript)? Let's take a look. var swingpkg = new JavaImporter(javax.swing, java.awt, java.io, java.lang) with(swingpkg) {     var frame = new JFrame()     frame.title = "Swing It"     frame.setLayout(new FlowLayout())     frame.setSize(300, 200)     frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE)     myLabel = new JLabel("Test")     frame.getContentPane().add(myLabel)     myButton = new JButton("Click Me")     myButton.addActionListener(         function() { myLabel.text = new Date().toString() }     )     frame.getContentPane().add(myButton)     frame.setVisible(true)     Thread.sleep(10000) } To run the above code, copy it into SwingIt.js and run jrunscript SwingIt.js (I'm running Java 6 for this). The code that caught I eyes here is:     myButton.addActionListener( function() { myLabel.text = new Date().toString() } ) How about trying this same example in JRuby? Here is SwingIt.rb. To run it type jruby SwingIt.rb: require 'java' module Java     include_package 'javax.swing'     include_package 'java.awt'     include_package 'java.awt.event'     include_package 'java.util' end my_label = Java::JLabel.new('Test') my_button = Java::JButton.new('Click Me') my_button.addActionListener(     Java::ActionListener.impl { |name, *args| my_label.text = Java::Date.new.toString() } ) frame = Java::JFrame.new frame.setSize(300, 200) frame.setLayout(Java::FlowLayout.new) frame.getContentPane().add(my_label) frame.getContentPane().add(my_button) frame.setVisible(true) Here the code that caught my eyes is: my_button.addActionListener(     Java::ActionListener.impl { |name, *args| my_label.text = Java::Date.new.toString() } ) Let's take a look at the event handling code in these languages: Java: myButton.addActionListener( new ActionListener()     {         public void actionPerformed(ActionEvent ae)         {             myLabel.setText(new Date().toString()); // This will require myLabel to be declared final in showExample         }     } ) Groovy: myButton.addActionListener( { myLabel.setText(new Date().toString()) } as ActionListener ) or myButton = button(text: 'Click Me', actionPerformed: { myLabel.setText(new Date().toString()) } ) JavaScript: myButton.addActionListener( function() { myLabel.text = new Date().toString() } ) JRuby: my_button.addActionListener( Java::ActionListener.impl { |name, *args| my_label.text = Java::Date.new.toString() } ) All these code do the same thing. However, each of them is idiomatically different (eloquent) in their own languages. Writing Java code in Groovy (or JRuby) is like me trying to translate an idiom from my mother tongue Tamil to English. That generally sounds real awkward and loses the essence. To say it in English, I would simply choose to use plain English or find a suitable English idiom. Like wise, we need to figure out the idiomatic way in languages we choose. And that is what keeps me excited and I hope it does you as well. <hints id="hah_hints"> </hints> <img width="0" height="0" src="http://www.agiledeveloper.com/blog/aggbug.ashx?id=47615df9-fcfe-45db-8fe9-cc5714834699"> Sun, 20 May 2007 13:00:00 CDT Jeff Brown - Autism Visibility Continues To Increase http://javajeff.blogspot.com/2007/05/autism-visibility-continues-to-increase.html <a href="http://www.doverspeedway.com/">Dover Speedway</a> has announced that the <a href="http://www.nascar.com/series/cup/">NEXTEL Cup</a> race coming up there in June will be named ?<a href="http://tinyurl.com/yvts4v">The Autism Speaks 400 presented by Visa</a>?. NEXTEL Cup racing is huge here in North America and has a very large fan base. <a href="http://www.autismspeaks.org/">Autism Speaks</a> is one of the largest foundations in the world that is dedicated to autism. I am happy to see them get their name on the marquee of an event like this. That can only help with awareness. This is not the first time that autism and automobile racing have crossed paths. <a href="http://www.jamiemcmurray.com/">Jamie McMurray</a> has an autistic niece and partnered with <a href="http://www.autism-society.org/">The Autism Society of American</a> in 2004 when he drove the ?Drive For A Cure? car. <a href="http://en.wikipedia.org/wiki/Tony_Renna">Tony Renna</a> drove the ?<a href="http://www.cureautismnow.org/">Cure Autism Now</a>? car in 2003. There have been others. It has been almost exactly 5 years since my youngest son Jake was diagnosed autistic. In those 5 years I have learned a number of things about autism and one of those things that I have learned is that there are not a lot of people who know much about autism. Awareness is increasing. That isn't because more people are reading medical journals in their free time. Aside from a dramatic increase in the number of kids being diagnosed autistic, the biggest reason that awareness is increasing is that more and more autism is showing up in the mainstream media. Recently some actors and other celebrities have been criticized for jumping on the ?autism bandwagon?. These criticisms often refer to autism as the disease du jour. I don't have much to say about that except to say that raising awareness is an important part of this fight and when I see people going out of their way to help with awareness, I am happy to see that. Sun, 20 May 2007 11:00:00 CDT Jeff Brown - Alternate Syntax For URL Mapping In Grails http://javajeff.blogspot.com/2007/05/alternate-syntax-for-url-mapping-in.html One of the cool new features that was introduced with <a href="http://grails.org">Grails</a> 0.5 is <a href="http://grails.org/URL+mapping">Custom URL Mapping</a>. The syntax for declaring the mapping looks something like this... <pre> class MyUrlMappings { static mappings = { "/product/$id" { controller = "product" action = "show" } "/$blog/$year/$month/$id" { controller = "blog" action = "show" constraints { year(matches:/\d{4}/) month(matches:/\d{2}/) } } } } </pre> Since the release we have added support for an alternate syntax (which I happen to like) that looks like this... <pre> class MyUrlMappings { static mappings = { "/product/$id" (controller:"product", action:"show") "/$blog/$year/$month/$id" (controller:"blog", action:"show"){ constraints { year(matches:/\d{4}/) month(matches:/\d{2}/) } } } } </pre> Dynamic languages like Groovy make these sorts of things really easy to support. Behind the scenes of this url mapping there there is no grammar file and no tangly parser to manage. The configuration file is plain old groovy code. Blurring the line between code and configuration files by using a DSL like this is so much easier in Groovy that it might be in a language like C++ or Java. You have got to love it. :) Sun, 20 May 2007 08:00:00 CDT Venkat Subramaniam - What's that Unit to test? http://www.agiledeveloper.com/blog/PermaLink.aspx?guid=5151f62a-9503-4e70-b1f1-9c37778515e2 Earlier this week I was in Canada teaching a Test Driven Development course. The team was great?very interactive and passionate. Unit Testing is very valuable, but I would be lying if I said it's easy. It takes effort to get good unit test written. A Unit Test is written on a Unit of code (yes, duh!) But, what's a unit of code? A unit of code is smallest piece of code that does useful work. Getters and setters usually are smallest piece of code, but often don't do much useful work (languages like Ruby and Groovy generate them for you automatically, but that is for another blog). So, I would not care to get them unit tested separately (they may get called in other tests, and that's OK). What about a method that has a long running task or that has to wait for an event that may happen at any time? Sure it's doing useful work, but it may not be "small." Chances are you can break it into smaller methods, where the method then may wait for an event, but when the event is received, can then call another (small) method that does useful work. In this case, I am quite happy unit testing this small method that does the useful work first and not worry about the event part yet. Don't we need to unit test the event receiving? We would separate the part that's waiting for the event into may be another small method, put in a mock for the event source if needed and have the event receipt unit tested. But, I would take that as the second or third test, not the first. When writing unit testing, some times we want to start testing everything we can think of. Sure, we are eager to have the functionality tested, in its entirety. But, that leads to two problems. We will find it very hard to comprehend the testing. We may write a large test. We may also overly complicating the solution in the process. Keep it small, keep it focused, fast, and automated. That is easier to say, but on a real project, can it get hard? Yes it does. When that happens, take a short break. Stepping away from the code helps us think. Ask for help?find a colleague and bounce some ideas. While you are trying to explain the problem, you go though logical steps in your mind and this often helps you to figure out an approach. And once you think you've figured it out, ask your coworker to do a quick code review, not just the code, but the test also. You only stand to improve you code this way. Any who does not want to improve? :)<hints id="hah_hints"> </hints> <img width="0" height="0" src="http://www.agiledeveloper.com/blog/aggbug.ashx?id=5151f62a-9503-4e70-b1f1-9c37778515e2"> Sat, 19 May 2007 08:00:00 CDT Craig Walls - XML-free Spring with Spring 2.1 and annotations http://jroller.com/page/habuma?entry=xml_free_spring_with_spring As a followup to <a href="http://jroller.com/page/habuma?entry=reducing_xml_with_spring_2">yesterday's post</a> about using Spring 2.1's annotation injection, I'm now ready to show you how to get rid of the XML altogether. When we last saw our Spring XML file (ctx.xml in the <a href="http://www.habuma.com/spring/knight-spring-2.1.zip">downloadable example</a>), it looked like this: <pre class="code"> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.1.xsd"> <context:component-scan base-package="com.springinaction.chapter01.knight" /> <aop:aspectj-autoproxy/> </beans> </pre> I had eliminated all of the app-specific beans ("knight", "quest", "minstrel") and had replaced them with only two infrastructural elements. <context:component-scan> to automatically scan for and load classes annotated with @Component, @Repository, or @Aspect; and <aop:aspectj-autoproxy> to automatically create proxies for any beans annotated with @Aspect. You can now delete that XML file...we won't be needing it anymore. We can get the same behavior of <context:component-scan> by changing the main() method to look like this: <pre class="code"> package com.springinaction.chapter01.knight; import org.springframework.context.annotation.ClassPathBeanDefinitionScanner; import org.springframework.context.support.GenericApplicationContext; public class KnightApp { public static void main(String[] args) throws Exception { GenericApplicationContext ctx = new GenericApplicationContext(); ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(ctx); scanner.scan("com.springinaction.chapter01.knight"); ctx.refresh(); Knight knight = (Knight) ctx.getBean("knight"); knight.embarkOnQuest(); } } </pre> Previously, I was using a ClassPathXmlApplicationContext to load the Spring definition from an XML file in the classpath. But since the XML is going away completely, we won't need that application context class anymore. This time I'm using GenericApplicationContext...it doesn't load anything. Instead, we'll load it using ClassPathBeanDefinitionScanner. ClassPathBeanDefinitionScanner does the work of <context:component-scan> scanning the com.springinaction.chapter01.knight package for classes that are annotated with @Component, @Repository, or @Aspect. When it finds them, it automatically registers them in the Spring context. After the context has been loaded with all of the bean definitions, I refresh the context to be sure that all of the wiring takes place. Without calling refresh(), the beans are loaded, but not wired together. Finally, I retrieve the knight bean from the context and invoke the embarkOnQuest() method. If you run this, you'll notice that the Minstrel aspect doesn't get woven. I haven't figured that one out yet, but I'm really close. Stay tuned. In the meantime, you can download the XML-free version from <a href="http://www.habuma.com/spring/knight-spring-2.1-noxml.zip">here</a>. After unzipping it, notice that aside from the Maven POM file, there's no XML to be found in the entire project. Disclaimer P.S.: As I've stated before, I have no problems with Spring XML and still prefer to configure my Spring apps this way. But I also enjoy trying out the other configuration options and letting my readers choose for themselves. Fri, 18 May 2007 16:00:00 CDT Bruce Snyder - Google Calendar in Thunderbird http://jroller.com/page/bsnyder?entry=google_calendar_in_thunderbird <img src="http://www.mozilla.com/img/thunderbird-logo-64x64.png" align="right" /> <img src="http://jroller.com/resources/b/bsnyder/google_calendar.gif" alight="right" /> Ever since <a href="http://calendar.google.com/">Google Calendar</a> was released, I've been in search of a way to integrate it with <a href="http://www.mozilla.com/en-US/thunderbird/">Mozilla Thunderbird</a> or <a href="http://www.apple.com/macosx/features/ical/">Apple iCal</a> to allow birectional updates. Right away I was able to subscribe to my Google Calendar from iCal, but I'm not able to update my Google Calendar from within iCal. This is a real pain because now I'm keeping both an iCal calendar and a Google calendar and they're completely separate. Up until today, I've always wondered if this is a problem with iCal or with Google Calendar. In speaking to people, including a friend at Apple who works on the Darwin Calendar server, it turns out that it's a because the iCalendar spec in that it was never built to allow collaborative calendaring. This is where the <a href="http://ietf.osafoundation.org/caldav/index.html">CalDav</a> spec comes in - but that's a different story entirely (and <a href="http://www.mozilla.org/projects/calendar/lightning/">Mozilla Lightning</a> even supports CalDav!). Well today I discovered that there is an integration with Thunderbird via <a href="http://www.mozilla.org/projects/calendar/lightning/">Mozilla Lightning</a> with the Google Calendar - and it's bidirectional! There is even a <a href="http://bfish.xaedalus.net/?p=239">visual howto with screenshots</a> which is pretty handy (nice work, Jonny). I've already tested it to verify that I can update the Google Calendar from within Lightning and it works beautifully. This is the first time I've tried Lightning and it seems fairly basic. Hopefully the features will improve over time. Many, many people have been waiting for the Mozilla Foundation to create a competing product to Microsoft LookOut for many years and it seems like it's finally beginning to appear. Fri, 18 May 2007 13:00:00 CDT Mark Fisher - Spring Web Flow Java One 2007 Demo http://blog.interface21.com/main/2007/05/18/spring-web-flow-java-one-2007-demo/ <a href="http://blog.interface21.com/main/author/keithd/" title="Posts by Keith Donald"><img src='http://blog.interface21.com/main/wp-content/images/authors/keithd.jpg' alt='Keith Donald' title='Keith Donald' align="right" hspace="10px" /></a>When Sun scheduled my JavaOne 2007 session on Spring Web Flow for Friday, the last day of the conference, I wasn't sure what to expect. I was honored to have been accepted again this year, but I wondered what I would see in terms of attendance presenting on the last day of the 4-day conference. I could not have been more pleased with how things transpired. When I checked in at speaker setup on Thursday 800 people had pre-registered for my Friday session. Fifteen minutes before my talk was to begin the room had reached that number. In the end, 1000 JavaOne attendees came to room 307-310 of the Moscone center to experience an adrenaline-powered Spring Web Flow test drive. <h3>Spring Web Flow Test Drive</h3> In this blog I am hoping to re-create some the best parts of my JavaOne Web Flow presentation. Checkout the screen cast below to see what was personally the most exhiliterating part of the presentation for me–building out a search flow from the ground up for deployment in a Java Server Faces (JSF) environment. <object width="425" height="350"> <param name="movie" value="http://www.youtube.com/v/N5l_CN-zD74"> </param> <embed src="http://www.youtube.com/v/N5l_CN-zD74" type="application/x-shockwave-flash" width="425" height="350"> </embed> </object> When watching the screen cast note how Web Flow manages all navigation and state for the application, while standard JSF components care for view rendering and model data binding. It really is a nice fit. Also note even when I screw something up I can quickly fix it and get back to work because I never need to restart my server or switch my editor. The Spring IDE visualization of this flow is below: <img src="http://blog.interface21.com/main/wp-content/uploads/2007/05/search-flow.png" alt="Search flow" /> Get the code for this demo <a href="http://static.springframework.org/spring-webflow/resources/phonebook-jsf/phonebook-webflow-jsf.zip">here</a>. If you are using Eclipse with Web Tools you can import phonebook as an Dynamic Web Project and fire up the webapp inside your IDE. Fri, 18 May 2007 11:00:00 CDT Brian Goetz - JCiP best seller at JavaOne 2007 http://www.briangoetz.com/blog/?p=35 For the second year in a row, <a href="http://www.amazon.com/gp/product/0321349601?ie=UTF8&tag=none0b69&linkCode=as2&camp=1789&creative=9325&creativeASIN=0321349601">Java Concurrency in Practice</a> was the best selling book at the JavaOne bookstore…thanks everyone! Fri, 18 May 2007 08:00:00 CDT Pete Behrens - Carnival of Agilists - 5/17/07 http://trailridgeconsulting.com/blog/?p=90 Welcome to the most recent edition of the Carnival of Agilists - a blog roll of some of the thoughts, insights, ideas and trends in the agile (and post-agile) communities. In continuing with the free-form format of our last couple of carnival posters and our first topic on post-agile, I have freed myself from the agile manifesto structure as well - freedom! Jason Gorman and Jonathon Kohl are revoicing their skepticism on the current Agile (capital A) movement hype and wanting to find a better place to do just what works for you in their recent postings on <a href="http://parlezuml.com/blog/?postid=407">Post-Agilism Explained</a> and <a href="http://www.kohl.ca/blog/archives/000184.html">Post Agilism Frequently Asked Questions</a>. I say ‘revoicing’ because this was started over a year ago. Has Agile (capital A) hyped out the benefits of agile (lowercase a)? While this may be true in the microcosm deep in the agile community - I still find too many people who haven’t even heard of agile. Ester Derby is confused by all of the talk about whether everyone on an agile team needs to be above average as she asks if we should <a href="http://www.estherderby.com/weblog/2007/05/focus-on-individual-or-system.html">Focus on the individual or the system</a>? Thanks Esther for pointing us back to the lean principle of optimizing the whole system and not locally optimizing its parts as we often tend to do. Diana Larson provides a quick method in gathering/prioritizing team retrospective feedback using FRequency & IMpact with <a href="http://www.futureworksconsulting.com/blog/2007/04/27/frim-another-way-to-gather-data/">FRIM: Another way to gather data</a>. This is another great visualization tool that I plan to try out on my next team retrospective. James Shore continues to make progress on his new book <a href="http://www.jamesshore.com/Agile-Book/">The Art of Agile Development</a>. He has generously posted most of his work online during the writing stages for you to absorb and respond. James, thanks for reminding us of the agile value of openness. Ron Jeffries and Chet Hendrickson invite you to <a href="http://xprogramming.com/xpmag/FiveDays.htm">Five Days of Software Development with Style and Grace</a>. This proves to be the experience of a lifetime for any (well, Java) developer! Mike Cohn provides some <a href="http://www.scrumalliance.org/articles/46-advice-on-conducting-the-scrum-of-scrums-meeting">Advice on Conducting the Scrum of Scrums Meeting</a> in scaling scrum across a larger organization. Bernie Thompson started a new blog and discusses post-agile with the essential principle that allows lean to be something more than agile - <a href="http://leansoftwareengineering.com/2007/04/22/schedule-is-orthogonal-to-workflow/">Schedule is orthogonal to workflow</a>. Scrum, being the closest to lean thinking separates workflow and re-enforces independent work items. The <a href="http://agile2007.com/index.php?page=schedule/&date=2007-08-14">Agile 2007 Conference Schedule</a> has now been published. There are a tremendous number of sessions over the course of 5 days in August. I would highly suggest attending some or all of the event. Previous Editions All previous editions of the Carnival are referenced at the <a href="http://www.agilealliance.org/show/1670">Agile Alliance website</a>. Join in the Fun! Have something that you think is worth sharing? Don?t be shy! We love new ideas and insights. Send us a link to your post at <a href="mailto:agilists.carnival@gmail.com">agilists.carnival@gmail.com</a>. Future editions will be on the first and third Thursday of each month. If you would like to participate, please send us a link to your post at <a href="mailto:agilists.carnival@gmail.com" title="Link outside of this blog">mailto:agilists.carnival@gmail.com</a> Or, if you prefer, use this handy dandy <a href="http://blogcarnival.com/bc/submit_115.html" title="Submit an entry to ?carnival of the agilists?">carnival submission form</a>. Thu, 17 May 2007 16:00:00 CDT Venkat Subramaniam - Going to Grails Exchange http://www.agiledeveloper.com/blog/PermaLink.aspx?guid=a9394f12-95de-4e92-aa54-2255d01d9558 <a href="http://www.grails-exchange.com/pcd/1010" title="Venkat Subramaniam at Grails eXchange 2007" alt="grails,groovy,java ee, grails exchange" target="_blank"><img title="Venkat Subramaniam at Grails eXchange 2007" alt="groovy, grails, java ee, grails exchange" src="http://www.grails-exchange.com/custom/images/Grails-exchange-im-speaking-@-280-84.jpg" border="0"></a> <img width="0" height="0" src="http://www.agiledeveloper.com/blog/aggbug.ashx?id=a9394f12-95de-4e92-aa54-2255d01d9558"> Thu, 17 May 2007 08:00:00 CDT Howard Lewis Ship - Tapestry at JavaOne 2007 http://tapestryjava.blogspot.com/2007/05/tapestry-at-javaone-2007.html JavaOne was a lot of fun this year; I didn't arrive in time for the JavaFX keynote, but I understood it to be underwhelming. Yep ... that's what Java needs ... to take on Adobe and Microsoft in Adobe's home territory. On the other hand, this was a very social JavaOne; lots of good conversations and meeting with people I only know online. I also attended the <a href="http://weblogs.java.net/blog/edburns/archive/2007/05/jsf_20_eg_kick.html">Java Server Faces 2.0 Expert Group kickoff</a>. I can't really see where that's going to go, alas. It's not like everyone bowed down and said "JSF 2.0 shall be Tapestry" (not even Jacob Hookom, who does see Tapestry as a good model for much of JSF 2.0). But I did get a chance to chat with Gavin King ... about motorcycles. He's riding a Ducati now, and I'm thinking about picking up a new bike once I buy a house. Gavin --- I used to ride a Yamaha FZR1000. The best part of the JSF meeting was when <a href="http://blogs.sun.com/jonathan/">Jonathan Swartz</a> stopped by. We shook hands and talked about how slow adoption of JCP standards. Elsewhere ... the fun part about the RubyEnv parody ad ... <object height="350" width="425"><param name="movie" value="http://www.youtube.com/v/PQbuyKUaKFo"><param name="wmode" value="transparent"><embed src="http://www.youtube.com/v/PQbuyKUaKFo" type="application/x-shockwave-flash" wmode="transparent" height="350" width="425"></embed></object> ... is that Tapestry is jar #3. Interesting, though I guess it's hard to know what "JSF in a Jar" looks like, or "Struts in a Jar" for that matter. My intention is to reverse the meaning, make Tapestry 5 something that'll make the Ruby guys envious. We'll see. Wed, 16 May 2007 16:00:00 CDT Northern Wisconsin Software Symposium - Aug. 03 - 05, 2007 http://www.nofluffjuststuff.com/show_view.jsp?showId=102 <div style="font-family: Arial, Verdana, Helvetica, sans-serif; font-size: 10pt;"> No Fluff Just Stuff is pleased to announce the <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_view.jsp?showId=102" target="new">Northern Wisconsin Software Symposium</a>, Aug. 03 - 05, 2007. <div style="background-color: #0860A9; color: #EFCE52; font-weight: bold; padding: 5px 5px 5px 5px;"> Catch these Featured Sessions </div> <div style="border: 1px solid #999999; padding: 0 5px 0 5px;"> <table cellpadding="0" cellspacing="0" style="font-size: 10pt;"> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7296&showId=102" target="new">Running Tested Features</a> by Kirk Knoernschild </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=893" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/893_Knoernschild_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> Running Tested Features is a metric used to measure the delivery of running, tested features to business clients, and collect their feedback. The idea is simple. Break the software down into features that represent observable value to the business. For each feature, create one or more automated acceptance tests that validate the feature. Consolidate all features into a single, integrated product and continuously execute the automated acceptance tests. At any given moment, the project team should know the number of features that are passing all acceptance tests. This number represents the RTF metric. </td> </tr> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7270&showId=102" target="new">Guerilla Unit Testing Part 1: TestNG with Code Coverage</a> by Howard Lewis Ship </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=31" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/31_Lewis_Ship_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> Part one (of two) coverts the TestNG unit testing framework, and shows how it integrates with tools such as Emma or Cobertura (for code coverage) and Selenium (for integration testing). </td> </tr> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7254&showId=102" target="new">Test Infecting the Legacy Organization</a> by Nathaniel Schutta </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=1314" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/1314_Schutta_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> When starting a new project, most developers make sure that testing is a priority. However, only the lucky few live in the idyllic world of greenfield development; the vast majority of us must contend with code written when "test" was a four letter word and testing was the sole responsibility of that "other" organization. We'll examine some techniques for introducing testing - not just to your code but to the rest of your development organization. </td> </tr> </table> </div> </div> Wed, 16 May 2007 15:00:00 CDT Howard Lewis Ship - Free and Excellent Code Coverage for Eclipse http://tapestryjava.blogspot.com/2007/05/free-and-excellent-code-coverage-for.html <img class="inline" src="http://www.eclemma.org/images/smallscreen.gif"/> The <a href="http://www.eclemma.org/">EMMA</a> plugin for Eclipse is my latest addition to the "can't live without it" category. It allows you to run applications and test suites from within Eclipse and gather code coverage ... better yet, that code coverage data is shown visibly in your code, much as it is in an HTML Cobertura report. The plugin is slick, fast, easy and non-intrusive. The one thing you do need to do is <a href="http://www.eclemma.org/faq.html#usage02">split your output directories</a>, so that production code goes into bin, and test code goes into test-bin; this allows you to turn off coverage information for your test classes, and just gather Of course, IDEA also has code coverage, based on EMMA, built right in. Wed, 16 May 2007 13:00:00 CDT Craig Walls - Reducing XML with Spring 2.1 and annotations http://jroller.com/page/habuma?entry=reducing_xml_with_spring_2 If you're a regular reader of this blog, then you know that I've been spending some time exploring alternatives to Spring's XML configuration. Although I have no specific issues with using XML to configure Spring, I do know that some folks think that XML is a bad thing--therefore to ease their mind, I've taken it upon myself to report about the configuration options available to Spring developers. In case you missed the <a href="http://www.interface21.com/news-home/2007/springframeworkannotations">memo</a>, Spring 2.1-m1 has been released. Among other things, Spring 2.1-m1 adds some configuration-by-annotation options as an alternative Spring's verbose (and allegedly evil) XML configuration. To demonstrate these new annotations, I'll revisit the knight example from chapter 1 of <a href="http://astore.amazon.com/habumacom-20/detail/1933988134">Spring in Action, Second Edition</a> (coming to a bookshelf near you in July). If you'd like to follow along at home, you can download the code from <a href="http://www.habuma.com/spring/knight-spring-2.1.zip">here</a>. (Note: The example code is a Maven-ized project. You don't need Maven to follow along, but if you want the convenience of using my predefined build, you'll need to have Maven 2 installed. When you're ready to compile/run it, just type "mvn install" at the command line.) Before we get started, let's take a quick look at the current state of the knight example's configuration XML: <pre class="code"> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"> <bean id="quest" class="com.springinaction.chapter01.knight.HolyGrailQuest"/> <bean id="knight" class="com.springinaction.chapter01.knight.KnightOfTheRoundTable"> <constructor-arg value="Bedivere" /> <property name="quest" ref="quest" /> </bean> <bean id="minstrel" class="com.springinaction.chapter01.knight.Minstrel"/> <aop:config> <aop:aspect ref="minstrel"> <aop:pointcut id="questPointcut" expression="execution(* *.embarkOnQuest(..)) and target(bean)" /> <aop:before method="singBefore" pointcut-ref="questPointcut" arg-names="bean" /> <aop:after-returning method="singAfter" pointcut-ref="questPointcut" arg-names="bean" /> </aop:aspect> </aop:config> </beans> </pre> There are only three beans and an aspect definition...not a grossly verbose bit of XML. Nonetheless, as this article concerns configuring Spring without XML, I'll need to gut this configuration file. Here's what I'll work with after removing the unneeded bean and aspect elements: <pre class="code"> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"> </beans> </pre> Wow! That's a lot cleaner. But it's also useless. To make Spring 2.1's annotations work, I'll need to add a tiny bit of XML back to the XML. Specifically, I'll need to put in a <context:component-scan> element: <pre class="code"> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.1.xsd"> <context:component-scan base-package="com.springinaction.chapter01.knight" /> </beans> </pre> (Notice that I also had to add the XML Schema preamble to make the "context" namespace available.) <context:component-scan> is a new configuration element in the "context" namespace (which, BTW, is also new in Spring 2.1). This modest little element tells Spring to scan the "com.springinaction.chapter01.knight" package (as specified by the base-package attribute) and any subpackage looking for classes that might be annotated with @Component (new in Spring 2.1), @Repository (new in Spring 2.0), or @Aspect (provided by @AspectJ). If it finds any such class, it automatically will register the class as a bean in the Spring application context. So, although <context:component-scan> takes up so very little space in the XML configuration, it could be responsible for configuring dozens, hundreds, or even thousands of beans in Spring. So where do these annotated classes come from? Well, we have to create them...let's do that now. <h4>Let's add some annotations</h4> Alrighty, then...I had to add a bit of XML, but fortunately, that's almost all of the XML we need. (I'll put in a bit more later for the aspect-oriented stuff.) Now I need to slap a few annotations into the knight example's Java class files. First up is the KnightOfTheRoundTable class: <pre class="code"> package com.springinaction.chapter01.knight; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component("knight") public class KnightOfTheRoundTable implements Knight { public void embarkOnQuest() { quest.embark(); } private String name = "Bedivere"; public void setName(String name) { this.name = name; } public String getName() { return name; } private Quest quest; @Autowired public void setQuest(Quest quest) { this.quest = quest; } } </pre> The first of the new annotations I used is @Component. @Component tells Spring that this class should be automatically registered in the Spring context. By default, the class name is used as the bean's ID, but here I've explicitly specified that the bean should have an ID of "knight". Next, notice that the setQuest() method is annotated with @Autowired. This tells Spring that this setter shold automatically be wired with a bean reference. The autowiring is "byType", so there will need to be a Quest bean in the Spring context. There's not one there now, but I'll add one soon. However, before we look at the Quest bean, you may be interested in noting that the @Autowired annotation doesn't have to be used with setter methods. In fact, you can use it with any method you want. For example, the following use of @Autowired is perfectly valid: <pre class="code"> @Autowired public void assignAQuest(Quest quest) { this.quest = quest; } </pre> Although it does the work of a setter, assignAQuest() isn't technically a setter method in the JavaBeans sense. Nonetheless, @Autowired has no problem injecting a quest into it through its argument. Moreover (and perhaps even more interesting), @Autowired doesn't even need a method at all to do its job. You can just as easily use it on a private instance variable: <pre class="code"> @Autowired private Quest quest; </pre> Goodbye unnecessary setter methods! (Well, only if you're using these annotations. If you're configuring with Spring XML, you'll still need them.) Now let's add the Quest bean to the Spring context. Normally I'd do this with a <bean> element in XML. But since I'm using <context:component-scan> I just need to annotate the HolyGrailQuest class with @Component: <pre class="code"> package com.springinaction.chapter01.knight; import org.springframework.stereotype.Component; @Component public class HolyGrailQuest implements Quest { public void embark() { System.out.println("Embarking on the quest for the Holy Grail!"); } } </pre> Voila! The "knight" and "quest" beans are now wired in Spring...using annotations instead of XML. We're about ready to add AOP to the mix. But first, let me address any concerns that you may have with auto-wiring. <h4>Explicit wiring with annotations</h4> If you're like me, auto-wiring makes you a bit nervous. It's fine for small examples, but as an application gets larger, auto-wiring can be quite a confusing mess, leaving you wondering how things are wired together. If explicit wiring is more your style, then Spring has you covered with the @Resource annotation. @Resource is a <a href="http://jcp.org/en/jsr/detail?id=250">JSR-250</a> annotation that lets you explicitly pick out which bean to wire into a property. For example, to hand-pick a bean named "grailQuest" to wire into the KnightOfTheRoundTable, you can annotate the setter method like this: <pre class="code"> @Resource(name="grailQuest") public void setQuest(Quest quest) { this.quest = quest; } </pre> Now let's turn our attention to AOP with annotations by wiring in the Minstrel (musically inclined logging system of medieval times) aspect. <h4>Spring, AOP, and annotations</h4> To setup the Minstrel aspect, I'll use <a href="http://www.eclipse.org/aspectj/">@AspectJ</a> annotations. Spring's support for @AspectJ annotations isn't new to Spring 2.1. But Spring 2.1 does make it a bit easier, as you'll soon see. To add AOP support, the first thing I'll do is add one more line of XML to the Spring XML configuration: <pre class="code"> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.1.xsd"> <context:component-scan base-package="com.springinaction.chapter01.knight" /> <aop:aspectj-autoproxy/> </beans> </pre> <aop:aspectj-autoproxy> was introduced in Spring 2.0 to automatically proxy @AspectJ-annotated classes. But in Spring 2.0, you'd still need to explicitly declare the @Aspectj-annotated classes as beans in XML. Spring 2.1's <context:component-scan> element simplifies things a bit by automatically registering any class that is annotated with @Aspect. Once @Aspect-annotated classes are registered in the Spring context by <context:component-scan>, <aop:aspectj-autoproxy> takes over to create the proxies. In the XML-oriented configuration, the Minstrel class was a simple POJO with no special interfaces or annotations: <pre class="code"> package com.springinaction.chapter01.knight; import org.apache.log4j.Logger; public class Minstrel { private static final Logger SONG = Logger.getLogger(Minstrel.class); public void singBefore(Knight knight) { SONG.info("Fa la la; Sir " + knight.getName() + " is so brave!"); } public void singAfter(Knight knight) { SONG.info("Tee-hee-he; Sir " + knight.getName() + " did embark on a quest!"); } } </pre> In the original version, I used elements in Spring's "aop" namespace to turn Minstrel into an aspect. But for this article, I'm trying to cut down on the XML and exploit the annotations. Therefore, I'm going to tweak Minstrel to use @AspectJ-style annotations: <pre class="code"> package com.springinaction.chapter01.knight; import org.apache.log4j.Logger; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; @Aspect public class Minstrel { private static final Logger SONG = Logger.getLogger(Minstrel.class); @Pointcut("execution(* com.springinaction.chapter01.knight.Knight.embarkOnQuest(..))") public void questEmbarkment() {} @Before("questEmbarkment() && this(knight)") public void singBefore(Knight knight) { SONG.info("Fa la la; Sir " + knight.getName() + " is so brave!"); } @After("questEmbarkment() && this(knight)") public void singAfter(Knight knight) { SONG.info("Tee-hee-he; Sir " + knight.getName() + " did embark on a quest!"); } } </pre> This new Minstrel class is a typical @AspectJ aspect. The annotations applied are: <ul> <li>@Aspect indicates that this class is an aspect.</li> <li>@Pointcut defines a pointcut. Notice that there's an empty method that serves as a place to attach the aspect and also provides the name for the pointcut. (Weird, yes...take it up with the AspectJ team.)</li> <li>The @Before and @After annotations indicate the methods to be invoked before and after (respectively) when the pointcut is encountered. </ul> And that's it! I've extracted all of the configuration details out of Spring XML and reworked it as annotations. As a reminder, here's the final version of the XML: <pre class="code"> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.1.xsd"> <context:component-scan base-package="com.springinaction.chapter01.knight" /> <aop:aspectj-autoproxy/> </beans> </pre> After yanking all of the application-specific bean definitions, I ended up putting back a couple of infrastructural elements. But in the end, there is not nearly as much XML. And, furthermore, as long as all of the application's beans are packaged in com.springinaction.chapter01.knight (or a subpackage), then I probably won't have to add much more XML to the Spring XML configuration. <h4>Conclusion</h4> Spring 2.1-m1 offers another choice for Spring configuration in the form of annotations. Although I still favor Spring XML, I'm happy to see that there are a wealth of configuration options for Spring developers to choose from. The downside of using annotations in this way, as opposed to XML or even <a href="http://www.springframework.org/javaconfig">Spring JavaConfig</a>, is that there's not a central place to look to gain an understanding of how application objects are wired together. With Spring's XML configuration, you would only need to view a handful of XML files to get the big picture of a Spring application's structure. Spring IDE and Spring BeanDoc take advantage of this to generate a visual guide to a Spring application's beans. With annotations, however, it's not so cut and dried. The application wiring is spread out across the application's many classes. In the end, Spring 2.1's annotations are one choice among many for configuring Spring. A wise developer will choose the correct configuration option for their application, whether it be Spring 2.1 annotations, XML, JavaConfig, or a scripted configuration like Groovy or JRuby. Or you may mix-n-match configuration styles in the same application. Finally, for those of you who may be wondering, <a href="http://astore.amazon.com/habumacom-20/detail/1933988134">Spring in Action, 2E</a> is on its way to being complete. The writing phase is complete and it has been in the production team's hands for a few weeks. We've hit a few snags, but those are clearing up and we're anticipating a July release. Unfortunately, the timing of Spring 2.1 didn't allow me to cover any 2.1 stuff in the book (I'm compiling my examples against Spring 2.0.5). But watch this blog for more interesting Spring 2.1 stuff as I have the opportunity to share it. Wed, 16 May 2007 11:00:00 CDT Venkat Subramaniam - The Agile Experience this Summer in San Jose http://www.agiledeveloper.com/blog/PermaLink.aspx?guid=baf62c91-6ff1-4b3b-bfce-c8fe01709710 I am excited to see that <a href="http://www.theagileexperience.com" target="_blank">The Agile Experience</a> was announced today! I look forward to meet and mingle with the speakers and attendees who share a common interest in the area that I am passionate about, July 12-14 in San Jose. All the exciting topics are centered around various topics related to Agile Software Development. You will have four simultaneous tracks to choose from. If you're interested in Agile Development (if you are reading this, I am sure you are!), you don't want to miss this event. You've got to check out the impressive <a href="http://www.theagileexperience.com/show_agenda.jsp?showId=100&byRoom=false" target="_blank">session schedule</a>. P.S.: Wait, I just noticed that the first 100 registrants will receive autographed copy of <a href="http://pragmaticprogrammer.com/titles/pad/index.html" target="_blank">Practices of an Agile Developer!</a> I will not only sign it, but personally imprint your first name on it, how about that!<hints id="hah_hints"> </hints> <img width="0" height="0" src="http://www.agiledeveloper.com/blog/aggbug.ashx?id=baf62c91-6ff1-4b3b-bfce-c8fe01709710"> Wed, 16 May 2007 08:00:00 CDT Desert Southwest Software Symposium - Jul. 27 - 29, 2007 http://www.nofluffjuststuff.com/show_view.jsp?showId=87 <div style="font-family: Arial, Verdana, Helvetica, sans-serif; font-size: 10pt;"> No Fluff Just Stuff is pleased to announce the <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_view.jsp?showId=87" target="new">Desert Southwest Software Symposium</a>, Jul. 27 - 29, 2007. <div style="background-color: #0860A9; color: #EFCE52; font-weight: bold; padding: 5px 5px 5px 5px;"> Catch these Featured Sessions </div> <div style="border: 1px solid #999999; padding: 0 5px 0 5px;"> <table cellpadding="0" cellspacing="0" style="font-size: 10pt;"> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7203&showId=87" target="new">Spring 2.0: New and Noteworthy</a> by Ben Hale </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=1564" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/1564_Hale_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> Spring 2.0 has marked a major advance in the Spring Framework. While still maintaining backwards compatibility, this release adds quite a few new features. What are those features and how do they add value? Come by and see. </td> </tr> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7192&showId=87" target="new">Rails for Java Programmers</a> by Bruce Tate </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=12" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/12_Tate_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> The productivity of Ruby on Rails cannot be denied, but the explosion of Ruby on Rails left many developers, with hard commitments to Java deployment platforms, out in the cold. The continued evolution of JRuby can change that. JRuby is a Ruby implementation on the Java virtual machine. And yes, it runs Rails. In this session, you will learn Rails as it was meant to be learned, within the context of building a live site, from scratch. </td> </tr> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7196&showId=87" target="new">RAD JSF with Seam, Facelets, and Ajax4jsf, Part One</a> by David Geary </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=4" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/4_Geary_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> In this session, see how you can get Ruby On Rails-like productivity on the Java side of the house with this compelling combination of technologies. </td> </tr> </table> </div> </div> Tue, 15 May 2007 09:00:00 CDT Mark Fisher - Annotation-Driven Dependency Injection in Spring 2.1 http://blog.interface21.com/main/2007/05/14/annotation-driven-dependency-injection-in-spring-21/ <a href="http://blog.interface21.com/main/author/markf/" title="Posts by Mark Fisher"><img src='http://blog.interface21.com/main/wp-content/images/authors/markf.jpg' alt='Mark Fisher' title='Mark Fisher' align="right" hspace="10px" /></a> Spring 2.0 introduced annotation support and annotation-aware configuration options that can be leveraged by Spring users who are developing with Java 5 (or later versions): <table> <tr> <th><a href="http://static.springframework.org/spring/docs/2.0.x/api/org/springframework/transaction/annotation/Transactional.html">@Transactional</a></th> <td>for demarcating and configuring transaction definitions</td> </tr> <tr> <th><a href="http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/org/aspectj/lang/annotation/Aspect.html">@Aspect</a> (AspectJ)</th> <td>for defining aspects along with @Pointcut definitions and advice (@Before, @After, @Around)</td> </tr> <tr> <th><a href="http://static.springframework.org/spring/docs/2.0.x/api/org/springframework/stereotype/Repository.html">@Repository</a></th> <td>for indicating a class that is operating as a repository (a.k.a. Data Access Object or DAO)</td> </tr> <tr> <th><a href="http://static.springframework.org/spring/docs/2.0.x/api/org/springframework/beans/factory/annotation/Required.html">@Required</a></th> <td>for enforcing annotated bean properties are provided a value</td> </tr> </table> With Spring 2.1, this theme of annotation-driven configuration has been significantly extended and will continue to evolve as we progress toward the RC1 release. In fact, it is now possible to drive Spring's dependency injection via annotations. Furthermore, Spring can discover beans that need to be configured within an application context. This blog entry will serve as a tutorial-style introduction to the basic features in 10 easy-to-follow steps. I will follow up later in the week with information on some more advanced features and customization options. If you are interested in alternative configuration options, you should also check out the <a href="http://www.springframework.org/javaconfig">Spring Java Configuration</a> project and <a href="http://blog.interface21.com/main/2006/11/28/a-java-configuration-option-for-spring/">this blog</a>. This tutorial requires at least Java 5, and Java 6 is recommended (otherwise there is a single requirement at the end of step 1). <h2>Step 1:</h2> Grab <a href="http://downloads.sourceforge.net/springframework/spring-framework-2.1-m1-with-dependencies.zip">spring-framework-2.1-m1-with-dependencies.zip</a>. After extracting the archive, you will find the spring.jar and spring-mock.jar in the 'dist' directory. Add them to your CLASSPATH as well as the following (paths shown are relative to the 'lib' directory of the extracted 2.1-m1 archive): <ul> <li>asm/asm-2.2.3.jar</li> <li>asm/asm-commons-2.2.3.jar</li> <li>aspectj/aspectjweaver.jar</li> <li>hsqldb/hsqldb.jar</li> <li>jakarta-commons/commons-logging.jar</li> <li>log4j/log4j-1.2.14.jar</li> </ul> (NOTE: If you are not running on Java 6, you will also need to add j2ee/common-annotations.jar) <h2>Step 2:</h2> Provide the interfaces and classes for the example. I have tried to keep it as simple as possible yet capable of demonstrating the main functionality. I am including all of the code and configuration in a single "blog" package. I would encourage following that same guideline so that the examples work as-is; otherwise, be sure to make the necessary modifications. First, the GreetingService interface: <div class="codesnip-container" > <div class="codesnip">public interface GreetingService {     <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> greet(<a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> name); }</div> </div> Then, a simple implementation: <div class="codesnip-container" > <div class="codesnip">public class GreetingServiceImpl implements GreetingService {     private MessageRepository messageRepository;     public void setMessageRepository(MessageRepository messageRepository) {         this.messageRepository = messageRepository;     }     public <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> greet(<a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> name) {         <a href="http://www.google.com/search?q=allinurl%3ALocale+java.sun.com&bntl=1">Locale</a> locale = <a href="http://www.google.com/search?q=allinurl%3ALocale+java.sun.com&bntl=1">Locale</a>.getDefault();         <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> message = messageRepository.getMessage(locale.getDisplayLanguage());         return message + " " + name;     } }</div> </div> Since the service depends upon a MessageRepository, define that interface next: <div class="codesnip-container" > <div class="codesnip">public interface MessageRepository {     <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> getMessage(<a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> language); }</div> </div> And for now, a stub implementation: <div class="codesnip-container" > <div class="codesnip">public class StubMessageRepository implements MessageRepository {     Map<String,String> messages = new HashMap<String,String>();     public void initialize() {         messages.put("English", "Welcome");         messages.put("Deutsch", "Willkommen");     }     public <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> getMessage(<a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> language) {         return messages.get(language);     } }</div> </div> <h2>Step 3:</h2> Define the beans for a Spring application context. Notice, that I am including a new 'context' namespace (NOTE: the 'aop' namespace is also included here and will be used in the final step): <div class="codesnip-container" > <div class="codesnip"><?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns:aop="http://www.springframework.org/schema/aop"        xmlns:context="http://www.springframework.org/schema/context"        xsi:schemaLocation="http://www.springframework.org/schema/beans            http://www.springframework.org/schema/beans/spring-beans-2.0.xsd            http://www.springframework.org/schema/aop            http://www.springframework.org/schema/aop/spring-aop-2.0.xsd            http://www.springframework.org/schema/context            http://www.springframework.org/schema/context/spring-context-2.1.xsd">           <bean class="blog.GreetingServiceImpl"/>     <bean class="blog.StubMessageRepository"/> </beans></div> </div> Obviously this configuration looks a little sparse. As you can probably guess, the 'context' namespace will soon play a role. <h2>Step 4:</h2> Provide a simple test case leveraging Spring's base support class: <div class="codesnip-container" > <div class="codesnip">public class GreetingServiceImplTests extends AbstractDependencyInjectionSpringContextTests {     private GreetingService greetingService;     public void setGreetingService(GreetingService greetingService) {         this.greetingService = greetingService;     }     @Override     protected <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a>[] getConfigLocations() {         return new <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a>[] { "/blog/applicationContext.xml" };     }     public void testEnglishWelcome() {         <a href="http://www.google.com/search?q=allinurl%3ALocale+java.sun.com&bntl=1">Locale</a>.setDefault(<a href="http://www.google.com/search?q=allinurl%3ALocale+java.sun.com&bntl=1">Locale</a>.ENGLISH);         <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> name = "Spring Community";         <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> greeting = greetingService.greet(name);         assertEquals("Welcome " + name, greeting);     }     public void testGermanWelcome() {         <a href="http://www.google.com/search?q=allinurl%3ALocale+java.sun.com&bntl=1">Locale</a>.setDefault(<a href="http://www.google.com/search?q=allinurl%3ALocale+java.sun.com&bntl=1">Locale</a>.GERMAN);         <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> name = "Spring Community";         <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> greeting = greetingService.greet(name);         assertEquals("Willkommen " + name, greeting);     } }</div> </div> Try running the tests and notice that they fail with a NullPointerException. This is to be expected since the GreetingServiceImpl has not been provided a MessageRepository. In the next two steps, you will add annotations to drive the dependency injection and initialization respectively. <h2>Step 5:</h2> Provide an @Autowired annotation on the GreetingServiceImpl's setter method, such as: <div class="codesnip-container" > <div class="codesnip">@Autowired public void setMessageRepository(MessageRepository messageRepository) {     this.messageRepository = messageRepository; }</div> </div> Then, add the 'annotation-config' element (from the new 'context' namespace) to your configuration: <div class="codesnip-container" > <div class="codesnip"><beans … >         <context:annotation-config/>     <bean class="blog.GreetingServiceImpl"/>     <bean class="blog.StubMessageRepository"/> </beans></div> </div> Rerun the tests. They will still fail, but if you look closely it's a new problem. The assertions fail, because the messages being returned are null. That means that the 'messageRepository' property has been set on the greeting service! Now, the StubMessageRepository simply needs to be initialized. <h2>Step 6:</h2> Spring provides a couple options for initialization callbacks: Spring's InitializingBean interface or an 'init-method' declaration within XML. As of Spring 2.1, JSR-250 annotations are supported - providing yet another option: @PostConstruct (and the @PreDestroy annotation can be used for destruction callbacks as you will see shortly). In the StubMessageRepository, add the annotation to the initialize method: <div class="codesnip-container" > <div class="codesnip">@PostConstruct public void initialize() {     messages.put("English", "Welcome");     messages.put("Deutsch", "Willkommen"); }</div> </div> Rerun the tests. This time they should pass! <h2>Step 7:</h2> The @Autowired annotation can also be used for constructor-based injection. If you'd like to experiment with that option, remove the setter method from the GreetingServiceImpl and add this constructor instead (then rerun the tests): <div class="codesnip-container" > <div class="codesnip">@Autowired public GreetingServiceImpl(MessageRepository messageRepository) {     this.messageRepository = messageRepository; }</div> </div> If preferred, you can even use field-injection. Remove the constructor, add the annotation directly to the field, and rerun the tests. The code should look like this: <div class="codesnip-container" > <div class="codesnip">@Autowired private MessageRepository messageRepository;</div> </div> <h2>Step 8:</h2> Add a JDBC-based repository implementation of the MessageRepository: <div class="codesnip-container" > <div class="codesnip">public class JdbcMessageRepository implements MessageRepository {     private SimpleJdbcTemplate jdbcTemplate;     @PostConstruct     public void setUpDatabase() {         jdbcTemplate.update("create table messages (language varchar(20), message varchar(100))");         jdbcTemplate.update("insert into messages (language, message) values ('English', 'Welcome')");         jdbcTemplate.update("insert into messages (language, message) values ('Deutsch', 'Willkommen')");     }     @PreDestroy     public void tearDownDatabase() {         jdbcTemplate.update("drop table messages");     }     public <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> getMessage(<a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a> language) {         return jdbcTemplate.queryForObject("select message from messages where language = ?", <a href="http://www.google.com/search?q=allinurl%3AString+java.sun.com&bntl=1">String</a>.class, language);     } }</div> </div> Notice that in addition to @PostConstruct for initialization, this is using @PreDestroy to mark a method to be called on destruction. One thing is unclear from this implementation: how will the SimpleJdbcTemplate be provided? One option would be to provide a bean definition for the template. Another option would be to somehow provide a DataSource implementation to the template's constructor. Add the following (annotated) method: <div class="codesnip-container" > <div class="codesnip">@Autowired public void createTemplate(DataSource dataSource) {     this.jdbcTemplate = new SimpleJdbcTemplate(dataSource); }</div> </div> This demonstrates dependency injection working with an arbitrary method (not a traditional 'setter'). This will be tested in the course of the next step. <h2>Step 9:</h2> In Spring 2.1, "candidate" beans can even be discovered rather than provided explicitly in the XML as above. Certain annotations are recognized by default. This includes the @Repository annotation as well as a new @Component annotation. Add those two annotations to JdbcMessageRepository and GreetingServiceImpl respectively: <div class="codesnip-container" > <div class="codesnip">@<a href="http://www.google.com/search?q=allinurl%3ARepository+java.sun.com&bntl=1">Repository</a> public class JdbcMessageRepository implements MessageRepository { … }</div> </div> <div class="codesnip-container" > <div class="codesnip">@<a href="http://www.google.com/search?q=allinurl%3AComponent+java.sun.com&bntl=1">Component</a> public class GreetingServiceImpl implements GreetingService { … }</div> </div> Then modify the XML file by removing the existing explicit bean definitions and simply adding a component-scan tag: <div class="codesnip-container" > <div class="codesnip"><beans … >     <context:component-scan base-package="blog"/> </beans></div> </div> Then, add just the DataSource bean definition and the new tag for configuring property placeholders: <div class="codesnip-container" > <div class="codesnip"><beans … >     <context:component-scan base-package="blog"/>     <context:property-placeholder location="classpath:blog/jdbc.properties"/>     <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">         <property name="driverClassName" value="${jdbc.driver}"/>         <property name="url" value="${jdbc.url}"/>         <property name="username" value="${jdbc.username}"/>         <property name="password" value="${jdbc.password}"/>     </bean> </beans></div> </div> … and the jdbc.properties file itself: <div class="codesnip-container" > <div class="codesnip">jdbc.driver=org.hsqldb.jdbcDriver jdbc.url=jdbc:hsqldb:mem:blog jdbc.username=sa jdbc.password=</div> </div> Rerun the tests, and you should see the green bar even though only the data source has been defined in XML. <h2>Step 10:</h2> Finally, add an aspect (the @Aspect annotations are also automatically detected by default): <div class="codesnip-container" > <div class="codesnip">@Aspect public class ServiceInvocationLogger {     private int invocationCount;     @Pointcut("execution(* blog.*Service+.*(..))")     public void serviceInvocation() {}     @Before("serviceInvocation()")     public void log() {         invocationCount++;         <a href="http://www.google.com/search?q=allinurl%3ASystem+java.sun.com&bntl=1">System</a>.out.println("service invocation #" + invocationCount);     } }</div> </div> And to activate automatic proxy generation, simply add the following tag to the xml: <div class="codesnip-container" > <div class="codesnip"><aop:aspectj-autoproxy/></div> </div> Rerun the tests, and you should see the log messages! NOTE: the scanning and configuration process can be initiated without any XML and can be customized (e.g. detect your own annotations and/or types). I will discuss those features and more in the next post. In the mean time, I hope this post will serve its purpose well - providing hands-on experience with these new Spring 2.1 features. As always, we are looking forward to feedback from the community, so please feel free to leave comments! Mon, 14 May 2007 16:00:00 CDT Research Triangle Software Symposium - Jul. 20 - 22, 2007 http://www.nofluffjuststuff.com/show_view.jsp?showId=89 <div style="font-family: Arial, Verdana, Helvetica, sans-serif; font-size: 10pt;"> No Fluff Just Stuff is pleased to announce the <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_view.jsp?showId=89" target="new">Research Triangle Software Symposium</a>, Jul. 20 - 22, 2007. <div style="background-color: #0860A9; color: #EFCE52; font-weight: bold; padding: 5px 5px 5px 5px;"> Catch these Featured Sessions </div> <div style="border: 1px solid #999999; padding: 0 5px 0 5px;"> <table cellpadding="0" cellspacing="0" style="font-size: 10pt;"> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7129&showId=89" target="new">Build Teams, Not Products</a> by Jared Richardson </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=339" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/339_Richardson_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> A great team builds great software, but how do you build a great team? </td> </tr> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7047&showId=89" target="new">Effective Concurrent Java</a> by Brian Goetz </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=24" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/24_Goetz_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support of multithreading. However, the Java concurrency primitives are just that: primitive. From them you can build many concurrency utilities, but doing so takes great care as concurrent programming poses many traps for the unwary. </td> </tr> <tr> <td> <div style="margin: 5px 0 4px 0;"> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/show_session_view.jsp?presentationId=7151&showId=89" target="new">Everything Old Is New Again</a> by Glenn Vanderburg </div> <a style="color: #336699; text-decoration: none;" href="http://www.nofluffjuststuff.com/speaker_view.jsp?speakerId=17" target="new"> <img src="http://www.nofluffjuststuff.com//s/bio/17_Vanderburg_medium.jpg" width="100" border="0" align="left" style="margin: 5 5 5 5;"/> </a> The early years of computers -- the '50s and '60s -- were characterized by furious exploration of a huge variety of different ideas. Since then many of the hot topics of those days have moved to the fringe, largely ignored by the mainstream of software development. But some of them are being rediscovered, and a lot of what we think of as "new developments" are really just some old ideas returning to center stage. </td> </tr> </table> </div> </div> Mon, 14 May 2007 15:00:00 CDT