Robert Fischer

By Robert Fischer

The power of multicore machines and cloud computing is all dependent on an application's ability to successfully leverage concurrency. Although concurrency has traditionally been considered fatally difficult in Java, a few simple architecture principles can make all the difference. This session will review some of those principles in both theory and practice.

This session will review the theory of concurrency and the different levels that concurrency will act on. With that basis, it explores the theoretical reasons behind the difficulties in writing concurrent code, and then some practical application architecture techniques to cope with those difficulties.

By Robert Fischer

For years, the venerable Hibernate object-relational mapping framework has dominated the persistence scene in Java. The Grails web application framework extended Hibernate and Spring with their impressive GORM persistence framework, providing convention-over-configuration development to the O/RM and DAO layers. This session will introduce GORM and work up to some of its intermediate features.

Before too long, every data access layer starts to look the same. Spring recognized this and provided some common functionality. The Grails web framework went one step further and provided conventional access to their ORM objects. Now GORM is available to non-Grails applications as well, so this session should have universal appeal.

By Robert Fischer

Development of a program has traditionally been done in one language and one language only. Increasingly, however, JVM languages are being expected to interoperate with one another. This talk explores what makes polyglot programming possible, why businesses should adopt the polyglot development model, and compares the interoperability of JRuby, Groovy, Scala, and Java.

It is very possible for an application written on the JVM to be made up of many different languages. In fact, that model of development will be increasingly popular as languages increasingly specialize in their domain of strength. Because of that, polyglot programming will become one of the key skills expected of JVM developers, and this session gives a leg up on that.

By Robert Fischer

JConch is a library that provides a few high-level tools for high-concurrency environments on the JVM. The java.util.concurrent package in the Java standard library provides low-level structures for managing concurrent communication. Learn here how to use both of them in order to produce clean, highly-concurrent, and highly-tunable code.

Programming in a concurrent fashion is quickly becoming mandatory for applications. This session will explore the best ways to do that on the JVM.

By Robert Fischer

With languages like F#, Clojure, and Scala increasingly taking up mindshare, many developers feel pressure to jump into functional programming. The jargon of functional programming can prove a huge barrier, though, and it really shouldn't. This session will explain what the functional programmers mean when they say things like "closure", "monad", "monoid", and "combinator", and show that they are actually ideas with Java analogs that are more familiar than their names may imply.

Functional programming has been the domain of academics for a long time, but the paradigm is increasingly being considered by business-line developers. Some people even tout it as the movement of the future. Unfortunately, the jargon of functional programming have been defined by academics, which makes breaking into the language tricky. As a student of pure mathematics, a Java programmer, and a functional programming consultant, Robert will translate these ideas between paradigms.

By Robert Fischer

The Grails web application is an innovative hybrid of best-of-breed Java technologies and dynamic/convention-based development. The result is a powerful, flexible, exciting framework that still fits comfortably into enterprise stacks. This session introduces Grails, but approaches it from the perspective of an enterprise web development stack, in order to see how Grails works well in mid-size and mature development shops.

Some technologies seem to think that running on the JVM is all that it takes to be enterprise-ready, but the reality is that there is a large context of standard Java technologies like Spring, Hibernate, Log4J, JNDI, and app servers that make up the backbone of enterprise Java shops. This presentation will show how Grails naturally fits into that context because it is built off of those existing technologies.

By Robert Fischer

Increasingly, people are adopting Agile practices a la carte, and some are even talking about "post-Agile" methodologies. If things are going to be changing, let's take a moment to review Agile development practices, the problems they were trying to solve, what worked, and what difficulties these new methodologies are responding to. With this information in hand, we can make an intelligent decision about the development methodology for our team.

This interactive session will review the why's, wherefore's, and why not's of test-driven development, continuous integration, iterations, "point"-based estimation, retrospectives, scrums, and other Agile practices.

By Robert Fischer

Although developers know that abstraction and code reuse are the best way to develop faster, projects so often start with a complete green-field and end up re-implementing standard business functionality. Service Oriented Architecture was one attempt to solve this, but the overhead in managing and communicating with remote services is often too much for a project to bear. OSGi, a technology for modularizing Java software, moves that service style of thinking into the application itself.

OSGi is an open standard which is implemented in a variety of containers, which allows you to choose from the bare-bones, embedded-focused 80kb Concierge to the full featured Equinox. The basic idea is to provide a module system within Java itself, built off of packages but smaller than the size of an application. By working with these modules and services instead of reaching directly into packages, true reusability and clear differentiation of concerns can be accomplished in the normal day-to-day work of building the application.

By Robert Fischer

All the code and unit tests in the world won't help you if your code can't be built. This session looks at the open source tools Hudson, Gant, and Ivy as ways to simplify and automate the build process, and also discusses best practices when it comes to the build.

The three tools reviewed here are: * Hudson - A continuous integration server, and the heir apparent to the venerable Cruise Control. * Gant - A thin Groovy wrapper around Ant which provides all the power and extensions of Ant combined with the flexibility of Groovy. * Ivy - A dependency management system that is supported "out of the box" by Gant.

By Robert Fischer

Although most people think of Ivy as just a dependency management tool, it can also be used for release management. This session moves beyond novice Ivy usage and shows how it can be used to help maintain sanity in a world of many JARs.

Ivy is the release and dependency management part of Maven with some modifications. Its capabilities are more than just fetching JARs from iBiblio, and this talk will go through the steps necessary in order to have an environment providing a safe, sane, and powerful way to deploy applications and their dependencies.

By Robert Fischer

The Groovy language now provides substantial concurrency capabilities via the GPars library, including the ability to work with actors and dataflow concurrency. This talk shows how you can integrate these Groovy concurrency structures into your Java applications.

The GPars project offers developers new intuitive and safe ways to handle tasks concurrently, asynchronously, and distributed by utilizing the power of the Java platform and the flexibility of the Groovy language. With GPars, Java programs can transparently leverage multiple cores and even multiple systems by moving through a layer of Groovy code.