Lone Star Software Symposium - Day 3 Recap

Meanwhile, back at the Ranch...
So the conference has come to an end and several hours driving and a short night's sleep in my own bed and now I'm back at work. This was a great experience for me. I would definitely go back to a NFJS conference if I got the chance.
The final day was no let down. The four sessions I attended were great.
The recap:

Design Patterns in Java and Groovy

I know I've gone on and on about Groovy, but this class really got my attention. This was my first session with Venkat Subramanium. Venkat is the author of several books (one of which I already have) and a very charismatic speaker. What he did in this session was present several common design patterns in Java, discuss the complexity, and then write the same functionality in Groovy right there. This was an excellent session to see some Groovy in action and see just how simple and easy it makes very robust Java tasks.

Caring about your Code Quality

This was more of a speach presentation than a coding presentation. But with Venkat back at the helm that's not bad at all. This session covered why Code Quality is important and why caring about your own code quality is important. He shed light on a lot of common coding fallacies and practices. This is a very important subject that encompasses every facet of Software Engineering, not just the Java world. Great stuff.

Agile Test Driven Development With Groovy

This and my last session were both presented by Jeff Brown. This was an interesting class to me. It started differently than I expected with a background of unit testing and TDD. But once Jeff got into the coding section and really greased the testing wheels with some Groovy goodness it was really interesting. The simplicity of your code that Groovy provides really makes some remedial testing tasks almost too easy (compared to what it takes to do those tasks in Java).

Powerful Metaprogramming Techniques With Groovy

This session really got into the mud with the meta-programming capabilities provided in Groovy. His examples were pretty cool. He made several builders (xmlBuilder, outlineBuilder) and showed how simple it is to manipulate compiled classes on the fly to empower your code to really do what you want it to do, not just what your framework wants it to do. He explained a bit about the ExpandoMetaClass which is a very powerful tool in Groovy (and a tool that came from the Grails project). Again, good stuff.

Conclusion
This conference was very useful to me and my colleagues and I have decided that Groovy is going to be a tool we use in our framework. We'll start small using it as a helper for our unit testing, then we'll see where we can take it from there.


Until next time
Les

Lone Star Software Symposium - Day 2 Recap

Here I am at the end of Day 2 and I'm miserable. There are several reasons for that, but they don't have anything to do with the Conference itself. One reason is that I miss my wife and my son. Another, and probably the biggest, reason is that I'm stuffed beyone enjoyment on BBQ from Red Hot and Blue because I have mostly no self control when it comes to BBQ.
Here's the wrap up:

Filthy Rich Clients with the Google Web Toolkit, Part I

Overall this is a very interesting toolkit. It allows you to development heavy, ajaxian, rich, javascript based web apps by writing nothing but Java code. Google has written a compiler that takes the Java code and compiles it into multiplatform, crossbrowser Javascript. It's really slick and I could definitely see using it to throw together some personal projects. The session wasn't horrible.

Real World JSON

This was another course by Scott Davis and I really enjoyed it. JSON (Javascript Object Notation) is basically the best alternative to XML (the 'x' in AJAX). JSON let's you express objects and lists of objects as plain text (and what's more light weight than that?) and process it right in your web page without have the heavy, cumbersome syntax of XML to grind through. I could see using JSON in future web endeavers. Good presentation.

Grails - Agile Web 2.0 The Easy Way

This got me back on track with my new trend in self study. It was presented by Jeff Brown and he did a really good job at showing the quick and dirty of what Grails really is. This was really a repeat for me since I attended Davis's Grails session yesterday, but he added fresh light to areas for me so it wasn't a waste. Good presentation and a good primer for the next session.

Advanced Web Development With Grails

So this was the best session of the day. It was Jeff Brown's second session and it really dug deeper into the workings of Grails and building real world web apps with it. He showed us the power and EASE of creating custom tags in Grails (as opposed to the painstaking process it in the JSP world). He demonstrated some remote calling and object relationships (managed right in your bean object and persisted on the fly to the Database, yeah, that's right). I definitely think that the entire Groovy/Grails paradigm could change my programming landscape for good, if only I could get it accepted at my job.

As I said to begin, overall I'm enjoying and learning. I would recommend this conference to any, ANY Java based developer.

Until next time
Les

Lone Star Software Symposium - Day 1 Recap

Without going into detail regarding the trip to Dallas and the typical checking into the hotel I'll just say that for the most part today is what you might expect from the first day of a conference. I really enjoyed the sessions I attended today. All three of the sessions I chose were led by Scott Davis and all things revolved around Groovy.

The Blue Pill

The first session was Groovy, the Blue Pill, and yes that is a reference to The Matrix and the next session carried the reference further. The Blue Pill was basically a crash course in Groovy. What it is. How can it be used. What are some basic features that make it so groovy and not just Java without the semicolons (which is optional). It was a good track for me as I'm still fairly new to Groovy. Sure I didn't really get a lot of "new" out of this one since I've been reading a lot of intro to Groovy stuff lately, but it was refreshing.

The Red Pill

The Red Pill was just a continuation of the Blue pill. After the intro course he was now able to present more nitty gritty Groovy functionality. It covered closures, metaprogramming, and much more. A very good session for me as this is where I'm standing on the Groovy landscape.

Grails for the Struts Developer

This was a very interesting session to me. He began and spent a large part of the course talking about Struts. It's origins and it's benefits. Much praise was discussed for what Struts had implemented in it's day. But then came the current state of development on the Java platform and some negative topics regarding Struts were breached. Then he introduced Grails and talked about how you can simply use Groovy over your current Struts apps. Then he rolled up his sleaves and created a Grails app from scratch. With scaffolding doing all the work it was a matter of minutes before he had 3 CRUD apps up an running. Not a lot of new stuff for me, but a good refresher preparing me for my session on Grails tomorrow.

Keynote

Interestingly enough to me, the keynote speach at the end of the day was almost the best part (not taking anything away from Scott and his Groovy kool-aid). It was an awesome presentation about the state of software development and how long it's been this way and where it will likely end up going (which looks bad from here). He talked a lot about development anti-patterns that are common and I swear the man must be camped out or video taping our department because the first six patterns he discussed were common every week practices for us. I wasn't really shocked, but hearing it all explained so pointedly really made me wonder how much longer I can put up with it (as if I wouldn't run into the same issues elsewhere).

Conclusion

Overall the first day was very enjoyable and full of information. I'm looking forward to tomorrow's sessions.

Until next time
Les