theJavaJar.com

I will be presenting, “Looking at the Google Web Toolkit”, at the Sarasota JUG on Wednesday, March 19th, 2008. It will basically be an intro to GWT, as I am not an expert. We will be looking at what the Google Web Toolkit offers to Java developers and how we might be able to leverage this tool in our Java Web development environments. Here is the presentation abstract:

In this session we will walk through the features of the Google Web Toolkit from a Java developer’s perspective. From installation to application development and deployment, we will see how the Google Web Toolkit can help Java developers get work done. Google Web Toolkit takes our Java code and produces HTML and JavaScript to create a fully functioning Web 2.0/AJAX based Web application. We will discuss problems encountered when developing AJAX Web applications for cross browser support and how the Google Web Toolkit has solved our problems. Of course, we will also look at some code and we will see what it takes to create our own Java Web application with the Google Web Toolkit.

The presentation materials will be online after the presentation and more information can be found at the Sarasota JUG’s site, www.sunjug.org.

I currently have taken down SWCM with the move to my new ISP hosting environment, but I will be re-factoring it for a client in the near future and should have a demo up sometime in April or May.

I attended the 2008 2GX software symposium in Reston, VA and I have definitely decided to use Groovy/Grails to develop Tangerine. I have been tossing and turning over the decision that I made a few months back to use Groovy/Grails, but now I really have some confidence in my decision. I have to re-factor my current code base a bit, but that should only take a month. I had originally intended to have Tangerine’s Product Manager out by the end of February but it looks like it will be in Beta by the end of March or mid April, with Sales Manager and Account Manager soon to follow.

I do not know where to start. 2GX was an incredible event that really sparked my interest in Groovy, Grails, Open Source development, and my passion for technology. First, Jay Zimmerman and the No Fluff Just Stuff staff and presenters really did a great job putting on an impressive event. The organization and setup of 2GX left you only worrying about one thing, attending the conference and getting as much out of it as you could. I basically didn’t have to leave the hotel and I barely slept at night(less than 4 hours each night). If there would have been presentations or BOF until 12am, I would have probably been there.

What I have taken from the conference or software symposium is that Groovy/Grails is not just a quick fix for Java Web development. With the power of ExandoMetaClass (create synthetic methods/properties), Duck Typing(walks like a duck, quacks like a duck: it is a duck), and static typing support inherited from Java, Groovy is the next generation of Java. In fact, the “next generation of Java” phrase came up quite frequently at 2GX. I think I have decided that would be the way to introduce and approach management and stakeholders with the power of Groovy.

Grails is not just another Web framework. It actually relies on Spring’s Webflow to handle the MVC pattern and Grails really is a development platform that “sits on the shoulders of giants” -Scott Davis, like Spring, Hibernate, and Quartz. The power of Grails is coding by convention but it also has the integration with proven technologies like Spring and Hibernate that force you to answer, why re-invent the wheel? Throw in Grails’ plug-in framework and you have modular and component based code that makes maintenance and releases have less impact on your enterprise software stack. The power of Java is platform independence and flexibility which has always driven my interest in Java. Now we have Groovy and Grails which can take advantage of everything we know and love in Java, like the hundreds of libraries already handling everything from logging to persistence, and include a very dynamic and flexible approach to what we have done in the past with fewer lines of code.

Day three of 2GX was a pretty exciting day. I checked out a presentation aptly titled “Groovier Spring” with Scott Leberknight. Basically, what I took from the presentation was that Groovy is not just another programming language to be compiled and executed in the normal sense. It can used for configuration or even dynamic creation of classes (not objects) and rules or maybe even work-flow. For example, if you wanted to, you can embed Groovy into your Spring configuration files or bean xml files to include logic during bean creation. So, that is cool but why not load some Groovy scripts from your database, use the bean builder and configure some beans when you need them or if you need them? Why not inject what you need when or where you need it? Yeah, I will expand on that at a later date.

I also stopped in at a presentation by Venkat Subramaniam titled “BDD in Java and Groovy”. I am really a big fan of Behavioral Driven Development and even more interested in learning more about Agile Development as a whole. Basically, BDD lets you drop the technical talk and test your software from a more native(like plain Englsh) approach that can be shared and interpreted all the way from conception to implementation. For example if you were writing a inventory system, one test would like this:

Given a customer buys a widget
and there are fifteen widgets left on hand
when a customer returns the widget for a refund
then I should have sixteen widgets on hand

I would like to spend some time in an Agile development environment to see how it all works.

After lunch, Jason Rudolph, author of Getting Started with Grails presented “Refactotum”. Jason was digging into the Groovy and Grails source code and looking at how to improve what has been written. He also encouraged the audience to get involved with Open Source development and his presentation proved how effective the community can be with somewhat little effort. Jason discussed Cobertura and the importance of testing, real testing, effective testing. I took away a great quote that I will definitely use in the future, “comments lie, tests don’t lie”. He is right, comments are sometimes needed but most developers can just interpret the code and comments are rarely updated after a fix. JavaDocs are a key part of documentation and I would rather have well written, meaningful tests rather code drenched in source code comments.

So, it has been another incredible day at 2GX. I sat in on presentations covering Spring and Groovy, Swing Mashups with Groovy and Grails, GORM(Grails Object Relational Mapping), and Groovy with the Google Maps API. Graeme Rocher, Andres Almiray and Scott Davis put together some great presentations and I have a few things I need to check out tomorrow. Again, I am overwhelmingly impressed with what the No Fluff Just Stuff crew has put together for this event. Jay Zimmerman, who runs No Fluff Just Stuff, sat down with a few of us for lunch today and rattled off the number of events(35+) they have going on this year covering everything from Ajax to Spring to Groovy and Grails. Hopefully, we (James Williams, Vladimir Vivien, and myself) can help bring an event of this caliber to the Tampa Bay area in the future.

Again, if you want to be on the edge of what is going on, you need to get out to an event like 2GX. The presenters and attendees are setting the stage for the future of software development. With the style/format of No Fluff Just Stuff, you not only listen to presentations, but interact with the presenters and your peers. I sat and absorbed information while I was thinking of how I am going to implement what I am seeing. In some cases, I was working with my current code while the topic was touching on what I was working on in my IDE. In other instances, I was up until 2am last night working with peers on what I was trying to figure out, doing some demos, and sharing some thoughts and code samples.

As day one of 2GX comes to a close I can honestly say that Groovy with Grails and it’s underlying technologies (Spring, Hibernate, Quartz…) is more impressive than I initially realized. Well, I knew what Spring and Hibernate could do but to see what Grails adds to the equation is incredible. Hearing it from the source is key. I mean it. Attend an event or training!

I sat in on 2 great sessions today; “DSL in Groovy” presented by Venkat Subramaniam and “The Grails Plug-in System: Plug into Productivity” presented by Graeme Rocher. What Groovy can do, blew my mind. Venkat really opened my eyes to the power of Groovy. I also underestimated what Grails is doing under the covers. Basically, if you know/understand how Spring and Hibernate make development easier, well think of Grails as another layer of abstraction that provides that same power in a much simpler format. Now, combine that power with a modular approach to development with plug-ins and a truly dynamic/agile language in Groovy. All I can say is that Groovy/Grails is turning the corner and not looking back, so don’t lose sight of what is out there. Once I get my ISP hosting situated, I will be deploying my first public Groovy/Grails application.

As far as 2GX, it is a great experience so far. I am really impressed with the No Fluff Just Stuff staff and what they have put together. Alright, hopefully I will have some more time to post my thoughts on day two in the evening.

Is there a “right” or “wrong” way to develop Java Web applications?
Short answer, Yes.
Long answer, No, there are many ways to do things “right”.

Is your application built the “right” way?
Well, answering that question might hurt a lot of feelings. I am not an expert and would never claim to be, but a running/working application doesn’t mean things were done “right”, although your manager and stakeholders may disagree.

I would like to mention a few things that I think are important when working with Java and most other object oriented programming languages. I would also like to clear up some misconceptions and lay down some ground rules for developers.

1) Re-usability does not mean copy and paste.
2) Don’t take ownership of your code. Each project should be a learning experience on how to do it better next time. When you are done, move on to the next project.
3) The number of lines in your application is not a benchmark.
4) If learning new technologies is a burden, become a manager or business analyst.
5) Don’t be afraid to leverage something that has already been written.
6) You are going to make mistakes.
7) Re-factor your code at least once during development.

I will add to this list in the future. This may not be helpful to anyone, but each one of these points keeps me in check.

Complexity is overrated. We each have our own concept of complexity. Complexity can be measured scientifically but in reality what I think is complex/simple may be simple/complex to someone else. Here is how seeking simplicity can have its’ advantages; Simplicity, at some common level, is key to a broader acceptance in our society.

With that, I am taking a look at Web sites and applications. Google, for example, has given us a text box and some buttons that allow us to search the Internet. Is searching the Internet complex? Yes, I think it is, but we are not presented with the complexity at all. When I use Google, all I care about is whether or not I find what I am looking for in the search results rather than the algorithm used to compile the results.

When developing Web sites or applications there should be an emphasis on simplicity. Of course, we expect that the content or purpose of the application may be complex, but that should not be represented in the presentation to the end-user. Obviously, for different spaces and environments we have to take into consideration our end-users or audience to determine a base simplicity level. The key is to ensure that simplicity is sought during development and during system design. Complexity will grow when needed.

Grails 1.0 was released this week and it is already installed and running on my machine. I am really excited about what Groovy/Grails is bringing to Java Web development. I currently have a few sites hosted on Windows and running PHP and MySQL but I really need to find a Java hosting provider.

The Groovy/Grails wave has swelled up and I think it is going to hit the shore of many Java developers in the near future. In almost any instance you need a Java, CRUD, Web application up and running quickly, Grails will fit the bill. For developers in small to medium sized businesses who need to roll-out a phase 1 of an Web application, Grails is the answer. The key to Grails is that it gets you to put almost everything together logically from a domain object perspective. Then Grails gets you up and running with a few commands. The next thing you know, you are building a .war file and moving on to phase 2.