Languages & Coding: Development Kung F00 Sessions

Languages & Coding: Development Kung F00

with Track Host: Glenn Vanderburg, Chief Scientist, Relevance, Inc. 

Our Development Kung F00 track will give you an overview of the Java language and platform landscape to help answer your language and coding questions. Learn how to choose which programming language to use for which project; Get best practices for building and coding scalable apps; Go in-depth on JRuby, Groovy, Scala, concurrency and more. Browse all languages and coding sessions or select a title from below:

More development-related sessions we recommend.

Sessions

• Boldly Go Where the Java Language Has Never Gone Before with Geert Bevin, Sun Java Champion; Creator, RIFE Application Framework

Developers don't have to learn a new language to touch other application domains. A new development trend focuses on achieving functionalities not provided by the JVM with the standard Java programming language. 

We're only just experiencing the advent of new creative uses for the Java programming language. Judging from the wide range of new areas that have already opened up, the future holds a lot of promise for this approach. This presentation will highlight several radically different approaches that all use the Java programming language as their foundation.

In this session, you will learn how:

• Terracotta brings clustering to any Java application by distributing the characteristics of the Java Memory Model;

• Google Web Toolkit allows you to write and debug Ajax Web 2.0 applications in Java that still execute as DHTML and JavaScript on the client-side; 

• Google Android converts Java byte code to an instruction set that is optimized for mobile phones;

• RIFE turns method calls into continuations so that stateful Web applications and event based systems are safer and easier to create. 

Each of these technologies will be introduced with characteristic examples. We will step through demos to show the benefits of each approach. You will see how your current knowledge of the Java language allows you to enter new application domains with a minimal of effort.

• Designing for Scalability with Patrick Linskey, EJB & JPA Team Lead, BEA

The enterprise software industry is becoming increasingly dependent on the ability to scale, driven by the rapid increase in the number of cores per CPU and by the mainstream adoption of virtualization solutions such as VMWare and Xen. However, many enterprise applications and frameworks are not really built with scalability in mind.

In this talk, Patrick explores the major problems surrounding scalable and concurrent architectures, including: "data coupling," in the form of shared memory and the synchronized keyword; "service coupling," in which tight implementation coupling between ostensibly separate parts of an application impedes scalability; and "performance coupling," in which performance-related concerns drive decisions to collocate business logic. We will look at how to identify likely trouble spots in existing code and discuss some techniques to eliminate or reduce them.

Patrick then discusses how to design new systems to be scalable from the beginning. This section of the talk includes a survey of interesting non-Java solutions for the JVM, such as Erlang and Scala.

In this session, you will learn:

• To design scalable systems;

• To analyze and retrofit existing systems to make them more scalable;

• High-level landscape of scalability and concurrency in Java;

• Key new Java language features that enable scalable system implementation;

• Basic features of non-Java languages for the JVM that assist with scalability.

Recommended general knowledge:

• Basics of enterprise systems;

• Business-logic-tier concepts;

• High-level database concepts;

• High-level understanding of messaging (JMS, etc.).

• Metaprogramming (Or: The Groovy Way to Blow a Buttoned-Down Java Developer’s Mind) with Scott Davis, Author and Editor-in-Chief of aboutGroovy.com

Dave Thomas and Andy Hunt recommend in The Pragmatic Programmer that you learn a new programming language every year - Doing so opens your mind to new possibilities not offered by your current programming language of choice. Groovy puts an interesting spin on that advice – Groovy teaches you more about Java by, paradoxically, staying within Java. 

In this session, Scott will teach you how to thumb your nose at The Man by leaving out many of the main syntactic hallmarks of Java: Semicolons, parentheses, return statements, type declarations (aka Duck-typing), and the ever-present try/catch block. Then he looks at features like operator overloading and method pointers that Groovy welcomes back into the language with open arms.

Then, Scott dives into metaprogramming with Groovy - Adding new methods to classes at runtime – even if they were originally implemented in Java, and even if they were declared final (Thanks, ExpandoMetaClass!); Calling methods that don’t exist and avoiding the dreaded MethodNotFound Exception (Thanks, invokeMethod!).  Scott will narrowly scope our metaprogramming shenanigans using Use blocks and Categories, and then cast our changes to the wind such that every instance of a class gets our added juice.

In this session, you will learn:

• How to Groovy-enable your Java application by adding a single JAR to the classpath;

• How Groovy can mix in seamlessly with your legacy Java applications;

• How to use your existing Java IDE and build process to write Groovy;

• Groovy's features that can turn a traditional Java developer’s world-view upside down, including adding new methods to classes at runtime and calling methods that don't exist;

• The shifting difference between “Java the Language” and “Java the Platform,” and learn how to use Java as a platform to pick the right languages for your project. 

• How to evaluate dynamic vs. statically-typed language features;

• Features of the java.lang.reflect package that you might not have used before;

• A new and exciting way to use the same old 12 year old programming language.

Recommended general knowledge: You should be comfortable with the basic syntactic rules of Java (so that we can mercilessly squash them); You should understand the basic “Laws of Java” when it comes to the semantics of a statically-typed language (so that we can kick sand in its face).

Full disclosure: If you are happy taking the Blue Pill, this talk is not for you. You can continue using Groovy as a slimmed-down dialect of Java – an “After” picture to Java’s “Before." If, however, the Red Pill looks interesting, please join me. Remember, all I’m offering is the truth. Nothing more. You should possess an open mind and a belly full of Dynamic-language Kool Aid. This is not the forum for someone to vocally defend the merits of checked exceptions and static typing. You will be unceremoniously tossed out on your ear, Jerry Springer-style. Seriously. I’m not trying to convince you that this is the way you should write Java. The status quo can defend itself quite nicely, thank you very much. I’m here to show you how your code could look, if you so desire.

• Multi-language Development with Steve Vinoski, Member of Technical Staff, Verivue, Inc.

Programming languages have varying capabilities and strengths, and no single programming language is good at everything. This explains why there are currently almost 300 different programming languages targeting the Java VM.

In this session, Steve covers why it's important for professional programmers to be adept at multiple programming languages (Including the fact that the growing use of multi-core CPUs to increase computing performance means that it's likely that future applications will be built using multiple programming languages, often integrated through an underlying virtual machine).

Steve describes different types of languages and what their strengths and weaknesses are. He then explores how the similarities between different languages can be leveraged to help learn them. Finally, he'll address some of the challenges of developing multi-language applications.

In this session, you will learn:

• The strengths and weaknesses of different programming languages;

• Hear about how different languages can be applied together to solve problems more easily or more efficiently than with just a single language;

• About the forces behind the growing interest in language diversity;

• About the concurrency concerns that have created significant
interest in concurrency-oriented and functional programming languages
like Erlang, Ocaml, and Haskell;

• Different techniques for learning and using multiple languages;

• The challenges you will face, and how to address them, when developing multi-language applications.

• Rails Powered by GlassFish and jMaki with Arun Gupta, Sun Technology Evangelist for Web Services

GlassFish is an open source, production-quality and Java EE5-compatible application server from Sun. In this session, Arun will introduce GlassFish's features, specifically how it can be used to deploy Rail applications on the Java platform. 

Arun will then go on to present how rich widgets from multiple Ajax toolkits can be easily embedded in a Rails application using jMaki. He will describe the jMaki framework and show through multiple samples how Rails applications can provide a visually compelling interface.

In this session, you will learn:

•How to develop with GlassFish as a deployment platform for a Rails application;

•How GlassFish v3 Gem provides an alternative to WEBrick and Mongrel;

•How to use jMaki to embed rich widgets into your applications

• Tactical Design with Glenn Vanderburg, Chief Scientist, Relevance, Inc. 

When we talk about design principles and patterns, the discussion tends to center around classes and components, focusing on responsibilities and interrelationships at the class and package level. But there are useful principles that apply on a smaller scale as well - methods and method bodies, for example. 

In this session, we will explore some small-scale, tactical design principles. Glenn will demonstrate how these principles are easier to keep continually in focus during the development process, easier to understand for those with weaker design skills, and -- most importantly -- how they can guide you to better designs overall, even without a lot of focus on the "big picture."

Learn to write better code: Design skills represent a crucial foundation for the good programmer. Additionally, the industry is seeing a renewed emphasis on code quality as an enabler of ongoing project success.

In this session, you will learn:

• Crucial design principles that can be applied throughout the coding process, in both production code and tests;

• How to apply design principles throughout the development process;

• Better ways of talking about good design to junior programmers and teammates with weak design skills.

• The Busy Java Developer's Guide to Scala with Ted Neward, Author, Effective Enterprise Java and more

Concurrency represents a huge new problem for Java developers, as evidenced by the rising number of concurrency issues brought about by the widespread acceptance of multiple-core CPUs "in the wild." A functional language makes concurrency easier by both making it easier to write code without "side effects" (local state changes that need to be protected by atomic access mechanisms), and by offering new approaches to writing parallelizable code, in this case, using a new model known as "Actors."

In this session we will cover some of the interesting aspects of Scala, a new functional/object hybrid language from Martin Odersky (creator of Pizza, GJ and a major contributor to Java5 generics) that brings together the expressive power of functional languages (such as Haskell, ML or OCaml) with the object-oriented ecosystem on top of the Java  Virtual Machine.

With Scala, Java developers can write more expressive, more powerful code for the JVM without having to abandon the existing code already in Production, the power of the JVM, or the rich community that has grown up around the JVM.

In this session, you will learn how to extend your programming abilities to include:

• Case classes;

• Pattern-matching;

• Sequence comprehensions;

• Type-inferencing;

• Powerful concurrency-execution mechanisms.

Recommended general knowledge:

• An intermediate feel for the Java language and virtual machine.

• Unit Testing in Java with Frank Cohen, Founder of PushToTest, Author of FastSOA

While unit testing began as a way to test individual software classes and objects, unit testing frameworks are now available to test Web applications, Ajax applications, Service-Oriented Architecture (SOA) and Web services. Developers need to be aware of these frameworks to avoid duplicating efforts and increase their productivity by reusing unit testing frameworks.

In this session, Frank Cohen will take Java developers through the advanced topics in unit testing, including turning unit tests into functional tests, running unit tests on a scalable grid of unit testing nodes, leveraging unit tests build by developers in the software testing effort, correlating unit test results to frameworks that observe hot spots of performance, and providing operational data to unit tests at test runtime.  This session is technical and will show code-level examples.

In this session, you will learn:

• How to optimize Java unit testing efforts;

• How to turn unit tests into functional tests;

• How to run unit tests on a scalable grid of unit testing nodes;

• How to leverage unit tests built by developers in the software testing effort;

• How to correlate unit test results to frameworks that observe hot spots of performance;

• How to provide operational data to unit tests at test runtime.

Recommended general knowledge:

  • Unit test creation and operation;
  • experience creating or maintaining Web applications, Ajax applications, Web services or Service-Oriented Architecture (SOA) applications.

• Unit Testing Java with JRuby with Glenn Vanderburg, Chief Scientist, Relevance, Inc. 

Developers are divided about dynamic languages like Ruby, Groovy, and Python - The productivity advantages are compelling, but the lack of type-safety seems dangerous. In unit tests, however, the tradeoff is much clearer. For one thing, the advantages really shine: Dynamic language features make unit tests easier to write and maintain, and can make them more expressive as well.  Furthermore, since unit tests aren't production code, and tend to have fewer interrelationships, the risks are greatly reduced. 

In this session, we will explore techniques for using JRuby to write unit tests for Java code.  Although JRuby is the primary language of the talk, most of the techniques described also apply to Groovy and Jython.

In this session, you will learn:

• How to be more productive writing unit tests;

• How to produce tests that are easier to maintain;

• A strategy for gaining familiarity and experience with dynamic languages in a safe context.

More development-related sessions we recommend: