Groovy mythsbuster

Groovy has evolved to being the de-facto standard for dynamic programming on the JVM. However, some myths are constantly retold about its scripting nature, type system, performance, tooling, and other "enterprise relvant" concerns. We will go through those rumors and conduct some experiments to (in-)validate their truth.

Building Scalable Applications with JPA

One of the most important factors when building high performance scalable applications is effective use of the Java Persistence API for database access. This session will explore through examples how many of the most common performance and scalability bottlenecks faced when accessing a relational database can be effectively addressed using EclipseLink JPA, the JPA 2.0 reference implementation.

Hands-on Agile Development

BRING YOUR LAPTOP WITH YOU, BUT A LAPTOP ISN'T REQUIRED! Reading and hearing about agile practices is one thing, but actually doing it is completely different. This session puts you to work in an agile fashion, applying agile developer practices. During this session, we're going to take a problem and iteratively develop the solution, using test-driven development, pair programming, retrospectives, pair rotation, and other agile development techniques. We work through 3 iterations during the 60 minutes, giving you a hands-on feel for real agile development. If you have a laptop, bring it, but only half the class needs one, so if you don't have a laptop, don't let it discourage you. Come see what it's like to work on a real agile project, even if it's just 60 minutes.

OSGi and the Enterprise: A match made in ... a box?

The Enterprise OSGi specification provides a compelling programming model for creating modular, portable, and dynamic enterprise applications. The Apache Aries project is an open source implementation of this standard. This session will present a overview of the Aries project and give a demonstration of how a simple - but useful - Aries Application can be assembled and dynamically deployed.

Even YOU can write safe concurrent code!

For much too long, concurrency has been solely occupied by the propeller-heads. It is high time that we average application programmers learn how to write concurrent code but without the fear of falling for the traps. The trick is to use the right concepts! Check out what is at every Java developer's disposal since recently.

Paying Lip-Service to Agile

More and more companies are advertising that they are 'agile'. Often this has little to do with agile development other than a belief that being 'agile' is a 'Good Thing'. On the other side of the coin there are teams and companies that aspire to being agile. This talk examines what it means to be agile and suggests shows how paying lip-service to agile can sometimes work, but more likely not.

Return to Requirements: Meeting customer needs and delivering value in

Agile software development is great at delivering software but doesn't always pay enough attention to what the customer actually wants, needs and values. Sure there is a Product Owner or Customer role - but how often can you get a real customer? This presentation looks again at the role of requirements in Agile development. Where they come from, who gathers them, how they are assessed.

Mastering Common Product Owner Challenges

Product owners play a key part in creating successful products: They are in charge of the product and lead the development effort. But this new multi-faceted role can be challenging to apply. For many organisations, the path to effective product ownership is littered with traps and pitfalls. This talk helps you recognize and address some of the most common challenges.

Zen and the Art of API Management

API's are fundamental for designing and maintaining quality components that are meant to last. Eclipse has first-class tooling to support for the design, implementation and maintenance of APIs. Eclipse provides API Tooling to support binary compatibility checking, API usage scanning, migration assistance and version numbering management. Attendees will learn how to apply API Tooling to their projects.

Emergent Design

This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don't yet know what you don't know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions. This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping your code in sync with the problem domain.

Busy Java Developer's Guide to Scala

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming. In this presentation, we begin by looking at the Scala type system and flow-control primitives, such as if/else, pattern-matching, tuples, lists, and more. Despite the name, "basics" in Scala can get the newcomer Scala developer quite some distance.

Aspects of Kanban

A Kanban system is an approach to creating a method in order to improve a business's capability to meet its purpose. This talk will introduce five aspects of a Kanban system: workflow, visualisation, work in process, cadence, and continuous improvement. These aspects are not practices to be followed, but key areas to consider to change and improve an organisation’s delivery capability.

Coaching Teams over Acceptance Testing Hurdles

On agile teams, testing is no longer something that happens at the end, testing is at the heart of what we do. However, teams face many hurdles when starting to integrate acceptance testing into their daily work. Some of the hurdles are technical but most are down learning a new approach where acceptance tests are pivotal our work. Pick up some practical tips, from an experience coach, on what you can do to coach your team over these hurdles.

Sustainable Test-Driven Development

This talk is about the qualities we look for in test code that keep the development "habitable". We want to make sure the tests pull their weight by making them expressive, so that we can tell what's important when we read them and when they fail, and by making sure they don't become a maintenance drag themselves. We need to apply as much care and attention to the tests as we do to the production code, although the coding styles may differ. Difficulty in testing might imply that we need to change our test code, but often it's a hint that our design ideas are wrong and that we ought to change the production code. In practice, these qualities are all related to and support each other. Test-driven development combines testing, specification, and design into one holistic activity.

Implementing Evolutionary Enterprise Architecture

We're drowning in needless complexity in the enterprise architecture space: heavy, bloated tools, complex middleware, just-in-case architectural decisions, and vendor-itus. The side effect of all that complexity drives us furthre from our goals: architecture that is simple, free, supports business goals, loosely coupled, and evolvable. This session describes how to use web technologies (HTTP, REST, hypermedia, etc.) to implement robust, scalable enterprise architecture. This talk is based on original research and development done by ThoughtWorks, and represents the current state of the art in building truly scalable enterprise architectures. This topic combines the subjects of service oriented architecture with web technologies to create a hybrid providing you with the benefits of both approaches. You can build robust, scalable enterprise architecture that allows individual applications to evolve indepentdently and rapidly. This talk describes how to make SOA suck less.

Can't Scrum, Won't Scrum

No big company has ever succeeded in an enterprise agile transformation. Does this prove what the sceptics have always said that Scrum doesn't scale to work in big companies? With inside experience of many large transitions, Geoff Watts and Paul Goddard will explore the red tomatoes of why some companies can't Scrum and the green peppers of why some companies won't Scrum.

Seam 3: State of the union

Seam is a powerful open source development platform for building rich Internet applications in Java EE, now rebuilt on JSR-299: Contexts and Dependency Injection for Java EE. JSR-299 is an elegant set of new services that include dependency injection, contextual lifecycle management, configuration, interceptors and event notification. While these services are familiar, the innovative use of meta-annotations is uniquely expressive and typesafe. Seam extends the CDI programming model by providing portable enhancements, extensions and integrations that tie technologies such as Java Persistence 2 (JPA), Enterprise JavaBeans (EJB 3.1), JavaServer Faces 2 (JSF), Business Process Management (BPM), business rules (Drools), reporting (PDF and Excel), security and e-mail templates into a unified full-stack solution, supported by sophisticated tooling. In this session, Pete Muir, the Seam project lead, will provide an overview of the Seam stack, and discuss how it can be used to address common business cases. He will then explore some of the directions that Seam will be taking over the coming year.

JDK7: The Future of the Java Platform

JDK7 will be the next version of the Java platform and this session will look at a number of the new features being included and how they affect developers. We'll cover the following areas:

• Modularisation
• Small language changes
• Support for dynamically typed languages running on the JVM
• The Garbage First garbage collector

This presentation will also include an update on how things are going with the inclusion of closures in Java.

The Lean Startup

When Matt arrived at Songkick.com's offices in a tiny flat over Spitalfields Market in the summer of 2008, they had a rapidly-expanding team of very bright developers, but almost no development process at all. At a start-up, reducing waste and inefficiencies is a matter of survival, and by gradually introducing a blend of lean and agile practices, he built a team that were able to respond to new feature requests in a matter of days, deploying new features to production several times a week. The pressure and focus of the start-up environment yields many lessons that larger organisations could do well to learn. In this talk Matt will present a case study of his time at Songkick, explaining the practices that were introduced, and the underlying principles he used to choose them and make them stick. You should leave this session with some fresh ideas and inspiration on how to make your teams even more effective.

Mylyn 3.4: from Stack Trace to Scrum

The rapid adoption of Mylyn has made next big evolution of the IDE clear. Stories and tasks are more central than source code, focus is more important than features, and integration with the Agile workflow is the biggest productivity boost since code completion. This talk will review how new features in the latest Mylyn release and new integrations can make the entire Agile team more productive.

Enterprise OSGi in WebSphere and Apache Aries

This session will describe the challenges faced by many complex enterprise Java projects and looks at how OSGi helps to simplify both development and operational aspects of these projects using Apache Aries technology and emerging tools for Enterprise OSGi development. Uniquely, this session will also look at how the integration of Apache Aries components with IBM's WebSphere Application Server enables enterprise OSGi applications to be deployed and managed alongside existing Java EE applications using common tools, runtime and administrative processes.

Experiences with OSGi in industrial applications

At the SCCH, we have been utilizing OSGi as a base for various projects since 2003. The range of application spans from high availability systems in the steel industry to a vehicle data collector/transmitter on an Embedded Java (CDC) platform. I will present the needs and requirements, which have driven us to utilize OSGi as well as experiences gained from these projects, covering every phase in the software lifecycle, from design, implementation and deployment to productive operation and maintenance at the customer’s site. Particular attention is paid to the appropriateness of OSGi for high availability requirements.

Using OSGi for the Realization of Home Automation Systems

OSGi has long history in the residential area and the recent acceptance of OSGi by organizations like BBF, HGI, and UPnP has enormously pushed its usage in home gateways and intelligent home control panels. The home automation services are among the most appealing services which can be offered on OSGi enabled boxes. This presentation explains: -why OSGi is suitable for the realization of home automation systems; -how the numerous existing home protocols (UPnP, Zigbee, Z-Wafe, etc.) can be supported in a convenient way; -how home automation GUIs for desktops and mobile devices can be build; -how home automation systems can be remotely managed. The topic is important because: - there are many home automation systems currently under development and their develops are looking for guidance in addressing the issues mentioned above; -if the OSGi community openly discuss and agree on a common approach for building home automation system, this will significantly improve the interoperability of the systems and the re-usability of their components. What can someone expect to take away from the presentation? -good understanding about the existing OSGi related technologies in home automation area; -a reference architecture for building such systems. What makes your presentation unique? -good knowledge of the ongoing standardization efforts in this area; -personal involvement in many real home automation projects; -successful OSGi productization work.

Rapid Bundle Development with Bndtools for Eclipse

Bndtools is an Eclipse-based development environment for OSGi bundles and applications that focuses on ease of use, rapid development and encouraging OSGi best practices. It is based on Bnd, the popular bundle builder tool developed by Peter Kriens. In this talk, Neil will demonstrate the unique features of Bndtools while live-coding a complete, end-to-end OSGi web application.

Predictability vs. Dynamism: managing dynamic real-time applications

Dynamic adaptive behaviour and real-time execution are new requirements of modern software. While the former primes for flexibility and unforeseen modifications in the environment at runtime, the latter concerns predictability and determinism of application’s deadlines (i. e. hard real-time) and homogeneous response times (i. e. soft real-time). Several solutions for dealing with both aspects separately have been fairly recently developed for the Java platform. Gradually, more and more Java applications have been migrating to the OSGi framework, due to its flexibility and dynamism. However, due to the popularization of solutions such as RTSJ in the world of real-time programming, some of these applications have real-time requirements and the dynamism offered by the OSGi platform is a factor that may compromise the deterministic behaviour of the application. In this presentation, we analyzed the impact of dynamism provided by the OSGi platform against predictability needed by real- time Java applications. We also suggest approaches such as architecture freezing and the usage of SLA extensions in order to take into account real-time requirements. The approaches are demonstrated using the Real-time Java System from Sun, and Felix and iPOJO from the Apache community. Finally, we hint on possible evolutions of the OSGi platform in order to run a mix of real-time and non real-time applications simultaneously.

OSGi and Android

Android holds the promise of an open source, Linux/Java based software stack, and various experiments have proved successful in demonstrating that OSGi can run in such an environment. But what does this mean in practice when you start trying to use the platform in earnest to run real-world java applications? In this talk we describe some of our experiences in running a full OSGi-based server on an Android phone, the good, the bad and especially the ugly. For Android is not as truly open as it purports to be, nor is it as flexible as its Linux/Java heritage could allow. This presentation, based on real-world experience, will open up the pitfalls of OSGi development on Android as well as highlighting some of the features of OSGi that make such development even possible. At the end you should have a good idea of the Java-capabilities of the Android platform and whether it is ready for more demanding Java-based applications.

Enterprise Platform Over OSGi: Migration Diary

Got a legacy Enterprise Platform you plan moving to OSGi? Join the club. OSGi is cool in lots of ways and the best thing is that it is a standard. Migrating your proprietary enterprise platform to the new technology is a very appealing idea too. What it certainly is not – a piece of cake. Application server providers have a long path behind creating proprietary component models, lifecycle, packaging and provisioning. Along with the obvious challenges such as backward compatibility and runtime environment specifics, there can be various impediments hidden down the road. Early discovery of those obstacles can save you tons of troubles and ensure a smooth ride. Join this session where we will open up our migration diary.

OSGi ME - An OSGi Profile for Embedded Devices

What is the talk about: OSGi technology is a reference for flexible software on home devices. The technology has become the basis for home gateway prototypes in labs around the world. Standardization bodies, e.g., Broadband Forum and UPnP Forum, are shaping their specifications targeting software modularity and openness to third parties according to OSGi model. However, home devices are not OSGi yet. The talk is about an OSGi Profile for Embedded Devices, named OSGi ME. It describes use cases in the home environment calling for the profiling of OSGi specification to the embedded world. The speakers deliver hints on the implementation and the first lessons they have learnt. Why is the talk important New applications in the home – energy efficiency, digital home – emphasize the need for ICT players to make their software architecture flexible enough to accelerate time to market of new services and to open their home boxes to third party applications. OSGi technology has appealing advantages that only partly fullfill technical requirements. OSGi ME goes through necessary enhancements and drawback removals to adapt the deployments of modules to cost effective markets: robustness of software, tiny footprint, download policy related to embedded industry business models. The speakers give technical hints to implement OSGi ME features like Java ME CLDC compatibility, code sharing and isolation mechanisms without user-defined class loaders, transactional deployments, stale reference detection. Thanks to OSGi ME, attendees will foresee embedded applications delivered with more guarantees on embedded devices where costs do matter.

OSGi & Private Clouds

This talk will discuss the benefits and challenges of using OSGi in Private Cloud environments. Private Clouds are increasingly being adopted by organisations to provide scalability and to rapidly respond to business needs. A demonstration will be provided based on the Paremus Service Fabric showing how an enterprise application can be deployed, upgraded and managed in this environment. Also showcased will be some of the advanced capabilities made possible by OSGi in the Cloud. Attendees should have a basic knowledge of OSGi to get the most out of this session.

Migration from Java EE Application Server to Server-side OSGi for Process Management and Event Handling

With the transition from Java EE to server side OSGi we tackled two problem spaces. At first, the migration of a Java EE based product (Ginger) for process management and for event handling to a product (Roots) based on an OSGi platform (Equinox). Secondly, the migration of existing customer applications from the Java EE based product to the OSGI-based product. To reduce the risk of a big bang a stepwise approach is chosen. The major steps are: Wrapping the Java EE product to run in the OSGi system, and re-engineering step by step single modules of the old system to OSGi. Technical focus is set on bundle and service architecture, distributed processing, web components, and event processing. A distinction is made between pure OSGI-features and Equinox add-on. The lesson learned will be presented which include: benefits and drawbacks of server-side OSGi, migration patterns, and finally re- engineering costs. Finally, from the experiences made a wish-list is stated for the future direction of OSGi.

Modular Applications on a Data Grid - A Case Study Using OSGi and Oracle Coherence

An overview of the technical architecture of a system that provides various application services around trades and positions for the post trade services area of an investment bank. The novelty of the architecture lies in the deployment of the Oracle Coherence data grid nodes within OSGi containers. This allows greater flexibility in the management and deployment of services and data models, and a less disruptive means of upgrading data models and services than is possible without the use of OSGi.

A crash course in OSGi application development

The new OSGi Alliance Enterprise Specifications release provides definitions and guidance for a number of enterprise technologies, and has led to a sudden growth in the number of runtimes offering an OSGi container such as Apache Aries, IBM's WebSphere Application Server, Oracle GlassFish Server, Eclipse Virgo and many others. The presenter will use his experience as an OSGi Enterprise Expert Group member and as an Apache Aries committer to provide an overview of the new OSGi standards that are brought together by the Apache Aries project. They will then be combined in a lightning-fast demonstration to produce a working OSGi application, complete with enterprise-level managed transactions and container managed JPA.

Automated Semantic Versioning for OSGi Bundles

The OSGi resolver relies on correctly set version numbers for packages and bundles, to determine their compatibility for wiring. We have researched a method to automatically create version identifiers of exported packages based on their subtyping comparison. This talk reports on our toolset (standalone webservice and Apache ACE integration, under development) which uses this method to assign bundle metadata which provably follow the policy set forth in the recent Semantic Versioning whitepaper.

OSGi and Terracotta: replication of states for clustered services

Terracotta is a solution for clusterizing applications across JVMs. It enables the replication of the state of Java class instances across several distributed virtual machines. Terracotta is not only popular for dependable Java platforms but also for distributing software that was originally designed in a centralized way. Transparent distribution is obtained by run-time bytecode injection, which is configured through an XML file. One of the numerous services provided is the distribution of objects across multiple virtual machines (DSO). Thus, an object is replicated on all the VMs, and the modifications on its value are propagated. We use Terracotta to replicate the internal state of an OSGi bundle across JVMs. We have designed a set of Java annotations for specifying replication metadata directly in the source code. They allow the definition of shared fields, distributed methods, classes to instrument, etc. With these annotations, a processor relying on APT generates a usable configuration file. Terracotta can be used even for bundles that use the service-oriented component model, iPOJO. We have validated our container with several scenarios, illustrating different ways to use DSO in the context of existing OSGi projects. Currently, we are working on techniques, for applying distributed updates of replicated bundles at run time. To summarize, the problem is to maintain the coherency of the whole application when an update cannot be applicated on all the VMs. This presentation will include two short demonstrations showing Terracotta and iPOJO.

Dynamic Swing Applications using OSGi

OSGi forms the basis of Eclipse RCP applications. For a number of reasons, XLegal needed a Swing based equivalent to Eclipse RCP. In devising our framework, which we call OSGi Desktop, we did not see the need for static configuration at startup using plugin.xml. In OSGi Desktop, all contributions to the menubar, toolbar, status bar and desktop are made by registering a service in the OSGi framework. All focus and select events are fired off to listeners, which are services registered on the framework. As in Eclipse RCP, OSGi allows third party contributions to a platform application. Those contributions can be at a fine granularity. For example, we have added a service which listens for the registration of third party services in order to add transparent layers to an existing window. This allows a third party contribution to annotate content provided by another contributor. A particular issue which we encountered was how to group services within the framework so that they can be treated as one. For example how to select services in the framework to be saved, depending on which window has the focus. Both persistable services and window services needed to be grouped in several dimensions for this purpose. We found the LDAP notation of OSGi unsuitable for this, and we devised solutions based on namespaces to overcome the problem.

Dependencies, dependencies, dependencies!

Not only does OSGi allow you to modularize your codebase, it also enables you to build highly dynamic applications. That means that often you have to deploy certain components together to create a working subsystem. It also means that components can have lots of different dependencies on other components, services or even resources and configuration data. Managing all of these is not trivial, but crucial if you want to end up with a system that's easy to deploy and upgrade. By applying the right design patterns and using libraries that help you declaratively specify dependencies, you can quickly create applications that are loosely coupled by services and have qualities like substitutability and scalability. During the tutorial, hands on excercises will illustrate the different patterns and demonstrate how to build robust components that can deal with all the dynamics that OSGi will throw at it. In the end you will have learned how to build on OSGi using much higher level primitives than the ServiceTracker and ServiceListener that the specification provides.

Case study report on i-House experiments using intermediate service platform based on OSGi technology

In this presentation, case studies on building various kinds of home networking services on OSGi-based home gateway are introduced. The intermediate service platform for home networking services, including OSGi service aggregation platform (OSAP) enables users to subscribe to new home networking services flexibly and easily. We evaluated the effectiveness of this platform on the real house facility "i-house" for experimental studies. This study was conducted based on the support of the national RD project, organized by Ministry of internal affairs and communications, Japan.

SOA Flexibility with OSGi Remote Services and the Service Component Architecture

OSGi V4 R4.2 introduced the Remote Services specifications which, for the first time, gave a standard way to describe the distribution of OSGi services. The design took a simple 'light touch' approach which meant that Remote Services implementations could embrace a wide variety of existing distribution technologies. In parallel, OASIS has been developing the Service Component Architecture (SCA) specifications. SCA provides a heterogeneous SOA programming model which spans an extensible number of implementation technologies (EJB, BPEL, C++, COBOL), bindings (Web services, JMS, IIOP, etc.) and policy languages (WS-Policy, etc). With SCA, you can assemble and re-assemble existing applications and assets, and mix in new implementation assets, improving re-use and flexibility to changing business needs. This presentation will give an introduction to the OSGi Remote Services and Service Component Architecture technologies. It will describe how the two can be combined allowing OSGi applications using Remote Services to exploit the variety of SCA implementation technologies, bindings and the policy framework. It will then give a demonstration of the combination in practice using a number of open source project, including Apache Aries and Apache Tuscany.

Arum DataEye - evolution of a modular rich internet application

This session describes the initial architecture of the Arum DataEye product (a management information dashboard for the Credit Management and Collections industry) and how it has evolved to the product it is today. From a web app with JEE dependencies using an embedded Equinox container, to a set of 'pure' OSGi bundles that can be deployed in to any OSGi container or wrapped in a WAR file for deployment to an app server. The session describes the mistakes of an OSGi novice (me) and the improvements made as that novice gains experience and it describes how OSGi remains flexible and robust even while making architectural changes. It shows (but does not focus on in detail) how to create a modular web application using OSGi and Flex / Flash.

Enterprise OSGi for Dev and Ops.

Enterprise Java applications are often deployed in archives that contain everything the application needs to run, including the kitchen sink. Sometimes they're deployed to a server environment hosting other applications, all with their own sinks. The Operations team has the duty of looking after all this plumbing - which might include multiple third-party frameworks with similar dependencies on common libraries. This can become a real headache if different frameworks require common libraries at different versions. Multiply this across all the applications deployed to an enterprise and Ops has a real job on its hands. Part of the problem is that, no matter how modular and serviceable each individual application is, the deployment process itself needs to understand the relationship between application modules and provide a better delivery mechanism than a bring-all-your-own-plumbing enterprise archive. Operations need a deployment infrastructure in which they can manage multiple versions of common modules, independent of the applications that require them; Development need a deployment system in which they deliver enterprise archives containing only application-specific modules, which are deployed and resolved against the common infrastructure managed by Operations. With the finalization of the OSGi v4.2 Enterprise platform specification this year, enterprise applications have a standard way to use familiar Java EE technologies in an OSGi environment and the opportunity to be deployed to enterprise servers as a collection of versioned bundles with well-defined dependencies. Common application infrastructure can be moved out of individual application archives into a shared bundle repository where different versions can be managed centrally. This session looks at how the enterprise OSGi landscape has changed over the last year and how WebSphere Application Server is using OSGi to address some of the oldest and most common Dev-Ops challenges in Enterprise Java.

Working with Eclipse and MS Visual Studio Team Explorer

Working within a heterogeneous development team with Visual Studio Team Explorer Everywhere Microsoft Team Foundation Server includes enterprise class version control, work item tracking, an automated build engine, reports and project dashboards. That's great if you're a .NET developer working in Visual Studio, but how can Eclipse based development teams also take advantage of these features and share a common development environment with .NET developers? This session will provide an overview of Team Explorer Everywhere and will demonstrate how this provides integration from Eclipse into Team Foundation Server.

Learning Lessons on Application Architecture from NoSQL

Over the past few years a large number of alternatives to RDBMS products have emerged. Whilst we may not all get to use these, the architectural trade-offs which their authors have made can give valuable lessons to apply to the applications we build, whether in fault-tolerance, scalability, availability, conflict resolution, and dealing with large geographical distribution.

Overview: Making Your App Shine with Rich Reports and Visualizations Using BIRT

Many applications collect and process data from users, real-time data feeds, SQL databases and more. The challenge is how to present this valuable data to users as information they can use. And how to quickly respond to requests from those users for different ways to visualize the data. BIRT, the industry leading open source reporting and Business Intelligence project within the Eclipse Foundation, is a new generation of reporting and data visualization technology that does just that – enabling you to focus on building the core capabilities of your application and utilizing ready-to-go BIRT technology to add rich information that meet your users’ needs. This session introduces BIRT and looks at how you can leverage BIRT to create data-driven reports, web pages, and add compelling information visualizations to your application. The session provides some background on the project and quickly dives into the architecture, key capabilities and how to use BIRT.

BIRT: Interactivity and Dashboards – Giving Your Users What They Want

The open source Eclipse BIRT (Business Intelligence and Reporting Tools) project is a huge success with developers and users alike, with an estimated 750,000 developers globally using BIRT. Even with this success, we see users clamoring for more: faster deployments, richer visualizations, and the flexibility to answer ad-hoc questions. In this fast paced, live demo-oriented session we dive into how Actuate has addressed these demands by extending open source BIRT with a range of capabilities including dynamic visualizations, interactive content delivery, data analytics and dashboards. With these new capabilities you can deliver visually rich, dynamic content to your users and empower them with very easy self-service data exploration (freeing you from day-to-day report development).

Agile Manifesto put to test

In 1848 Marx and Engels created the exemplar of a “Manifesto” , a document meant to collate and summarise the thoughts of a movement. If you wanted to know what a Communist could be expected to think, or do, you could look in the Manifesto. So it is with the various Manifesto's we have in the IT industry. I you want to know how an Agile developer should behave you can look at the manifesto. As with the Communist Manifesto the Agile Manifesto can be considered a critique of and a response to industrial conditions in a certain time and place. What does that tell us about the recommendations in that Manifesto? Do those conditions still apply? How has current good practice changed? What guidance can this model provide for what comes next?

Focus agile development on tasks in Eclipse with P4Mylyn

With P4Mylyn, which is included in the Perforce Plug-in for Eclipse, developers can focus work on given tasks managed in common bugtrackers like Bugzilla easily within Eclipse. Get an overview of a typical Agile developer's workflow using Perforce and Mylyn. See how developers can schedule and manage a task list and how those tasks eventually become completed with a submitted Perforce changelist.

The Long And Winding Road...