Forgot your password?

Conference slides of S&S Media Group
until september 2019

Register

  • By sending the registration you confirm our general terms and conditions and data protection regulations.

DIREKT BESTELLEN

Bestehendes Abonnement zum entwickler.kiosk-Zugang erweitern

Bitte wählen Sie Ihr bestehendes Abonnement:

Volltextsuche

Ihre Suchergebnisse für:

No content found!

JAX – DevCon – OSGI London 2010

JAX – DevCon – OSGI London 2010

bis
Unleash your domain

Our application runs over 10,000 sustained transactions per second with a rich model. The key? Modeling state transitions explicitly. In today's world many systems have non-functional requirements that prevent them from being single database centric. This presentation looks at how Domain Driven Design can fit into such environments including extremely large scale web sites, batch processing, etc.

The Long And Winding Road...

Jim will discuss the long and winding road of OSGi's role in end to end middleware and where that road may lead in the future.

It's Not About Technology Anymore (Including a Case for Modularity)

At a certain point in the evolution of a large IT environment, investing in developing new applications becomes less important than rationalizing existing investments. In the case of the Credit Suisse Investment Banking Division at least, it is clear that we have more than enough IT applications to run the business. To successfully improve the existing application environment we are defining target architectures, application roadmaps, and the governance processes to ensure we move toward the targets. The architecture work is based on SOA, which requires modularization of the existing application landscape. This talk describes why improving IT is more important than new technology, outlines the Credit Suisse IT strategy, and provides details of the Investment Banking Division architecture and modularity initiatives.

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.

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.

Eclipse Virgo Update

The Eclipse Virgo project is approaching its first release as a kernel-based application server built from the ground up on OSGi and supporting sophisticated OSGi applications. The session will cover why you would use Virgo, what it can do, where it's got to, and how you can get started.

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.

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.

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.

App Store for the Connected Home Services

In the mobile space app stores are very succesful. But where to find the killer app for your connected home devices? Carriers, Service providers or device manufacturer selecting an OSGi-based open approach can easily build such stores and increase their presence and service uptake within the subscriber's digital home in order to increase their average revenue per user, reduce customer churn and decrease operational expenditures. My presentation will give an idea on existing Eclipse- and OSGi- based tools that help service providers to built such app stores. It will in addition present the concept of an white-labled SDK which may contain feature such as: - Eclipse plugins for OSGi development - Target device runtime definition for Eclipse, containing the exact device APIs - PC or Mac based emulation and simulation environment for the target device - Integration with the OEMs or Carriers app store - Documentation, References, Samples The presentation is very important for device OEMs or Carriers planning to open up an OSGi based device to the public developer community. It shows how to enable the developer community to create OSGi content for a dedicated device - branded and published by OEMs or Carriers.

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.

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.

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.

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.

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.

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.

Running your Java EE 6 applications in the Cloud

GlassFish v3, the Reference Implementation of Java EE 6, can easily run on multiple cloud infrastructures. This talk will provide a brief introduction to Java EE 6 and GlassFish v3. The attendees will learn how to create a simple Java EE 6 sample application and deploy them on GlassFish v3 running locally and then deploy it using Amazon, RightScale, Joyent, and Elastra cloud infrastructures.

Spring 3.1 - Themes and Trends

On the foundation of the well-received Spring 3.0 platform, the upcoming Spring 3.1 release introduces major new features for modern enterprise Java applications: conversation management, conditional component definitions, and dedicated support for the Servlet 3.0 and JSF 2.0 standards. This talk will provide insight into the latest developments in the Spring Framework space, in the context of current enterprise Java trends. The Spring 3.1 release is scheduled for general availability in December 2010.

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.

Hands-on Agile Development

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.

Spring: Having fun with the RestTemplate

In this session, Arjen will talk about the RESTful features. Specifically, we will focus on the client-side: the RestTemplate. We will show how to use the RestTemplate to integrate with Twitter, Flickr, and other web sites.

Architectural Kata

Fred Brooks said, "How do we get great designers? Great designers design, of course." So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect. The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than "Hello world". The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.

Challenging Requirements

In this presentation, Gojko Adzic talks about common failure patterns with requirements and specifications on agile projects and talks about ideas, patterns and practices for requirements and specifications that lead to much less rework, more consistent specifications with less functional gaps and ultimately happier customers.

Advanced security for Web services

The WS-Security standard is widely used today. However, it's functionality is rather limited and suitable for basic scenarios only. At the same time, Web services are being used in scenarios that are increasingly advanced. This session introduces more advanced Aspects of service security, like Secure Token Service (STS), authentication with SAML tokens, single sing-on for services and standards like WS-Trust or WS-SecureConversation.

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.

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.

Windows Azure Platform Best Practices

This session will look at some of the best practices used by early adopters to get the most out of the Windows Azure Platform. It will whizz through topics such as auto-scaling, Azure Tables as NoSQL, data tricks, data partitoning and running code that isn't .NET. It assumes familiarity with the basics of Azure.

CQRS, Diving Deeper?

You understand the benefits of CQRS but now you want to implement it. In this presentation we will look strategies for implementing CQRS. We will delve into Event Sourcing, and understand how and when to implement this technique. We will also discuss NoSQL databases and show how they match up with our requirements. Finally we will look at what this means for your overall application architecture.

Busy .NET Developer's Guide to F#

F# is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the CLR as standard assemblies. Sporting the usual object-oriented concepts as classes and inheritance, F# 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 the CLR and .NET class libraries, F# offers .NET programmers an opportunity to write powerful programs with concise syntax for a new decade of .NET programming. In this presentation, we focus on the parts of F# that form the "foundation" of the language, such as its data types, type-inference, and flow control constructs, from basic decision making (if/else) to more advanced constructs like like pattern-matching.

LINQ in Layered Applications

If you are building applications with LINQ there are a number of trade offs you need to evaluate from an architectural perspective. In this session we'll talk about deferred execution and the important performance distinction between Enumerable and Queryable data sources. We'll look at the decisions impacting flexibility, extensibility, performance, and maintainability.

Multimedia in Silverlight 4.0

Learn how to encode, publish, download and display video and audio files and streams using Silverlight 4.0. Use the Expression Encoder to create videos for Silverlight complete with markers and other features. Learn how to access the webcam in Silverlight 4. Great demos.

Keeping SCM Flexible for the Agile Workflow

Discusses the benefits of using Software Configuration Management toolsets to version all the assets used in the development process. The SCM system sits at the very foundation of an agile workflow. It provides a hub through which developers can communicate regarding their tasks and changes, and it pulls together all the threads of an agile architecture.

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.

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.

Improving Developer and Tester Collaboration with Visual Studio 2010

An effective collaboration between developers and testers is paramount and can make the difference between shipping quality applications on time, or slipping because bugs are found late. In this session, we'll show you how developers and testers benefit from integrated tools throughout the development lifecycle

Dynamic Consumption in C# 4.0

C# 4.0 supports the new "dynamic" keyword, which promises easy interaction with those parts of the programming world that are, well, dynamic in nature. In this session, Oliver walks you through several scenarios, interfacing with dynamic programming languages as well as Automation, and explaining some of the basics of how dynamic calls work in C#.

Dynamic C# 4.0 - the provider side

The integration of dynamic features in C# 4.0 is based on clever architecture that hooks into the DLR. Therefore, the APIs are complex (and well designed!) enough to allow for extensions, so that C# programmers can create their own dynamic classes, either to implement fully dynamic structures for use on the "static side" of .NET programming, or to provide APIs to dynamic languages. This session provides several practical examples!

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.

An Introduction to Clojure

In an increasingly crowded field of languages on the JVM and CLR, Clojure stands out as unique. It is a dynamic, functional, high performance dialect of Lisp that runs on both the JVM and CLR. The creator cast aside assumptions from both the Lisp and Java communities to create a remarkable language implementation. This session introduces Clojure to Java developers who might not have seen a Lisp and don't yet understand why that's such an advantage. I introduce the language syntax (what little there is of it), cover interoperability with Java, macros, mutlti-methods, and more. I also cover the functional aspects of Clojure, showing it's powerful immutable data structures, working with threads and concurrency, and sequences. Attending this session will show enough to pique your interest and show why many of the people who were interested in Java in 1996 are interested in Clojure now.

Architectural Katas

Fred Brooks said, "How do we get great designers? Great designers design, of course." So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect. The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than "Hello world". The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.

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.

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.

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.

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.

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.

Java Performance Tuning - not so scary after all

No one likes slow applications, but sometimes it's hard to know where to start when trying to fix a performance problem. This talk will cover a range of tools and techniques which can be used to track down and fix performance issues and will answer questions such as: Why performance really really matters? 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? Are you waiting around on locks? Is your application running the code it should be?

X
- Gib Deinen Standort ein -
- or -