Design Patterns Workshop

This class goes underneath design patterns to understand the principles behind the patterns. Patterns are a manifestation of 3 principles:

• Find what varies and encapsulate it
• Design to public methods
• Prefer delegation over inheritance

This session describes how to think in terms of the principles of patterns to be able to discover patterns in your designs and to create new quality designs when patterns aren’t present.

After presenting the fundamental lessons of design patterns the class proceeds into how patterns can be used both in an upfront manner or in an agile manner. The tutorial continues by comparing and contrasting seemingly different design methods:

• test driven development
• pattern oriented design
• refactoring from poor designs
• commonality variability analysis
• designs based on code qualities with standard object-oriented approaches

Functional Programming Workshop

With Java supporting lambda expressions, we have nothing to stop us from creating functional style of code for our day to day applications. We're so used to object-oriented programming, but remember the paradigm shift we went through to adapt to that way of programming. It is yet another paradigm shift and most of us wonder how in the world can we write functional style code. Much like how OO was not as much about the syntax as it was about the design, functional programming is about the design, the idioms, and the data structures we'd use to program.

In this hands-on workshop, we will learn about functional programming using practical examples, create small apps that will make use of this style of programming, and relate to how it differs from the traditional way we're used to and the benefits it offers.

JavaScript Workshop

Get your skills up to speed for JavaScript, the oft-misunderstood language of the web, in this full day workshop. We'll start from the very basics and learn the ins-and-outs of JavaScript. We'll look at the (many) quirks in JavaScript, and work through advanced features that make this language so powerful.

We'll talk about JavaScript design patterns, frameworks, and conventions. We'll end the day with and advanced, hands-on session, on functional programming in JavaScript. Come with an open-mind and ready to dig into code!

This workshop requires a laptop, and assumes the attendee has ZERO knowledge of JavaScript. We'll break down your bad habits, and build upon known patterns and best practices to raise your JavaScript-fu.

Groovy Workshop

This workshop will bring you up to speed on the specifics of the Groovy programming language. We'll touch on most of the major features of the language, from collections and closures to builders, AST transformations, and metaprogramming. Specific examples will cover topics from Groovy itself and will be supported by unit and integration tests and built using Gradle.

Featured topics will include: collections, closures, operator overloading, scripts and classes, unit and integration testing, AST transformations, parsing and building both XML and JSON, and working with SQL. If time is available, other projects from the Groovy ecosystem, like Gradle, Spock, and GPars, will be included.

A minimum comfort level with Java is assumed. Some exposure to Groovy would be helpful but not required.

REST Workshop

Many people are drawn to the ideas of REST but aren't sure how to take the next steps. This workshop will help get you to a comfortable place by introducing the concepts and walking through a series of exercises designing REST APIs from a variety of domains.

We will break up into teams and tackle the various aspects of a solid, stable, evolvable REST API design. This will not be a tutorial in particular REST implementations (Jersey, Restlet, etc.). The ideas will transcend specific technologies although we will talk about some particular choices.

Refactoring to Modularity

Monolithic applications are difficult to understand, maintain, and extend with new features and functionality. Modularity helps achieve these goals. Unfortunately, few applications have been designed with modularity in mind. In this workshop, we take a deep dive into modularity. We'll start by briefly examining the benefits of a modular architecture and exploring several patterns that help us design modular software. Then we'll launch into several exercises where we take an existing monolithic software system and refactor it to a modular architecture.

Along the way, we'll examine useful tools that help us along the journey and will demonstrate the benefits of our new architecture.

Git Workshop (Bring A Laptop)

Git is a version control system you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands on experience is what really counts. In this workshop, you'll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.

The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You'll be cloning, creating, commiting, and pushing repositories by the conclusion of this session.

PreReq:
Basic knowledge of a version control system. Subversion knowledge is a plus, but not imperative.

Cassandra: NoSQL with teeth!

While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.

While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.

Cujo.js: Rabid Application Development in Javascript

In modern applications, Javascript is increasingly prevalent both on the client-side and to some degree on the server-side. As we continue to crank out more Javascript code, we're finding that many of the same hard-lessons we learned in writing decoupled Java code are equally desirable in Javascript code. Without the benefit of dependency injection and AOP, both Java and Javascript code can quickly become an unnavigable and untestable mess.

Where frameworks like Spring have helped us gain control over our Java code, Cujo.js similarly aims to give our Javascript code more structure and testability.

In this session, we'll look at Cujo.js, an “unframework” that provides dependency injection that takes Javascript's unique needs into consideration to create loosely-coupled code. We'll also see how, although Cujo.js isn't strictly a UI framework, elements of Cujo.js can be brought together to elegantly build client-side UIs.

DDD GREEN AND BROWN

This workshop leads you through the central concepts of Domain-Driven Design (DDD) and allows attendees to work through software modeling problems that address integrating new Core Domains with legacy systems using an event-driven architecture.

Learn hands-on to use DDD strategic design patterns to model in a financial trading legacy application, and to model and develop a new Core Domain that supports algorithmic trading. Again, using hands-on modeling exercises you will employ DDD tactical modeling to create a new algo-trading Core Domain that integrates with the legacy trading system.

Introduction to Clojure

Clojure is a powerful dynamic language that compiles to many target environments, including the JVM, JavaScript, and the CLR. In this talk, you will learn how to think in Clojure, and why you should want to.

Clojure encourages functional style with persistent data structures, a rich library of pure functions, and powerful processing support via the seq and reducer abstractions. Clojure implements a reference model for state, where references represent atomic successions of values, and change is encapsulated by value and reference constructors. This reference model is more substantive and suitable to application development than individual techniques such as Software Transactional Memory (STM) or actors.

The most important single principle behind Clojure is simplicity. Clojure's abstractions are simple and orthogonal. A la carte polymorphism, careful support for names and namespaces, the reference succession model, and a wide selection of small, composable protocols make Clojure programming swift, surgical and accurate.

Clojure's expressiveness does not mean that you have to compromise on power. It is an explicit design goal of Clojure to provide access to the power of the underlying platform, and for programmers never to have to “drop down” to the platform level for performance-sensitive work.

On the Web

• Programming Clojure by Stuart Halloway and Aaron Bedra

Java EE 7 Hands On Lab

The Java EE 7 platform focuses on Boosting Productivity and Embracing HTML5. JAX-RS 2 adds a new Client API to invoke the RESTful endpoints. JMS 2 has undergone a complete overhaul to align with improvements in the Java language. Long awaited Batch Processing API and Concurrency Utilities are now added to make the platform richer. A new API to build WebSocket driven applications is added. JSON parsing and generation is now included in the platform itself. JavaServer Faces has added
support for HTML5. There are several other improvements in this latest version of the platform. Together these APIs will allow you to be more productive by simplifying enterprise development.

This hands-on lab will provide a comprehensive introduction to the updated Java EE 7 platform using WildFly. The attendees will learn the design patterns of building an application using Java EE 7.

Virtualizing and Tuning Large Scale Java Platforms

The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs. In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB.

In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption.