Ten Ways to Destroy Your Object Relational Mapping Project

Object Relational Technology has been widely adopted by the IT  industry, yet using it presents challenges that might not be apparent at first. In the object domain, inheritance and rich data types are  common; in the relational domain, complexity is built using relations  among simple data types. Success in ORM projects comes only by understanding both domains. Here are ten pitfalls of ORM to watch out for, including normalization, too-eager and too-lazy loading, and distributed caching gotchas.

Don't Know Jack About Object-Relational Mapping?

You don’t know Jack about Object Relational Mapping. So why are you considering using it? Keeping up with the Joneses? There’s a great community or two out there, and who doesn’t need another community? You already know that modern applications are built using two very different technologies: Object-oriented programming for business logic, and relational databases for data storage. Object-oriented programming is a key technology for implementing complex systems, providing benefits of reusability, robustness, and maintainability. Relational databases provide data independence as repositories for persistent data. Object-Relational Mapping (ORM) is a bridge between the two that allows applications to access relational data in an object-oriented way.

What’s new in Spring 3   

The Spring Framework has led the industry in innovation for years. Starting with dependency injection and promoting testing through removal of framework dependencies. Spring 3.0 continues that innovation in a way that takes full advantage of the Java 5 platform. There are a number of significant changes to the framework. So whither you are new to the framework or an experience Spring developer, this is a great session to come up to speed on the latest from SpringSource.

This will cover all the new features in Spring 3 complete with demos. This will include a look at the following:

• Spring MVC
• Spring REST
• Spring EL
• Spring Portlet
• Spring Declarative Validation

Spring and JPA   

This session will look at in detail the persistence capabilities of the latest Spring 3 and how to provide data access capabilities, including nicely added features for unit tests. We’ll focus the persistence discussion on JPA and examine a number of ORM mapping scenarios and how JPA maps to them. We’ll focus on the spring integration including transactional capabilities.

Temporal Determinism in Java – Not impossibility anymore!

Java, as we know, has a low entry barrier – the platform has several erstwhile programmer controlled features in-built. Think of features that Java provides out of the box – Memory Management, Security through Lazy Class Loading, Portability etc.. Some of these come with the penalty of losing temporal determinism – for instance, unexpected Garbage Collection Cycle when executing a Rocket Launcher might make the mission fail! What if we could bring the best of both worlds (A Java Platform with low entry barrier, but at the same time with technology to provide Real-Time guarantees)? That’s a reality today through Real-Time Java. This session will deal with various aspects of non-determinism in Java platform and the technology solutions/innovations that allow Java to overcome those aspects. It will also cover IBM’s Real-Time Java solution set in detail.

Search with Apache Lucene

With explosion of information, "SEARCH" has become mandatory for every application. This session will cover the fundamentals of building a domain specific search engine. We will cover in detail the challenges involved in building indices and parsing text queries using Apache Lucene. Finally, we look at Lucene tools that help with debugging and enhancing the capabilities of the core library.

Social Computing, Collaboration and Enterprise 2.0 with Liferay.

This presentation will go beyond the superficial applications of social computing to show real pragmatic value, cost reduction, and increased efficiencies gained by those deploying Liferay's open source social computing platform. We will highlight several successful case studies, including Cisco Systems' new developer network and Liferay's own social platform running on Liferay.com, and contrast the benefits and drawbacks of using a complete Liferay solution (including CMS, collaboration, and social) vs. integrating with best of breed products such as Atlassian or Jive.

So you want to be an Architect  

This session is a quick look at all aspects of being a corporate software architect. Whither you are a developer looking to move into the role of architect, needing to have an understanding of what is expected or already in the role of software architect looking for new and interesting ideas, this session is for you.
This session is designed to be a jam session on all aspects of software architecture and many of the roles of software architect. The following subject areas will be covered:

• Software Development Process
• Project Key Mechanisms: Languages and Frameworks
• Security: Threats, Securing Code Review, Adding Security to you process
• Layers, Partitions and Topologies
• VM Optimizations
• Usability and User Experience
• Optimizing the Web
• Ready for Production: Monitoring
• Integration

Lucky Number 6 for Java EE   

Java EE 6 is the latest Java EE release and shows the maturity of Java in the enterprise. In this talk we will take a quick tour of the highlights of the release, touching on many of the new features that are being introduced in the existing sub-specifications, and introducing some of the new specifications that have been added. Java EE is in the interesting position of having to ensure brand new and successful technologies are included and standardized, and that older less-favored technologies are not dragged along endlessly until they simply die on the rope to become dead platform weight. We will discuss some of the process changes that are designed to help keep the platform dynamic and vibrant.

OSGi and Java EE: Friends or Foes?

OSGi started life some years ago as an embedded technology but is now making a leap into the enterprise domain. Some people are asking why we need another technology when Java EE has been so successful in providing enterprise solutions. Others are wondering if OSGi is going to unseat Java EE as the enterprise development platform of choice. In this talk we will introduce what OSGi is and give an overview of its constituent layers. We will finish by comparing it with Java EE, discussing briefly where they meet and whether they can and should co-exist. We will also give an update on the progress being made in the integration of the two, and what is on the horizon for their integration.

Spring Dynamic Modules by example

The Spring Dynamic Modules project (Spring-DM, formerly known as Spring-OSGi) allows developers to combine the Spring Framework with the OSGi service platform. The session presents the basic concepts behind the Spring-OSGi combination and how the dependency injection facilities of Spring are combined with the dynamic service concepts of OSGi. The talk will present the concepts via a number of examples and shows how Spring-DM can be used to implement various kinds of enterprise applications. Attendees will see running examples for dealing with Spring-DM, with the dynamic nature of OSGi and how OSGi programming can be simplified by using Spring.

Test-Driven Design

Most developers thing that Test-driven development (TDD) is about testing, but testing is only a small benefit from using TDD techniques. This session demonstrates how stringent TDD improves the structure of your code. I discuss TDD as a technique for vetting consumer calls, using mock objects to understand complex interactions between collaborators, and some discussions of improved code metrics yielded by TDD. This session shows that TDD is much more than testing: it fundamentally makes your code better at multiple levels.

Unit Testing that Sucks Less: Small Things that Make a Big Difference

Unit testing seems to a lot of managers and developers like pure overhead, but professionally responsible developers know that it is one of the keys to quality. This session covers a bunch of small tools that makes testing easier & faster. I talk about tools like Infinitest, Jester, MockRunner, Hamcrest, Groovy, RSpec/EasyB, Selenium, and others. While none of these tools is elaborate enough for it’s own session, together they add up to more than the sum of the parts. This session shows tools and strategies to streamline testing, making easier and more palatable for both managers and developers.

Writing Killer JSF 2.0 UI Components

One of the key goals of JavaServer Faes (JSF) 2.0 is ease of use, and component development is a prime example: all it takes is a single file. What does this mean? Now you can write a reusable widget with ease, whether it’s a single HTML element, a reusable panel, or a powerful Ajax widget. If you can’t express everything in a single Facelet template, that’s okay – you can add logic with either Groovy or Java. And don’t worry – JSF 2.0 lets you easily package and version resources (such as stylesheets, images, or JavaScript files) in libraries, which you can load from a JAR file, or from your web application. In this session, we’ll walk through the process of creating UI components with JSF 2.0, moving from a simple component to a more complicated Ajax widget, looking at all of the great facilities JSF 2.0 offers component developers. We’ll also discuss the new Ajax JavaScript API, which simplifies the process of writing Ajax components and facilitates interoperability between different Ajax component suites.

JSF 2.0 in Action

JavaServer Faces, the standard Java web development framework, has gained quite a few fans and detractors over the past few years. Regardless of the camp, most agree that the framework could be improved. JSF 2.0, the latest release of the framework, is a dramatic leap forward. This session covers enhancements, changes, and new features currently under discussion by the JSF 2.0 expert group. These include improved Ajax support, better UI component interoperability, simpler component development, native support for Facelets instead of JSP, automatic re-deployment of application artifacts, support for annotations, and several other goodies.

From Loose Coupling to Event Driven Architecture and Lean SOA

Loose coupling is one of the key factors of the success of the Service Oriented Architecture. It allows easy distribution and replacement of components across wide spread networks. The real value of Loose Coupling unfolds when it is used in an Event Driven Architecture (EDA). EDA is the basis of any modern operating system and the key factor of the internet. This presentation gives you a kick-start in orchestrating loosely coupled services via events. Thinking in events is different from classical procedural programming. This session will make you acquainted with the different thinking structures of EDA and the possibilities that lie in them. It explains why loose coupling in combination with EDA will lead into a much leaner overall service-based infrastructure and a lean SOA.

Model driven SOA using SAP Composition Environment

Composite applications empower companies to drive innovative business processes. This talk will introduce you to SAP's Composition Environment a (SAP NetWeaver CE) which provides a methodology and toolset to efficiently develop and manage composite applications, following service-oriented architecture (SOA) principles. The session will cover model driven tools that SAP offers for process, rules, User interface and service development.

Why is Design Time Governance key for the success of SOA?

This talk will focus on the importance of Design time Governance in Service Oriented Architecture - both from the process and the tool perspective. The discussion will focus on concrete customer scenarios to explain how Design Time Governance was instrumental in the success / failure of these SOA initiatives. As part of the talk, Rathish will also share SAP's experiences with Design Time Governance and discuss briefly on SAP Internal governance process (PIC) and the Enterprise Services Repository which acts the central repository to manage SOA artifacts.

The brave new world of cloud computing

Cloud computing is not just another hype and far more than joining the computer power of many virtual servers. The disparate nature of clouds allow complete new possibilities in algorithmic. Can you imagine: clouds allow data security without certificates and passwords. Clouds can reduce costs by dynamic service selection; clouds accelarate computing; clouds reduce traffic for video-conferencing. All this and a lot more can clouds do. But how do clouds work? What are pre-requisites? What are the risks? Do we need a new breed of developers for it?

Atomic Communication Patterns for the Enterprise Service Bus

An Enterprise Service Bus is meanwhile a mandatory component for every modern development. Knowing the atomic communication patterns that work on an ESB are the basicskill-sets required to model efficiently business flows. In this session you shall learn basic patterns like filter pipes, synchronous and asynchronous coupling and more complexpatterns like fan-out, fan-out and merge, bucketing and campaigning while getting a feeling how an ESB can help you making application design very efficient. This is a that is targeted to build the bridge between modern application design and the idea of distributed computing in the spirit of service oriented Architecture.

Communication Skills for Geeks

Software is fundamentally a communications game, and good skills differentiates between good and great developers. This session describes communication techniques and skills to people who skipped English 102 to hack some code. I talk about effective communication techniques for presentations, documentation, memos, and how to sell your technical ideas to a non-technical crowd.

All About Merb 

Merb is a ruby web development framework that is fast, lightweight, and powerful that can be a great alternative to Rails. Merb doesn't have any opinions: you can use any ruby database abstraction library, any javascript library, and any template engine. In this presentation we'll take a look at the history of merb, how to get up and running, and when you should replace a heavy Rails action with a merb equivalent. We'll also do a live code demonstration where we build a sample application.

REST with Rails

What is REST and how to write in the “RESTful Rails” style. Why skinny controllers and fat models are all the current “Best Practice” and how to do it. This talk will cover exposing your application as a REST API/interface and how to use ActiveResource as a consumer for another RESTful interface.

Introduction to JRuby

JRuby is currently the fastest Ruby-Interpreter on earth. In this session you will learn how to use JRuby to integrate your Java libraries with the Ruby programming language the easy way. The session demonstrates the concepts and proves them with many live coding, so that attendees will get the most out of it. In the second half of the talk, Michael is showing you how to create a simple Rails application and how to deploy it as a WAR file into an application server like Glassfish.

Introduction to JRuby on Rails

Ruby on Rails is the star in the field of full stack web development frameworks today. This session will demonstrate how to use Rails on the JRuby interpreter in your regular VM environment. Many live coding will help you to understand the concepts of Rails and how to leverage the framework in your existing Java projects. You will also get information about available IDE’s and typical deployment szenarios for JRuby on Rails.

Dive Into Grails

Grails is one of the many web frameworks for the Java platform. However it shines through by its ability to use the best ideas from the Ruby on Rails world while at the same time continuing to leverage the tried, tested and trusted Java platform as well as established frameworks like Spring and Hibernate. With Grails' tight integration with Java, Groovy based features, growing popularity and improved support from IDEs, Grails looks poised to become the RAD framework of choice for the Java platform. This session takes you through the features of Grails, it's working and how Grails utilization of meta programming and coding over convention can get you major productivity boosts as compared to traditional Java web applications.

Groovy Poised

Groovy is a new age language for the Java platform that’s easy for Java folk to pick up. It compiles to Java bytecodes and does not waste any of the investment you have made into Java over the years. Out of the box, it supports and simplifies a host of Java developer tasks. Groovy today enjoys good support on all IDEs and also has a vibrant community driving the language. This session looks at Groovy syntax, closures, APIs and how you could get things done with Groovy. It also look at Groovy’s meta programming capability that lets you enhance classes with new methods and properties at runtime.