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
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
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.
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.
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.
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 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.
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 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.
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.
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.
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.
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.
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!
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 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.
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.)
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).
-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?
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!
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.
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.
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
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)
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!
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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
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.
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.
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!
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.
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.
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.
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.
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.
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?
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!
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).
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?
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
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
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.
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.
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.
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.
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?
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.
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.
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.
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.
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.
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.
Interview with Patrik Fredriksson and Peter Backlund about DDDSample
Interview with Rickard Öberg at Jfokus 2009 about Qi4j and Composit Oriented Programming
När: 13-15 februari 2012
Språk: Engelska & Svenska
Plats: Stockholm Waterfront Congress Centre