Native clients for iPad and Android is available on market. Enjoy downloaded talk for off line viewing experience with presentation and speaker synced.

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

Zero Downtime Continuous Deployment of Java Web Applications

This presentation will show how to create a continuous deployment process with zero downtime for Java web applications. Using tools like Hudson/Jenkins, REST services and open source application servers, you'll learn through real world examples how to create a secure and error free continuous deployment process for your application. We will also show how to deploy to cloud based servers, like Amazon AWS, what are pitfalls and limitations for these cloud offers and how you can overcome them

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

Vad Clojure lärt mig om objektorientering

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.

It Is Possible to Do Object-Oriented Programming in Java

OO means different things to different people, but they normally focus on defining terms such as encapsulation, polymorphism and inheritance, and talk about data abstraction, abstract data types and so on. In this talk we take a brief look at what one particular theory of OO suggests and what it means for regular Java programmers and their practice.

SQL, NoSQL, NewSQL? What's a developer to do?

In this presentation you will learn about popular NoSQL databases - MongoDB, and Cassandra - as well at VoltDB. We will compare and contrast each database's data model and Java API using NoSQL and NewSQL versions of a use case from the book POJOs in Action. We will learn about the benefits and drawbacks of using NoSQL and NewSQL databases.

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.

Tuning the HotSpot JVM's Garbage Collectors

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.

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.

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.

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.

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.

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.

Up and out: Scaling software with Actors

We believe that one should never have to choose between productivity and scalability, which has been the case with traditional approaches to concurrency and distribution. The cause of that has been the wrong tools and the wrong layer of abstraction and Akka is here to change that. Akka is using the Actors together with Software Transactional Memory (STM) to create a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). With Akka 2.0 this will be taken to a whole new level, and in this presentation we will talk about "Distributed by Design", how it scales from small projects to huge projects, and how we've projected what we've learned during the 1.x series into the 2.x series.

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!

Regex Applied - When Regex is a Winner

Everyone knows that Regex (Regular Expressions) can make fascinating tricks. Some people know and other people suspect that regex can do valuable things ? sometimes. Some problems are more suited for regex solutions than others. What are the common traits of those problems? How should we think in order to solve them? What alternative solutions are there? Staffan categorizes and exemplifies when you should and should not use regex. He'll also show how to do refactorings using regex, from the Search/Replace dialog in text editors like Eclipse and Emacs.

Tesla - the Maven successor

Tesla is a new build framework by the original founder of Apache Maven, Jason van Zyl. In simple terms it can be described as a superset of the Maven tool and is designed to kickstart the development of software projects. It's fully compliant with Maven builds but has many new features which will help you in areas where Maven comes up short. This talk will cover the basics of Tesla, describe the new features compared to Maven, and also show how Tesla will work in your existing Maven-based development infrastructure.

Android: A Security Analysis

This session provides a security analysis of Android stack (a.k.a Android OS) from software, application development, programming constructs, all the way down to hardware-specific features of Android devices (mobile phones, tablets, and other consumer electronics devices.) Specific attention will be paid to Android applications and use cases where security is not a "nice to have"; rather, it's a "must-have" (such as payment, identity binding, and generic authentication.)

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).

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?

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!

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.

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.

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

Scrum & XP - beyond the trenches

4 years have passed since I wrote "Scrum and XP from the Trenches". What have I learned since then, and what would I have done differently if I could go back in time? During the past few years I've mostly been "trench-hopping", i.e. helping lots of different organizations implement agile software development in practice, and talking to other people that do the same. Consequently there are now several things in the book that I don't agree with any more, so this talk is the first step towards a followup article :o)

To be relational, or not to be relational? That's NOT the question!

This session aims at guiding you on the journey from using a single relational database server, to making it as scalable as possible and choosing proper alternative solutions: explaining pros and cons of tools available depending on your needs, their impact on your architecture, the concepts and algorithms under the hood, and when NoSQL should really be Not Only SQL. This session should be attended by developers and architects that plan on delivering applications in the next couple of years, as the future is now and you can't get struggled with hamletic questions!

Top SOA Tips - A Road to a Successful SOA Implementation

In this session Jeff Genender explores the key characteristics of successful SOA projects. He covers some of the patterns, and anti-patterns, tool sets, and strategies that he himself learned the hard way through his own trial and error experiences as an architect. Last, he provides a strategy and blueprint for achieving a high likelihood of success in your SOA project.

The Future Java Developer

New languages, work environments, technologies, and devices. Clouds roll in bringing new rules. The future is now, what comes later? Java developers thread on a fine line between working standards and bleeding edge science-fiction experiments. What are the possibilities for the future? Can new languages available for the JVM warp the realities of software development? Will Java really be part of the new flock of devices? Cloud computing is changing the game, how Java is a fundamental part of it? New enviroments affect our code and skills we must have, how does our experience count? Are we prepared? This session will explore possibilities for the future of development, sharing insights on what's coming up in the future of Java.

Java EE 6 Toolshow

The Java EE 6 platform improves on the Java EE 5 developer productivity features. The true potential of this platform can be unleashed using tools and IDEs to quickly create Java EE 6 compliant applications. It will demonstrate how NetBeans, Eclipse, IntelliJ, JDeveloper, and Maven makes developers life easy in creating Java EE 6 applications. The attendees will learn several tips & tricks for each IDE to boost their productivity.

Git Going with DVCS

Get on board with Git, a distributed version control system. Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository and connectivity redundancy (at $0 cost).

Folding Together DDD and Agile

This talk will consider ways of incorporating modeling and design into the iterative process in a lightweight way that increases communication with stakeholders and decreases the likelihood of painting ourselves into corners, without returning to the deadñhand of the analysis phase.

Abstraction distractions

Computer science is built on a shaky tower of abstractions, but we've been distracted by other things until we believe it is reality. This Keynote teases apart some of the tangled abstractions that have become so common they are invisible yet impact important decisions. It will cover languages, tools, platforms, and burrow all the way down to fundamental concepts.

Designing RESTful Domain Application Protocols

REST is ready for the enterprise. Imagine an information platform that is open and available to systems throughout the enterprise estate. A platform that eschews integration in favour of composition, connected data over siloed databases. In this session I show how to design and implement RESTful domain application protocols for complex business processes.

Binary patching of Java classes for fun (and profit).

The what/why/how of runtime binary patching of JAVA applications, frameworks and application servers to provide custom integration. We will follow the JRebel integration story from dirty bytecode insertions to readable Java code patches. The session is intended for advanced Java developers interested in patching or integrating with binary java applications.

Cloud Computing with Scala

The topic of this presentation is about using Scala programming language as a part of a simple and productive cloud computing platform. Scala is a hybrid function and object-oriented language that is rapidly gaining traction in becoming the next Java in JVM-based language evolution. GridGain is one of the cloud development platforms for JVM-based languages.

JDK7 Update

This session will look at a number of the new features in development in JDK 7 and how they affect developers. We'll take a close look at the current status of JDK 7 development, and learn how you can keep up to date, get your hands dirty with the code & provide useful feedback on planned features.

Ubiquitous Language

Apart from being hard to say, ubiquitous language seem to be the hardest part of Domain Driven Design to grasp. We dive into what is meant with a "language" in this context, and how it is linked to domain modeling. Of course there will be philosophy, but the focus will be on how to make the practice valuable to our development effort.

HTML5 APIs - The New Frontier

HTML5 is upon us and it offers a wide range of exciting possibilities when it comes to developing rich web interfaces. This talk will introduce you to a number of them and hopefully inspire you to create amazing things!

Visualizations for Code Metrics

Judicious use of metrics improves the quality of your code. But interpreting metrics presents a challenge. You have a list of numbers for a project - what does it mean? And what does it tell me about the health of the project overall? This sessions shows how to produce visualizations for software metrics, making them easier to understand.

Architecture remakes with DDD, true stories from the wild

Applications have a tendency of becoming harder and harder to maintain over time. In my experience, DDD is often used for describing the new target architecture. In this presentation we have distilled a set of common key possibilities in such situations, both how they can be achieved and what benefit they will give.

JRuby + Rails = Awesome Java Web Framework!

When looking for a productive, innovative web framework for a Java environment, who says it has to use Java the language? Rails is the framework that sparked a new wave of innovation in web development, and it's available on the JVM, via JRuby. With Rails 3 allows you to mix and match components, making it easier to use existing Java code.

An interactive approach to load testing with JavaFX, Groovy and OSGi

This presentation will start with a short demo of a novel distributed load-testing tool, loadUI, that makes load-testing into something interactive and fun by providing an extremely "playful" javaFX interface on top of a groovy-centered component framework. The demo will be followed by an overview of utilized technologies and of the groovy DSL used for creating components.

NoSQL consistency models and transactional semantics

NoSQL technologies often use different models for failover, high availability, and multi-data center support than traditional databases. In this session we will review how traditional database and how NoSQL sometimes offers a different approach to these problems.

Future-proofing collections: from mutable to persistent to parallel

In this talk I will describe the new Scala collections framework, and show how it allows a seamless migration from traditional mutable collections to persistent collections, and from there to parallel collections. I show how the same vocabulary of methods can be used for either type of collection

Overview of NoSQL

This talk is an overview of the four main categories of NoSQL databases: Key-Value Stores, ColumnFamily implementations, Document and Graph databases. We'll compare and contrast the major players of each type. You will take a way a better understanding of what your choices are, and what scenarios each database type is meant to solve.

Terrastore: document database for developers

This is a rundown on the Terrastore "NOSQL" store, providing a quick introduction to its most important features and how it will boost your productivity in developing data-centric applications.

Domain Driven Security Code Kata

The top two risks for applications where Injection Flaws and Cross-Site Scripting (XSS) according to OWASP as well 2007 as 2010. Time to do something about it. In this code kata we address both Injection Flaw as well as XSS by applying techniques from Domain Driven Design - thus Domain Driven Security.

Test-driven Regex Development

There are many popular myths concerning regular expressions (Regex). First, it's exceptionally hard to master Regex. Second, a normal programmer rarely needs Regex. Third, Regex are tricky to read and hence can't be maintained. That is all wrong!

The Java EE 6 Programming Model Explained

In this session, we'll look at the Java EE 6 programming model as a whole, then dive into the different layers of a typical Java EE Web application and show how to implement them using the latest Java EE features with the help of a modern IDE.

Scala, from newbie to ninja in less then one hour

We started learning Scala in spring 2010, and have probably encountered about every pitfall the language has to offer by now. And that's a lot. In this talk, we'll demonstrate some of them in way that's fun and easy to follow, present solutions to common problems and give you a head start to learning Scala.

Programming in pain

Achieving programming concepts you have at hand with Scala in pure Java does rarely bear its weight. In this talk we'll go through some of the things a Scala-trained programmer will start to use in Java. We'll look at the things you can achieve easily and show examples for when you'll miss Scala.

A new dimension for Android

With the new year we have a new version of Android available. There is also new hardware coming on the new devices that will enable developers to do some really exciting things. Come listen to what Sony Ericsson is doing with Android and see what makes the most entertaining smartphone to date.

Google Cloud Computing for Java Developers: Platform and Monetization

This session will provide developers with an overview of Google Cloud computing services and monetization opportunities: Google App Engine Java: Developers can leverage Google's cloud infrastructure to run their Java applications at scale, leveraging Java standards such as Java Servlet, Java Data Objects, and Java Persistence API.

What's New in Google Web Toolkit

Google Web Toolkit (GWT) lets you build and optimize rich browser-based apps without having to be an expert in browser quirks, XMLHttpRequest, or JavaScript. In this talk, we'll look at powerful new capabilities in GWT 2.1 including MVP architecture with Activities and Places, client-server communication with RequestFactory, visual layout with GWT Designer for Eclipse.

The Secrets of Concurrency

The talk does have something for everybody, but is mainly aimed at the intermediate to advanced developer. What you will get out of the talk: You will learn several tips that will help you in writing correct threaded code in Java.

Running your Java EE applications in the clouds

GlassFish, the Reference Implementation of Java EE 6, can easily run on multiple cloud infrastructures. This talk will provide a brief introduction to Java EE 6 and GlassFish v3

Emergent Design

The talk does have something for everybody, but is mainly aimed at the intermediate to advanced developer. What you will get out of the talk: You will learn several tips that will help you in writing correct threaded code in Java.

Top reasons why you should switch to Maven 3

This session will be a countdown of the top ten reasons why you should switch to Apache Maven 3.0, as well as pointers to a few changes that could break your project and how to deal with them.

What a crazy year it has been

The 12 months following this have arguably been among the most eventful, at least in the public eye, in the history of Java. We will do a year in review, comparing press coverage with actual events and tell you what has happened in 2010 to make the Java ecosystem stronger than ever. In what direction is Java heading? What are Oracles plans?

Yet more performance tuning

The session will further demonstrate a performance tuning methodology that has been presented at previous Jfokus sessions. Following the methodology allows one to progress from diagnostic to diagnostic to a diagnosis in a matter of minutes.

Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors & STM

We believe that writing correct concurrent, fault-tolerant and scalable applications is too hard. Most of the time it's because we are using the wrong tools and the wrong level of abstraction. Akka is here to change that!

Portrait of a Developer as a Kid in a Candy store

There has never been a better time to be a developer! This presentation will give you an overview of Google developer tools and open standards that help developers create these applications: Browsers (html5, w3c geo, svg), Mobile (android), Cloud (appengine), Social (Opensocial), Geo (Google Maps).

NoSQL, One size fits all: A concept whose time has come and gone

Major Internet companies, including Google, Amazon and Facebook, are taking an alternative approach to the traditional SQL database. The primary reason is that the existing SQL database doesn?t fit their scalability requirements. Does this mark the end of the relational database era?

How to save 3-7 weeks a year

This summer, over 1100 developers reported that they waste an average of one month per year waiting for builds and redeploys. In 10 minutes, we'll show you how to get that time back, without the need to re-engineer your applications or change the way your team works

Prestanda, skalbarhet och tillgänglighet för stora system

Internetpoker är en av de mest avancerade realtidsapplikationerna du kan tillhandahålla över nätet. Du behöver inte bara bygga ett tillräckligt snabbt system, det måste vara tillräckligt snabbt oavsett antalet användare och dessutom tillgängligt utan avbrott. bwin har nyligen releasat en ny generation av sitt pokersystem som lägger ribban högt med avseende på icke-funktionella krav. När du bygger en tjänst som används av 10 miljoner användare och 45 000 samtidiga spelare så måste du ha tänkt igenom din arkitektur

Deep dive on the Java EE 6

J2EE was reliable and scalable but somewhat verbose and sometimes inflexible. Java EE 5 adopted new principles (POJOs, annotations, default behavior) to ease the development paradigm and was certainly the biggest release ever. Java EE 6 also has a lot in store for server-side development - some more ease of development, a web profile, unified injection, lighter-weight components, RESTful integration, and major enhancements to the EJB, JPA and JSF specifications. This presentation will offer an overview of Java EE 6, new EJBs, simplified packaging, improved persistence layer, new API for RESTful services, a validation framework, a radical simplification of the web layer and ... many other improvements.

Why Your Agile Roll-Out is Failing

You read the books. You went to the talks. You even paid for the 3 day course. Then you rolled out Agile across the organization. What could possibly go wrong? Why, after 18 months, are you not seeing the better-faster-cheaper results they guaranteed you? And where can you get your money back? Rather than paying for yet another Agile consultant to come in and tell you how you're doing it all wrong, come along to Dan's talk about the most common failure modes he encounters in Agile adoption.

Introduktion till Clojure för Javautvecklare

Clojure är ett generellt, funktionellt, dynamiskt, starkt typat programmeringsspråk som körs på JVM:en. Clojure är en modern Lisp-dialekt som genom sin nära integration med Java redan från start har tillgång till ett mycket omfattande utbud av API:er och tredjepartsbibliotek. I denna intensiva femtonminutersintroduktion till Clojure för Javautvecklare kommer vi att få lära känna språket lite närmare. Du som lyssnar på denna presentation kommer att få med dig en översiktlig förståelse för Clojure som språk och det du behöver för att på egen hand börja utforska språket.

Scaling Real-World Large Financial Systems, from iPhone to Cloud

John Davies will take a short but technical deep dive into the world of FX, equity and derivative trading. With demands for extremely low latency, massive volumes, absolute transactional integrity and a daily turnover in the billions, the trading community has been at the forefront of technology for decades. John will talk through the technologies, practical problems and technical solutions in this industry. From low-latency algorithmic trading to back-testing from over a peta-byte of data to mobile device integration. He will explain how to move the grid into the Amazon cloud and how many clients are using Amazon's EC2, EBS and S3 for delivery onto iPhones and Android.

Introduction to Cloud Computing

Cloud Computing sounds fluffy, so what are the real-life benefits? And how can I start using the Cloud today, in my own projects? The first step: Getting more power at a low low cost How can we use the cloud today, by moving parts of our application or environment to the cloud? We'll share our hand-on experiences with developing using the cloud for everything from testing to deployment. The next step: Scaling out in the cloud The cloud brings new issues and concerns. How do you best store data if it's stored in distributed data centers? How can you ensure data consistency when ACID-style transactions are your biggest bottleneck? How will it affect your architecture that servers are added at any time?

Java Performance Antipatterns (15 min)

Java performance is seldom as easy as it looks. Spending time optimizing Java code might easily lead to worse results. This talk introduces some common Java performance antipatterns and show how you trick yourself and the JVM.

The Benefits of Graph Databases

Most applications today handle data that is deeply associative, i.e. structured as graphs (networks). The most obvious example of this is social networking sites, but even tagging systems, content management systems and wikis deal with inherently hierarchical or graph-shaped data. This turns out to be a problem because it?s difficult to deal with recursive data structures in traditional relational databases. In essence, each traversal along a link in a graph is a join, and joins are known to be very expensive. Furthermore, with user-driven content, it is difficult to pre-conceive the exact schema of the data that will be handled. Unfortunately, the relational model requires upfront schemas and makes it difficult to fit this more dynamic and ad-hoc data. A graph database uses nodes, relationships between nodes and key-value properties instead of tables to represent information. This model is typically substantially faster for associative data sets and uses a schema-less, bottoms-up model that is ideal for capturing ad-hoc and rapidly changing data. This session will introduce an open source, high-performance, transactional and disk-based graph database called ?Neo4j? (http://neo4j.org), which frequently outperforms relational backends with >1000x for many increasingly important use cases.

The Pair Programming Show

Did you ever wonder what makes pair programming tick? Or maybe why it didn't work well when your team tried it? Are you considering trying it but not sure it it's worth it? Then, this play is for you.

Pragmatic Real-World Scala

In this talk we will give you an introduction to Scala from a Java/JEE and real-world perspective. How to make effective use of Scala's richer OO abstractions and type system to create more flexible and reusable components and systems. How to take advantage of Scala's FP nature for more clean, safe, conceptually coherent and deterministic code.

Meet Puke!

But fear no more, we say! Meet Puke, the street-wise coding cousin of good ol' Duke. She doesn't care what the others think. Instead, she knows that beautiful code is code that works for the customer, and that there is no orthodox way to that working code, only ways that cost more and ways that cost less. Some say Puke is a threat to quality.

Controlling Your Architecture

Agile architectures is a key ingredient to create systems that will last over a long period of time, but how do we achieve them? This presentation will show you how to control your architecture with common tools and some clever code to create solid and help you achieve long lasting systems.

Faster Java, the VM perspective

The time when Java could be considered slow is long gone. This presentation gives you a quick look at what is going on behind the scenes - how the JVM transforms your Java code into machine code, and the tricks and techniques employed to squeeze the maximum performance out of it.

JavaFX in Action

This jam-packed talk will detail JavaFX from cover to cover. Come learn about this exciting new technology from Sun Microsystems for creating compelling rich internet applications on the Java platform.

Concurrent and Performance Reloaded

Net Framework + Java = sant

Power and Elegance of WebBeans

Scrum Shock Therapy

Domain Driven Design - DDDSample, en introduktion

Interview about DDDSample

Interview with Patrik Fredriksson and Peter Backlund about DDDSample

From good to great developer

Java 6 upd 10, ease of deployment and Java SE 7

Interview with Rickard Öberg about Qi4j

Interview with Rickard Öberg at Jfokus 2009 about Qi4j and Composit Oriented Programming

Groovy and a first step into DSLs

Whats New and Exciting in JPA 2.0

Hibernate Search

KeyNote: JavaFX: The Platform for Rich Internet Applications

Stealth Scrum: Being agile in waterfall organizations

Javaplattformens framtid