Northern Wisconsin Software Symposium
August 3 - 5, 2007 - Green Bay, WI
Ryan Breidenbach - Co-author of Spring in Action
In 2006, Spring 2.0 was released and Spring became ubiquitous in the enterprise Java space. So if you haven't taken a peek at Spring yet, what are you waiting for?!? If the answer is "This session," you have come to the right place. This session will familiarize you with the benefits Spring provides and why they have made the framework so successful. In addition, we will focus on the efforts that went into Spring 2.0 to make these benefits much more developer friendly. By the end of this session, you should have a grasp of how Spring 2.0 simplifies the utilization of Spring's core features such as bean wiring, AOP, and the simplification of using enterprise Java. If your head is not spinning too much.
Although Spring's rise to ubiquity was driven by its IoC and AOP services, it offers so much more. One of the most powerful of these services is Spring's MVC framework.
If you are familiar with other Java web frameworks such as Struts or WebWork, you will recognize that Spring MVC is a similar request-response web framework driven by a Front Controller, in this case the DispatcherServlet. But Spring also provides considerable functionality out of the box. One of the beauties of the Spring MVC is that, like the rest of Spring, all of its components are quite modular. This allows you to mix and match different implementations of the various MVC components as you see fit for you application.
In addition, Spring MVC provides rich capabilities for data binding. This allows you to transparently bind form parameters to your application objects without having to create any intermediate objects. Spring's validation features allow you to capture both binding and application errors. And with Spring 2.0's much improved JSP tag library, both creating forms and displaying validation errors is quite simple.
Jeff Scott Brown - Core Member of the Grails Development Team
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. Grails provides simple mechanisms for leveraging the power of Ajax.
Groovy is an agile dynamic language for the Java platform. Groovy has a Java like syntax along with many features inspired by languages like Python, Ruby and Smalltalk. This session covers a lot of ground including many interactive examples to hilite the powerful language features that make Groovy compelling. A lot of momentum is building in the Groovy and Grails communities right now and this session is aimed at Java developers who want to leverage the power of Groovy.
Grails brings the powerful "coding by convention" paradigm to Groovy and Java. Grails is not just another flavor in the pool of web development frameworks for Java. Grails leverages the powerful dynamic features of Groovy while taking advantage of best of breed technologies like Hibernate, Spring, Sitemesh and Quartz to make web application development both fun and easy.
The value of Test Driven Development (TDD) has become widely accepted. The practice has extended beyond just XP teams. Good TDD practices yield high quality software and help teams maintain confidence in their software as complexity grows. The dynamic nature of Groovy makes TDD easy and fun. Groovy may be used to unit test not only Groovy code but other code as well. Testing Java code with Groovy is a snap. Learn to use the power of Groovy to test your systems.
Neal Ford - Application Architect at ThoughtWorks, Inc.
You can read books about Agile projects, but you must consult real-world experience to really understand the dynamics of agile project management. This session discusses agile management topics including estimation, project tracking, and useful metrics (and how to obtain them). And just a little about Mingle, the agile project tracking tool from ThoughtWorks.
This session discusses building Domain Specific Languages and DSL-style code in Java, Groovy, and Ruby. It discusses the different types of DSLs, details on how to implement them in Java, Groovy, and Ruby, and example problem domains where DSLs make sense.
This talk avoids SOA hype and gets to the meat of the matter: how do you implement a Service-Oriented Architecture, what are the technological pitfalls, how do you test it, and what traps should you avoid. No marketecture: just implementation details.
This session describes JRuby, the 100% pure-Java implementation of the Ruby programming language. It covers the basics of programming with JRuby and examples of how to integrate it into existing Java projects.
About bridges, languages, engineering, polyglot programming, and the near future.
This session discusses how to use the Productive Programmer principles of acceleration, focus, and indirection to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.
This session discusses how to use the Productive Programmer principles of automation and canonicality to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.
This session explains all the hype surrounding Ruby on Rails, in a context familiar to Java developers. It covers convention over configuration, ActiveRecord, controllers, views, Ajax, scaffolding, testing, and deployment...on the JVM, using JRuby.
Regular expressions should be an integral part of every developer?s toolbox, but most don?t realize what an important topic it is. Regular expressions have existed for decades, but many developers don't understand how to take full advantage of this powerful mechanism, either through command line tools and editors or in their development.
No one writes perfect code: even the best developers fall into bad habits and traps. These topics from The Productive Programmer illustrate blind spots and helps you write better code.
Andrew Glover - Founder of easyb
Behavior-driven development, or BDD, has attracted a lot of attention a la RSpec in the Ruby community, but BDD's roots stem from JBehave, a Java based framework. In this session, we'll look at what BDD is and how it shifts the traditional testing vocabulary from being test-based to behavior-based.
Because GWT applications are written in plain old Java, they can be easily incorporated into a traditional build process and your favorite IDE; plus, you can test aspects of these applications with JUnit, not to mention, everyone's favorite functional testing framework: Selenium.
The practice of continuous integration facilitates early visibility into the development process by regularly conducting software builds, thus integrating disparate software pieces earlier than later, which often times minimizes the interval between when a defect is coded and when it is discovered. Given the automated nature of continuous integration spawned builds, software teams can now start to look at their build process as something more useful than a simple compile and test process.
Are your Ant builds giant XML files that scream for attention? Why not enhance your build process to act like a quality gate, much like a test suite would?
There's no question that Ant is the de facto standard for building Java applications; however, even its creator has acknowledged an inherent limitation with Ant's expressiveness due to its reliance on XML.
Kirk Knoernschild - Software Developer & Mentor
Traditionally, we attempt to make the right architectural decisions early due to the significant anticipated cost affiliated with making incorrect decisions. But this contradicts agile practices which have taught us to embrace change. So how do agile and architecture come together? Conceptually, the goal of agile architecture must be to eliminate the architectural significance of change by crafting software that can easily adapt to change. In practice, developing agile architecture is much more difficult.
Why is software so difficult to change? When you establish your initial vision for the software’s design and architecture, you imagine a system that is easy to modify, extend, and maintain. Unfortunately, as time passes, changes trickle in that exercise your design in unexpected ways. Unlike what you had anticipated, each change begins to resemble nothing more than another hack, until finally the system becomes a tangled web of code that few developers care to venture through. Eventually, modifications to the software intended to improve the system have the opposite affect of breaking other parts of the system. The software is beginning to rot.
Design Patterns are proven and powerful techniques that can help improve the resiliency, maintainability, and extensibility of your applications. However, overusing or misapplying patterns is a common mistake often times resulting in applications that are over-architected, and resemble a tangled web of classes. How can patterns be applied to achieve the goal of better software?
Ted Neward - Enterprise, Virtual Machine and Language Wonk
Mustang, the Java6 release, is out, and even if you're not looking to adopt the new platform right away, it's important to know what's there so you can start to plan for it. In this presentation, we'll go over the major new features of the Java6 platform, including the new integrated XML services capabilities (JAX-WS and JAXB), dynamic/scripting language support (javax.script), new JVM "attach" capabilities, new annotations supported by the javac compiler, and more.
Want to get the soup-to-nuts story on Java annotations? In this presentation, we'll first talk about what annotations provide to the Java language. After setting ourselves a conceptual basis to operate from, we'll look at the language definition for Java annotations, from how to use them to how to define them. Finally, we'll take a look at the other side of annotations, consuming them at source-level (using "apt", the annotation processing tool), class-level (using a bytecode toolkit such as BCEL), and at runtime (using enhancements to the Reflection API made in Java5).
If you've ever gotten a ClassCastException and just knew the runtime was wrong about it, or found yourself copying .jar files all over your production server just to get your code to run, then you probably find the Java ClassLoader mechanism to be deep, dark, mysterious, and incomprehensible. Take a deep breath, and relax--ClassLoaders aren't as bad as they seem at first, once you understand a few basic rules regarding their operation, and have a bit more tools in your belt to diagnose ClassLoader problems. And once you've got that, and hear about ClassLoaders' ability to run multiple versions of the same code at the same time, and to provide isolation barriers inside your application, or even compile code on the fly from source form, you might just find that you like ClassLoaders after all... maybe.
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)
Bugs? We all know your code has no bugs, but someday, you're going to find yourself tracking down a bug in somebody else's code, and that's when it's going to be helpful to have some basic ideas about bug-tracking in your toolbox. Learn to make use of the wealth of tools that the Java Standard Platform makes available to you--tools that your IDE may not know exist, tools that you can make use of even within a production environment.
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.
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?
If you've been keeping your ear to the ground, you may have heard some talk recently about "rules", "business rules" and "rules engines", but not necessarily any clear discussion on what they are, how to use or design them, or why they might be useful or important.
Nathaniel Schutta - Author, speaker, software engineer focused on user interface design.
Ajax might not be the most complex thing the average web developer has ever encountered but that doesn't mean building Ajax applications is without some quirks. While you can certainly use the raw technologies beneath Ajax or even roll your own framework, there are a number of well-designed open source libraries that you can take advantage of. After providing a quick survey of the field, this talk will feature live coding examples comparing and contrasting some of the more mature Ajax toolkits including Dojo, Prototype, script.aculo.us and YUI. We'll show you what these various libraries do and do not provide and give you some ideas about which ones make the most sense for your needs.
So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.
With all the attention being paid to Ruby and it's hip cousin Rails, many in the Java camp may be feeling like their party invitation is "lost in the mail". Fear not loyal Java lovers, the dynamic language meme is alive and well in your space! Between numerous JSRs and various languages, the JVM is becoming quite the dynamic disco. After an overview of what it means to be dynamic, this talk will look at JRuby, Groovy, and Rhino.
When starting a new project, most developers make sure that testing is a priority. However, only the lucky few live in the idyllic world of greenfield development; the vast majority of us must contend with code written when "test" was a four letter word and testing was the sole responsibility of that "other" organization. We'll examine some techniques for introducing testing - not just to your code but to the rest of your development organization.
Brian Sletten - Forward Leaning Software Engineer
Ok, I can't promise you profit, but hopefully you'll have fun. Maven 2 introduces a number of new features (including that performance feature) that make it a swell project management tool for development.
Come hear about how we can abuse Maven to manage distributed deployment scenarios before the Modules JSR is done.
Most people new to Aspect-Oriented Programming (AOP) are fed up with separation of concerns zealots explaining how great their techniques are at dealing with... logging. Ok, you get it. Logging is a cross-cutting concern that can be appropriately modularized. What else does AOP have to offer? A lot, it turns out. This talk will give an introduction to the motivations of AOP as well as a series of concrete examples drawn from enterprise and client side Java. Come learn how AspectJ-flavored AOP can begin to benefit you immediately either in development or production environments. Learn how to enforce architectural policies, find Swing threading issues, reduce the invasiveness of the Observer design pattern or even improve the reusability of your domain models. Now that Spring 2.0 provides support for AspectJ, the time has never been better to learn about these new (but backwards compatible) ways of thinking about building software.
Object-oriented code metrics are a little like Artificial Intelligence: those who did it twenty years ago roll their eyes at the thought and prophesy the same ultimate failure at applicability now. Those who grew up with Java are approaching the topic with new eyes and are finding useful ways of incorporating metrics into their projects. Come hear about tools and ways to measure properties of software, how they might be beneficial and where you are likely to go astray with this approach.
Ever since we started doing relational joins, we've looked for ways to tie data together. The web has given us no end of new data sources to integrate but it seems like the best we can come up with is locating Starbucks on Google Maps. The problem with browser-based mashups is that they don't survive the session, we have no way of referring to the results in future queries and ultimately we don't maintain ownership or control of the process.
We want control of our data and our mashup results. We want ever more ways to view, explore and requery them in multi-faceted ways. Do you know what your data integration strategy is for the next few years? Are you sure? You owe it to yourself to come find out.
Software engineers are usually familiar with the notion of scheduled tasks and cron jobs at the OS level. Quartz is a relatively new open source Java API for scheduling jobs in your applications or Enterprise.
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 the new vision of machine-processable documents and metadata to improve search, knowledge discovery and data integration and management. While there are many naysayers chiding such grand visions, there are also pragmatic and useful technologies emerging that can be applied today.
Imagine the simplicity of REST married to the power of Unix pipes with the benefits of a loosely-coupled, logically-layered architecture. If that is hard to imagine, it may because the architectures available to you today are convoluted accretions of mismatched technologies, languages, abstractions and data models.
NetKernel is a disruptive technology that changes the game. It has been quietly gaining mind share in the past several years; people who are exposed to it don't want to go back to the tired and blue conventions of J2EE and .NET. Not only does it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.
Come see how this open source / commercial product can change the way you think about building software.
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.