Language

The Language track looks into emerging features of the Java language, such as EJB 3.1 and JavaFX, and provides in-depth expert recommendations on the use of Java and complementary languages in daily practice, such as Scala, JRuby and Groovy. These sessions are designed to expand your skill set, make yourself more productive, and help you think more broadly in addressing application development challenges.

Technical sessions are being finalized in the coming weeks. Here are a few of the sessions already confirmed:

• DSLs in Groovy: Say What You Mean, Mean What You Say
• DSLs in JavaScript
• Functional Programming
• Intro to JRuby
• Meta-Programming with JRuby
• Sensible Interop Programming with Fan
• The Amazing Groovy Weight-loss Plan
• The Busy Java Developer's Guide to Scala

 

DSLs in Groovy: Say What You Mean, Mean What You Say

Scott Davis, Editor in Chief, about Groovy.com; Author, Groovy Recipes: Greasing the Wheels of Java and more

"Simplicity is the ultimate sophistication." (Leonardo da Vinci)

The history of computer programming has been bridging the gap between what the user says ("We need to add sales tax to each item in the order") and what the programming language requires you to say ("for Iterator i = orderList.iterator();"). Building Domain Specific Languages (DSLs) allow you to express the solution in the language of the domain user instead of the language of the programmer.

DSLs can be written in any programming language, but the more flexible the programming language used, the closer to plain English the DSL can be. Groovy is a dynamic language for the Java platform that is ideally suited for creating DSLs. This session show you how Groovy can leverage the power of Java in a way that your users might actually be able to read and understand.

In this session you learn:

• How to create DSLs in Groovy;
• The value of DSLs in specific enterprise applications;
• How to design DSLs to meet the needs of business problems.

---

DSLs in JavaScript

Nathaniel Schutta, Co-creator, Taconite Framework; Co-author, Foundations of Ajax

Domain specific languages are all the rage these days - from ordering hash-browns to building complex business rules, DSLs are showing up everywhere. Though not the right tool for every job, DSLs can prove very useful in simplifying business problems, but they require a language with the right characteristics. Most examples are written in Ruby or Groovy, but if you find yourself in an organization that isn't as accepting of new languages, all is not lost...we can use JavaScript! Though often dismissed as a toy language, JavaScript is very powerful and includes many of the features of today's darlings. We'll take a look at a leading example of a JavaScript DSL, JSSpec and show how you can mold JavaScript to suit your needs.

In this session you learn:

• How to leverage JavaScript to build domain-specific languages;
• How to apply those DSLs to problems in your daily work;
• How to work with JSSpec, a leading JavaScript DSL, as an example of a JavaScript-based DSL.

---

Functional Programming

Ted Neward, Interoperability Expert; Author, Effective Enterprise Java and more & Amanda Laucher, Independent Consultant

Functional programming languages seem to be popping up all over the place again after many years with no press. Has anything changed? Why do they seem to be making a come back and more importantly why should you care? We explore what it means for a language to be functional, and how this alternate programming paradigm will affect your work. This session includes example in Scala, a programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine.

In this session you learn:

• The driving force behind the revival of functional languages;
• What it means for a language to be functional and how this affects your work;
• Examples of functional programming in Scala.

---

Introduction to JRuby

Neal Ford, Author, Art of Java Web Development; Software Architect, ThoughtWorks

This session explores JRuby, the 100% pure-Java implementation of the Ruby programming language. JRuby allows you to harness the awesome power of Ruby in your Java projects. In this session you learn the basics of programming with JRuby and see examples of how to integrate it into existing Java projects. We'll explore the origins, capabilities, and limitations of JRuby, and demonstrate some areas where it makes sense to mix in Ruby and Java code, such as Rails on Java, testing, and dynamic programming.

In this session you learn:

• The origins of JRuby and how to integrate JRuby into existing Java projects;
• How to call Java from Ruby, and Ruby from Java;
• The limitations and pitfalls of using JRuby;
• Example usage, including Rails on Java, testing and dynamic programming;
• The future of JRuby and Polyglot Programming.

---

Meta-programming with JRuby

Pat Farley, Lead Consultant, ThoughtWorks

Meta-programming is a powerful and expressive set of language features and idioms that let us do more with less. JRuby opens up the world of Ruby meta-programming to Java developers. In this session, we tour JRuby meta-programming facilities and dive into examples of how they work and how to use them. Effective meta-programming requires both knowledge of the language and good judgment. As Stan Lee said, “with great power comes great responsibility.” We'll also discuss when meta-programming is appropriate and, more importantly, when it is not.

Topics covered in this session include:

• Open classes, anonymous classes, and singleton classes;
• Declarative programming;
• Interpreter directives;
• Adding, removing, and re-defining methods at runtime;
• Sharing behavior with Modules;
• Reducing structural duplication;
• Dynamic method invocation with #send;
• Handling the unknown with #method_missing and #const_missing.

---

Sensible Interop Programming with Fan

Andy Frank, Co-Author, Fan programming language

Does it seem that you’re fighting with your programming language rather than using it to build your application?  Do you need a language that is native to both the JVM and the .NET Framework?  Or does it seem to take too much work to do the simplest things in Java or another language?  Fan may be your answer.

Fan is an object-oriented, functional language designed to cross compile to both the Java and .NET platforms. It’s designed to be a real-world language for enterprise-quality applications that enables developers to do more in less. It boasts a familiar Java/C# style syntax, static and dynamic typing, closures, mixins, elegant APIs, concurrency features such as immutability and message passing, and a declarative programming syntax for serialization.

The software landscape is changing, and large scale cloud-based, concurrent programming is going to be taking center stage soon, if not already. With the ever-evolving JVM and .NET platforms driving more and more software, it’s important that a language embrace these concepts to make new application development easier, faster, and more robust, but still lets us reuse the massive amounts of existing code already available for these platforms.

In this session you learn:

• An introduction to Fan, an object-oriented, functional language that can be used in a cross-platform enterprise environment to bridge the gap between Java and .NET systems;
• Fan's familiar Java/C# style syntax, static and dynamic typing, closures, mixins, elegant APIs, and concurrency features;
• How Fan makes application development easier, faster and more robust, while allowing you to reuse code;
• A demonstration of applying Fan to easily solve programming problems that can be challenging in other languages.

---

The Amazing Groovy Weight-loss Plan

Scott Davis, Editor in Chief, about Groovy.com; Author, Groovy Recipes: Greasing the Wheels of Java and more

"The central enemy of reliability is complexity." (Dr. Daniel Geer)

Java is a powerful programming language. A smart developer can do nearly anything with Java. So the next question is, "How quickly can it be done? How many lines of code does it take to do common tasks?"

Groovy greases the wheels of Java by decreasing the complexity of the language while preserving the raw power. At first glance, you might think that this is simply about how Groovy drastically reduces the lines of code you need to write. What this talk is really about is bringing simplicity, clarity, readability, and yes, beauty to your source code.You'll see common problems presented in Java and the corresponding solutions in Groovy. From something as simple as defining a JavaBean up through File I/O, XML, networking, and database interaction, Groovy offers identical capabilities in a fraction of the lines of code.

In this session you learn how to:

• Decrease the complexity of Java yet preserve the language's power;
• Bring simplicity and readability to your code;
• Solve common problems in Java with fewer lines of code;
• Apply the simplicity and flexibility of Groovy to common development problems in your work.

---

The Busy Java Developer’s Guide to Scala

Ted Neward, Interoperability Expert; Author, Effective Enterprise Java and more

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming. This session focuses on the parts of Scala that feel comfortable to the traditional object-oriented developer, and the various ways that Scala improves the object-oriented experience.

In this session you learn:

• How to leverage functional and object-oriented techniques for the JVM with Scala;
• The language’s powerful functional features, such as algebraic data types, immutable objects by default, patter matching, closures, anonymous functions and currying, and more;
• Scala’s deep support for XML generation and consumption;
• How Scala lends itself to building highly scalable, concurrent architecture.