Main:
Main.RecentChanges
Edit Page
Page Revisions
|
Main:
|
SearchWiki Main.RecentChanges Edit Page Page Revisions |
| Home Design Patterns Heuristics Software Development Software Process Patterns TheIntroduction LogicalDesign PhysicalDesign PatternFoundations GuidelinesAndMyths ReferenceImplementation DependencyPatterns UsabilityPatterns ExtensibilityPatterns MaintenancePatterns AntiPatterns UtilitiesAndTools AllPatterns | 12-25-2005 Server ConversionI've just completed converting the site to a new server. Some of the links to older material might be dead. I'll work to clean these up soon.The Purpose of ExtensibleJava.comThe primary goals of the object oriented paradigm are easily stated - reusability and maintainability. In an attempt to achieve high degrees of reuse, however, maintainability is often sacrificed. While this may seem like an oxymoron, consider that many development efforts tend to emphasize reuse, while placing little or no emphasis on system maintainability. This is unfortunate, as emphasizing reusability over maintainability discourages the design of more extensible software. Ultimately, reusability is achieved through extensibility. How is this so? Low coupling and high cohesion are central to any resilient software design. The object oriented paradigm introduces logical design techniques, such as inheritance and polymorhpism, that allow us to more effectively manage coupling and cohesion of system classes. Applying these techniques yields more extensible systems that are configurable at predefined variant points, resulting in more extensible and reusable software. Many design patterns focus on helping create these flexible logical structures. But flexible designs exhibit characteristics beyond a resilient logical design. The deployable units, or physical entities, containing the logical class structures must also be designed with coupling and cohesion in mind. How a software application is built and deployed has a significant impact on the ability to maintain system modules, or components. Loosely coupled components can be deployed independently, with the positive side effect being easier use, and increased reuse, of system components. But well designed components also ease maintenance by allowing you to manage the ripple effect of change and the complexity of deploying individual components composing a large software system. Combining a robust physical design with a flexible and configurable logical design further increases the likelihood of reuse and maintainability due to the ease with which components can be independently deployed and configured based on desired usage. Unfortunately, constructing large software systems is not easy. Yet, experienced developers know that applying proven designs (aka. design patterns) encourages the design of software with higher degrees of integrity. Using design patterns in software development, however, involves more than simply applying a pattern to a challenging design problem. How do we know what pattern might be most useful given our current context? Is there another pattern that might offer a more resilient design? These questions are not answered by understanding a multitude of design patterns, but instead by understanding how design patterns expose and apply the fundamental principles of logical and physical design. Through the exploration of these fundamental principles, we present a suite of heuristics that serve as the foundation of patterns, and allow us to realize the goals of object orientation. At ExtensibleJava.com, we'll explore how to apply proven object oriented techniques to develop more extensible software. These techniques are applied using examples in Java. Throughout our explorations, we'll uncover a suite of powerful design heuristics captured by many of the most common and powerful patterns. Enjoy the site, and please offer your feedback by contributing to the site (see below), or by e-mailing me (remove the _nospam).Changes to ExtensibleJava.comI've changed the site because I needed a way to more easily update content. Because the old site was basically static jsp, it was a pain to update and deploy each time I wanted to make a change. This resulted in me doing a poor job of updating the site with new content on a regular basis. Now that the site is running Wiki software, I'll be forced to find another excuse. The Wiki software I chose was PmWiki?, a WikiWikiWeb? clone developed in PHP by PatrickMichaud?. I've used Wiki software OnTheJob pretty successfully, and have really grown to like it's flexibility. So I decided to set out and find a Wiki that I felt would be a good fit for what I wanted on ExtensibleJava. PmWiki? works for a few reasons.
Software behind ExtensibleJava.comHere are some useful default pages installed along with the PmWiki? software. Before you offer any content, you might want to take a quick peek:
|