As web sites transition from simple content to full-blown, two-way applications the legacy cruft of the past ten years is becoming apparent. There are millions of sites and billions of pages that have been around since the 1990s. Many of these pages were designed for browsers like Netscape 3, Internet Explorer 2, or even Mosaic. They may have been redesigned several times, but the underlying structure and markup remains the same; and this is becoming a problem. These pages don't work well with modern technologies and tools like AJAX, DOM, E4X, JavaScript, and more.
Consequently, many web developers and designers find themselves faced with legacy code for the first time. Until recently most sites and pages just weren't old enough for legacy issues to be a major concern. While legacy issues and the tools and techniques for managing them are well known to programmers, web folks are just now learning about these problems. As web designers begin to grapple with the legacy issues that have hampered programmers for so long, they'll need to learn the same refactoring techniques programmers have used to manage these problems.
Elliotte Rusty Harold is originally from New Orleans to which he returns periodically in search of a decent bowl of gumbo. However, he currently resides in the Prospect Heights neighborhood of Brooklyn with his wife Beth, dog Shayna, and cats Charm (named after the quark) and Marjorie (named after his mother-in-law). He's an adjunct professor of computer science at Polytechnic University where he teaches Java, XML, and object oriented programming. His books include Java I/O, Java Network Programming, the XML Bible, and XML in a Nutshell. His next book will be Refactoring HTMl from Addison-Wesley.
Code Organization Guidelines— Structuring a large code base maintained by teams working in parallel can be a real challenge. If you are not disciplined about code structure overtime, you will end up with a tangled, unmaintainable mess that cannot adapt to change and risks ossifying into legacy. This session presents typical challenges in evolving large code bases, focusing on package interdependencies and module decomposition according to 'conceptual boundaries'. We will discuss lessons learned from the Spring project itself, and investigate the use of tools for validating architectural soundness.
Top 10 Ways to Botch Enterprise Java Applications— This follow-on to last year's JavaOne sleeper hit 'The Top 10 Ways to Botch an Enterprise Java Technology-Based Application' explores best practices for protecting against scalability and reliability in Java Enterprise Edition applications and compute grid environments. Starting with simple abuses of messaging and clustering technologies, this presentation navigates a wide swath of options available to enterprising architects seeking to limit the effectiveness of scale-out environments.
How to build Enterprise Java applications with Spring— The Spring framework has an extremely rich set of features that span all tiers of the application. If you are relatively new to Spring you might be wondering which of the many features to focus on; which features to avoid; and how to use the various features together in an application. This talk describes how the Spring framework was used to build an enterprise Java application. We will walk through each tier of the application and describe how the Spring framework was used.
Coherence, An introduction— Oracle Coherence enables in-memory data management for clustered J2EE applications and application servers that makes sharing and managing data in a cluster as simple as on a single server. Developers can easily take advantage of Coherence features using the standard Java collections API to access and modify data, and use the standard JavaBean event model to receive data change notifications.
The future will be about programming languages— During this Jazoon keynote Ted Neward talks about why the next five years in IT will be about languages. The programming language virtualization, tools, linguistic focus and expressiveness are different forces that are coming of age. Not to mention the impact of the over-used and over-hyped Domain-Specific languages. How will these languages tackle the evolving application security demands or rich user interfaces, Ted Neward approaches these questions in his own unique style.
