Best Practices for Scaling your SOA Infrastructure and Project, Albert Tay, Director - Service Oriented Architecture, Oracle Corporation

Service-Oriented Architecture (SOA) has been touted to deliver efficiency gains with increasing scale and expansion. But there is a concern that SOA projects tend to stall early due to issues related to performance, scalability, security, and organizational structures. This session shares Oracle's experiences from powering thousands of SOA implementations across industry verticals and geographical regions around the globe. Come listen to experts discuss the right architectural approach and the best implementation practices to overcome these issues to make SOA a success within your enterprise.

How to achieve business results faster from your SOA and EA with BPM by Mr Paul Henaghan, Senior VP for Asia and Mr Yew Cheng Cai, Solutions Consultant, Software AG

Many organizations today are either considering or in the process of implementing Enterprise Architecture (EA) and Service-Oriented Architecture (SOA) as part of their IT strategy, with an ultimate goal of becoming agile and adaptive.. At this presentation, you will learn the pitfalls to avoid and best practices to adopt when deploying your EA and SOA. More importantly, you will understand how to leverage your EA and SOA using Business Process Management (BPM) to deliver business results, faster. Software AG’s approach and methodology used in helping organizations reap the business benefits of EA – through the compound effects of SOA and BPM, will also be discussed, together with relevant case studies.

Are your services loosely coupled?

Web Service technology has become a popular choice for the integration of enterprise applications. While most software architects would agree that loose coupling is one of the most important goals of enterprise integration, the way Web services are used in practice very often leads to a fairly tight coupling. The resulting architectures are brittle and vulnerable to change. The implementation of new requirements becomes increasingly difficult and expensive. In this session you’ll learn how to avoid typical pitfalls and how to use Web service technology in a way that results in loosely coupled integration solutions instead.

Enterprise Integration and SOA with Open Source

Enterprise Integration is one of the most critical IT requirements for many organizations today. And with the emergence of SOA, the ESB approach has become a popular choice. But opinions differ significantly. While many organizations have adopted ESBs, there's is also widespread criticism. ESBs are criticized as being expensive and creating vendor lock-in. This talk discusses alternatives for implementing an integration infrastructure, based on a selection of individual open source products. Topics include messaging, routing and mediation, message transformation, business processes and business rules.

Comparing JRuby and Groovy

Life used to be so simple in the Java world. The only real decisions you had to make was which dozen frameworks to use in your project. Now, dynamic languages have invaded Java land, and you now have lots of choices. But, to the casual observer, JRuby and Groovy look like pretty much the same thing, with slightly different syntax. Nothing could be further from the truth. While they both share lots of commonalities, they are also quite different. This session delves into those differences, providing the attendees with enough concrete facts to make decisions. This session covers differences between type systems, extending the core JDK, closures, and properties. This session also covers meta-programming differences, where the languages diverge the most, including open classes, code synthesis, mixins, interfaces, intercepting method missing calls, shadow meta-classes, and lots more. Code is the focus of this talk, with tons of examples. Attendees leaving this talk will have a clear picture of the real differences of these new kids on the Java block.

Evolutionary SOA

Managers and ivory tower architects seem to think that all the rules that apply to “normal” software don’t apply to SOA. Ironically, they matter even more. Agility and SOA are closely aligned because SOA is about building complex distributed systems and Agility is about effectively building complex software. This session unveils the pillars of successful SOA and how to achieve them in a testable, iterative fashion. It discussing testing strategies, how to make your architecture more robust and maintainable, and how to design an evolutionary architecture.

• The Pillars of Successful Software
• Testing Strategies
• Choosing Infrastructure
• Avoiding Fragility
• Designing Evolutionary Architecture

Introduction to Jruby

Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This session describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This session also demonstrates some areas where it makes sense to mixin Ruby and Java code: Rails on Java, testing, and dynamic programming. JRuby is a powerful implementation of Polyglot Programming, and this session shows you how to leverage this cutting-edge concept.

• JRuby’s origins
• Calling Java from Ruby
• Calling Ruby from Java
• Limitations and pitfalls
• Example usage o Rails on Java o Testing o Dynamic programming
• The future

EclipseLink JPA

For over a decade now, Oracle TopLink has delivered a premiere Java persistence solution. With the open sourcing of the complete TopLink product in the Eclipse Persistence Services (‘EclipseLink’) Project, a new era has begun. EclipseLink delivers a comprehensive set of Java persistence services addressing relational, XML and non-relational data stores through standard interfaces including JPA, JAXB, SDO and JCA. In this session, we’ll focus on EclipseLink JPA: its advanced features, how it can be used in various Java containers, and its role as the JPA 2.0 reference implementation.

OSGi Persistence

OSGi is quickly gaining mind share amongst Java developers who want to build modular and manageable applications. But not all the commercial and open source projects that you might be using today work out of the box in OSGi. Fortunately, for developers needing Java persistence there’s EclipseLink, the Eclipse Persistence Services Project. EclipseLink provides high performance native OSGi implementations of the Java Persistence API (JPA), Java Architecture for XML Binding (JAXB), and Service Data Objects (SDO) specifications. This session will provide a brief overview of EclipseLink and the standard technologies it implements, but the focus will be on using EclipseLink in OSGi and the issues to be aware of when developing OSGi based applications with Java persistence.

XML Binding with EclipseLink: JAXB and SDO

The use of XML in Java applications is extensive and continues to grow. It’s used everywhere from configuration files, JMS messaging, Web Services, and Ajax applications. In this session attendees will be introduced to the MOXy (JAXB) and SDO components of the Eclipse Persistence Services Project (EclipseLink) and will discover how these technologies can be used in Java SE, EE, OSGi and Spring.

Building Applications with EJB 3.1

In its last release, EJB 3.0 underwent a substantial overhaul, making component development easier than it has ever been, even compared with the state-of-the-art dependency injection containers of the time. However there were still a number of features that were missing from EJB that other containers had. In this talk we will discuss some of the features that EJB 3.1 is introducing, including being able to run EJB in a standalone JVM, singletons, asynchronous session beans and additional Quartz-like scheduler mechanisms. Attendees will get a chance to see how EJB 3.1 provides all that developers need in order to write enterprise Java components with increasingly complex requirements.

JPA: The Standard for Enterprise Persistence

The introduction of the Java Persistence API signalled the beginning of the end of using proprietary Hibernate or TopLink mapping files and session APIs to persist your business objects to a relational database. The standardization of object-relational mapping means that developers may now use a powerful yet simple API consisting of 4 easy-to-learn classes, and still access vendor-specific features through JPA extensions. This talk will cover some of the important features of JPA, including the EntityManager API, object-relational mapping, and queries. You will also get valuable tips and tricks for developing better JPA applications.

OSGi and Java EE: Friends or Foes?

Although OSGi started life as an embedded technology it is now making a leap into the enterprise. The problem is, many people are aready using an existing enterprise Java technology (Java EE) so naturally questions are being asked about why we need another technology, and what purpose it might serve. In this talk we discuss what OSGi is, how it compares to Java EE, where they intersect and whether they can and should co-exist. We will also discuss the active progress being made on each side and what is on their respective horizons. Attendees can expect to learn more about how these standards are currently developing and how they will be affected in the future.

Software quality - you know it when you see it

Software quality has an obvious external aspect, the software should be of value to its users, but there is also a more elusive internal aspect to quality, to do with the clarity of the design, the ease with which we as technologists can understand, extend, and maintain the software. When pressed for a definition, this is where we usually end up saying “I know it when I see it.” But how can we see quality? This session explains how visualisation concepts can be applied at the right level to present meaningful information about quality. Different visualizations allow us to spot patterns, trends, and outliers. In short, they allow us to see the quality of our software. The tools and techniques shown are easy to apply on software projects and will guide the development team towards producing higher quality software.

HTML 5 WebSocket - The Future of the Web

There are several innovations within the HTML 5 specification that will forever change the direction of the web, and one in particular - WebSocket - that will revolutionize the way we develop and deploy web applications. Until now, bi-directional browser communication has been an elusive goal of the Comet community, usually achieved with an assortment of hacks. However, with recent updates to the HTML 5 specification, developers can now use a full-duplex communications channel that operates over a single socket.

The HTML 5 WebSocket enables communication from the browser to any TCP-based back-end service (for example, JMS, JMX, IMAP, Jabber, and so on). For example, it is now possible to avoid convoluted architectures by simply channeling certain protocols to the browser over HTTP and web applications can now be deployed without the need for a traditional web server.

This session will provide an in-depth look into the use of HTML 5 WebSocket and the techniques and technologies required to build "real-time" Web applications with it.

Kaazing Gateway: An Open Source HTML 5 Websocket Server

Ajax killed the click-and-wait experience we once associated with the Web and today, Comet is eliminating the stale data-delivery associated with traditional Ajax techniques such as polling. However, based on recent progress within WebSockets in the HTML5 specification, Web developers can finally make streaming data to browsers in real-time a reality.

Kaazing Gateway is an Open Source, enterprise Comet solution that enables full-duplex communication from the browser to any TCP-based back-end service. Kaazing Gateway is the first Java solution that understands the WebSocket protocol and provides support for all major enterprise protocols (for example, JMS, IMAP, JDBC, Jabber, and so on).

Kaazing Gateway eliminates the need for using convoluted server- and client-side architectures to map server-side protocols to the browser over HTTP. The resulting, simplified architecture allows Web developers to use the browser's native JavaScript support to code directly against the back-end services without the need for custom Servlets or server-side programming.

That's right! Kaazing Gateway allows developers to take full advantage of the HTML 5 WebSocket interface today. Once browsers support full-duplex connectivity, per the HTML 5 specification, there is no need to change any server or client code; applications will automatically take advantage of the native browser implementations of HTML 5s WebSocket interface with improved performance. This makes browsers first-class participants in the server-side message bus, allowing browsers to send and receive messages in text and binary form using standard server-side protocols, and to communicate directly with any back-end services over the Internet.

Kaazing Gateway also brings the elastic scalability required to support hundreds of thousands of concurrent users to Comet, as well as the performance necessary to guarantee service-level agreements within milliseconds. Come see how you can start changing the way the Web works!