Reviewed Ted Neward's "Tech Predictions, 2011 Edition".
We barely made it through the list.

The list can be found on his Ted Neward's Technical Blog .

The Phunctional System Integration (PSI) is a Java testing harness for managing the life cycle of Java Web Application containers, including the starting, stopping, and deployment. PSI alleviates the need to have an external Servlet container such as Tomcat or Jetty running to test your Web Applications, as PSI will dynamically create the container in your testing process. This is in contrast to Cactus which requires you to modify and keep running an existing installation of a Servlet container. If you are using Selenium , PSI could construct and mediate a Servlet container for your Selenium process to consume.

For this session's demo we will be discussing Jetty, Maven, a Prime Number generator, RESTful services (JAX-RS), Spring, TestNG, Tomcat, and Wicket.

On-Line Presentation

A presentation of what can be called laws that govern SDLC. These laws were described in the book "The Mythical Man-Month" by Frederick P. Brooks, Jr.

Many social factors are at play during the development of a software product. Most technical problems have long been solved. The management and control of these social factors determine the quality and cost of a software product.

But most importantly for the programmer, these social factors cause major headaches and frustration. Understanding the laws of SDLC can improve a programmers quality of life and encourage programmers to discover new ways to overcome these SDLC laws.

Today, Hibernate is a collection of related projects enabling developers to utilize POJO-style domain models in their applications in ways extending well beyond Object/Relational Mapping.

Brian will present a discussion on Hibernate resources, tools, and server environments available for developing Hibernate solutions. With Brian's depth of knowledge about software languages and language parsers, you can bet that there will be a fair amount of discussion about the pro and cons of Hibernate's overall strategy and its integration into other technologies (frameworks, tools, and servers).

Mark presented a comparison of patterns that are in common use. Some patterns differ only in their intent of purpose. Others differ only in their intent of effect, structure versus run-time. A few are very similar yet differ in their intended application. While a few exist for the sole purpose of lively discussions.

For the advanced session we continued our discussion on other patterns and selected some more patterns for comparisons that Mark will present to the group in future meetings.

Mark identified two works that are used as guidelines and principles for crafting object oriented software:

• GRASP
• SOLID

The group offered these books for design pattern references (not in any particular order):

• Design Patterns: Elements of Reusable Object-Oriented Software By Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides
• Head First Design Patterns By Eric T Freeman, Elisabeth Robson, Bert Bates, Kathy Sierra
• Design Patterns in Java By Steven John Metsker, William C. Wake
• Patterns of Enterprise Application Architecture By Martin Fowler
• Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions By Gregor Hohpe, Bobby Woolf
• Core J2EE Patterns: Best Practices and Design Strategies By Deepak Alur, Dan Malks, John Crupi
• Domain-Driven Design: Tackling Complexity in the Heart of Software By Eric Evans
• Amazon's Complete Selection of Christopher Alexander Books

For the purpose of illustrating differences between design patterns the group offered these factors:

• Intent
• Motivation
• Cost / Complexity / Maintenance Effort
• Phase: Static / Instance and Structure / Runtime
• Dependencies
• Mutability / Immutability
• Application and Purpose
• Object Oriented Principles (Barbara Liskov, Jeannette Wing)

A comparison of the patterns Builder , Factory Abstract , and Factory Method .

Open Discussion

A brief talk on the experimental Protocols typeloader for Gosu and some discussion about Ronin , a small Gosu-based web framework.

Protocols provide a way to achieve duck typing in Gosu without sacrificing static verification. This functionality is achieved by introducing Protocol Types into Gosu via The Open Type System.

Ronin is a strongly typed MVC web framework for the Gosu programming language. It integrates seamlessly with (but can be used independently of) Tosa, a Gosu-based object-relational mapping layer.

A presentation continuing the discussion of patterns within Java, including implementation and applicable theory. This session will focus on three patterns: Iteration, Composition, and Decoration.

With proper mark-up/logic separation, a POJO data model, and a refreshing lack of XML, Apache Wicket makes developing web-apps simple and enjoyable again. Swap the boilerplate, complex debugging and brittle code for powerful, reusable components written with plain Java and HTML.

Vaadin is a web application framework for Rich Internet Applications (RIA) . In contrast to Javascript libraries and browser-plugin based solutions, it features a robust server-side architecture. This means that the largest part of the application logic runs securely on the server. Google Web Toolkit (GWT) is used on the browser side to ensure a rich and fluent user experience.

Vaadin is a large collection of UI components. You compose the application user interface from components such as Buttons, Tables, Trees and Layouts. The components use events, listeners and data binding to communicate with each other and with your business logic.

Vaadin is a robust architecture for rapid application development. The component-based architecture together with statically typed Java language and data binding features help you build applications that are easily modularized and refactored as needed. The IDE and tooling support including visual designing tool help you to build web user interface extremely fast.

Presentation includes live coding of a RIA application using 100% Java.

Gradle Gradle pushes declarative builds to a new level. It allows users to provide there own declarative elements and to customize the behavior of the build-in ones. Thus enabling concise, expressive and maintainable builds. All this is build on a rich, flexible imperative layer of tasks.

With its Deep API, Gradle allows you to hook in and customize every aspect of the build, be it configuration or execution behavior.

Gradle comes with many optimization strategies for building fast and yet reliably. It has a powerful support for multi-project builds and transitive dependency management. It allows to integrate with your existing Ant/Maven builds and your Ivy/Maven/Custom repositories.

Wicket version 1.5 is here!

With proper mark-up/logic separation, a POJO data model, and a refreshing lack of XML, Apache Wicket makes developing web-apps simple and enjoyable again. Swap the boilerplate, complex debugging and brittle code for powerful, reusable components written with plain Java and HTML.