Greater Florida Software Symposium
April 16 - 18, 2010 - Tampa, FL
Jeff Scott Brown - Core Member of the Grails Development Team
Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. (Such concerns are often termed crosscutting concerns in AOP literature.)
The dynamic nature of Groovy makes it a fantastic language for building dynamic applications for the Java Platform. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts. Taking advantage of Groovy's metaprogramming capabilities brings great new possibilities that would be very difficult or just plain impossible to write with Java alone. Building Domain Specific Languages in Groovy is easy to do once a team has a good understanding of the Metaobject-Protocol (MOP) and the method dispatch mechanisms used by the Groovy runtime environment.
GORM is a super powerful ORM tool that makes ORM simple by leveraging the flexibility and expressiveness of a dynamic language like Groovy. With GORM developers get access to all of the power and flexibility of an ORM tool like Hibernate without any of the complexity.
Prerequisite: Advanced Grails
Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks. Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. GORM is super powerful ORM. Grails provides simple mechanisms for leveraging the power of Ajax.
Grails is one of the most flexible and most powerful frameworks on The Java Platform. Grails leverages the flexibility offered by the platform in a way that other web frameworks do not. Grails is a fantastic platform for polglot web programming.
Prerequisite: Advanced Grails
Neal Ford - Application Architect at ThoughtWorks, Inc.
Emergent design is a big topic in the agile architecture and design community. This session covers the theory behind emergent design and shows examples of how you can implement this important concept.
Prerequisite: understanding of architectural and design concepts
This talk describes an agile approach to architecture, and merges the current state-of-the-art thinking in both service oriented architectures(SOA) and web-based architectures like HTTP, REST, and hypermedia.
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 talk covers testing the entire stack: unit, integration, functional, behavior-driven, databases, user acceptance, mocking & stubbing, and other topics and strategies.
Prerequisite: Confusion about what to test when and where
Tiffany Lentz - Principal Consultant & Program Manager with Thoughtworks
This session focuses on visibility of team progress and correcting team "bad smells" using Agile metrics. Since we use metrics to self-correct and sharpen the team, they are an integral part of each iteration and flow into release planning. We will discuss some of the How's and Why's of team metrics and review the risks that are inevitable when it comes to gathering metrics.
Is your Agile team running smoothly? How do you know? This answer is found in your iteration and your toolkit for constant team improvement! Comparing Iteration Management skills and tools to those of the Agile Project Manager, Scrum Master and Technical Leader roles, you will see that Iteration Management encompasses end to end activities of the iteration, which are crucial to unblocking your software production line and making your team a success.
Agile techniques are often pigeon-holed as just applying to software projects and IT organizations. Agile techniques are a mindset more than a list of rules to follow and can bring efficiency and improvements to all areas of an organization.
Ted Neward - Enterprise, Virtual Machine and Language Wonk
Once you've learned the core Collections clases, you're done, right? You know everything there is to know about Collections, and you can "check that off" your list of Java packages you have to learn and know, right?
Prerequisite: Busy Java Developer's Guide to Collections
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.
Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.
Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.
Prerequisite: The Busy Java Developer's Guide to Concurrency (Part 1: Threads)
Much noise has been made in recent years about functional languages, like Scala or Haskell, and their benefits relative to object-oriented languages, most notably Java. Unfortunately, as wonderful as many of those benefits are, the fact remains that most Java developers will either not want or not be able to adopt those languages for writing day-to-day code. Which leaves us with a basic question: if I can't use these functional languages to write production code, is there any advantage to learning about them? The short answer is yes, for the fundamental premise--"I can't use functional code on my Java project"--is flawed. Java developers can, in fact, make use of functional ideas, and what's better, they don't even have to reinvent them for Java--thanks to the FunctionalJava library, many of the core primitives--interfaces that serve as base types for creating function values, for example--already exist, ready to be used.
Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala 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 XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.
Pratik Patel - CTO TripLingo & Code Hacker
This session is aimed at helping developers get started with automating the collection of software quality metrics. We'll cover continuous integration, automated code metrics gathering, and analysis of these metrics. The ability to be able to detect problems early, and also to write higher quality code early, helps avoid bugs and headache down the line. We'll cover some best practices around using and putting in tools to help achieve higher quality.
As with many technologies, the basics are easy. The hard part comes when the developer needs to do sophisticated integration, development, and testing as part of an enterprise application. A large enterprise application requires the developer to think of issues that affect the development, scalability and robustness of the application. This presentation will cover the advanced topics described below with a focus on the new persistence features in Spring 3.0 and JPA 2.0.
Performance tuning any application is a black art that can consume much time. Fortunately, Java has many tools that can aid in this effort. There also are a number of basic tips that can help to analyze and fix performance problems. The Java memory model is usually something that you don't need to tune, but for high performance applications it is necessary to tweak. While there are a number of advanced things that can be done to performance tune an application, we'll discover that the simple, basic things are all that are usually needed to make your apps fly.
We've all heard about virtualization for deploying applications. How about leveraging virtualization for development? In this session, we'll look at some time saving tips and build a virtual VM for development and testing.
Mark Richards - SOA and Integration Architect, Author of Java Message Service
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.
Apache Camel is a robust open source integration framework that handles routing and mediation tasks associated with enterprise integration. Camel allows you to quickly and easily route messages and integrate components in a distributed, decoupled manner. For example, using the Camel Java DSL, you can send and receive JMS messages in just a couple of lines of Java code. In this live coding session I will describe what Camel is, describe the overall architecture, show why it is useful, and demonstrate through live coding examples how to use the Camel Java DSL to write simple (and complex) routing logic. By attending this session you will learn Camel well enough to use it at work the next day.
More and more companies are using messaging as a means for heterogeneous communication, scalability, performance, and load balancing. Why? Because messaging provides asynchronous requests, guaranteed delivery, load balancing, and ease of development. In this session I will introduce some basic messaging fundamentals, then show how easy it is to send and receive messages using the JMS API. During this session I will also show how to setup and configure ActiveMQ, an open source enterprise-wide messaging provider. By attending this session you will see how easy messaging using JMS really is!
Messaging is both a science and an art. Messaging is a science with respect to the mechanics of the JMS API and the syntax for sending and receiving messages. However, messaging is also an art when it comes to applying the JMS API to solve real-world problems. In this session I will review some of the more common use cases for messaging and show techniques for significantly increasing both the performance and scalability of messaging-based applications. Using ActiveMQ, you will see how to create embedded brokers, how to use asynchronous logging with Log4J and JMS, and how to significantly speed up your messaging applications. In this session I will also describe and demonstrate some emerging trends in messaging, including RESTful JMS (that is, JMS over HTTP) and also AMQP (Advanced Message Queuing Protocol). Come to this session to find out how much fun messaging can really be!
Prerequisite: Some knowledge of JMS and Messaging in general
Nathaniel Schutta - Author, speaker, software engineer focused on user interface design.
Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.
While your project might have nearly 100% code coverage on the server tier, many projects ignore testing the web layer. With more and more code being pushed to the browser, a lack of tests for the client code begs for trouble.
Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.
Aleksandar Seovic - Software Developer and Author
While many developers still think of in-memory data grids as clustered caches, in reality they are much more and provide a solid foundation for the next generation of scalable web and enterprise applications.
Building scalable, highly-available applications that perform well is not an easy task. These features cannot be simply “bolted” onto an existing application – they have to be architected into it. Unfortunately, the things we need to do to achieve them are often in conflict with each other, and finding the right balance is crucial.
Ken Sipe - Architect, Web Security Expert
The agile development process is all about early and often feedback. One aspect of feedback is how is the team doing... Are we accurate in our estimates? Are we consistent in our velocity? As velocity varies, what is it telling me?
Scale... what is scale... how do you applications that are scalable. How do you know if the application scales?
So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 6 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.
This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily enterprise builds.
When it comes to cross cutting software concerns, we expect to have or build a common framework or utility to solve this problem. This concept is represented well in the Java world with the loj4j framework, which abstracts the concern of logging, where it logs and the management of logging. The one cross cutting software concern which seems for most applications to be piecemeal is that of security. Security concerns include certification generation, SSL, protection from SQL Injection, protection from XSS, user authorization and authentication. Each of these separate concerns tend to have there own standards and libraries and leaves it as an exercise for the development team to cobble together a solution which includes multiple needs.... until now... Enterprise Security API library from OWASP.
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.
REST as an architectural approach is greatly simplified through the selection of framework or tool to help with the tedious and repetitive template style that it demands. Until recently, some of the best approaches where through frameworks that required the use of languages other than Java, such as Rails or Grails. In the Java space, the choices were limited. The newly released Spring 3 changes that. One of the most significant changes in Spring 3 is it’s support for REST, which includes client as well as server support.
Prerequisite: Java 5
Brian Sletten - Forward Leaning Software Engineer
HTML 5 is an adventurous and confusing prospect that will help change the Web as we know it. It is being finalized as a standard but won't be fully supported by most browsers for quite some time. Companies like Apple and Google have already committed to it as the future of Web application development, however. There are a huge number of new features, updates and gotchas coming at us (including the proverbial kitchen sink!) so it is time to get prepared. This talk will walk you through the new bits and try to put it all into perspective.
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.
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.
Just as the world is feeling comfortable with the Web, Tim Berners-Lee et al inform us that what we have seen so far is just the beginning. His original plans at CERN were larger and grander. The Semantic Web is a vision of machine-processable documents and metadata to improve search, knowledge discovery and data integration and management. The only problem is that there is no such thing. There is no Semantic Web, just the Web we have that is increasingly semantics-enabled. Forget the hype. Come learn how the technologies of this vision are being used today on the Web and in the Enterprise by more people than you might think.