Whether you are designing and building the next generation cell phone, PDA or are part of a team working on developing a large-scale, mission critical system in which software is tightly connected to specialized hardware, such as those systems found in the telecommunications, aerospace, medical, or similar kind of industries, you can manage the scope and complexity of the project far more efficiently by refining and solidifying the architecture early in the process. To accomplish this, you need the tools that let you do your job faster and more efficiently; and tools and technology that will allow you to identify and manage key decisions all throughout the development lifecycle to minimize the kinds of errors that traditionally arise from integration issues, operational dependencies and common coding mistakes. In today's competitive, global markets, you also need tools that accomplish these tasks while also enabling you to respond quickly to opportunities, competitive threats, or customer demands.

Tools that support model-driven design are particularly ideal for complex systems development because you can work at a higher level of abstraction for greater productivity. The ability to encapsulate business logic and industry best practices into models that can be used for application development, code generation, testing, and maintenance improve the overall development experience in every way that is important to improving productivity and reducing time to market and development costs.

Model Actors
Modeling provides a way to render a complicated architecture into various context levels, giving developers the equivalent of a black box view of the system, while also identifying external actors and the boundaries of system/actor interactions. This enables developers to detect critical elements in the early stages of architectural design, letting the development team refine the various elements of the architecture before it is rendered into code. Once the context level has been defined, the development team can decide which discrete elements must be incorporated in the system to satisfy the requirements or business processes that were identified at the context level. Various levels of models can be employed and implemented to define and refine a myriad of specific details to be implemented throughout the development process, including enhancing technology integration and interoperability, as well as enforcing and monitoring governance policies. This also helps the team to easily identify which portions of the system need to be implemented using software, hardware, or firmware, as well as describing the most efficient way to implement the model into the final deliverable product.

If you are starting to think this appears to be more trouble than it's worth and more difficult than you are prepared to handle—you're wrong. Using model-driven systems development to implement a cohesive hardware and software systems project—no matter how simple or complex—is easier than you think with IBM Rational Systems Developer. This solution simplifies the complexity of creating and delivering well-architected systems by providing the tools you need to rapidly design, build and manage everything from simple devices to large scale, complex hardware systems.

From Model to Code and Back Again
IBM Rational Systems Developer simplifies and accelerates the use of UML 2, while enabling you to create model-driven C/C++, J2SE, and CORBA applications. It is built on Eclipse and has the great Eclipse tooling you rely on. More importantly, IBM Rational Systems Developer leverages and extends the Eclipse framework with numerous, useful features including enhanced debuggers and editors. At the same time, it gives you access to the rich set of Eclipse plug-ins that you may require to customize your development environment.

You will find it is relatively easy to transition from code to code-level modeling using IBM Rational Systems Developer. You won't find any of its UML model-driven capability intimidating or difficult to use. You will just be working with a more abstract, architectural view of your code because your existing code is rendered in UML and you use UML 2 notation to help capture and communicate all aspects of an application architecture, using a standard notation that many different stakeholders can recognize.

You can easily see the intricate details of your architecture using IBM Rational Systems Developer's model-driven development environment. Since the various design elements are captured in UML models and application artifacts in the development workspace, you get a visual picture (and a greater understanding) of your code and architecture. This lets you generate high-quality source code based on decisions you make about the architecture, as well as allows you to create and enforce rules to support the architecture. Additionally, you have a flexible way to manage your models for parallel development and architectural re-factoring because the tool supports tasks such as splitting, combining, comparing and merging models or model fragments.

UML visualization is a graphic depiction of source code using UML notation. However, you can create a model using UML and generate code from the model using a transformation or forward-engineering. If a change is made to the code, another transformation or reverse-engineering must be made to get that change back to the model. The UML visualization diagram and the source code are linked, with changes in one reflected in the other. The UML visualization diagrams cannot be considered a model—they are just a graphical depiction of source code.

To further tempt you to consider model-driven development, IBM makes the tool easy to install and gives you multiple, flexible installation options and integrated design and development capabilities. After installing the product, you can build a perspective comprised of the views that contain everything you want to see on your desktop (e.g. text editor, link to the project requirements that are in another view, debugging window, etc.). You can easily rearrange these views to see only what you require to get your job done.