As a software developer, you must be highly productive to meet the growing demand for software. Many IT professionals continue to spend too much time repetitively and manually developing similar solutions at low-level abstractions. New methods in building software must be employed to free skilled IT professionals from these repetitive tasks and raise the level of abstraction to more powerful concepts. Better tools must be utilized to support these higher levels of abstraction and enable developers to deliver higher productivity by encapsulating proven experience as tool-enabled assets and artifacts. This Web site contains patterns that are already built and freely available for use as well as information about how to build your own custom patterns. Discover how patterns provide solutions to recurring problems while allowing experienced developers to work at higher levels of abstraction. By capturing design expertise and best practices as tool-enabled assets and artifacts, patterns can greatly facilitate the development of Service-Oriented Architecture (SOA) applications -- resulting in significant improvement in productivity. You can author, apply, and reuse patterns with IBM® Rational® Software Architect to improve design and development. Tell us what you think about pattern solutions. Send feedback to patterns@us.ibm.com.
Model-driven software development (MDSD) uses models as primary software artifacts from which other artifacts, such as lower-level models and code, can be generated. MDSD allows you to work at higher levels of abstraction, enabling you to focus on essential variables in your designs and delegating standard, algorithmic, and repetitive activities for expressing these variables to tooling. MDSD is one approach that can benefit from patterns; however, to use patterns does not require a MDSD approach.
More resources:
Patterns begin as an idea or a best practice used in many projects. Patterns can exist at various levels -- from business to architecture, design, and programming to deployment and run-time administration -- and assist in the creation of artifacts according to best practices through all stages of the solution development life cycle.
A pattern is first abstracted from an exemplar that offers the best available solution to the problem within a certain context. This knowledge about the solution is documented with a formal description known as a pattern specification.
New methods now exist that allow us to implement patterns by capturing them in tools (known as microtools). As a result, the patterns are made available in other forms of reusable software artifacts, which helps to improve the software development process. Capturing these reusable software artifacts, or pattern implementation, is assisted by tooling capabilities such as those found in Rational Software Architect and enables patterns to be easily shared and applied.
When numerous patterns and other artifacts exist, you can use "recipes" to combine them to form larger-grained reusable assets. Recipes describe the ingredients (patterns and other artifacts) and the process guidance for using them together to rapidly solve a problem.
Solution exemplars are the foundation for patterns and represent the best solution to a given problem within a certain context, so they must be developed by an expert in the target domain. Quality exemplars should contain best practices reflected in the pattern, and in applications of the pattern, including all variations that the pattern automation will support.
Exemplars provide the basis for the pattern implementation.
- Specification: Exemplar is used to specify what the pattern will generate.
- Test case: Exemplar is used as a test case for the pattern output.
Patterns are traditionally captured in documentation form called pattern specifications. A pattern specification is a precise definition and description of a pattern in conceptual terms that allows for its communication and reuse by others. Pattern specifications provide formal documentation of:
- Context: Strategy for applying the pattern and when to apply it
- Problem: Precise statement of the problem the pattern solves
- Solution: Description of the solution the pattern provides
- Results: Consequences and advantages and disadvantages of applying the pattern
Patterns can now be implemented using software development tools. A pattern implementation is an artifact that greatly facilitates the application of a pattern in a particular environment, provides realized solutions to real problems, and makes patterns sharable and reusable. After they are implemented, these patterns become concrete artifacts, such as Rational Software Architect Patterns, Rational Software Architect Transformations, plug-ins, alphaWorks Design Pattern Toolkit (DPTK) patterns, and the like.
Tooling technologies
Rational Software Architect and DPTK/JET2 provide the tooling to author and apply patterns implementation. Patterns (specification and implementation) help the creation of various software artifacts needed for a software solution. The patterns themselves, once applied, are part of the solution.
The advantage of implementing patterns
Patterns provide a powerful way to improve product development by identifying best practices and design expertise that can be captured in tools and are then available for reuse.
By using patterns, your organization can:
-
Improve productivity. Automate highly repetitive, algorithmic processes to free your developers to perform higher-level tasks.
-
Reduce development time. Eliminate the need to start your project from scratch, using reusable assets.
-
Minimize complexity. Get rid of tedious error-prone tasks, reduce confusion, and break down your project into manageable patterns.
-
Increase quality. Encapsulate best practices into tooling to enable your developers to consistently deliver best practice output.
-
Improve governance. Distill practices or policies into tooling to automate compliance.
-
Gain business agility. Respond more quickly to changing business requirements with increased flexibility.
-
Leverage IT skills. Empower your experienced developers to focus on developing reusable patterns for reuse by newer team members.
-
Promote open standards. Reduce dependence on particular tools and make routine development platform independent.
-
Close the gap between business and IT. Elevate development focus from technical syntax to business variables, to reduce the possibility of mistranslation.
-
Improve cost. Reduce your overall development costs with less complexity, reusable assets, and less time on project.
| 
