Venkat Subramaniam


Dr. Venkat Subramaniam is the founder of Agile Developer, Inc. and an adjunct faculty at University of Houston. Venkat helps his clients to adopt agile practices and prudent technologies. He has trained and mentored thousands of developers around the world and is a frequent invited speaker at international conferences. Venkat is the author of “.NET Gotchas,” co-author of award winning “Practices of an Agile Developer,” author of “Programming Groovy,” and “Programming Scala.” His latest book is “Programming Concurrency on the JVM—Mastering Synchronization, STM, and Actors (Pragmatic Bookshelf)”

Talk 1:

Tackling Multicore Complexity on the JVM

The gaining popularity of multi-core processors has rekindled the concurrency question: How do you effectively implement multithreaded applications on the Java platform? The familiar approach in Java is to create threads and to manage access to shared mutable state using synchronized locks. This approach to concurrency is fraught with hard work and uncertainties. Have you marked the appropriate methods synchronized, did you decorate the relevant fields volatile, did you properly construct the mutually exclusive regions of code, and is there a potential for deadlock lurking in the code. In this talk you will learn about alternate ways to tackling concurrency on the JVM. One approach is the functional way, along with an actor based model provided in Scala, to deal with immutable state. This removes the problem at the root, since data cannot change there is no issue of contention to contend with. Another distinct approach, provided in Clojure, is to protect access to mutable data, not using locks, but using transactional boundary. The Software Transactional Memory brings database like transaction model to in-memory data. In this presentation we will discuss the pros and cons of these approaches and how to effectively apply them.

Talk 2:

Effective Java

Java is a well established language, that has been around for more than a decade. Yet, programming on it has its challenges. There are concepts and features that are tricky. When you run into those, the compiler is not there to help you. In this presentation we will look at various concepts that you will use in general programming with Java. We will discuss the issues with those and how you can improve your code. We will look at concepts you can do better and those you should outright avoid.


Thinking and Programming in Functional Style

Functional programming has been around for a while, however, they have sharply raised to prominence on the JVM with the emergence of languages like Scala, Clojure, Groovy, and JRuby. Programming in functional style is not about picking a set of syntax, it is thinking in a particular idiomatic style and programming using a set of constructs. One of the better way to learn this is by doing it. In this workshop, we will take ten different tasks, discuss how to do them with the all-too-familiar imperative style and then how to program it using functional style. We will then implement our design for each task using a language that provides functional style of programming on the JVM.

Additional details:

Participants will be working in pairs. One laptop is needed for every two participants.

It is required to have the following software installed on a laptop:
JDK, languages like Scala, Groovy, Clojure installed on participants machines, and a favorite IDEs.

Limit of participants: 30

  • jdd


Gold Sponsors:

  • e-point
  • j-labs

Silver Sponsors:

  • Lumesse
  • Luxoft
  • SII


  • Redhat
  • WITS

Sponsor JDD Afterparty:

  • WITS

Media Partners:

  • helion
  • Polish JUG
  • Poznan JUG
  • SDJ