Session Schedule

By Scott Davis

"The central enemy of reliability is complexity." (Dr. Daniel Geer)

Java is a powerful programming language. A smart developer can do nearly anything with Java. So the next question is, "How quickly can it be done? How many lines of code does it take to do common tasks?" Groovy greases the wheels of Java by decreasing the complexity of the language while preserving the raw power. At first glance, you might think that this talk is simply about how Groovy drastically reduces the lines of code you need to write. What this talk is really about is bringing simplicity, clarity, readability, and yes, beauty to your source code.

In this talk, you'll see common problems presented in Java and the corresponding solutions in Groovy. From something as simple as defining a JavaBean up through File I/O, XML, networking, and database interaction, Groovy offers identical capabilities in a fraction of the lines of code.

By Scott Davis

"XML is like violence: if it doesn't solve your problem, you aren't using enough of it." (Anonymous)

XML is everywhere. Whether you are dealing with local configuration files (web.xml, struts-config.xml) or remote web services (SOAP, REST, RSS, Atom), the modern software developer needs to be able to request, slice, and dice XML with ease. That requires a set of razor-sharp tools that reduce the inherent complexity of the problem, not multiply it. Once you see XML tremble in fear at the awesome power of Groovy, you'll wonder what you ever did without it.

In this talk, we look at various Groovy tools to create, parse, and export XML. To read in XML, we'll explore the XmlSlurper and the XmlParser. To write out XML, we'll use the MarkupBuilder, StreamingMarkupBuilder, and the XmlNodePrinter. We'll go beyond simple Plain Old XML (POX) and demonstrate using namespaces, CDATA blocks, and more.

By Scott Davis

"Tests don't break things; they dispel the illusion that it works." (Anonymous)

In this era of "Test-First" and "Test-Driven" development, the modern software engineer knows that testing is no longer an optional part of the process. You need to have the best tools at your fingertips: a set of utilities that maximize your results with a minimum of effort. Groovy offers Java developers an optimal set of testing tools.

In this talk, we use EasyB to gather user stories as executable documentation. We look at GroovyTestCases -- a drop-in replacement for JUnit TestCases that expand the pool of helpful assertions. We'll explore mocking and stubbing with Groovy. And we'll finally go public with Groovy's privacy "issues".

By Scott Davis

"The proof of the pudding is in the eating. By a small sample we may judge of the whole piece." (Miguel de Cervantes Saavedra)

Most Grails tutorials demonstrate how easy it is to build simple CRUD (Create/Retrieve/Update/Delete) applications. While skinning a database with a web front-end is undeniably one beneficial aspect of Grails, it isn't the only thing Grails is good for. As you'll see here, Grails can be used to build a wide variety of web applications. You won't see a single HTML table with "edit" and "delete" links, I promise.

In this talk, we look at a variety of Grails applications that go beyond the simple CRUD metaphor -- blogs, wikis, maps, portals, and more.

By Scott Davis

"The challenge of modernity is to live without illusions and without becoming disillusioned." (Antonio Gramsci)

There are plenty of sarcastic "Web 2.0" checklists out there -- be perpetually in BETA, when in doubt add rounded corners, etc. While we can all laugh at the superficial aspects of the Web 2.0 revolution, there are plenty of serious aspects to it as well. Is your website mash-up friendly or hostile? Do you tell your visitors when things change (via RSS or Atom syndication), or do you expect them to check in daily for updates? Is your website a silo or a part of a larger ecosystem?

In this talk, we discuss what makes a "modern shiny Web 2.0" website look the way it does. But we go beyond simple look and feel as we catalog the common features in modern websites and show you how to implement them yourself.

By Neal Ford

By Neal Ford

Most developers think that "TDD" stands for Test-driven Development. But it really should stand for "Test-driven Design". Rigorously using TDD makes your code much better in multiple ways.

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.

By Neal Ford

Developers from the 1980s would be shocked at how inefficiently developers use their computers because of the advent of graphical operating systems. This talk describes how to reclaim productivity afforded by intelligent use of command lines and other ways of accelerating your interaction with the computer and bending computers to do your bidding. Stop working so hard for your computer!

In The Productive Programmer, I identify 4 principles of productivity: acceleration, focus, automation, and canonicality. This session defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Acceleration covers ways to speed up development by taking command of your computer. This includes keyboard shortcuts (including ways to learn them and make better use of them) in both IntelliJ and Eclipse. Focus describes how you can utilize your environment (both physical and computer) to greatly enhance your productivity. Canonicality (the DRY principle from The Pragm

By Neal Ford

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain.

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with t

By Neal Ford

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

By Neal Ford

Judicious use of metrics improves the quality of your code. But interpreting metrics presents a challenge. You have a list of numbers for a project - what does it mean? And what does it tell me about the health of the project overall? This sessions shows how to produce visualizations for software metrics, making them easier to understand and more valuable. It covers metrics at the individual method level all the way up to the overall architecture of the application. This isn't just a talk about how some tools produce visualizations: this session shows you how to generate your own visualizations, allowing you to customize it to the level in information density that shows real value on your project. I show how to produce projected graphs from dependencies, heat-maps for cyclomatic complexity and code coverage, using XSLT to extract visual information from XML configuration documents, and others. Metrics can't help you if you can't understand them. By creating visualizations, it helps leverage metrics to make your code better.

Judicious use of metrics improves the quality of your code. But interpreting metrics presents a challenge. You have a list of numbers for a project - what does it mean? And what does it tell me about the health of the project overall? This sessions shows how to produce visualizations for software metrics, making them easier to understand and more valuable. It covers metrics at the individual method level all the way up to the overall architecture of the application. This isn't just a talk about how some tools produce visualizations: this session shows you how to generate your own visualizations, allowing you to customize it to the level in information density that shows real value on your pr

By Neal Ford

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.

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.

By David Geary

This session introduces JSF 2.0 fundamentals, with emphasis on new features in JSF 2.0.

JSF 2.0 has been a long time coming, but now that it's here, it boasts an impressive set of improvements over JSF 1.X, including standardization of Facelets as the default display technology, a much richer event model, and built-in support for Ajax. Come to this session to see how you can use Java's standard web application framework to create industrial-strength web applications. This session will cover the following features of JSF 2.0: Resources Using Groovy System events Bookmarkable views Templating

Prerequisite: Familiarity with JSF, or other component-based frameworks

By David Geary

This session covers two of the most important features of JSF 2.0: composite components and built-in Ajax.

JSF is a component-base framework. Components are a powerful reuse mechanism, but they were rendered nearly inconsequential in JSF 1.X, because components were so difficult to implement. JSF 2.0 makes implementing cusomt components easy with a new feature that builds on Facelets and the new resource capabilities in JSF 2.0: composite components. This session shows you how to implement your own components with JSF 2. Additionally, this session covers the built-in Ajax that comes with JSF 2.0. Come to this session to see how you can easily implement custom components with integrated Ajax capabilities.

Prerequisite: Familiarity with JSF, or other component-based frameworks. Familiarity with Ajax. This session builds on the JSF 2.0 Introduction talk, so it is helpful, although not required, if you attend the intro talk before coming to this session.

By David Geary

An introduction to Flex for Java developers.

Want to develop expressive web applications? Them come to this session and see what Adobe's Flex is all about. Flex has lots of similarities to Java-based web development, so you'll find it easy to learn, and powerful to use. Come to this session if you want to take your web application user interface to the next level. This session will cover: An introduction to Flex ActionScript, HTTPService, and data binding Drag and drop Components View state Integrating with Java back ends

Prerequisite: Familiarity with Flex and at least one other web application framework

By David Geary

Learn to implement web applications with GWT.

Google Web Toolkit lets you create killer Java-based web applications using familiar Swing and AWT idioms. This session will introduce you to GWT and teach you the fundamentals of using this cutting-edge framework for creating rich user interfaces that run in a browser. For most of this session, and the session that follows--GWT fu, Part 2--I will live code a desktop-like, ajax-based, web application that illustrates the awesome power of GWT. In this session, I will cover the following topics: Widgets Remote procedure calls and database access Event handling Ajax testing

Prerequisite: Familiarity with a component-based framework, preferably a desktop application framework

By David Geary

Learn to do amazing stuff with GWT.

This session picks up where GWT fu, Part 1 left off. In this session, I will continue live-coding the Places application. In taking the Places application to its exciting conclusion, I will cover the following advanced aspects of GWT: Dialog boxes Sinking events DOM elements Working with HTML Modules Image loading and busy cursors Event previews Timers In this session, I focus primarily on implementing a viewport widget in a custom module, and using that widget in the Places application. When I'm done, we'll have a very cool web application that shows the awesome potential of Google Web Toolkit

Prerequisite: GWT fu, Part 1 is not a prerequisite for this session, but it will help if you have some familiarity with GWT.

By Matthew McCullough

Maven has been on the Java build tools scene for quite a number of years, but the adoption rate in enterprises is now going through the roof. Maven can seem daunting, but this presentation will equip existing Maven users with more efficient techniques and tools to overcome the biggest perceived Maven hurdles and build issues with ease.

We'll examine tools to help you find artifacts in central repositories, manage your corporation's internal Maven artifacts with a proxy tool such as Nexus, view and override dependency graphs, dependency management and multi-module best practices, create OS specific profiles, and leverage the latest Maven plugins for the top Java IDEs.

Topping it off, we will review migration paths from Ant, and why Maven just makes sense with your company's use of the ever growing web of open source libraries. This presentation will take beginning and mid-level Maven users up to a higher level of efficiency and mastery.

Prerequisite: Basic Maven knowledge

By Matthew McCullough

Open Source is not just a suite of libraries you consume within your application, but now reaches into the space of tools to help you troubleshoot and improve your applications.

This session will quickly survey a wide range of tools across the Java, Networking, Filesystem, SOAP, REST, HTML, CSS and JavaScript realms. We'll look at applications such as VisualVM, which help you analyze your heap and garbage collection cycles of both local and remote applications. Performance and load testing tools such as JMeter will expose bottlenecks, threading, and scalability concerns of everything from Java modules to Web Apps (even ones that don't use any Java).

Learn how web service tools such as SOAPui and TCPMon allow you to inspect your SOAP and REST calls at the data structure level, and how Firefox Poster lets you test web services right from the browser. And when only a raw look will do, we can always fall back on the venerable TCPDump. This tool-centric presentation will expose developers to approaches to inspect, debug, tune and troubleshoot Java desktop apps, language-neutral web apps, and framework-neutral web services using Open Source Tools.

By Matthew McCullough

Many development shops have made the leap from RCS, Perforce, ClearCase, PVCS, CVS, BitKeeper or SourceSafe to the modern Subversion (SVN) version control system. But why not take the next massive stride in productivity and get on board with Git, a distributed version control system (DVCS). Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository redundancy at $0 cost. Understand how distributed version control systems are game-changers and pick up the lingo that will become standard in the next few years.

In this talk, we discuss the team changes that liberate you from the central server, but still conform to the corporate expectation that there's a central master repository. You'll get a cheat sheet for Git, and a trail-map from someone who's actually experienced the Subversion to Git transition. Lastly, we'll even expose how you can leverage 75% of Git's features against a Subversion repository without ever telling your bosses you are using it. Be forewarned that they may start to wonder why you are so much more effective in your checkins than other members of your team.

Prerequisite: Basic understanding of Subversion or similar version control system

By Matthew McCullough

iPhone development is all the rage both in the mobile entertainment, social networking, and productivity application spaces. As a Java developer, prepare yourself to be a participant in aspects of this new breed and platform of development. Hop on board with a quick start to iPhone application coding in Objective-C and integration with some of our favorite Java web service back-ends such as RESTful Grails.

We'll build out a graphical demo application on the iPhone that depends on and responds to data from a Java web service; then we'll deploy it live to the desktop simulator, and finally, a real iPhone. This presentation will make you conversant in iPhone development procedures and able to make smart decisions about your back end Java web services ability to serve data to iPhone native client apps.

By Ted Neward

  Even though the Java 7 JSR has yet to be formed, some interesting things are beginning to emerge from Sun about what Java7 may include when its formal release contents are finally made public.

In this presentation, we'll examine some of the forthcoming details, including some of the JSR-166 "add-ons" like the Fork/Join framework, some of the proposals for extensions to the JVM to support dynamic languages, and the so-called "closures" proposals circulating around.

By Ted Neward

Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.

For an intermediate-level audience.

By Ted Neward

So you know the platform security model, and now you want to use it in new and interesting ways, like creating a custom Policy implementation, a custom Permission, or create a custom security context in which code will execute. Perhaps you even wish to make certain objects accessible only to those with the right permissions, or cryptographic key. Nothing could be easier, despite Java security's reputation as a dark and arcane place.

In this presentation, we'll pick up where the "Platform Security" talk leaves off, and demonstrate how to engage the security model of the JVM at a much deeper level, regardless of your favorite programming language: Java, JRuby, Groovy, Scala, ....

Prerequisite: The Busy Java Developer's Guide to Platform Security

By Ted Neward

For so many Java developers, the java.util.* package consists of List, ArrayList, and maybe Map and HashMap. But the Collections classes are so much more powerful than many of us are led to believe, and all it requires is a small amount of digging and some simple exploration to begin to "get" the real power of the Collection classes.

In this presentation, Java developers will see the basic breakdown of the Collection API designs, the relationship of the interfaces to the implementations, how to create a new Collection implementation, and how the new Collections introduced as part of JSR-166 (the concurrency JSR) and Java6 make their programming lives easier.

By Ted Neward

Wondering why your enterprise Java app just... sucks? Trying to figure out why you can't get more than 10 concurrent users online at the same time? Looking for ways to try and spot the slowdowns and ways to fix them?

In this talk, we'll look at the various things that can occur in an enterprise Java app (from the smallest web site to the largest multi-resource environment) to make your Java apps perform and scale less well than they should, and how you can work to correct them. We'll examine a variety of broad concepts to apply in architecture and design, and examine what factors make an enterprise application slow, then use a variety of tools to figure out how to remedy them.

By Mark Richards

In the book "97 Things Every Software Architect Should Know" (O'Reilly, 2009) I wrote about the importance of design patterns as a useful means of communication between architects and developers. Equally important to patterns is an understanding of AntiPatterns - things that we repeatably do that produce negative results. AntiPatterns are used by developers, architects, and managers every day and are one of the main factors that prevent progress and success. In this session we will look at some of the more common and significant development and architecture antipatterns. Through coding and design examples, you will see how these antipatterns emerge, how to recognize when the antipattern is being used, and most importantly, how to avoid them. By attending this session, you will be part of a movement to reduce the AntiPattern catalog from hundreds of entries to only a few.

Agenda - What are anti-patterns? - Factors that cause anti-patterns - Common software and architecture anti-patterns I have selected 7 of the most common anti-patterns I see continually in the industry and in my travels. We will be going into the details of each of these anti-patterns.

Prerequisite: None

By Mark Richards

One way to stop a conversation dead while at a party or gathering is to mention you are a software architect. Why? Because it takes about an hour (complete with Powerpoint slides) to explain what you do for a living. By then the person you are talking to is so bored they would rather sit in a corner licking nine-volt batteries. The problem is that no one inside or outside our industry really knows what a software architect is or what they do. In this highly interactive (and slightly humorous) session we will take a deep dive into the role a software architect plays in the IT industry. We will explore the characteristics an architect needs to have, and the elements that make a good architect and a bad architect. Through amusing antidotes and real-world examples, we will see how to become an effective software architect and help shape the industry in terms of the role and title of software architect.

Agenda During the introduction we will talk about the roles an architect plays, architect certification, and the decisions an architect typically makes. We will then take a deep dive into the qualities of a software architect, including Leadership and Communications, Technical Knowledge and Breadth, Domain Knowledge, and Methodologies. Interspersed into the mix will be some amusing anecdotes of my experiences as an architect, with a few jokes and humor thrown in for good measure

Prerequisite: None

By Mark Richards

In previous years I have given sessions related to my book "Java Transaction Design Strategies", where I have reviewed the basics of programmatic and declarative transactions and outlined the basic patterns described in the book. In this new session for 2009 I will focus on some of the pitfalls encountered while dealing with transactions and then how to develop an effective transaction strategy. I will start this session by describing and illustrating some of the common pitfalls I continue to see in both Spring and EJB. I will then describe four common transaction strategies you can use and implement, including a transaction strategy for high-speed transactions, a transaction strategy for client orchestration, a transaction strategy for use with API's, and finally a strategy for highly concurrent environments.

Note: This session assumes you know a little bit about transactions and have been using them in either Spring or EJB. It is not intended to be an introductory session on how transactions work. You can obtain a free PDF download of my transaction book at http://www.infoq.com/minibooks/JTDS to quickly come up to speed with transactions.

Agenda - Introduction - Common Transaction Pitfalls - API Transaction Strategy - Client Orchestration Transaction Strategy - High Concurrency Transaction Strategy - High Speed Transaction Strategy

Prerequisite: Java, Spring or EJB; some knowledge of transactions and JTA.

By Mark Richards

There's no doubt about it - messaging is quickly becoming a standard part of most application architectures, particularly as more and more companies struggle to find ways to integrate heterogeneous environments due to mergers, acquisitions, or to streamline existing application portfolios. The Java Message Service (JMS) API allows Java applications to implement messaging using a standard API, therefore removing the dependency of any particular messaging provider. In this introductory session we will take a look at the basics of messaging and the JMS API. I will start by discussing the different messaging models, the structure of a basic JMS message, and the JMS API interfaces and how they interrelate. Then through interactive coding I will show the basics of sending and receiving messages using the point-to-point messaging model and how to do request/reply processing. NOTE: this session is meant to be an introduction to messaging and JMS - no prior JMS or messaging experience is needed for this session.

Agenda: - Messaging Introduction - JMS Message Types - Primary JMS Interfaces - Configuring Queues and Topics - Sending and Receiving Messages - Request/Reply Messaging

Prerequisite: None

By Mark Richards

This session covers some of the more advanced features of JMS messaging, and is intended for those who are familiar with JMS and messaging in general. Some of the topics I will be covering in this session include message grouping (where I will demonstrate sending a large JPG image using messaging), transacted sessions, client-based acknowledgement, and some various messaging design considerations and things to watch out for from a design and coding perspective. I will be doing live coding demonstrations to illustrate the techniques described in this session. Although this session is entirely JMS provider agnostic, I will be using ActiveMQ, a popular open source JMS provider, during the live coding demonstrations.

Agenda - Details behind the acknowledgement modes - Message grouping / sending images and documents - Transacted sessions - JMS Design Considerations - Common Messaging Pitfalls

Prerequisite: Some knowledge of messaging and JMS would be helpful

By Mark Richards

Ever wonder how to accurately calculate high availability and continuous availability? Ever wonder the real difference between clustered and active/active topologies? Ever wonder why the extraordinary cost and effort to put a CA environment in place rarely yields the expected results? Ever wonder how to make CA work without having to sit through vendor presentations or demos? Ever wonder why businesses not needing the "6 nines" of availability commonly found with CA environments are still pursuing CA? Ever wonder if there's more to CA than numbers, calculations, and topologies? Ever wonder what the future holds for continuous availability computing?

While some industries such as Telecommunications have solved the continuous availability issue, other industries such as banking, insurance, and financial markets still find continuous availability a challenging and complex task. These industries typically have a complex and heterogeneous assortment of technologies, platforms, and architecture layers which make designing and implementing continuous availability particularly challenging. Introduce Service Oriented Architecture into the mix, and the issue becomes even more complex.

Come to this vendor-agnostic session to see some of the answers to the mysteries surrounding the black art of continuous availability; all is not what it seems....

While the technical solutions to implement continuous availability are widely known and generally understood, the limitations and constraints of continuous availability generally are not. Just because the technical architecture supports continuous availability does not mean that the applications and systems using that infrastructure can leverage it. In fact, as you will see in this session, application architecture ends up playing an important part of a holistic continuous availability solution. In this session I will focus on the challenges faced by the financial services industry with designing continuous availability in the application and services layer and how those challenges are addr

By Brian Sam-Bodden

Drools is an open source pure-Java implementation of a forward chaining rules engine. Drools can be used in a J2SE or J2EE application and allows you to express rules programatically or by building domain specific rule languages. Learn how Business Rules with Drools can make your Java applications more flexible and robust.

Software development is expensive, when business rules are hard-coded in your application's source code, changes and additions to those rules translate to wasted time and money. Good object-oriented, component-based approaches can alleviate the burden of keeping up with changes in the business world but they still require that expert knowledge of the changes be passed from the decision makers to the business analysts and finally to programmers that need to implement these changes. Business Rule Engines and Business Rule Languages are based on the basic premise of separation of concerns by empowering business domain experts to express the rules of business in a way that it is directly usable

By Brian Sam-Bodden

In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules application covering such topics as:

• Fine control and monitoring of a Working Memory session
• Using Decision Tables
• Advanced Rule Language Features
• Building Domain Specific Languages
• Managing your Rules

Many of the problems that we deal with in enterprises around the world are not usually related to the particular infrastructure, framework or programming language chosen but rather to the evolution and maintenance of the business logic that governs those systems. All knowledge in an enterprise is handed down stream until it arrives at the programmer's door. With Rule based systems we can empower those with the business but there is still a fair amount of work to get the ideal architecture for a particular problem in place. In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules ap

Prerequisite: Beginning Drools

By Brian Sam-Bodden

Learn 10 tried and true ways to improve the way you use Hibernate today. In this session you would learn about a collection of 10 tips, tricks, practices and tools that will make you more effective at designing, implementing, testing and tuning your application's Hibernate-powered object-relational layer.

Learn 10 tried and true ways to improve the way you use Hibernate today. In this session you would learn about a collection of 10 tips, tricks, practices and tools that will make you more effective at designing, implementing, testing and tuning your application's Hibernate-powered object-relational layer. Some of the topics covered include: - Handling and implementing inheritance - Caching - Profiling your queries - Using filters for virtualization - Custom SQL for performance - Query caching - ... and more

By Brian Sam-Bodden

Mylyn, Eclipse Plugins, Tips and Tricks

Mylyn, Eclipse Plugins, Tips and Tricks

By Brian Sletten

There is a shift going on in the Enterprise. While still used and useful, the promises of the SOAP/WSDL/UDDI Service-Oriented Architecture (SOA) stack have failed to live up to their promise. A new vision of linked information is enveloping online and Enterprise users. The REST architectural style is squarely behind this thinking as a way of achieving low-cost, flexible integration, increased data security, greater scalability and long-term migration strategies.

If you have dismissed REST as a toy or are unfamiliar with it, you owe it to yourself to see what is so interesting about this way of doing things.

There is tremendous interest in REpresentational State Transfer (REST) as an architectural style for building scalable, flexible, information-driven architectures in the Enterprise. The success of the Web has caught our attention in the face of increased complexity and many failures with more traditional Web Services technologies. The problem is that it is difficult to sell a way to do things. Managers do not want to feel like they are innovating in the middleware space. They want to understand why they should deviate from the blue prints laid down by the industry leaders. They want to understand when they should use REST, when they should use SOAP and when they might fallback to regular old

By Brian Sletten

The human-friendly Web is about nicely-formatted, accessible content for users to browse. There is an emerging Data Web that relies on technologies from the Semantic Web stack to link increasingly rich connections between various data sources. SPARQL and RDF are the main tools for expressing and using this connectivity. This talk will introduce you to one of the practical and accessible aspects of employing these ideas on the Web and in the Enterprise.

Getting people to come to consensus on common models and schemas is usually the hardest part of any data integration strategies. These technologies help lower the bar on both the technical and social costs of stepping up your integration strategies. We will explore: an introduction to RDF and the SPARQL query language the fantastically successful Linked Data project that connections billions of interrelated content how to include relational data in the mix how to include enriched Web pages in the mix how to build client-friendly applications on top of this information

Prerequisite: The Semantic Web: The Future, Now and Rich Web Pages : Publishing Semantic Content with GRDDL and RDFa would both be helpful but are not required

By Brian Sletten

The goal for web services was always to reduce our burden by increasing the potential for reuse of business functionality. Somehow, we got lost along the way in a morass of confusing, unfulfilling and downright broken technologies.

While we are interested in pursuing REST-based systems for managing information, we need some strategies for tying it all together sensibly. If we abandon WSDL, SOAP and UDDI, what do we replace them with? This talk will walk you through combining resource-oriented strategies with technologies from the Semantic Web to describe, find, and bind to services in dynamic, flexible and extensible ways.

We will start to blur the distinction between data, documents, services and focus on information and how it is connected to what we already know.

This talk will introduce you to strategies for building on individual REST services to produce a well-described, dynamic, discoverable fabric of services that can be used in a variety of scenarios including: finding data sources finding transformation services orchestrating these sources and services in reusable ways publishing discoverable services

Prerequisite: The Semantic Web: The Future Now, Give it a REST and SPARQL : Querying the Data Web would all be helpful talks to have attended

By Brian Sletten

The human web is reasonably well in hand by now. We are getting pretty good at building systems that people find valuable and entertaining. We have not spent as much time concerned about our software friends. There is a ton a rich content available on the web that is too difficult to extract in automated ways using just XHTML, the meta tag and microformats. This talk will introduce you to some emerging technologies from the Semantic Web camp to enrich your web pages with useful information for both automated extraction and improved browsing experiences.

The Resource Description Framework (RDF) is the metadata substrate of the Semantic Web. It allows you to express fairly arbitrary relationships about people, places, things, content in an open world way. It is trivial to mix and match terms, vocabularies, etc. to have a rich expressive capability not bound by the limitations of the relational data model and XML schemas. GRDDL is a technology for generating RDF metadata from content on demand. This can include XML documents, XML-RPC requests, XHTML pages, etc. The content could include authorship information, geotagging, creative commons license information, the topic of the document, etc. RDFa allows us to be more explicit about the metadat

Prerequisite: The Semantic Web: The Future Now would be helpful, but not required

By Venkat Subramaniam

Java is a well established language, that has been around for more than a decade. Yet, programming on it has its challenges. There are concepts and features that are tricky. When you run into those, the compiler is not there to help you.

In this presentation we will look at various concepts that you will use in general programming with Java. We will discuss the issues with those and how you can improve your code. We will look at concepts you can do better and those you should outright avoid.

By Venkat Subramaniam

Projects often start out simple, but soon become complex and turn into a lose cannon. Organizations are struggling to maintain and evolve software. Poor code quality is a significant part of that problem. Improving the quality of code is critical to success of enterprise projects.

In this presentation we will discuss ways to identify code smell. We will discuss several code smells and how to clean it up. We will also discuss proactive ways to avoid that smell in the first place.

By Venkat Subramaniam

You're most likely familiar with the Gang-of-four design patterns and how to implement them in Java. However, you wouldn't want to implement those patterns in a similar way in Groovy. Furthermore, there are a number of other useful patterns that you can apply in Java and Groovy. In this presentation we'll look at two things: How to use patterns in Groovy and beyond Gang-of-four patterns in Groovy and Java.

Patterns overview Implementing common patterns in Groovy Beyond Gang-of-four patterns in Java and Groovy Lots of examples

By Venkat Subramaniam

Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries.

In this presentation we will take a in depth look at what Scala is, its strengths, weaknesses, and why, when, and where you'd use it on your applications.

By Venkat Subramaniam

Domain Specific Languages (DSLs) are languages targeted at a particular problem and domain. They have context and are fluent. They help users of applications at various levels to easily communicate with your application. Developing DSLs, however, are not easy. You could easily get dragged into using parsers and tools with steep learning curve.

In this presentation, we will look at various options to create DSLs on the Java platform. We will focus on external DSLs–these give you the absolute flexibility to chose syntax, but involve the most work as well. We will look at various tools and techniques that can ease this development effort.