Programming Language BOF

Except Java and JavaScript we are just starting to get used to Scala, Groovy Clojure, JRuby, Jython as alternate languages on the JVM... then we have the second wave introducing languages as Kotlin, Ceylon, Xtend, Fantom and a couple of more.

This BoF is for everybody that wants to discuss programming languages. Bring your questions and your expertise for this informal chat.

Cloud Conversations BoF

In this Cloud Conversations BoF we will have an informal chat about what the Cloud is, whether we should use it, and what the options are. Bring your questions and your expertise for this informal chat about the Cloud.

Dart Language and Modern Web Apps

Modern Web apps are rich, snappy, and work offline and mobile, too. In this talk, we'll look at the frameworks and HTML5 features that make these possible and introduce Dart, a new language for structured Web programming. In particular, we'll take a look at the motivation for Dart, language syntax and features, the Dart Editor, using the Dart JS compiler, and improvements to the DOM. We'll take a look at several sample apps built with Dart and see how easy it is to use Dart with HTML5+CSS to create rich client applications.

AST Transformations

AST Transformations are how many language features are implemented, and is the magic behind frameworks like Lombok, Groovy, Mirah, IDEA Inspections, CodeNarc, Spock, and Groovy++. This session reviews these approaches including examples of how and why we'd want to do this. Come see the newest language tools, look in-depth at production deployed AST Transforms, and view libraries based on these techniques.

The Kotlin Programming Language

Kotlin is a new statically typed JVM-targeted programming language developed by JetBrains and intended for industrial use. Kotlin is designed to be fully Java-compatible, and at the same time safer, more concise than Java and way simpler than its main competitor, Scala. Also, IDE support is being developed in parallel with the language itself. Kotlin is under development. Currently, documentation describing the design of the language is available, and an initial beta release of the compiler is planned for the end of 2011. In the presentation, we will give an overview of the language and demonstrate the IDE support capabilities. The features we're planning to cover include: first-class functions (closures), pattern matching, null safety and automatic casts, extension functions, class objects, reified generics and declaration-site variance. Project homepage: http://jetbrains.com/kotlin

Application Security for Rich Internet Applications

In this session, you'll learn about the top security risks in web applications, and, with demos, how REST backends and rich JavaScript applications map to these risks. Current and upcoming countermeasures include new HTTP headers, double submit cookies, and escaping input client-side to avoid DOM-based XSS. We will look at each of these, discuss the techniques you?ll want to add to your developer toolbox.

Client-side Storage: When & How

With the increasing availability of HTML5 client-side storage APIs like localStorage and IndexedDB, web developers can choose to store application information locally. But what should you be storing, how long should you store it for, and what technology should you use? In this talk, I'll review the current storage APIs and libraries and give real world examples of how to use them across websites, mobile apps, and browser extensions both to improve performance and add functionality.

CoffeeScript: JavaScript without the Fail

JavaScript. Love it or hate it, in the web development world it's impossible to avoid it. It was designed in one week by one man at Netscape, just to keep the browser from standardising on something even worse—and it shows. Oh, it's not all bad, but the Good Parts—which actually make up a pretty neat language—are well hidden in among all the Bad Parts, which are there to make you, the JavaScript developer, suffer.

CoffeeScript is a language designed to take the Good Parts out of JavaScript and make a new, concise and beautiful language out of them. It runs anywhere JavaScript does—in fact, it compiles to fairly readable JavaScript—so you can already use it in your web applications and wherever else you've been stuck with JavaScript. In this talk, you'll learn what CoffeeScript looks like, how it relates to the JavaScript you know, and what new features it has to offer. In fact, if you already know JavaScript well, you'll probably be perfectly fluent in CoffeeScript after this—it's that easy. And trust me, your life will be so much better for it.

Play Framework 2.0

The Play framework has brought high-productivity web development to Java with three innovations that changed the rules on Java EE: Java class and template save-and-reload that just works, a simplified stateless architecture that enables cloud deployment, and superior ease-of-use. Following Play's rapidly-growing popularity, Play 2.0 will be released in early 2012 with innovations that are not just new in the Java world: type safe view templates and HTTP routing, compile-time checking for static resources, and native support for both Java and Scala.

Type safety matters. After dynamically-typed programming languages such as PHP and Ruby set the standard for high-productivity web development, Play built on their advantages and has created a type safe web development framework with extensive compile-time checking. This is essential for applications that will scale to tens of thousands of lines of code, with hundreds of view templates. Meanwhile, Play avoids the architectural-complexity that is promoted by Java EE-based approaches. The result is that Play 2.0 first enables rapid initial application development and then Play 2.0 helps you build big, serious and scalable web applications.

Duchess BOF - How to benefit from networking with other women in IT.

Duchess is a network of women who are interested in Java technology, created to support and promote women in the Java industry. If you are both female and interested in Java technology, join us to network and share your knowledge and experiences. This BOF is organized by Duchess World Wide and Duchess Sweden. We will have a discussion about the role of women within both Java and IT in general, and we will also discuss how different people can benefit from networking in different ways. We think that these are important topics that need special attention. Everyone will be welcome to join this discussion, men as well as women. We have previous experience with organizing similar sessions, for instance at Devoxx, JavaOne, and others. Duchess: http://jduchess.org/

The OpenJDK Community BOF

Informal gathering with OpenJDK committers and enthusiasts - bring your questions about OpenJDK and we'll try to answer them.

Comparing JVM Web Frameworks

One question developers often ask is "What web framework should I use to build my application?" High-traffic sites (e.g. eBay, LinkedIn, Twitter, Overstock) have proven that the JVM is a great platform for web scaling. This session takes a look at the top web frameworks for the JVM and discusses various methodologies for choosing one. It describes two different techniques (a matrix and performance testing) and pros and cons of the top frameworks from each.

Framework included: Grails, GWT, JSF 2, Lift, Play, Ruby on Rails, Spring MVC, Stripes, Struts 2, Tapestry 5, Vaadin, Wicket

The Curious Clojureist

-Why should you learn Clojure now? It?s the coolest new language on the JVM -What makes it so cool? It?s a dynamically typed, functional Lisp that offers sophisticated capabilities like software transactional memory -Why should I learn it? Lisp is the most powerful style of programming language possible (don?t believe me? Come see - I?ll show you), so you get the best language (Lisp) on the best runtime (JVM) -Isn?t Lisp the one with all the parenthesis? Yes. -What?s so compelling about Clojure? It?s fast, expressive, powerful, and allows you to do all sorts of things that other languages won?t let you do. It?s an elegant language. -Why is the entire talk done as question and answer? It?s an homage to a series of books, The Little Lisper and The Little Schemer. Because Lisp?s are simple and homoiconic, this style works nicely for them. Besides, it?s better than 1000 bullets, isn?t it?

JavaScript bonanza - the modern developer story

There is a bonanza going on in the JavaScript world which changes everything. JavaScript performance is increasing by orders of magnitude enabling web applications no one dreamed possible. Frameworks emerge and evolve at a breathtaking rate. This effects everyone, including you. With small efforts you can ride this wave and benefit from all the greatness. This session will give you the inside scoop on the current JavaScript landscape, how it has evolved and where it is heading. You will see a standard java web application and learn how it can be modified to a cleaner and more responsive architecture by adding JavaScript. I will also show how to run and debug Java and JavaScript together and what tools to use. These skills will make you as a java developer look and feel stronger and more empowered, and you will become best friends with the UX department.

Stop sleeping, start awaiting!

Testing asynchronous systems is hard. Not only does it require handling threads, timeouts and concurrency issues, but the intent of the test code can be obscured by all these details. Awaitility is a small Java based DSL that allows you to express expectations of an asynchronous system in a concise and easy to read manner. Come and see how easily fragile time consuming tests can be transformed into its more robust and elegant counterpart.

The road to REST

Building REST API's for distributed applications is becoming more and more popular. But, there is one thing that most developers miss, which is the HATEOAS requirement, i.e. linking. This session will explain how exposing use-cases brings a natural solution to this problem, and how this will simplify both API development, documentation, as well as client development.

Vad Clojure lärt mig om objektorientering (som jag inte lärt mig av Java)

Trots att Clojure är ett i grunden funktionellt språk innehåller det många aspekter av objektorientering. Genom att studera Clojure får man upp ögonen för nyanser av objektorienterad design som man inte stöter på i rena Java-sammanhang. Jag vill ge några tankeväckande exempel på områden där jag tycker att Clojure uppmuntrar objektorientering på ett enklare sätt än Java.

Enterprise Integration Patterns and DSL with Apache Camel

Apache Camel, a very popular integration framework, builds on the principles of the EIPs (Enterprise Integration Patterns) and DSLs (Domain Specific Language). In this talk we show how integration can become much easier and accessible with Camel. By wiring together EIP patterns, processes and transports, integrating becomes as simple as building routes "lego style.", The wiring is done using the Camel DSL. We will cover some of the most used EIP patterns such as Splitter, Aggregator, Recipient List, Dead Letter Channel, Idempotent Consumer etc. And give pointers about tips and tricks along the way. This talk includes live demos that show how to build integration flows in the four DSLs: plain Java, XML, Groovy and Scala. We will also show you how you can use Eclipse tooling to build routes using a graphical drag'n'drop environment, as well how to gain insights into running Camel applications, such as message tracing.

Unleash Your Domain

Our application runs over 10,000 sustained transactions per second with a rich model. The key? Modeling state transitions explicitly. In today's world many systems have non–functional requirements that prevent them from being single database centric. This presentation looks at how Domain Driven Design can fit into such environments including extremely large scale web sites, batch processing, and even using highly scalable backing stores such as CouchDb or HyperTable. Event streams, a different way of storing the current state of an object, open many doors in this session not only in how we scale and store our domain but also in how we rationalize about it

Agile Architecture - Design For Replaceability.

The most important question to be asked when developing a new software system is "How will we replace it?" It is however a question seldom asked. Instead organization focus on reusability, which unfortunately helps create rigid and inflexible architectures. The talk shows how to design systems made up of small parts, why you should standardize on protocol and not platform and how you will end with a system that is easier to scale and maintain.

Patterns of Agile Enterprise Architecture

There is widespread acceptance that software development using Agile methods works well. However, there are still areas of software development organisations that view their roles or mandates as incompatible with Agile methods. This talk addresses the legitimate role of an Enterprise Architect and provides concrete recommendations on how Architects can work with Agile development teams to accomplish their objectives. Topics will include concerns about data architecture, addressing the "ilities", and why evolutionary architecture works.

An Intro to Hadoop

Enterprises today collect and generate more data than ever before. Relational and data warehouse products excel at OLAP and OLTP workloads over structured data. The open-source project administered by the Apache Software Foundation known as Hadoop, is designed to solve a different problem: the fast, reliable analysis of both unstructured and complex data. As a result, many enterprises deploy Hadoop alongside their legacy IT systems, which allows them to combine old data and new data sets in powerful new ways. Technically, Hadoop consists of two key services: reliable data storage using the Hadoop Distributed File System (HDFS) and high-performance parallel data processing using a technique called MapReduce. This technology opens the door to new enterprise solutions, as you no longer have to predict how you want to search or query your data in future use cases! This technology is playing a key role in the new trend of Big Data that is taking off in a rapid speed within huge enterprises. Come see this talk to get an intro to Hadoop, what it is, and what it can do for you - and how you can get involved to influence the future!

Jenkins Evolutions

Jenkins is believed to be a continuous integration tool, but in reality it is an orchestration platform with a GUI. The large set of plugins and the loose definition of projects lets you use Jenkins for operations that it was not originally meant for. We use it for building software, artifact propagation, release management, VCS branch propagation, cron replacement, server monitoring etc. In this session, I will go through the different successes and failures that we?ve experienced in the past years of using Hudson/Jenkins to get our products and company off the ground.

MongoDB and JVM: Bringing NoSQL and Java Together

MongoDB is a scalable, high-performance, open source, document-oriented NoSQL database. It features document-oriented, JSON-based document storage and dynamic schemas providing simplicity, power and flexibility, combined with full indexes similar to what a traditional RDBMS user would expect. MongoDB also provides solid replication & high availability features as well as an auto-sharding system for transparent horizontal scalability. This talk introduces MongoDB for developers who aren't familiar with it, and discusses various integration points for MongoDB & the JVM including Spring's "Spring Data" component for MongoDB, the Morphia Object Mapper for Java, MongoDB's Scala Drivers (Casbah, as well as a new experimental Asynchronous driver), Akka Durable Mailboxes, Lift's MongoDB Active-Record integration, and MongoDB's Hadoop integration.

Eclipse Xtend - A Language for Java Developers

Are you waiting for closures in Java 8 or hoping for more type inference in Java 9? Thinking about switching to Scala or even holding your horses for Ceylon or Kotlin? How about keeping Java where it seems fit, but replacing just its outdated parts with a concise and modern language? What about an enhancement to Java instead of yet another attempt to hire a killer.

Xtend is an open-source programming language hosted at Eclipse.org and built for Java developers. It reuses Java's keywords, terminology and concepts as much as possible, but abandons some dead freight at the same time. Xtend is a very powerful alternative for implementing Java classes and works great with all the existing libraries. Since the language can be seen as a little complementary add-on to Java, it offers many modern language features that you are currently missing in your daily work. Xtend comes with a variety of goodies reaching from type inference over closures and extension methods up to smart string interpolation that make development great fun again. And of course there is powerful Eclipse IDE tooling available.

In this session we will demonstrate why Xtend is so great for everyday programming. You will get an introduction to the seamless integration with the Eclipse Java IDE and an impression of the expressiveness and conciseness of the language.

JavaFX 2.0 from a developer's perspective

JavaFX is an environment for building rich client applications. Using a scenegraph at its core and providing many advanced features, e.g. effects, animations, media-support, it greatly simplifies the task of implementing expressive user interfaces with engaging user experience. The API is entirely provided as a Java API making it also available for other programming languages that run on top of the JVM. In this talk we will take a look at JavaFX 2.0 from a developer's perspective. Explaining the underlying concepts of the API and touching some of the more advanced features, all major components of the API will be covered. After this talk you will have a clear understanding of the possibilities JavaFX 2.0 provides, which will enable you to make sound decisions how it may help you in your future projects. You will also be aware of the basic concepts which will help you to get started quickly with JavaFX 2.0.

Migrating Spring Applications to Java EE 6

The Spring Framework has no-doubt played a major role in evolving the way we write enterprise applications on the Java platform today. However, it is still a proprietary framework owned by a single company. The age of having to rely on such proprietary frameworks in order to develop decent enterprise applications is now over and Java EE 6 has become an even easier way to develop enterprise applications based on standards which makes it the best choice for any enterprise application. In this session you will experience how to migrate a typical full stack Spring application to a standards based, completely portable, Java EE 6 application including integration tests.

Maven vs Gradle, On your marks, get set, go!

Ant, Maven, Gradle, Buildr - the choice of built systems for Java based systems is manifold and only discussions about coding styles are getting more heated than discussion on which built system is superior. In this talk we are looking at two built system - the well established veteran Maven against the Groovy based newcomer Gradle. Where are the similarities between these two built systems and what differentiates them? Why and when would you chose one over the other? Both built systems are introduced by examples and the Open Source project Hibernate is used as a case study for a migration from Maven to Gradle. We will learn why this migration took place and what the lessons learned were.

Java 7 - State of the Enterprise

With Java 7 being GA you can start thinking about putting it to work in the Enterprise. But what are the challenges? How does the adoption path look like? What are the reasons you should do it and when? This session looks at the details about putting Java 7 into production. Tells you about things to keep in mind and gives a brief overview about how Enterprises would put it into production.

JDK 7 Updates & JDK 8

We'll first take a quick look at how the JDK 7 Updates Project in OpenJDK works, how to track changes, and follow along as e.g. the Mac OS X Port gets integrated into future JDK 7 update releases. Then we'll switch gears, take a deep breath, and dive into some of the planned features of the next Java SE Platform, JDK 8 - modularity, lambdas, and more!

A JVM Does What?

Just what the heck is a JVM *supposed* to do? JVMs already provide a host of services. The 'J' part definitely slants the service selection and the 'V' part means that underneath the illusion there's a lot of really cruddy stuff. The success of these illusions has led to the real popularity of JVMs. In particular, JVMs are probably the most popular way to distribute ready-to-use GC technology to the masses, and the 2nd most popular way to distribute ready-to-use compilation technology (just behind "gcc" I'm guessing).

Just what are these illusions? The illusion that bytecodes are fast and have a reasonable cost model : (machine code generation, profiling, JIT'ing). The illusion that you can quickly change the program at any time (dynamic class loading, deoptimization, re-JIT'ing). The illusion of infinite memory (Garbage Collection). The illusion of a consistent threading and memory model (the JMM, volatiles, locks). The illusion of quick time access (i.e. Intel's "rdtsc" is mostly useless for time). The illusion that these other illusions all work on all sorts of machines from cell phones to 1000-cpu mainframes (it's kinda sorta mostly true). But these are not enough! The People cry out for more illusions! The illusion of an Infinite Stack (tail recursion), the illusion that running-code-is-data (closures), the illusion that Integers are as cheap as 'ints' (autoboxing optimizations), or that BigIntegers are as cheap as 'ints' (tagged ints), the illusion that memory supports atomic update (software transactional memory), or the illusion that with enough hard work other language implementation experts can make a JVM run utterly different languages (invokedynamic). Meanwhile, JVM engineers labor under the illusion that they can maintain this giant piggy pile of code, and maybe even expand the provided services without it collapsing under it's own weight.

Here's my take on what services could & should be provided by a JVM, what services probably belong to the next layer up (STMs, new concurrency models), and what services belong to the next layer down (fast time management, sane thread scheduling).

Enterprise Java in 2012 and Beyond

The Java space is facing several disruptive middleware trends. Key factors are the recent Java EE 6 and Java SE 7 platform releases, but also modern web clients, non-relational datastores and in particular cloud computing, all of which have a strong influence on the next generation of Java application frameworks. This keynote presents selected trends and explores their relevance for enterprise application development, taking the most recent Java SE and Java EE developments into account as well. In addition, the Spring Framework will serve as a reference example for an application framework on top of modern deployment platforms. Topics include flexible deployment, web endpoints, caching abstractions, access to alternative datastores, and patterns for concurrent programming.

Tuning the HotSpot JVM's Garbage Collectors

The HotSpot JVM has been refined and revised with every release of the JDK since the advent of Java in the mid 90ies. Today, Java developers face an abundance of GC algorithms - from plain and simple serial stop-the-world collectors with a single reaper thread to highly parallelized collectors that run several GC threads concurrently with application threads. Each of these collectors can be configured and tuned in various ways in order to control pause times or increase throughput. The number of choices a Java developer has for configuring the JVM:s garbage collection for his application is overwhelming. Hence, garbage collector tuning for the SUN/Oracle JVM is a daunting task. The talk aims to shed light onto the garbage collection strategies in the Sun/Oracle JVM by explaining all algorithms (including Java 7:s Garbage-First collector) and discussing strategies for tuning and configuration of the various collectors.

jHome: Having Fun with Home Automation and Java

jHome is complete Java EE 6 API for home automation. With jHome you can control wall jackets, lamps, RGB LEDs, gates and much more. The reference implementation application is using EJB's, REST, WebService, JMS, JSF and jQuery to show how you can use Java EE 6 in a totally different application context. The proposed hardware is open-source, so you do it your self. During the talk we will be showing nice and funny demos: - Controlling lamps; - Color RGB led stripe; - Controlling via Twitter; - Feed a web page with a temperature sensors. We also will be showing the software architecture and some pieces of interesting code.

From Swing to HTML5 Canvas

Short overview of what you have be aware of when you try to create a HTML5 port of your custom Java Swing components. Unfortunately one could not simply convert the Swing component to HTML5 but with a little knowledge and fortune one could port most of the Java2D code to HTML5 Canvas. As an example a gauge from the Java Swing library "SteelSeries" will be ported to HTML5 Canvas.