White Papers and Presentations

An update to my earlier "PPP" talk, given at QCon San Francisco, where I focused on the ways that "PPP" can simplify your designs and reduce the size of your code base. This version of the slides includes some extra slides I omitted from the actual talk to save time. InfoQ.com may offer a video of this talk. Stay tuned.

Is one language and one modularity paradigm really sufficient for modern applications? Often, no. This presentation discusses the strengths of different languages and different modularity approaches (objects, aspects, functions, etc) and cites examples where mixed approaches succeeded.

How do you keep systems and architectures "clean"? This is a talk I gave at Agile2008, based on the "Clean Systems" chapter I wrote for Bob Martin's new Clean Code book.

I discuss 10 mistakes I see Java teams make, why they are bad, and what to do instead.

I've given this presentation now at several venues. It provides a short introduction to some of the seductive features of Scala, like Traits for Mixin Composition, succinct syntax, and support for Functional Programming. I've presented variations of this talk at Agile 2009, Chicago Code Camp 2009, the first meeting of the Chicago Area Scala Enthusiasts, and the Chicago Java User's Group (CJUG).

An older overview of Scala. I hacked-up a presentation tool that Dave Thomas created, which is based on S5. To view the presentation, open html/all.html in a browser. The code used in the slides is in the code directory.

The first presentation is an expanded version of the talk I gave at RubyConf 2008 and Chirb (Chicago Rubyists) where I introduce the principles of Functional Programming and why applying these principles can improve the quality of Ruby applications, especially when concurrency is required. Here are the code examples used in that talk. (Confreaks recorded the earlier version given at RubyConf. You can see it here.).

The Son of version provides a shorter introduction. Instead, it focuses more on ways that functional thinking improves the quality of our object-oriented (OO) code and when OO is not the best design choice. In particular, I argue how functional idioms are better for creating a successful software component model. Update: The video of the WindyCityRails talk is now available.

A tutorial that Aslak Hellesøy and I did August 27, 2009 at Agile 2009.

A talk I gave at Dr. Dobb's Architecture and Design World 2008. It discusses object-oriented and functional design principles that promote smaller, higher quality Ruby code. I don't discuss the "obvious" stuff, like how to use Rails, gems, JRuby, etc. Rather this talk is based on the premise that a successful architecture must be based on a foundation of good OO design, with a healthy dose of ideas from Functional Programming, Aspect-Oriented Design, etc. Feedback is welcome!

This short talk (30 minutes) presented Aquarium to the aspect-oriented programming research community at the Aspect-Oriented Software Development 2008 Conference, in Brussels. It assumes some familiarity with aspects. See the next, longer presentation if you are new to AOP/AOSD. The talk was based on my Industry Track paper.

This talk introduces Aquarium, an AOP framework for ruby. I gave this talk at the Chicago Ruby User's Group (Chirb), Oct. 1, 2007 (Updated: April 16, 2008). I discuss how Aquarium works and why AOP is interesting for Ruby. For example, I show a simple example of refactoring Rails code to improve it's clarity when Aquarium is used vs. using metaprogramming (e.g., class_eval and alias_method). There are a few exercises that go with the talk: Aquarium_RubyAOP_exercises.zip

I discuss some of the academic research and industry trends that led to the creation of AOP, the current state of things, and how both can contribute to the future development of AOP and emerging technologies that might use it.

This is an introduction to AOP, given as a presentation at the Chicago Java User's Group, Sept. 6, 2007. I discuss why AOP is interesting, what problems it solves, followed by a look at how aspects can be implemented in AspectJ and Spring AOP. I then look at several object-oriented design principles adapted to aspects and, along the way, demonstrate fine-grained separation of concerns using AspectJ.

I tried to follow the Takahashi Method of presentation design, which is especially challenging when you present code. Some of the slides look a bit busy, but only because the PDF doesn't show you the builds that I use in the live presentation. Any feedback on the presentation is welcome!

An examination of 11, well-established OOD principles and how they apply to AOD. The main objective of this paper is to address pragmatic issues of designing production-quality aspect-based software. In today's world, aspects won't prosper unless they promote agility, reusability, and maintainability. The 11 OOD principles discussed have proven to be effective design tools that promote these qualities (especially in languages like Java, C#, C/C++, etc.). I discuss how the principles apply to aspect software, how AOD refines them, and how they lead to new aspect-specific extensions that promote better aspect design. This paper is part of the Industry Track at AOSD 2007 in Vancouver, BC.

Ivan A Krizsan graciously donated this paper which discusses how to build Contract4J from scratch, using Eclipse, and it provides an example of using Contract4J. Thanks Ivan!!

An introduction to Contract4J and how to use it. The article also briefly discusses some emerging ideas about the nature of interfaces in Aspect-Oriented Design, and how Contract4J demonstrates some of those ideas.

Writing Contract4J revealed many of the challenges faced when trying to write generic, reusable aspects in AspectJ. This paper discusses those challenges, how they were addressed, and offers suggestions for improvements to AspectJ and our concepts of AOD that will make it easier to write reusable aspects. Presented at the Industry Track, AOSD 2006, Bonn Germany, March 22, 2006 (Click here to get all the Industry Track papers).

Contract4J comes in two forms; an implementation where contract tests are defined using Java 5 annotations and a more experimental implementation where the tests are defined as regular Java methods with a JavaBeans-like naming convention. This paper discusses how these two forms define a protocol with two different syntaxes that allow aspects to advice objects with minimal coupling, in the spirit of interface design. Presented at the ACP4IS Workshop at AOSD 2006, Bonn Germany, March 21, 2006.

Predictions about the likely future of AOSD, based on the history of OOP. The basis for this comparison is the conceptual parallels between the two technologies. The presentation also has a brief description of AOP itself. It ends with an appraisal of the current state of AOP and offers some recommendations for how to begin working with it today.

Some preliminary work on Ivar Jacobson's idea of considering Use Case-oriented software development as a form of AOSD.

An examination of how AOSD addresses some technical challenges in OMG's Model Driven-Architecture (MDA).