For over ten years now I've helped corporations use object technology to build business information systems. During this time I've built business object models using several design techniques and programming languages. Along the way I've written several books and appeared at quite a few software development conferences.
For nearly all of this time I've worked as an independent consultant. In March 2000 I returned to a regular paycheck by joining ThoughtWorks, a company that does consulting and development of business systems. I've consulted with them for a while and have found them to be a great company. They are giving me a lot of leeway to do the things I like to do - the writing, conferences appearances etc. Although I'll spend a lot of time on their projects, I still have freedom to do other consulting work as well, so do get in touch if you have a particularly interesting project that you might like to involve me in.
A few years ago I wrote a book on Analysis Patterns. Analysis patterns are those repetitive ideas that I have come across in the business (domain) modeling that I have done during my career. As such they bring together the important areas of patterns and business object development. I also wrote (with Kendall Scott) a second book: UML Distilled . It's a concise overview (under half an inch!) of the notation, semantics, and an iterative development process. It won a Software Development Productivity award in 1998 and is now available in a second edition. Last year I wrote Refactoring: how to alter the design of existing software in a controlled and rapid manner. My most recent book is Planning Extreme Programming which I wrote with Kent Beck.
I've been a regular speaker at object technology conferences including OOPSLA, Software Development, and ECOOP, where I have given tutorials on analysis and design methods, the UML, Refactoring, lightweight processes, and Analysis Patterns. I'm a content advisor for Software Development West and on the program committee for XP 2001. This year I'll be starting the design column for IEEE Software.
Refactoring: Improving the Design of Existing Code
Wednesday 10:15 - 11:00 (Conference Hall)
Almost every expert in Object-Oriented Development stresses the importance of iterative development. As you proceed with the iterative development, you need to add function to the existing code base. If you are really lucky that code base is structured just right to support the new function while still preserving its design integrity. Of course most of the time we are not lucky, the code does not quite fit what we want to do. You could just add the function on top of the code base. But soon this leads to applying patch upon patch making your system more complex than it needs to be. This complexity leads to bugs, and cripples your productivity.
Refactoring is all about how you can avoid these problems by modifying your code in a controlled manner. Done well you can make far-reaching changes to an existing system quickly, and without introducing new bugs. You can even take a procedural body of code and refactor it into an effective object-oriented design. With refactoring as part of your development process you can keep your design clean, make it hard for bugs to breed and keeping your productivity high.
In this tutorial we'll show you an example of how a lump of poorly designed code can be put into good shape. In the process we'll see how refactoring works, demonstrate a handful of example refactorings, and discuss the key things you need to do to succeed.
Continued: Refactoring: Improving the Design of Existing Code,
Wednesday 11:15 - 12:00 (Conference Hall)
Tutorial half day Thursday
Enterprise Application Architecture
The last decade or so has been one of technology churn. We've seen client/server, CORBA, J2EE, COM, .NET and a host of other enterprise platforms appear or fade from view, or both. Keeping up with resulting alphabet soup is a full time job, even without applications to ship.
But amongst all of this churn, some techniques stay relatively constant. So we've been trying to identify these common patterns and taking note of how we use the ideas from one technology and use similar, but not the same designs in others. (You can find these at martinfowler.com/isa)
In this talk we'll explore a number of these patterns. We'll touch on various topics including layering, business logic organization, database mapping, webserver design, and session state management.
The talk is based on the material at http://martinfowler.com/isa