Technical Classes

Tuesday Classes - Wednesday Classes

100 Series - 200 Series - 300 Series - 400 Series - 500 Series

600 Series - 700 Series - 800 Series - 900 Series

Wednesday, March 3, 2010
600 series
8:15 am - 9:30 am

601 - A Rational Approach to Programming Style
Dan Saks
Good programming style is an essential part of good programming. Good style leads to programs that are more likely to be correct, and easier to fix when they aren't. Although project-wide style guidelines can improve team productivity, programmers often disagree about what those guidelines should be. This session presents an approach toward achieving consensus on programming style. The key is to base style guidelines on common principles rather than on arbitrary rules. This talk examines a number of these principles and how they lead to specific programming guidelines.

Note: Although this session draws most of its examples from C and C++, the lessons are generally applicable in many languages.

602 - Easy BDD with Groovy
Andrew Glover
The Manifesto for Agile Software Development essentially focuses on meeting customer needs through reducing wasteful activities. For example, Agile developmental practices push for reducing repetitive documentation and for a rapid acceptance of change. Yet, achieving these goals is by no means easy. While a process can enable increased collaboration, for instance, there are various tools that can effectively implement Agile principles.

Once such tool is easyb (www.easyb.org), which is a Groovy-based domain specific language, which facilitates collaboration by bridging those that define requirements (i.e. customers) and those who turn requirements into code (i.e. development). With easyb, collaborative teams can develop stories in a specific format, which are then implemented as tests through a framework that marries the underlying application. This test suite enables change and produces accordance among Agile teams in short order.

In this talk, you will learn how to embrace collaboration and change rapidly by defining easyb stories that exercise a Java application end to end. You will learn how to define specific easyb structures, how to plug them into real code, and how to run them in an automated fashion. You will see first hand how non-coders can define tests easily and how the collaboration this brings yields working software faster.

603 - Enterprise Application Development with Spring
Ramnivas Laddad
The Spring Framework is a comprehensive platform for developing enterprise applications. At the core, it supports dependency injection, aspect-oriented programming and enterprise service abstraction. Come to this class to understand why Spring is a compelling platform for building enterprise applications.

You’ll learn how Spring helps in building Web applications, adding persistence and transaction management, and how to secure them them. We will also peek into integrating with third-party systems through Spring Web Services, implementing monitoring and management using aspects and JMX, and utilizing messaging with JMS along with Spring Integration. By the end of this session, you will have a good understanding of the value proposition of Spring and related technologies.

604 - Building Desktop Applications with Griffon (Part 1)
Andres Almiray
Building a desktop application is a hard task; there are so many things to keep track of that many projects simply fail to meet their goals. Setting up the project structure, keeping each artifact in a well-identified location given its responsibility and type, defining the base schema for managing the application's life cycle, making sure the build is properly set up, and more. These are recurring tasks that should be handled by a tool or, better yet, a framework. Griffon is such a framework. Inspired by the Grails framework, Griffon aims to bring the same productivity gains to desktop development. There are so many traits shared by both frameworks that a Grails developer should be able to pick up the pace fairly quickly.

Prerequisites: Attendees should have good knowledge of the Java language and Java Swing. Laptops loaded with the latest stable Griffon distribution found at griffon.codehaus.org/Download.

605 - Going Lean: Slash Waste with Build & Deployment Automation
Jeffrey Fredrick
Current trends in software development have brought new challenges for build and release cycles. The shorter cycle times of Agile means more builds, more deployments and more releases. The adoption of SOA means more complexity, more elements to juggle. The move to global, round-the-clock, 24-hour development means more teams to service and less downtime. Adding headcount is often not an option, and instead you’re told to get Lean and Mean. But how do you get Lean and Mean without being stretched too thin?

The need to keep costs fixed while adding capacity is leading a growing number of organizations to take a look at Lean Software Development. Instead of attempting a sweeping change to how you develop software, a Lean approach focuses on improving efficiency by rooting out waste. Build and deployment automation offers fertile ground for removing waste and improving the productivity of the entire team.

This session is for engineers and managers who want to learn how to develop and implement their own program for getting a Lean build and release process. You’ll learn:

• Investigation tools such as Value Stream Mapping and Spaghetti Diagramming
• The “Null Release” exercise for identifying bottlenecks in your build and deployment process
• Common build and release productivity blockers and the best practices for removing them

606 - An Introduction to Cryptography (Without the Math)
Allen Holub
This talk discusses how booth cryptography and related technologies (such as digital signatures) work from the perspective of a programmer, not a mathematician. You should come away from the class understand both the technology (and the buzzwords) well enough to understand the incomprehensible documentation that usually accompanies crypto libraries. We'll talk about how both secret-key and public-key/private-key encryption works, look at digital signing, and discuss the mechanics of the SSL (and https) protocols. We'll also discuss key stores, and smartcards, and some of the more commonplace algorithms. Finally, we'll look at the math at a very high level. Time permitting, we'll finish up with a discussion of the Kerberos protocol and single-sign-on architectures.

607 - Construction Techniques for Domain Specific Languages
Neal Ford
Domain-specific languages have been the Next Big Thing for years now, but they have quietly started penetrating the development world. This talk covers language techniques in Java, Groovy and Ruby on how and why to create DSLs. This class starts by motivating you to convert APIs into DSLs, and various patterns, anti-patterns, and best practices for how to achieve the optimum effect. You’ll also learn about the very important topic of implicit context, and how language constructs can allow you to write less verbose and more expressive code.

 

Wednesday, March 3, 2010       Back to top
700 series
11:30 am - 12:45 pm

701 - The Google Web Toolkit (GWT): Programming Client-side AJAX in Java
Allen Holub
The Google Web Toolkit (GWT) is an open-source development framework that makes it possible to write a complete AJAX application (both client and server side) without the pain of JavaScript. The GWT compiler translates client-side code—written in Java using standard tools like Eclipse and JUnit and tested with your normal debuggers—to platform independent, browser-complaint JavaScript. When debugging, you can trace from the client-side to the server-side code, set breakpoints, etc. Most importantly, you can effectively write a JavaScript application without needing to know about the subtle incompatibilities between browsers and the JavaScript minutiae that complicate client-side AJAX development. Consequently, the client-side application goes together much faster and with many fewer bugs than it would were you writing in JavaScript.

This class teaches you about the GWT library, showing you how to install it, how to build and deploy applications, and more importantly, how to write a complex client-side UI using GWT. We'll look at the GWT architecture and classes, and examine a real-world GWT application that implements multiple widgets interacting in complex ways on the client side. We'll also discuss GWTs RPC protocol that you use to talk to the server side of the application.

702 - Declarative UI Programming with XAML: WPF, Silverlight & Surface
Tim Huckaby
XAML has become the de facto declarative language for UI development on the Microsoft platform spanning Windows, Web and the Microsoft Surface. This transformation to a single declarative language for all platforms has enabled Microsoft to deliver on the bold promise of a cross platform user experience programming model for the future.

In this unique session, we take a look at how knowledge of XAML and .NET languages like C# and VB.NET allow you to develop applications for Windows (WPF), the Web (Silverlight), and Microsoft Surface using the same coding constructs and idioms. In this demo packed session we will take a look at how graphics, animations, data binding, styles and templates are commonly implemented on these platforms, and how XAML makes all of this possible.

703 - Agile Analysis: Aligning Decisions with Three Views of Requirements
Ellen Gottesdiener
On an Agile project, you don’t attempt to understand or predict all product requirements up front. But you do need to sketch out the long view of the product to establish a common focus and marshal organizational resources (people, money, space and governance). From that point, you define what to build in each release, and then in each iteration. These three levels—product, release and iteration—correspond to three views (the Big-View, the Pre-View, and the Now-View) of the product requirements.

This class will explore the analysis techniques Agile teams use at each view to define and confirm product needs. You will learn how analysis needs to be both strategic and tactical, how to incorporate collaborative workshops to align delivery decisions, and why Agile projects rely on business analysis as the basis for planning, development and delivering business value.

704 - Building Desktop Applications with Griffon (Part 2)
Andres Almiray
Please see description for course #604.

705 - Agile Modeling: No, It’s Not an Oxymoron
Terry Quatrani
So you have adopted an Agile process and think you don’t need to model. You should think again. One of the key principles of Agile development is communication. One of the best ways to facilitate communication is by using a model. Even though Agile modeling is different than traditional modeling, you will still be modeling. Requirements are needed in order to build the right system. Architecture is key; no one just sits down and writes code. Testing is imperative; "Test early, test often" is a mantra often heard. Come to this class to learn how modeling and, yes, even UML can be used effectively in an Agile development process.

706 - Design Patterns for Navigating Complex Taxonomies
by Loren Baxter
Content is expanding at a dramatic rate. Traditional enterprise navigations models like inverted “L” portal menus or Cascading menus quickly become difficult to navigate and provide little support for site scalability. We will explore new navigation design patterns that use non-linear techniques to address the usability and design issues associated with today’s more complex information taxonomies.

708 - Five Static Code Audits Every Developer Should Know—and Use
Mike Rozlog
In today’s competitive market and economy, developers need every tool to increase productivity, reduce cost and lower maintenance, while ensuring proper execution in production. One of the truly underutilized tools is a static software audit. The concept of static analysis has been around for years, and over the past few years, tools to evaluate and diagnose the style of the code have really matured. There are hundreds of software audits available to developers today in almost any language. These audits can isolate additional poor-coding practices in various areas like Arrays, Loops, Coding Style, Design Issues, Duplicate Code, Naming Style, Performance, and many others. Inside each one of those top-level classifications is another full set of audits to be used by the developers or their team.

You’ll learn the ins and outs of five code audits that are easy to understand and offer real benefit: Numerical Literal in code, String Literal, God Method, Shotgun Surgery, and Duplicate Code.

Prerequisites: Intermediate knowledge of code

Wednesday, March 3, 2010       Back to top
800 series
2:30 pm - 3:45 pm

801 - T4: Code Generation Microsoft Style
Kathleen Dollard
Microsoft’s code generation tools have sometimes been called the best-kept secret in Visual Studio 2008. You’ll explore how you can leverage Microsoft’s code generation techniques regardless of where you fall on the timeline of Microsoft’s gradual involvement in this space. The T4 language is straightforward, and you’ll learn how it works – and you’ll become comfortable defining templates themselves. The class then shifts to the harder issues of how to pass data into your templates, how to output multiple artifacts, how to protect handcrafted code, and how to perform coherent processing.

There’s no perfect code generation. You’ll learn how to identify the principles you care about and measure the evolution of the process in relation to those principles. The talk closes by addressing code generation as the coherent marriage of business engineering expressed as metadata with well defined architectures defined as templates and specialization held in handcrafted code. The dance between these three aspects is both the power and challenge of code generation.

802 - Comparing the Cloud: Google App Engine vs. Amazon's EC2
Andrew Glover
Several years ago, a few smart companies took advantage of the commoditization of hardware (and related software) by building systems made up of a lot of cheap machines, knowing that the entire infrastructure would continue to work even if individual machines broke at some point. Those smart companies—like Google and Amazon (to name a few)—have enormous infrastructures that they can literally rent out to people like you and me (and keep their core business running smoothly at the same time).

This class will teach you about Google's and Amazon’s Cloud infrastructures, and the two are quite different. Google's App Engine is more of a platform for developing Java Web applications. Amazon's EC2 offering is less of a development platform per se and more of a generic infrastructure service that hosts virtual machines (which can be Linux- or Windows-based) on which you can run anything you'd like.

Open-source solutions combined with borrowed infrastructures are changing the character of Java development, letting teams deliver better software quickly and at a low cost. Come to this class to learn how it works, and how to get started.

803 - Pragmatic Interoperability: Making Java and .NET Play Well Together
Ted Neward
Java and .NET represent the lion's share of enterprise development. In this class, you’ll learn how the two environments can interoperate with one another, not only over Web services, but also via in-process channels and other methods. Along the way, you’ll see how to leverage the strengths of each, such as using Microsoft Office to act as a "rich client" to a Java middle-tier service, or building a Windows Presentation Foundation GUI on top of Java POJOs, or even how to execute Java EE functionality from within a Windows Workflow host.

804 - Hyperperformance: Scrum As A Catalyst For Continuous Productivity Improvement
John Clifford
Perhaps the most common Scrum axiom is, “Scrum exposes your problems; it doesn’t solve them,” a response given by Scrum advocates to those who are looking for the proverbial software development Silver Bullet. However, exposing problems is a huge benefit for most organizations, because problems are typically managed (or lived with) instead of solved, becoming the organizational equivalent of a minor ache or pain.

This class will teach you how to use the feedback provided by Scrum’s empirical nature along with the constraints of the Scrum process, combined with complex adaptive theory and the principles of organizational development, as stated by Tuckman, Carnall, White and others, to force the emergence of desired adaptive behaviors in order to increase productivity. This session is for team members (to understand why they must follow the processes), Scrum masters (to understand why they must enforce the processes), product owners, and other external stakeholders (to understand why they must respect the process, and to learn what benefits they’ll obtain by doing so).

805 - Tap into the Exploding Mobile Apps Market Using Your Web Development Skills (Part 1)
Jeff Haynie

While the market for mobile apps is larger than ever, developing and supporting multiple platforms can be complicated and expensive, particularly as fragmentation in the mobile ecosystem becomes a real issue. With a burgeoning market at their fingertips, how can developers adjust to demands of new platforms and rapidly develop cross-platform applications for netbooks, desktops, the browser and mobile platforms?

You’ll learn how to leverage your skills with industry-standard Web technologies, such as HTML, CSS and JavaScript, to develop and deploy mobile apps. Don’t worry: You don’t need to learn Objective-C or Java to create native mobile apps that use Web connectivity.

In this class, you’ll walk through sample applications, unveil code for developing the apps, and illustrate how you can extend your application's reach. At the end, you’ll leave with a cross-platform app, and also gain a larger understanding of the future of a "build once, publish many" form of application development.

Prerequisites: Knowledge of JavaScript or other Web scripting languages. To be hands-on, bring a laptop and install the Titanium Application from www.Appcelerator.com.

806 - Adapting to Continuous Integration and Build
Mario Moreira
The term “continuous integration” refers to the process of integrating code frequently (or on-demand) to reduce large integrations, complexity, and pain in the future, and to make functional software readily available for testing and the customer. Establishing continuous integration and build provides development teams with immediate feedback on the success or failure of changes via a build and smoke test of the product and reduces large integration efforts.

The notion of continuous integration and build takes a different mindset where the team needs to constantly be thinking in smaller bite-sized tasks that allow for frequent check-in and build. In order to design and implement this value-added practice effectively, there are some elements that must be considered. This class will walk you through the criteria needed to establishing a successful continuous integration and build process, so that you can have a solid road map for implementing a continuous integration and build process that is right for your Agile team. Topics include:
• Appropriately "bite-sizing" story tasks
• Right-sizing the branching strategy
• Shifting roles and responsibilities in merging;
• Minimizing the merge process and merging at the appropriate level
• Emphasizing the build at the appropriate level
• Providing testing with teeth (unit and smoke)

Prerequisites: Some experience with Agile and with configuration management build processes.

807 - Improving Code with Test-Driven Development
Neal Ford
Most developers think 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. You’ll learn about 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 teaches that TDD is much more than testing: It fundamentally makes your code better at multiple levels.

808 - Self-Managing Agile Teams Demystified: The Twelve Step Program
Damon Poole
As a manager, you’ve heard a lot about the benefits of self-managing teams, but you’re not sure where to start, and you suspect self-management may lead to chaos. You could just take a leap of faith, set self-management as a goal and then look for ways to achieve self-management. But there is another way.

We’ll cover self-management from the bottom up using concrete examples of twelve widely adopted Agile practices: user stories, product owner, product backlog, standup meetings, whole teams, collocation, assignment and estimation of tasks by team members, short iterations, Scrum master, burn-down charts, and retrospectives. You’ll learn how each practice contributes to self-management by reducing and/or redistributing traditional management activities. These practices also help to reduce the temptation to get wrapped up in the details; provide a framework for delegation, communication and coordination; encourage team ownership, commitment and accountability; and create management artifacts that are appreciated by all.

Wednesday, March 3, 2010       Back to top
900 series
4:00 pm - 5:15 pm

901 - Everything You Know Is Wrong: Why Inheritance and Get/Set Methods Are Evil
Allen Holub
Many programming techniques that you may use regularly have a dark underbelly. Implementation inheritance ("extends" in Java) and get/set methods, for example, can cause considerable damage if used indiscriminately.

This class teaches about commonplace misunderstandings of OO principles and techniques—particularly inheritance and get/set methods—in such a way that you'll be able to make informed choices about whether or not to use them. The point isn’t to push some misplaced notion of "purity," but rather to provide you with the information that you need to understand the consequences of your design decisions.

In particular, you’ll learn how implementation inheritance and get/set methods can hurt you when they're used out of context. We'll discuss fragile base classes and implementation hiding in depth. We'll look at examples, explain both the up and down sides of the idioms, and explain how to design your code so that these problems tend not to emerge. The examples will be in Java, but the concepts apply to all OO languages. There will also be a Q&A period in which you can work out the details or hurl invective at the speaker.

902 - RESTing Easy With Grails
Andrew Glover
Representational state transfer (REST) is a way of thinking, not a protocol or standard. It's a style of designing loosely coupled applications that rely on named resources (in the form of URLs, URIs and URNs, for instance) rather than messages. Ingeniously, REST piggybacks on the already validated and successful infrastructure of the Web: HTTP. That is, REST leverages aspects of the HTTP protocol such as GET and POST requests, which map standard business-application needs, such as create, read, update and delete (CRUD). By associating requests, which act like verbs, with resources, which act like nouns, you end up with a logical expression of behavior (GET this document and DELETE that record, for example).

In this class, you will learn about the mechanism for creating RESTful applications with Groovy’s Grails, which gives you the ability to apply RESTful techniques with a full-fledged Web application framework that supports an ORM and testing to boot! As you will learn, using Groovy's Grails framework makes building RESTful Web services a snap.

903 - Agile Workshops: Collaborating to the Rhythm of the Agile Beat
Ellen Gottesdiener
On Agile projects, planning and requirements elaboration converge. Requirements unfold within the context of the rhythm of Agile planning: product, release and iteration (or sprint). Collaborative workshops provide an effective venue for Agile teams to work together transparently to make the complex decisions about what to build, and when.

You hold different kinds of requirements workshops (or planning meetings) at different points in your project. These workshops, which incorporate requirements exploration as well as allocation, are the product road-mapping workshop, release planning workshop, and iteration planning workshop.

In this class, you will learn about calibrating your requirements focus based on the applicable workshop: product road-mapping workshops (to explore and allocate the Big-View of requirements, and map out a strategy for the entire product); release planning workshops (to focus on a smaller time horizon to get a Pre-View of requirements for the next release); and iteration planning workshops (to explore and plan for a small, concise set of requirements for the immediate iteration, the Now-View).

Learn about these useful workshops to enable Agile teams to make smart choices in a manner that yields a healthy project community sharing focus, values and trust.

904 - Enterprise AOP with Spring and AspectJ
Ramnivas Laddad
Enterprise application development is a goldmine for applications of AOP. There are many crosscutting concerns found in a typical enterprise application, ranging from well-known security and transaction management concerns to application- and technology-specific concerns.

Using AOP leads to implementations that are easy to understand and easy to change. When we combine Spring with AspectJ, we get a pragmatic AOP solution. This class will show you how to implement common functionality needed by typical enterprise applications, with a focus on Web applications. We will start with a barebones Web application and develop aspects to incrementally add functionalities such as monitoring, exception handling, policy enforcement, transaction management, fault tolerance and domain-object security.

905 - Tap into the Exploding Mobile Apps Market Using Your Web Development Skills (Part 2)
Jeff Haynie
Please see description for course #805.

906 - Creating Habitable Code: Lessons in Longevity from CruiseControl
Jeffrey Fredrick
A major challenge for software organizations is creating software that can continue to adapt and change over time, a codebase the team can live with. Good architecture creates a habitable space where many people can contribute effectively. This session reviews the architecture of CruiseControl, a popular tool for continuous integration.

CruiseControl is an open-source success story not only because it has had over 400,000 downloads, but also because it has created a codebase that has been successfully contributed to by over 200 different people. For practitioners who are tired of brittle code that must be discarded and rewritten instead of inherited, the design of CruiseControl provides valuable lessons. Specific topics for this session will include inversion of control, dependency injection, separation of concerns, and the role of a project architect. The code examples will be in Java, but the principles are language independent.

908 - The Busy Developer's Guide to ECMAScript/JavaScript
Ted Neward
ECMAScript, better known by its original name, JavaScript, remains one of the most popular—and misunderstood—programming languages in use today. While most developers see JavaScript as a crippled form of its namesake (Java), it turns out that ECMAScript represents a powerful dynamically typed language, easily equal to the other popular dynamic languages of the day (Python or Ruby).

In this class, you’ll take a fresh look at the ECMAScript language, examine its basic structure and syntax, and learn about how it manages objects internally. Then, with the basics out of the way, we'll dive into the more interesting parts of the language, and wrap up with some discussion of how ECMAScript can be integrated into more than just a Web browser to provide extension capabilities.