Archive

Author Archive

4/14/2010 Language Panel

April 1, 2010 1 comment

Location: Auraria Campus, TIV 320 AB – Baerresen Ballroom
Address: Walnut St. & 9th St; Denver CO 80204

Schedule:
5:30-6:00 PM Refreshments and Networking
6:00-7:00 PM Polyglot Approaches with Ruby, Groovy, Scala and Clojure
7:00-7:05 PM Short break
7:05-7:15 PM Announcements
7:15-8:45 PM Panel Discussion: Ruby, Groovy, Scala, Clojure and Polyglot
8:45 PM Door prize raffle

Polyglot Approaches with Ruby, Groovy, Scala and Clojure
Ruby – Frederic Jean
Groovy – Scott Davis
Scala – Tom Flaherty
Clojure – Daniel Glauser
Polyglot – Venkat Subramaniam

In the first hour each of the five panelists with give a 12 minute talk.

The four language talks will feature common examples along with the
influence that each language has on it’s web framework: Ruby On Rails,
Grails, Lift & Cascade.

In the fifth 12 minute talk Venkat will make the case for when to use
which language. While all the languages can do almost all of the tasks
(they are all general purpose languages), each shines a bit more than
the others in some areas.

Panel Discussion: Ruby, Groovy, Scala, Clojure and Polyglot

The audience and panelists will start off with a discussion of the
examples from the previous session. For each language, we will discuss
why one is better than the other. We expect all the languages to come
out winning, but in different areas.

Other topics up for discussion are web frameworks, DSLs, concurrency,
what is a dynamic language, Polyglot Maven and Ola Bini’s Language Pyramid.

About the Panelists:

Frederic Jean (Ruby) has recently joined Time Warner Cable’s Advanced
Technology Group. Frederic focuses on using dynamic languages such as
Ruby and Groovy to build and test complex applications. Frederic worked
on Project Kenai at Sun based on JRuby, to provide a hosting facility
for Open Source Projects. Frederic is the speaker coordinator for the
Boulder Java Users Group. In Colorado Frederic has spoken at Boulder
Ruby Users Group, Derailed, DJUG, BJUG, DOSUG and CSOSUG.

Scott Davis (Groovy) is launching Closely.com to make real-time social
networks work better for businesses and consumers. For training Scott
founded ThirstyHead.com, that specializes in Groovy and Grails training.
Scott published one of the first public websites implemented in Grails
in 2006 and has been actively working with the technology ever since.
Author of the book Groovy Recipes: Greasing the Wheels of Java and two
ongoing IBM developerWorks article series (Mastering Grails and in 2009,
Practically Groovy), Scott writes extensively about how Groovy and
Grails are the future of Java development. Scott teaches public and
private classes on Groovy and Grails for start-ups and Fortune 100
companies. He is a regular presenter on the international technical
conference circuit (including No Fluff Just Stuff). In 2008, Scott was
voted the top Rock Star at JavaOne for his talk “Groovy, the Red Pill:
How to blow the mind of a buttoned-down Java developer”. In Colorado
Scott was president of DJUG and BJUG. Scott has spoken at DJUG, BJUG and
IASA Denver.

Tom Flaherty (Scala) is Chief Architect for Axiom Architectures. Tom is
currently building an open source release of IDD (Intelligent Documents
& Drawings) an interactive drawing, symbolic math and stylistic editor
application written in Scala. Tom is writing a series of papers titled
“The Scala Way” to explore advanced concepts about OO, functional
programming, concurrency and Ola Bini’s language pyramid layers. In 2009
Tom introduced Axiom’s “A Practical Road Map to Enterprise Architecture”
a refined approach based on 12 core practices for 4-Tier platforms with
Agile and quantitative benefit methodologies. The “Road Map” summarizes
14 years of enterprise architect experience at Williams Communications,
DMR, XCare and Axiom. In Colorado Tom has spoken at DOSUG, BJUG and CSOSUG.

Daniel Glauser (Clojure) is the featured speaker for a night of Clojure
at the Denver Open Source User’s Group on April 6, 2010. Daniel has
recently spent time with two Clojure based web frameworks, Cascade (a
web framework authored by Howard Lewis Ship) and Compojure. Daniel is a
software architect with over twelve years’ development and architecture
experience for companies like Comcast, BellSouth and NBC-Universal.
Daniel has designed and implemented a digital classroom, worked on
large-scale data processing systems for the state of California, and a
high-volume content management system for Telemundo.com. Daniel’s
interests include functional programming, logic systems, and enterprise
architecture. Daniel is a nationally-recognized whitewater kayaker who
recently relocated to Castle Rock, Colorado, and spends most of his time
away from the computer either with his family or on the water. In
Colorado Daniel has spoken at DOSUG, BJUG and CSOSUG.

Venkat Subramaniam (Polyglot) is founder of Agile Developer, Inc. Venkat
has trained and mentored thousands of software developers in the US,
Canada, Europe, and Asia. Venkat helps his clients effectively apply and
succeed with agile practices on their software projects, and speaks
frequently at international conferences and user groups. He is author of
“.NET Gotchas,” coauthor of 2007 Jolt Productivity Award winning
“Practices of an Agile Developer,” author of “Programming Groovy:
Dynamic Productivity for the Java Developer” and “Programming Scala:
Tackle Multi-Core Complexity on the Java Virtual Machine” (Pragmatic
Bookshelf). In Colorado Venkat has spoken at DJUG, BJUG, DOSUG and CSOSUG.

Advertisements
Categories: Monthly Meeting

Slides: Building SOFEA Applications with GWT and Grails by Matt Raible

November 13, 2009 Leave a comment

Here are the slides from the talk Matt Raible gave this week.

Categories: Monthly Meeting Tags: , , ,

‘Javascript and DOM Scripting’ Book Review

November 8, 2009 Leave a comment

cover.cfmReview of JavaScript and DOM Scripting by Edward Young

I’m an experienced software developer but unfamiliar with Javascript, and this book was an excellent way to learn through example. It’s also a pretty good reference for javascript and DOM scripting, plus has some good introductory info on XHTML and CSS. I’m also a software engineer who appreciates and relies on good software tooling to help make code projects comprehensible, and manageable. The chapter on how to test and debug Javascript, showed how to install and set up firebug, and then how to use it to examine, execute and debug javascript applications. That chapter alone is worth the price.

This book is both a good how to manual (Nearly all the chapters start with “How to”), but is a great reference, with a 1 page brief contents and then a 10 page detailed table of contents.
This book is also not only a book on learning Javascript and DOM scripting, but also ensures that the reader learns the vital peripheral technologies alike XTHML and CSS, by taking the reader through the development of several interesting and useful applications over it’s 20 chapters.
This is my second Murach book and is also excellent. I highly recommend it.
Categories: Book Review Tags:

November 11th, 2009 Meeting

November 7, 2009 2 comments

Location: Auraria Campus-Tivoli Bldg; Room: TIV 320 AB – Baerresen Ballroom

*** Free Pizza @ 5:30 ***
Main Session Speaker: Matt Raible
“Building SOFEA Applications with Grails and GWT”
7:15pm -8:30pm
BC Session Speaker: Panel, Q & A
“How to Become and Independent Consultant: Panel Discussion Q & A”
6:00pm – 7:00pm
Basic Concepts – Panel Discussion ‘How to Become and Independent Consultant: Panel Discussion Q & A’

How To Become an Independent Consultant: Panel discussion; Q & A This session explores the trials and tribulations of an independent consultant. How do you find contracts? Should you setup an LLC, an S-Corp or just be a sole proprietorship? What about health insurance and benefits? Are recruiters helpful or hurtful? Learn lots of tips and tricks to get your dream job and your ideal lifestyle. Ski season is coming up after all. 😉

Panel: Matt Raible, Tim Berglund, Matthew McCullough, James Goodwill

Featured Talk: Matt Raible ‘Building SOFEA Applications with Grails and GWT’

In early 2009, Matt participated in a major enhancement of a high-traffic well-known internet site. The company wanted to quickly re-architect their site and use a modern Ajax framework to do it with. An Ajax Framework evaluation was done to help the team choose the best framework for their skillset. The application was built with a SOFEA architecture using GWT on the frontend and Grails/REST on the backend. This talk will cover how Matt’s team came to choose GWT and Grails, as well as stumbling blocks they encountered along the way. In addition, we’ll explore many topics such as raw GWT vs. GXT and SmartGWT, the GWT-Plugin, modularizing your code, multiple EntryPoints, integration testing and JSON parsing with Overlay Types.

Speaker:
Matt Raible resides in Denver, Colorado, where he runs Raible Designs, a consultancy that specializes in open source Java frameworks and Ajax development. Matt has been surrounded by computers for most of his life, even though he grew up without electricity in the backwoods of Montana. Matt is an author (Spring Live, Pro JSP), active Java open-source contributor, and blogger on raibledesigns.com. He is the founder of AppFuse, a project which allows you to get started quickly with Java frameworks, as well as a committer on the Apache Roller project. Matt’s presentations can be downloaded from his website. Contact him if you can’t find one of his presentations.
Categories: Monthly Meeting Tags:

Slides: Test First, Refresh Second: Web App TDD in Grails by Tim Berglund

October 15, 2009 Leave a comment

Here are the slides for the talk Tim Berglund gave this week.

Categories: Monthly Meeting Tags: , ,

‘Java Servlets & JSP’ Book Review

October 15, 2009 Leave a comment

murach_cover

Review of Java Servlets and JSP by David Madouros

I’m torn after reading Murach’s Java Servlets & JSP book, 2nd Ed. I read the first version when I was making the transition from mainframe programming to Java programming and found the information to be extremely helpful for getting up and running very quickly. With the authors’ assistance I had a database server, a servlet container, and a ‘hello world’ web app running within a couple of hours. On the other hand, reading the second edition as an experienced Java developer made me cringe. Ultimately, I have to side with the my experienced side. Especially when I consider how well the format of Murach books tends to make them canonical references and how easy it would have been for the authors to teach better practices.

The cover of the book makes at least three claims:

  • Get off to a quick start
  • Build professional web sites
  • Handle databases like a pro

Get Off to a Quick Start
The authors get off to a great start by helping the reader to download, install, some basic tools including a servlet container, a database server, and an IDE. They guide the reader with step by step instructions for installing both Tomcat and MySQL — bonus points for recommending the latest versions of each. However, I’m stumped by their choice of IDE — NetBeans — and their claims that it is a top notch IDE. Technically, I suppose it is third, but in my experience it’s a distant third well behind Eclipse and IntelliJ.
Build Professional Web Sites
I take issue with much of the material presented in the book and how it lends itself to creating ‘professional’ web sites. For starters, the authors provide an excellent introduction to HTML. Too bad XHTML is the current standard. The authors state that they’d rather discuss HTML than XHTML because they feel that XHTML is too difficult to teach in a single chapter. I thought this was ridiculous, but assumed they would at least promote well-formed HTML — boy, was I wrong. They consistently use of malformed HTML in their examples and go as far as mentioning the lack of unquoted attributes as a good thing! This is bad, but it gets worse because a couple of chapters later they have to discuss well-formed HTML before they can teach the reader how to use JSTL.
The authors discuss both JSP and Servlet technologies in separate chapters and demonstrate how to create ‘complete’ websites with each technology. I suppose this is necessary to teach the underlying technologies, but I wish that the authors had down played their use a little more. They do eventually discuss MVC (model 2) and state that it is a better solution, but they take the easy way out by saying that sometimes straight JSP and straight Servlet implementations are except- able.
My final grumble about creating professional websites has to do with the chapter on custom tags. While using the classic tag mechanism was a pleasure (not!), the simple tag mechanism is exactly what it claims to be — simpler — and much more straight forward. However, the authors only mention the classic mechanism — no mention of SimpleTagSupport and no mention of tag files. Long live SKIP_BODY!
Now for the good stuff… My favorite chapter in the entire book has to be chapter 9 because they give a high-level summary of JavaBeans and JSP tags stating that they are outdated and rarely used anymore — replaced by JSTL. The only reason the authors even mention them is that the reader may need to know about them to support legacy applications. I wish the rest of the book gave more of these disclaimers.
Finally, the authors really do a good job of describing the technologies. I just wish that they’d promote best practices and shun bad ones more often.

Handle Databases Like a Pro
The authors give a good overview of SQL and then move on to coding straight JDBC code. However, they choose to close the connection inside of the try block rather than follow the best practice of closing the connection in the finally block. Also, they mention the differences between Statement and PreparedStatement and seem to lean towards Statement unless there is a need to execute the same statement repeatedly, but throughout the entire discussion there is no mention of cross site scripting prevention as one of the benefits of the PreparedStatement (not that PreparedStatement completely eliminates the threat of XSS, but it greatly reduces it).

Summary
In summary, this book is a disappointment. The subject of web development involves many technologies: CSS, HTML/XHTML, Java, Servlets, JSP, JSTL, EL, SQL, Http, and Javascript; and this doesn’t include the various frameworks (Struts, JSF, Spring, Hibernate, GWT, etc.) The authors make a valiant effort to cover all the base technologies, but there’s just too much to cover in a single book and be able to make the claim that the reader will have all the skills necessary to create professional websites. This book barely manages to cover the basics. I give the authors an A for effort, but a D for execution. Having said that, if you don’t understand any of the technologies (other than Java) and read the book with the understanding that this is just the beginning, this might be the book for you.

Categories: Book Review Tags: , ,

‘Modular Java’ Book Review

October 15, 2009 Leave a comment

Review of Modular Java by Johnny Wey cwosg

“Modular Java: Creating Flexible Applications with OSGi and Spring” provides a great introduction to those either curious about OSGi or wanting to get more out of their existing OSGi workflow using the Spring Framework. Craig Walls, author of “Spring in Action, 2nd Edition”, opens the book explaining why OSGi matters and how it can be used to enhance the modularity and maintainability of those application stacks containing multiple and complex moving parts. He not only serves up a great introduction to the technology, but also directs the reader to several tools that make OSGi development significantly easier.

In the second portion of the book, Craig throws Spring into the mix and demonstrates how the power of Spring Dependency Injection, autowiring, and the Spring MVC web framework can not only run seamlessly in an OSGi container, but also remove a large portion of the burden that OSGi’s API can put on application development.

Finally, Craig spends some time describing how an actual deployment might look in a production environment using both Tomcat and Jetty and provides optimization tips that make the process as painless as possible.

The book itself is logically organized and Craig’s writing style is approachable and easy to follow. All the example source code is available online, and Craig demonstrates how to install OSGi packages using both Eclipse Equinox and Apache Felix, leaving the final OSGi container decision up to the preference and requirements of the project. The sample application Craig uses to demonstrate the concepts in the book is surprisingly fun and useful, and the book contains some wonderful appendices that function as a great reference for current and future development projects. The book is a relatively quick read but surprisingly complete.

For someone looking to get the most out of OSGi or wanting to find out what all the “buzz” is about, Craig Walls’ book is an outstanding choice.

Categories: Book Review Tags: , ,