Devoxx 2009 - Devoxx 2010

Parleys.com - Presentations for channel 'Devoxx'09' (The Parleys.com RSS presentation feed for channel 'Devoxx'09')
Lombok Devoxx'09 Interview In this JavaPosse interview the developers of Lombok talk about @Data, how to debug Lombok annotated code and what future ambitions they have with the project.
Turning labours of love into day jobs James Gosling talks about the beta release of the Java store. This talk has the audio break cut out !
Stephen Colbourne Devoxx'09 Interview The JavaPosse.com interviews Stephen Colbourne during Devoxx 2009 on the recently announced Closures support for JDK7. They briefly also discuss Joda time.
A Year of Monitoring with Java-monitor We will examine strange garbage collector behaviour, talk about file descriptors in GlassFish, look at what memory leaks look like and how to tune memory pools in JVM's. This presentation is most interesting to developers who got bullied into being the local Java system administrator too. You will learn what to monitor and look at in order to be able to assess the health of our JVM in production. It is also very informative for system administrators who have been pressed into being responsible for a Java application server. You will learn more about the internals of a JVM, without having to learn Java.
Design to Development part 2: Adobe® Flash® Builder In this session, we use Flash Builder, starting from a project file built in Flash Catalyst and creating a finished Flex application. We enhance the application functionality by adding code in Flash Builder, as well as Flash Builder's data services feature to retrieve and display dynamic data.
Traditional Programming Models: Stone Knives and Bearskins in the Google Age Learn how many of yesterday's programming principles have inadvertently become today's worst practices, and how these anti-patterns continue to form the basis of modern programming languages, frameworks and infrastructure software.
Test-driven development in Flex Nordin will demonstrate how to implement user stories taking a test-first approach and how to set up a continuous build.
Scala Actors The advent of multicore processors has brought about renewed interest in concurrent programming: To harness the abilities of multicore CPUs, programs must be written with concurrency in mind. Actors provide an alternative paradigm to threads in developing concurrent programs. Languages and tools that support Actor-based programming have become increasingly popular. Scala Actors make actor-based concurrency available on the Java Virtual Machine, and enable JVM-based applications to scale to potentially thousands of concurrently executing processor cores or processors. This talk provides an introductory tutorial on Scala Actors: It explains the main Actor concepts and APIs, and provides tips and techniques on how to maximize the benefits of Actor-based concurrency to scale both Scala and Java programs on the JVMs.
Distributed Programming the Google Way Portions of this infrastructure have been made available as open source projects or published in academic papers: MapReduce, GFS, Sawzall, Chubby, Protocol Buffers, and more. Because the extend of Google's software infrastructure (both public and proprietary) is mindboggling, this talk distills recurring design themes or patterns, which can be reused in other contexts.
Model-Driven Development Using Adobe® Flash® Builder 4 and LiveCycle® Data Services ES See how to build and maintain data-driven Flex applications with an unprecedented level of productivity and flexibility. In this session, we use Flash Builder together with Data Services to build a sophisticated, data-driven application from A to Z. You focus on your data model: The client and server side of your application are created and kept in sync for you automatically.
Enhancing the JavaServer Faces 2.0 Component Model In this comprehensive session, we will: * explore how to create JSF 2.0 components. * explore how to enhance the JSF 2.0 component model by leveraging the new behavior model. * see ho we can create tool tips, client side validation and leverage 3rd party JavaScript libraries with JSF 2.0 components.
SLF4J and logback The logging abstraction problem will be presented. SLF4J tackles this problem in a decidedly unsophisticated manner. There are valuable lessons to be learned from SLF4J's approach. Logback, as the successor to log4j, is an evolution of the former project. It builds on the log4j experience, first by modularizing according to intended usage and second by simplifying the implementation. As a result, logback accomplishes more with less code. The talk will demonstrate some of the unique capabilities found in logback.
Dimensional Planning This intensified iterative development results in extra feedback loops and more adaptability, that in turn results in shorter time to market and building what's needed, not what was originally conceived. Adapting to change becomes manageable with Dimensional Planning. Topics Covered: * The difference between iterative and incremental development * Dirt, cobblestone and asphalt road as a metaphor for the depth dimension * Applied at the feature (depths )and feature group (alternate futures) level * Functional and non-functional dimensions * Demonstrate the economical benefits (Lean and Theory of Constraints) * In combination with Scrum and Kanban/Pull (and even as a stepping stone from waterfall to agile)
Tapestry 5 In this session, we'll introduce Tapestry and explain its innovative approach to building fast, complex, reliable applications from simple and reusable components. Along the way, we'll demonstrate the features that make Tapestry so fun and productive: including live class reloading and convention over configuration: we'll show how these result in minute amounts of code to accomplish big goals, and how Tapestry brings scripting language productivity within reach of Java developers without sacrificing any of Java's inherent speed and power.
Linking Business Processes with User Interfaces The basis of this approach is a network of links from business process models, imported from existing modeling tools, until final user interfaces, independent of the technology in which they were developed. The benefits of this approach impacts not only IT stakeholders, but end-users and business analysts by: a) concretely representing how activities are performed through organization's systems; b) showing the impact of business modifications on the way users are going to operate systems; c) keeping the end-users aware of which part of the process is being executed when interacting with a specific user interface; d) allowing end-users to report bottlenecks and suggestions of improvement in user interfaces that cannot be detected by monitoring tools; and e) providing analytical data that supports the analysis of users, user interfaces and business processes, enabling fast adaptation to the business dynamism. Instead of using existing IT approaches, such as SOA, to manage processes and
Turning Labours of Love into Day Jobs James Gosling talks about the beta release of the Java store. This talk has the audio break, so please watch the other one :)
Java Business Intelligence with Penthago - Part II * Introduction to Pentaho : project & company * The Pentaho BI Platform overview * Pentaho Analyses (OLAP) a.k.a Mondrian. * Pentaho Reporting a.k.a JFreeReport * Pentaho Data Integration (ETL) a.k.a. Kettle * Pentaho Data Mining a.k.a. Weka * Pentaho Metadata * Recap, useful links, etc. * Q&A
Introducing Scimpi using a selection of powerful taglibs. The end result is a development environment that rivals (exceeds?) the productivity of Rails coupled with the familiarity and robustness of the Java platform. Moreover, your domain model need not be deployed only to the web; Naked Objects also supports other viewers (including RESTful viewers) and client/server remoting, as well as Fitnesse-based testing capabiliities.
Adobe® University - Part II The Adobe® Flash® player has never known a faster adoption rate, with more than 80% of all online videos playing on top of the Flash player. Rich internet applications (RIAs) are commonplace, and common sense, and the Adobe AIR® platform is doing well as a standalone RIA deployment platform. But there are still many exciting things to come: Flash player 10 on mobile devices, improved designer/developer workflows, more online services, better tools, richer media, more flexible and powerful RIA development tools and platforms, and much more. Join us in this university session for a full overview of the Flash platform, including topics like new tools technologies, new developments in Flex and the Flash platform, and the Open Screen project.
Adobe® University - Part I The Adobe® Flash® player has never known a faster adoption rate, with more than 80% of all online videos playing on top of the Flash player. Rich internet applications (RIAs) are commonplace, and common sense, and the Adobe AIR® platform is doing well as a standalone RIA deployment platform. But there are still many exciting things to come: Flash player 10 on mobile devices, improved designer/developer workflows, more online services, better tools, richer media, more flexible and powerful RIA development tools and platforms, and much more. Join us in this university session for a full overview of the Flash platform, including topics like new tools technologies, new developments in Flex and the Flash platform, and the Open Screen project.
Java Business Intelligence with Pentaho - Part I * Introduction to Pentaho : project & company * The Pentaho BI Platform overview * Pentaho Analyses (OLAP) a.k.a Mondrian. * Pentaho Reporting a.k.a JFreeReport * Pentaho Data Integration (ETL) a.k.a. Kettle * Pentaho Data Mining a.k.a. Weka * Pentaho Metadata * Recap, useful links, etc. * Q&A
Java Generics in action (2/2) Since version 5, Java supports the definition of generic classes and generic interfaces. Even before their final release, the new language constructs were praised by some and criticized by others. In this talk, we start with a short overview of the basic concepts for defining and instantiating generic classes in Java. We then discuss type erasure as a technique to ensure backward compatibility. At the same time, we pinpoint potential dangers of that approach. In the second part of the talk the focus is on inheritance. We start this with a short overview of wild cards in specifying generic arguments, and discuss their pros and cons. We then discuss problems that arise in developing hierarchies of generic classes and interfaces. We finish the talk with a look at concepts supporting the definition of generic methods.
Java Generics in action (1/2) Since version 5, Java supports the definition of generic classes and generic interfaces. Even before their final release, the new language constructs were praised by some and criticized by others. In this talk, we start with a short overview of the basic concepts for defining and instantiating generic classes in Java. We then discuss type erasure as a technique to ensure backward compatibility. At the same time, we pinpoint potential dangers of that approach. In the second part of the talk the focus is on inheritance. We start this with a short overview of wild cards in specifying generic arguments, and discuss their pros and cons. We then discuss problems that arise in developing hierarchies of generic classes and interfaces. We finish the talk with a look at concepts supporting the definition of generic methods.
Hibernate Search university: full-text search for Hibernate (2/2) Search has become a fundamental tool not only for Web applications but also for internal and rich applications. Data should be found efficiently and fast. Solving this problem encompass both technical and user interaction design decisions. Plain old SQL search has reached its limits in a world where users are accustomed to full-text search.This presentation will demonstrate a practical approach to expose your data via full-text search using Hibernate Search and Lucene. This demonstration will show you how the tools has been designed for simplicity and freedom and how it feels natural to an Hibernate user.
BPM in a SOA Environment These provided services are used by different types of interfaces and (potentially, at least) other services. This talk explores some of the common design patterns linking BPM engines, other services, interface components, and applications. We begin by exploring the relationship between SOA and BPM. From the BPM engine perspective, it is tempting to consider other services to be passive providers of functionality that are called upon demand. However, this view is too narrow. Non-BPM services may notify business processes asynchronously when certain business events occur, with this notification serving to triggering activity within the BPM engine. Non-BPM services may also recognize that an event has occurred and initiate a BPM process via the services provided by the BPM engine. Exploring this further, we realize that there are portions of every business process that cannot be managed by a BPM engine - in particular, the sequence of events that leads to the initiation of a BPM proces
Gaming JavaFX JavaFX brings a fully hardware accelerated graphics stack, true 3D transforms and effects, an easy to write declarative programming language and powerful graphical APIs to allow you to write fun, compelling, consumer content. Come see how to have more fun creating your next application with JavaFX.
JSF 2 and beyond (2/2) The JSF 2.0 specification (JSR-314) addresses a substantial number of long standing pain points that JSF users have just come to accept as a hard knock life (or death by 1000 paper cuts). At last, JSF is a true contender amongst web frameworks. Now that the specification is final, it's time to take a step back and evaluate the results and also look ahead to JSF 2.1.This presentation will provide an in-depth introduction to many of the new JSF 2.0 features and will ask of each: Is the currently specified solution sufficient? We'll also consider whether other concerns have been overlooked.
Java and JavaFX Technology and the Nintendo Wiimote: Just How Much Fun Can You Have? To provide control of an on-screen cursor, the Wiimote has a special camera that can track up to four points of infrared light and report their positions in real time. This session explores how the Wiimote can be used in ways not originally intended by the Wii designers. Example applications keep the Wiimote stationary and use it to track moving infrared LEDs, which can be mounted on a pen, a screen, or even an umbrella. Data about the position of the infrared lights can be used to control the position of images so they are always projected on a screen or to provide a virtual whiteboard environment. The demonstrations use JSR 82 (Java APIs for Blue-tooth), the WiiremoteJ open-source API, a Java platform library, and JavaFX code to drive the user interface. The session shows how JavaFX technology really is, \"for all the screens of your life\", including ones you've never thought of.
The JavaFX Platform - A Java Developer's Guide JavaFX is the future of RIA development. It takes the power of a modern scene graph, adds rich animation and multimedia capabilities, and extends to the web and beyond with seamless portability. At the same time, it leverages the power and breadth of the Java platform, allowing full access to existing Java libraries and integration with Java client technologies.This session will introduce you to the JavaFX language and platform from the perspective of a seasoned Java developer. This will start with a quick language tour focused on the differences between Java and JavaFX, and pointing out specific benefits of the JavaFX Script language for UI development. The breadth of JavaFX APIs will be explained through several examples that we will build out during the course of the session.
Modular Web Applications with OSGi In this session we will look at the current state-of-the-art for modular Web applications with OSGi and in a series of live demonstrations, show that truly modular Web applications are now a reality. Attendees should have an understanding of OSGi basics and be familiar with Java Servlets.
Hibernate Search university: full-text search for Hibernate (1/2) Search has become a fundamental tool not only for Web applications but also for internal and rich applications. Data should be found efficiently and fast. Solving this problem encompass both technical and user interaction design decisions. Plain old SQL search has reached its limits in a world where users are accustomed to full-text search. This presentation will demonstrate a practical approach to expose your data via full-text search using Hibernate Search and Lucene. This demonstration will show you how the tools has been designed for simplicity and freedom and how it feels natural to an Hibernate user.
Managing Glassfish on OpenSolaris In this session we will show how to use Open Solaris features to monitor, provision and backup Sun's Glassfish Application Server. An example is using ZFS to host the domain directory for a GF domain, that would allow you to take a snapshot of your working configuration prior to an upgrade of your application and very easily and quickly go back to the previous version in case the upgrade failed. The same method can be used for backups and recovery. You could even put your disaster recovery image on a cloud storage eg. Amazon S3 or similar. Security separation of different components usually means that we will have to use multiple systems or multiple VMs on the same system. Using OpenSolaris, Containers and Crossbow network virtualization, we can build a systems that have security separation between each component, but still only use one physical system and just one kernel, thus, no VM overhead.
Introduction to BIRT Reporting We will discuss and show several deployment options that range from API integration to integrating BIRT Viewers into web applications. Topics covered include using the BIRT Designer, the BIRT APIs, and working with the open source BIRT web viewer example. We will also look at a JavaScript API for embedding and controlling BIRT reports, using Flash charts and gadgets with BIRT reports, AJAX-based interactivity on BIRT reports, and a web-based BIRT designer for end users.
Maven 3 Reloaded The Maven team has gone to the ends of the earth to ensure backward compatibility, improve usability, increase performance, allow safe embedding, and pave the way for implement many highly demanded features. This talk will briefly cover the process and tooling changes that have occured in the Maven project in order to accomplish what we have done with Maven 3.0, as well as discuss the architectural and feature changes. Some of the process changes include setting up a multi-platform Hudson grid, building out a framework of over 440 integration tests, creating integration tests for all core Maven plugins, and systematically seeking out Maven 2.x OSS projects to validate Maven 3.x's compatibility. We also built out a framework that measures disk I/O, network I/O, memory consumption, and CPU utilization to ensure that performance doesn't degrade.
Performance for the performance-shy Topics covered: * Performance tuning - not just for performance geeks. * What's the garbage collector doing? (And why you should care.) * But why is the garbage collector doing all that, anyway? How to find out what's in your heap (tools discussed are applicable to most JVMs). * Are you waiting around on locks? * Is your application running the code it should be? * Solving problems you didn't even know existed with the Health Center (applicable IBM VMs).
Android: resolution independence and high performance graphics By the end of the year, Android devices will exist in different screen resolutions and densities. In this session you will learn how Android copes with multiple resolutions and densities and how you can adapt your application. You will also discover a new graphics technology developed for the Eclair branch of Android. This technology helps you easily write efficient visual effects and animations in your Android applications.
Funky Java, Objective Scala Recently, while the Java platform has been going from strength to strength, improving both performance and support for alternative languages, the Java language has started to appear less exciting than many of the alternatives that now run on the JVM. There is a lot to be said for the modern features of many of these new alternatives, but does that mean the fat lady has sung for Java? Not so, while we might still not have closures or properties, there are many new and interesting libraries and techniques that can breathe new life and style into your Java source. A stronger emphasis on immutable value objects, use of third party libraries like the Google collections library, DSL like fluent interfaces and more radical ideas like Project Lombok can all help you improve your style, reduce the boilerplate, reduce errors and be more productive with Java. It will bring fun back to your Java development. The first part of this session will look at libraries and techniques that you can use wi
Deep dive on the Java EE 6 platform with GlassFish V3 We'll explain how features such as profiles and pluggability are rooted at the implementation level in the modularity of GlassFish V3, in itself based on OSGi, and how this benefits Java EE developers. We'll highlight all the extensibility contracts that are part of Java EE 6, showing how they are relevant to application developers. We'll look at things like: pluggability in the web container, portable extensions in CDI (JSR-299), support for scripting languages, use of OSGi services in GlassFish and more. Finally, we'll address tool integration (including the admin console and the CLI) and the importance of features such as fast redeployment and session preservation across deployments to maximize productivity.
Using BTrace and DTrace to Instrument and Analyse Java Applications However, DTrace depends on the underlying platform whereas BTrace works on all platforms with Java support. In this session we will start with a quick introduction to BTrace and then look at how to use BTrace to track down performance issues that otherwise might be hard to solve. For more detailed investigation of how Java applications areinteracting with the underlying OS DTrace has no equal. This session will also look at how to use DTrace on Solaris machines and give examples of how support in the virtual machine can be expanded by adding your own probes to application code.
Detecting and preventing bugs with pluggable type-checking This talk describes a set of pluggable type checkers that operate as annotation processors for javac. The type checkers are easy to use (for example, the syntax is much less verbose than generics) and have found many errors in real programs. Java 7 will contain syntactic support for type annotations, but in the meanwhile your code remains backward-compatible with all versions of Java. The talk also describes the Checker Framework, which enables a programmer to write an annotation processors that checks custom properties of your code and prevents even more bugs. The talk will demonstrate the tools in action. The type-checkers and the Checker Framework are publicly available at http://types.cs.washington.edu/jsr308/
Keep pushing: How we rebuild Y! Mail and Facebook using JSF. And survived In this presentation we will take a look at the building blocks of JSF and how to push the boundaries of the provided UI components and layout managers to rebuild two well known websites from scratch: Yahoo! Mail and Facebook. We will discuss challenges, limitations, and advantages of using JSF that were found along the development process.
Windmill Originating at the Open Source Applications Foundation Windmill was built to help QA keep up with the rapid release cycles of the Chandler Server Web UI (Cosmo) project. As the Cosmo client is heavy in JavaScript and AJAX functionality, Windmill makes the communication between the service and the client code a priority.
Google Appengine Java: Groovy baby! With the Google Eclipse Plugin, as often demoed, it takes 5 minutes to put a GWT/GAE Java Hello World application in production: this talk will be about what can you do after these first 5 minutes of total bliss Patrick will cover Appengine Java's APIs, including recent features like XMPP and Task Queues, tools integration, limitations, how to run other JVM based languages used in the wild (Groovy, JRuby, Scala, Javascript), and show cool apps that have been developed with appengine. Guillaume will present Gaelyk, a lightweight toolkit for easily developing applications in Groovy to be deployed on Google App Engine Java. We'll learn more about what the toolkit provides, how to leverage it for your own needs through some demos.
Development is Social? With OpenSocial - software development can be seen as the most social thing you will ever do. So poke your friends, chuck some sheep and come to this presentation to learn how commits, code review, and software documentation can turn you into the life of the party.
iBeans: dead-simple integration for the Web This talk will cover some options available that greatly reduce the amount of code and effort for performing these tasks without introducing new complexities or architecture considerations using new framework - iBeans. Who should attend this session: * Java Web Application developers who need very simple integration and routing options without the hassle. * Developers who don't really care about SOA but need to build service oriented applications. * Developers who want to talk to public services like Twitter, Gmail or Flickr What problem(s)/challenge(s) will an attendee learn to solve by attending your session? This session will teach the audience how to integrate their web applications with other applications and services on the web and the enterprise in a way that doesn't add complexity to the code or architecture of the application. Using a couple of simple constructs developers will be able to integrate with services such as Twitter, Google Maps and Gmail in minutes.
Scaling CometD to the Masses Comet, often called Reverse Ajax\", allows you to push data from the server to the browser. Comet has been slow to adopt because it has been plagued with scalability problems. Traditional web servers were plagued with one thread per request problems, which limited support to a few hundred clients per server. This problem has been solved by Asychronous Servlets standardized as part of Servlet 3.0. Asynchronous Servlets solved many of the major scalability problems, but CometD's original server implementation hid much of the internal information about what was going on inside the CometD server. Working with a closed box made scalability nearly impossible. Over time CometD has opened access to it's internals to help you Scale CometD to the Masses. Many of these enhancements to CometD were suggested by speaker Kevin Nilson. In this session Kevin will walk you through recent enhancements to CometD and teach you how to Scale CometD to the Masses.
Pomodoro Technique You have so much you need to accomplish today. Your list is a mile long and you find yourself getting interrupted every other minute. You'd like to tell everyone to leave you alone, but most of the interruptions are coming from you! You think of a phone call you need to make or a web site you need to check and before you know it you're answering email, checking twitter, and finding a million other things to occupy your time. You need to focus - really focus. The Pomodoro Technique puts you back in charge of your day. You'll apply successful techniques from software engineering to identify what you should be doing today and to help you achieve your goals. Your mind won't wander when it is fully engaged in short bursts of focused activity. Learn to work less and accomplish more using nothing more than paper, pencil, and a simple kitchen timer.
The not so dark art of Performance Tuning In this talk Dan, our typically developer, will go bumbling off in an attempt to tune a poorly performing application. During the process we will introduce a number of best practices that could have helped him reach his performance goals, without the need of magic.
Effects in Flex - The Romain and Chet Show (1/2) One of the most powerful things about the Adobe Flex platform is the ability to easily create rich, compelling user experiences through the built-in effects library. On some platforms, creating animations can require a lot of knowledge about animation programming, a lot of code to get things working, and a lot of prototyping to get things right. But with effects and state transitions built into the Flex platform, adding animations to your Flex applications far simpler, often boiling down to single lines of declarations to tell the system what effects to run and when to launch it. In Flex 4, effects are better than ever, taking advantage of new capabilities in the Flash player and in the Flex language and platform to offer increased functionality and power for better and more dynamic user experiences. Come to this session to learn how Flex effects work in general and where we are taking the effects library in the latest release of Flex, Flex 4.
Pro JavaFX - Developing Enterprise Applications What you will get is a down-and-dirty, hands-on guide to building real JavaFX enterprise applications. This includes using controls and layouts to quickly prototype a profressional UI, seamless web service communication with your back-end server, integrating with existing web applications, and deploying an easily maintainable application to the web, desktop, and mobile.
The JavaFX Platform - A Java Developer's Guide (1/2) JavaFX is the future of RIA development. It takes the power of a modern scene graph, adds rich animation and multimedia capabilities, and extends to the web and beyond with seamless portability. At the same time, it leverages the power and breadth of the Java platform, allowing full access to existing Java libraries and integration with Java client technologies.This session will introduce you to the JavaFX language and platform from the perspective of a seasoned Java developer. This will start with a quick language tour focused on the differences between Java and JavaFX, and pointing out specific benefits of the JavaFX Script language for UI development. The breadth of JavaFX APIs will be explained through several examples that we will build out during the course of the session.I will also cover third-party, open-source libraries with a focus on technologies that make it possible to write full enterprise applications. This includes web service integration and UI control libraries t
Towards A Universal VM The success of the Java platform is powered by the Java Virtual Machine (JVM), which many people assume is tied to the Java programming language. In fact, 100+ programming languages are hosted on the JVM, including JavaFX, JRuby, Jython, Groovy, Clojure, and Scala. A key implementation challenge is to make code written in non-Java languages run as fast as code written in the Java language. This talk looks at how the design of the JVM is evolving to improve performance of all languages. It explains new features like the invokedynamic bytecode - intended for the next release of the Java SE platform - that let language implementers fully realize the power of the JVM.
Infinispan and the future of data grids The extreme scalability offered by data grids are powering the greatest and most high-profile of today's applications, and data grids take on a far more prominent role in cloud deployments as traditional databases hit scalability and resilience issues. In his talk Surtani introduces Infinispan, the new open source data grid platform, and it's motivations and evolution as a project. Distributed data structures and the use of data grids as a viable, cloud-ready data storage mechanism will be discussed in depth.
Using XML with Java: Spoilt for Choice? Yet the reality is that it's easy to get bogged down writing thousands of lines of code that do nothing other than translating data from one representation to another (and soaking up machine cycles while they do so). So it's important to choose the right tool for the job. This talk examines the options available and tries to help you make a choice. It also hazards some guesses about future directions that the technology might take. Should we all be waiting for something like LINQ, for example?
The Web on OSGi: Here's How Enterprise Web applications tend to grow like weeds in monolithic complexity. OSGi, although more often associated with Java technology-based clients and application servers, can bring a new level of modularity, uptime, and stability that is needed with today's always-on hosted Web applications. OSGi gets really interesting when the pretty architecture diagrams meet the real world, because it consists of various deployment platforms, development environments, and application architectures. This presentation, for Java 2 Platform, Enterprise Edition (J2EE platform)-savvy architects and senior developers, provides a practical guide to the Web on OSGi, from integration approach to bundle development, to real-world code you can use today.
Do you really get class loaders? In this session we'll take a tour of the Java class loading mechanism, both from JVM and developer point of view. We'll see how different delegation systems are built, how synchronization works, what is the difference between finding classes and resources, what wrong assumptions has been made and are now supported. Next we will look at typical problems that you get with class loading and how to solve them. ClassNoDefError, IncompatibleClassChangeError, LinkageError and many others are symptoms of specific things going wrong that you can usually find and fix. For each problem we'll go through a hands on demo with a corresponding solution. Finally we'll take a look at the complicated class loading mechanisms like the ones used in OSGi and Tapestry 5. We'll look in detail at the benefits they have and problems they might cause.
ArchiMate ArchiMate is the open standard modelling language for Enterprise Architecture, maintained by The Open Group. Learn in this presentation about enterprise architecture and the core components of a complete EA approach. We focus on the common language for enterprise architecture, why this is a necessity and how it relates to TOGAF. After explaining the most important concepts and relations, we will present various views which can be generated from the model repository based on a short case study. The presentation ends with real life examples and tips regarding the implementation of ArchiMate.
Spring Framework 3.0 This talk discusses Spring as a modern Java 5 oriented application framework: covering the core component model, annotation-driven web MVC as well as platform integration.
The Lift (Scala) Web Framework It stresses the importance of security, scalability, and performance while enabling high levels of developer productivity. Lift applications, written in Scala and deployed as WAR files offer very high performance and are being deployed in organizations as diverse as web 2.0 start-ups, right up to companies such as SAP. In this session, project committer Timothy Perrett, gives an overview of Lift and demonstrates its advantages for building rich Internet applications. This presentation is intended for Web application developers and architects who want to learn about leading-edge technologies on the JVM platform.
The JavaPosse.com Live Live recording of the JavaPosse.com podcast at Devoxx'09.
Turbo-charge your UI - The Romain and Chet Show (2/2) Learn practical tips, techniques and tricks for making your Android applications fast and responsive. This session will focus on optimizations recommended by the Android framework team to make the best use of the UI toolkit.
The Java EE 6 Platform (2/2) Take a deep breath at Java EE 6. In this session, Antonio Goncalves will present the just released Java EE 6 plateform with slides, showing you code, and demoing a Java EE 6 application using open-source implementations. Antonio will show you some novelties of the plateform : new EJBs, simplified packaging, an enriched persistence layer, a new API for RESTful services, a validation framework, a radical simplification of the web layer and ... many other improvements that make Java EE 6 ideal for your applications. Java EE 6 applications combine standards and robustness. Come to this university talk and check it out by yourself.
The Java EE 6 Platform (1/2) Take a deep breath at Java EE 6. In this session, Antonio Goncalves will present the just released Java EE 6 plateform with slides, showing you code, and demoing a Java EE 6 application using open-source implementations. Antonio will show you some novelties of the plateform : new EJBs, simplified packaging, an enriched persistence layer, a new API for RESTful services, a validation framework, a radical simplification of the web layer and ... many other improvements that make Java EE 6 ideal for your applications. Java EE 6 applications combine standards and robustness. Come to this university talk and check it out by yourself.
Project Coin: Growing a Language Without Stretch Marks Besides discussing the actual language changes, this talk will discuss the criteria and considerations used to evaluate language proposals and judge their utility and appropriateness to the platform.
Animation Rules! GUIs are not cartoons, but they share some of the same constraints: they are a visual medium, inherently 2D, and they must convey potentially complex information to the user in a very short amount of time. A confused user is an unhappy user, so the clearer we can make our GUIs to our users, the more productive they will be in using the applications we build. In the 1920s through the 1940s, animators at Disney Studios studied motion in real life in order to come up with what they called the Twelve Rules of animation, for providing more lifelike and enjoyable cartoons. We examine each of these rules to see how we can apply the same techniques to GUI animations to create better and more enjoyable user experiences.
Keeping Your Options Open, Even if the Cloud is Not Once you've chosen a cloud vendor, how can you avoid being locked in to a proprietary API or service? And even if you're happy with your cloud provider, what happens when you partner with someone who uses different cloud services? Unfortunately, the picture of cloud standards is, well, cloudy. In this session we'll look at the services provided by the major cloud vendors and the standards efforts of various standards bodies. From there we'll look at design patterns and code libraries to make your cloud computing applications as robust, vendor-independent and open as possible. Cloud computing is possible because of the virtualization and commoditization of hardware and processing power; to make the most of it, we'll need standardization as well.
Open Source SOA with Fuse Fuse components are based on Apache SOA projects, and are integrated, tested and supported to combine the speed and innovation of open source software with the reliability and expertise of commercially provided enterprise services. This talk will give you an overview of what exactly Fuse stands for.
Project Lombok: Bye Bye Boilerplate In this presentation, the developers of lombok, Reinier Zwitserloot and Roel Spilker, will show the audience what lombok is about, and how you can use it to eliminate boilerplate from your java code. For example, instead of writing out common boilerplate such as getters, setters, toString, equals, and hashCode implementations, you can use lombok's @Data annotation. Lombok hooks into your compiler and IDE so that their interpretation of your source includes these methods, while you never actually see any of them in your editor. For IDEs, this means that you get all the benefits, such as auto-completion, the methods show up in your outline views, and search tools such as 'go to declaration'continue to work. While most IDEs offer a feature to generate the boilerplate, this is little help when reading the resulting code, and such code is much harder to maintain.
Google App Engine for Java (2/2) Starting a greenfield project is your chance to give the latest, most hyped technologies a spin. What would you choose? Spring 3, GWT, JSF, maybe a dynamic language? Of course you'd want to get your development environment setup like a well-oiled machine - complete with testing, continuous integration, IDE support, and a shiny Maven or Ant build. Unfortunately, you'll also have to pull out that old dusty copy of Linux for Dummies to setup your development and production servers. Or will you?Just for this talk, I'm developing a new, non-trivial application called swagswap on Google App Engine for Java. It's an app to categorize, rate, and trade swag (conference goodies). As we stroll through the code you'll experience the exhilaration of appengine development. I'll talk about the the pleasures, convenience, and the overall giddiness you feel when developing on this platform. With that come the pitfalls, limitations, and forced choices I had to either overcome or swallow whole.The
The Modular Java Platform & Project Jigsaw Modular applications will share these benefits; they'll also be simpler to construct and maintain as well as easier to integrate with native operating systems. This session will describe the design of the module system being developed in Project Jigsaw, demonstrate its key features, and show how it's being used to modularize the platform.
Google App Engine for Java (1/2) Starting a greenfield project is your chance to give the latest, most hyped technologies a spin. What would you choose? Spring 3, GWT, JSF, maybe a dynamic language? Of course you'd want to get your development environment setup like a well-oiled machine - complete with testing, continuous integration, IDE support, and a shiny Maven or Ant build. Unfortunately, you'll also have to pull out that old dusty copy of Linux for Dummies to setup your development and production servers. Or will you?Just for this talk, I'm developing a new, non-trivial application called swagswap on Google App Engine for Java. It's an app to categorize, rate, and trade swag (conference goodies). As we stroll through the code you'll experience the exhilaration of appengine development. I'll talk about the the pleasures, convenience, and the overall giddiness you feel when developing on this platform. With that come the pitfalls, limitations, and forced choices I had to either overcome or swallow whole.The
JDK7 Update and Java SE 7 A survey of the key features being developed for JDK 7, by both Sun and non-Sun contributors, followed by a speculative look at potential features for future releases.
Spring ActionScript Primarily focusing on Flex and AIR development, you'll learn how this framework can be used to build testable and maintainable applications. We'll take a look at the different kinds of configuration options and will also see how the minimal MVCS infrastructure fits into an application.
Writing Asynchronous Web application (Comet) using the Atmosphere Framework Today writing portable Web applications that can use the power of the Comet technique is almost impossible: Tomcat, Jetty, and Grizzly/GlassFish application server all have their own set of private APIs. Atmosphere leverages and builds on Project Jersey and the Java API for RESTful Web Services (JAX-RS). Jersey is the open resource reference implementation of JAX-RS that makes it easier to build RESTful Web services. Atmosphere and Jersey complement each other, with the goal of making it easier to build Comet-based Web applications that include a mix of Comet and RESTful behavior. This session briefly explains what Comet is and demonstrates the power of Atmosphere by building multiple applications, starting with a simple chat, then building a REST Twitter-like application, and many more Attendees will learn what Comet is and how to write portable applications by using Atmosphere and using the language of there choice: Java, JRuby, Scala and Groovy
Solr Power with Lucene In this university lecture we'll cover the typical workflow of getting data into Solr, configuring Solr's indexing and search processes, and building a searching client user interface. Common indexing options will be explored: database (JDBC) indexing, RSS/Atom and other XML data sources, CSV formatted data, rich text (Word, PDF, HTML, etc) documents and indexing through Solr's various native language APIs. Solr's configurability and usage options discussion will include query parsing, faceting, relevancy ranking, spell checking, highlighting, clustering and more-like-this.
Get Higher with ScalaTest This talk will show you ScalaTest, a new testing tool that will let you work at a higher level than JUnit and TestNG. You'll learn about high-level features of Scala such as traits and self-types, implicit conversions and parameters, functions and closures, and internal DSLs, and see how ScalaTest exploits these features to help you work more productively. You'll see how you can reduce the lines of test code you write by half and more, how to mix Scala into your existing JUnit or TestNG infrastructure, and how to use Scala in various testing styles, including unit testing, behavior-driven development, integration and acceptance testing, and high-level property-based testing. You need not already know Scala to attend this talk, as you will be taught just enough Scala to understand the examples.
Solr Power with Lucene (2/2) Solr powers the search of many enterprise applications, and long before Solr shone on enterprise search, Lucene - Solr's core library, was and still is used to drive the search of applications pervasively around the world. In this university lecture we'll cover the typical workflow of getting data into Solr, configuring Solr's indexing and search processes, and building a searching client user interface. Common indexing options will be explored: database (JDBC) indexing, RSS/Atom and other XML data sources, CSV formatted data, rich text (Word, PDF, HTML, etc) documents and indexing through Solr's various native language APIs. Solr's configurability and usage options discussion will include query parsing, faceting, relevancy ranking, spell checking, highlighting, clustering and more-like-this.
JavaFX We will cover design patterns and idioms, enhancing the user experience through good visual design and the use of several data access strategies. Come see how to be more productive by building your next application with JavaFX.
Gradle - A Better Way To Build Specially for large enterprise builds, the build performance is critical. Yet the build must be reliable and should be intuitive to use. Gradle offers plenty of features to support this: Gradle keeps a history of past build executions, provides ready to use and performant tools for change detection. You will learn about the unique Gradle incremental compile with a state-of-the-art dependency analysis. We will show Gradle's multi-threaded test execution and the advantages of a fully customizable fork frequency. You will also learn about Gradle's smart skipping and the many ways how you can control the execution of a multi-project build and optimize it for certain use cases. All this is provided out-of-the-box for standard Java project's. Yet Gradle provides all this not via a rigid framework but by a rich domain model. That way all those features a part of an extremely customizable, true build language.
Solr Power with Lucene (1/2) Solr powers the search of many enterprise applications, and long before Solr shone on enterprise search, Lucene - Solr's core library, was and still is used to drive the search of applications pervasively around the world. In this university lecture we'll cover the typical workflow of getting data into Solr, configuring Solr's indexing and search processes, and building a searching client user interface. Common indexing options will be explored: database (JDBC) indexing, RSS/Atom and other XML data sources, CSV formatted data, rich text (Word, PDF, HTML, etc) documents and indexing through Solr's various native language APIs. Solr's configurability and usage options discussion will include query parsing, faceting, relevancy ranking, spell checking, highlighting, clustering and more-like-this.
TeamCity When Martin Fowler first wrote about Continuous Integration, he described it as a practice that changes integration from a long and unpredictable process to a non-event - something that every team could use to make their code more reliable and clean, with minimal effort. Using code-level demonstrations, we will go through the CI practice using TeamCity, a distributed build management and continuous integration system which was designed specifically to improve team communication, integrate into the development process, run builds, detect problems, and report issues in a non-intrusive way, so that your code base stays clean and your projects are completed faster.
Smals-IDE - open source to the rescue Smals is a medium sized company. We have more than 250 Java/JEE programmers together with as much analysts working on +100 projects. Most of these projects are in the same domain (health care, social security) A few years ago we were confronted with the harsh truth that, although each team was efficient in solving his problem, the coming-together of all the solutions on our infrastructure and vis-à-vis the clients was far from ideal. Quality Assurance was a problem. In an attempt to solve some of the problems an initiative was started a few years ago to unify the Smals developers community. This resulted in the Smals-IDE which consists of an IDE, a continuous build and test environment and a release system, all based on open source tools with some customizations. We hope this presentation will demonstrate that some organizing coupled with open source tooling can help a business to become more responsive to the market and improve quality of service.
Lookup - A new OSGi Service Registry Lookups were originally invented as a basic pattern for loosely coupled communication in the NetBeans platform. Thinking of them as a data structure they are typesave, observable maps that take class objects as keys and return instances of the class. Lookups also provide an implementation for the Service Provider Registration mechanism detailed in the JDK 1.3 specification, that is more powerful and adds a lot of additional features. Due to the simplicity, type-safety, standard compliance and performance this approach is also very useful in OSGi. In a plain Java application you simply need to drop the jar on you classpath and it works. We made this mechanism available for OSGi as well.
Kanban in Action (1/2) Kanban is one of the newer agile methodologies. This session introduces Kanban, explains what it is, how it works and how it can be applied to software development.Kanban acts to limit work-in-progress and focus the team on achieving a continuous flow of value to the customer. Kanban innovates on accepted agile management practice by providing an iteration-less process with a regular release cadence. It helps achieve a balance of demand against capacity on the team and eliminate multi-tasking.Although loosely based on Toyota Production System, the Kanban software development community has taken the underlying principles of TPS and used them to achieve a similar results in software development.Kanban teams value: Quality, limited work-in-progress, balance capacity against demand and prioritization.In this session we'll discuss Kanban, its values, flow, cadence, theory of constraints, bottlenecks and of course how to apply these in real projects.
Kanban in Action (2/2) Kanban is one of the newer agile methodologies. This session introduces Kanban, explains what it is, how it works and how it can be applied to software development.Kanban acts to limit work-in-progress and focus the team on achieving a continuous flow of value to the customer. Kanban innovates on accepted agile management practice by providing an iteration-less process with a regular release cadence. It helps achieve a balance of demand against capacity on the team and eliminate multi-tasking.Although loosely based on Toyota Production System, the Kanban software development community has taken the underlying principles of TPS and used them to achieve a similar results in software development.Kanban teams value: Quality, limited work-in-progress, balance capacity against demand and prioritization.In this session we'll discuss Kanban, its values, flow, cadence, theory of constraints, bottlenecks and of course how to apply these in real projects.
Design to Development: Flash Catalyst to Flex A number of examples will be shown together with a case study of BandGeek\", an AIR/Flex application made by iDA MediaFoundry
Agile Mythbusters: What People Are Really Doing in Practice Some of the myths are that agile has been adopted by the majority of development teams, that agile approaches are more effective than waterfall approaches, that agile is empirical, that agile teams don't do up front requirements or architecture, that agile teams produce less documentation, that it is common for agile teams to take a test-driven approach, and many more. Several of those myths are true, several false, and some we're not so sure about yet. This talk summarizes the results of 4 years of industry surveys concerning the adoption and effectiveness of agile techniques. Very often the reality is significantly different than the rhetoric presented in mailing lists, in articles, and even in books. It is time to cut through the dogma promoted by agile consultants and instead focus on what agile practitioners are actually doing on their projects.
jBPM4 in Action The business value of BPM is well known. But jBPM is unique in offering that value in a way that developers love it. jBPM is based on the Process Virtual Machine, which enables it to support multiple process languages like jPDL and BPMN. We'll show a concrete example of how to build a train ticket application based on jBPM. And we demonstrate how the process file looks like, how to use the new API and how it fits into any plain Java application architecture.
Advanced Artifacts Management with Artifactory Artifactory is an enterprise Repository Manager for your Maven and other binary artifacts, now available in both Open Source and Cloud-based versions. In this demo-centric session, we present new methods for managing your build artifacts and third-party dependencies using Artifactory's unique features. By attaching metadata to your artifacts and artifact containers (e.g.:version folders), we show you how to open up unlimited possibilities for managing and controlling the artifacts you use in your daily work, including: promotion and demotion, staging, licensing, assigning quality metrics, using ratings, and so on. We also demonstrate a complete, holistic approach toward artifacts management by integrating your artifacts repository manager with your CI server, we will show how your build can be automatically linked to the artifacts it produced and to the dependencies used.
The Java EE 6 Platform Antonio will show you some novelties of the plateform : new EJBs, simplified packaging, an enriched persistence layer, a new API for RESTful services, a validation framework, a radical simplification of the web layer and ... many other improvements that make Java EE 6 ideal for your applications. Java EE 6 applications combine standards and robustness. Come to this university talk and check it out by yourself.
Clojure That's Clojure, which feels like a general-purpose language beamed back from the near future. Clojure embraces functional programming with immutable data types and first class functions. It is fully interoperable with Java. Clojure's approach to concurrency includes asynchonous Agents, and Software Transactional Memory. Clojure is fast, elegant, dynamic, and scalable: a language for the future, today.
Java Generics in action Even before their final release, the new language constructs were praised by some and criticized by others. For reasons of backward compatibility, Java erases all information related to genericity at runtime. This talk starts with a critical view on type erasure, pinpoints potential dangers in developing generic classes and interfaces, and illustrates how it might jeopardize client code. We then focus on wild cards that serve two different purposes in the language. First of all, we discuss how wild cards support restricted genericity in a rather elegant way. We then explain why type erasure complicates polymorphic assignments by imposing wild cards on variable declarations.
Java EE 6 and GlassFish V3: Evolution of a Platform Like any complex software system, both Java EE 6 and GlassFish are subject to a lot of competing pressures and face a host of constraints. At the same time, there are clear expectations in terms of what the next version of each should deliver: new functionality (e.g. scripting support, easy and extensible administration, integrated tooling, monitoring), better performance, OSGi compatibility, etc. We will describe the balancing act that we performed in developing both systems in parallel and highlight the importance of the feedback cycle between specification and implementation.
Architecting Robust Applications for Amazon EC2 (1/2) The Amazon Elastic Compute Cloud (EC2) is a virtualized computing environment where you rapidly provision and manage servers via a web services API. It is ideally suited to running Java applications because it allows you to develop applications using standard software packages such as Tomcat and MySQL. However, because it is a cloud, some aspects of EC2 are very different than a traditional, physical computing environment, which impacts how you handle security, networking, storage and availability. In addition, Amazon provides several extremely useful web services. These include the Simple Storage Service (S3), Simple Queuing Service (SQS) and Simple DB. By using these scalable services in your application, you can reduce the complexity and cost developing and deploying your application.
Architecting Robust Applications for Amazon EC2 (2/2) The Amazon Elastic Compute Cloud (EC2) is a virtualized computing environment where you rapidly provision and manage servers via a web services API. It is ideally suited to running Java applications because it allows you to develop applications using standard software packages such as Tomcat and MySQL. However, because it is a cloud, some aspects of EC2 are very different than a traditional, physical computing environment, which impacts how you handle security, networking, storage and availability. In addition, Amazon provides several extremely useful web services. These include the Simple Storage Service (S3), Simple Queuing Service (SQS) and Simple DB. By using these scalable services in your application, you can reduce the complexity and cost developing and deploying your application.
JSF 2 and beyond (1/2) The JSF 2.0 specification (JSR-314) addresses a substantial number of long standing pain points that JSF users have just come to accept as a hard knock life (or death by 1000 paper cuts). At last, JSF is a true contender amongst web frameworks. Now that the specification is final, it's time to take a step back and evaluate the results and also look ahead to JSF 2.1. This presentation will provide an in-depth introduction to many of the new JSF 2.0 features and will ask of each: Is the currently specified solution sufficient? We'll also consider whether other concerns have been overlooked.
Java, the Platform for the Future This success is powered by the community of developers and users. Today the Java platform faces new challenges. We will examine these challenges and the keys to meeting them in order to broaden Java adoption and improve competitiveness
Integrating designers into your application development While one is creating the experience, the other one is making things work. And even though they are different, combining their powers is the only way to create those great rich internet applications. Adobe® created Flash Catalyst for designers, and Flash Builder for developers ... 2 tools that enable these users to build the entire application from the experience down to the code, all using the open source Flex framework
Spock - the smarter testing and specification framework We will start out by showing Spock's beautiful and highly expressive specification language. Built on top of Groovy, it removes the need for assertion APIs, record-and-replay mocking APIs, and other unnecessary distractions. What remains is a succinct description of a program's desired behavior. Leaving theory behind us, we will have fun with Spock in action by writing and running specifications in different environments. Along the way, we will discuss how Spock compares to well-known testing tools like JUnit and EasyMock. Many of Spock's features are implemented by hooking into the Groovy compiler and rewriting specifications at compile-time. Fortunately, this is completely transparent to users and execution environments. Nevertheless, we will reveal some of the dirty little secrets. Towards the end of the presentation, we will present our vision for Spock's future, and show h
The Next Generation Profiling and Diagnostics Tools The latest version of JRockit Mission Control is a very potent suite of Java tools for monitoring, managing, profiling, finding latency related problems and hunting for memory leaks in Java applications. This talk will start with a quick re-cap of the major JRockit Mission Control tools, then quickly move on to discuss some exciting features available in the most recently available version of JRockit Mission Control. Most of the talk will be spent on features that will be released quite
Detecting Fast Flux Botnets The development of the World Wide Web is an evolution. The cybercrimes have been becoming more diverse and sophisticated. But also the methods to protect against them have gone a long way since the beginning of the WWW. This arm race is experiencing a rapid growth and there still are many things to do, especially on the bright side. This talk goes through the various types of malware and the different methods to spread it together with the state-of-the-art detection approaches. Our focus is on a DNS technique called fast flux. This technique is used by botnets to hide phising and malware delivery sites. We present an algorithm and a Java tool to detect the fast flux domains. The tool has been developed in
SOA, OpenESB and OpenSSO Programming with Passion! (2/2) Service Oriented Architecture (SOA) represents a fundamental shift in the way applications are built, deployed, and used (or reused). By moving from big, monolithic applications to smaller, re-usable service blocks, companies can dramatically reduce time-to-market, increase maintainability and flexibility over the applications they build. This session starts with a brief discussion on the concept of SOA application. The majority of the session is devoted to explaining and demonstrating several concrete technologies that make SOA architecture possible - BPEL (Business Process Execution Language), JBI (Java Business Integration), and OpenESB. Several popular OpenESB modules are then introduced, and they include Intelligent Event Processing (IEP), Master Data Management (MDM), Work List Manager (WLM), etc. The last hour of the session will be devoted to discussing Identity management and Single Sign On based on OpenSSO technology. This session is based on the free online course of the s
SOA, OpenESB and OpenSSO Programming with Passion! (1/2) Service Oriented Architecture (SOA) represents a fundamental shift in the way applications are built, deployed, and used (or reused). By moving from big, monolithic applications to smaller, re-usable service blocks, companies can dramatically reduce time-to-market, increase maintainability and flexibility over the applications they build. This session starts with a brief discussion on the concept of SOA application. The majority of the session is devoted to explaining and demonstrating several concrete technologies that make SOA architecture possible - BPEL (Business Process Execution Language), JBI (Java Business Integration), and OpenESB. Several popular OpenESB modules are then introduced, and they include Intelligent Event Processing (IEP), Master Data Management (MDM), Work List Manager (WLM), etc. The last hour of the session will be devoted to discussing Identity management and Single Sign On based on OpenSSO technology.
Craftsmanship and Policy Ten years ago Extreme Programming, Agile Development, and Scrum shook the foundations of our industry. Our cherished beliefs were brought into question and turned inside out. The echoes of that revolution continue to resound. But now an even bigger tide has begun to turn. The Agile movement has helped software developers, testers, and business analysts to define their profession with unprecedented clarity. Craftsmanship is the watchword of the day. There is a ground swell of individual contributors who have decided that they want to be true professionals instead of technical laborers. They want authority over their workmanship, their disciplines, and their practices, and they are willing to take the corresponding responsibility. But is management ready for the tsunami of professionalism that's on the horizon?
Design to Development (1/2) : Adobe® Flash® Catalyst Learn how using Flash Catalyst and Flash Builder 4 together enables designers and developers to work jointly to create high-fidelity Rich Internet Applications. In this first part, we take a look at the designer's role in this workflow. We will use a design file authored in Adobe Illustrator as the starting point for our application UI and will work in Flash Catalyst to convert design elements into functional UI components, states, and navigational elements. After the interaction design is finished, the project is give to the developer to add application functionality, which we will see in Part 2.
Do we really know how to develop software? Specific problems include: * The prevalence of fads more typical of fashion industry than of an engineering discipline. * The lack of a sound, widely accepted theoretical basis. * The huge number of methods and method variants, with differences little understood and artificially magnified. We support a process to refound software engineering based on a solid theory, proven principles and best practices that:* Include a kernel of widely-agreed elements, extensible for specific uses * Addresses both technology and people issues As a community we need to change the way we deal with methods and processes. This will, if successful, have a significant impact on our industry and on the education, the research and the developer community. This talk guarantees to be as fresh as tomorrow.
jBPM in Action (2/2) jBPM is the leading open source BPM and workflow engine. The business values of BPM are well known, but jBPM is unique in offering value in a way that developers just love it. jBPM is built upon the Process Virtual Machine, which enables support for multiple process languages like jPDL and BPMN. In this talk, we'll dive deeply in the core of jBPM, demonstrating the new API, the revised XML presentationand much, much more. We'll demonstrate all these features by showing how to build a high-performant, scalable train ticket handling platform based on jBPM. We'll look into how jBPM can be embedded into your application and how it can enrich your domain model. In short: if you have the slightest interest in jBPM or BPM, then this talk simply cannot be missed!
jBPM4 in Action (1/2) jBPM is the leading open source BPM and workflow engine. The business values of BPM are well known, but jBPM is unique in offering value in a way that developers just love it. jBPM is built upon the Process Virtual Machine, which enables support for multiple process languages like jPDL and BPMN. In this talk, we'll dive deeply in the core of jBPM, demonstrating the new API, the revised XML presentationand much, much more. We'll demonstrate all these features by showing how to build a high-performant, scalable train ticket handling platform based on jBPM. We'll look into how jBPM can be embedded into your application and how it can enrich your domain model. In short: if you have the slightest interest in jBPM or BPM, then this talk simply cannot be missed!
The Cambrian Cloud Computing Explosion (2/2) A complete survey of cloud computing starting with early IBM ideas, traveling through Google's implementation, Amazon's Web Services; continuing with the state of the industry as it stands in late 2009. We will also provide some insights and predictions for 2010, 2011, and beyond. This presentation cover the complete state of cloud computing and be useful for anyone working or planning to work in IT.
NoSQL with Cassandra and Hadoop As the amount and pace of data-generation keeps growing, businesses are stepping away from traditional rdbms solutions and go for highly scalable store solutions. Numerous papers are being published on this topic for instance by well known companies like Google, Facebook and Amazon and opensource projects come into existence like Cassandra and Hadoop. In this BOF we want to give an overview on these emerging technologies and discuss what they could mean for your business applications. We would also like to gather experience reports from people using for instance Cassandra.
Easing JPA data access with Hades The talk introduces the OpenSource library Hades that significantly eases implementing data access layers with JPA. Thus it will take the audience on a guided tour through code samples introducing the features of Hades: * Executing queries by only declaring interface methods * Extending the EntityManager to provide a typed interface, programmatic pagination and sort support * Combining execution of finder methods with pagination * Auditing of entities to keep track of creation and modification date and user * Integration of custom data access code * Integration into Spring applications via Spring namespace and Spring IDE extension
The Cambrian Cloud Computing Explosion (1/2) A complete survey of cloud computing starting with early IBM ideas, traveling through Google's implementation, Amazon's Web Services; continuing with the state of the industry as it stands in late 2009. We will also provide some insights and predictions for 2010, 2011, and beyond. This presentation cover the complete state of cloud computing and be useful for anyone working or planning to work in IT.