|
|
|
The following Pathfinder Solutions White Papers and User Guides are provided
free of charge in PDF format.
|
|
Accelerate Embedded Software Development with Model Driven Architecture
Understand what Model Driven Architecture is, its benefits, and how it works. Also learn how to realize MDA's benefits with PathMATE™, a model automation and transformation environment that you can use today.
|
How to Apply Model Driven Architecture
Rigorous Software Development with Domain Modeling
After you define your requirements, you must translate them into a model. Domain modeling is the place where analysis, organization, creativity, and practical insight all coalesce in the formation of a new software system. Read this paper to deepen your understanding of this critical skill, and to learn how you can become an expert domain modeler yourself.
|
Managing a Transition to Model Driven Architecture
This paper outlines common pitfalls encountered when adopting the Unified Modeling Language (UML) to develop high performance software, and how to manage risks that accompany the adoption of new technology. Learn the organizational challenges companies face in a transition to Model Driven Architecture, and understand how to overcome these challenges.
|
Platform Independent Action Language
This overview of the action language used in Model Driven Architecture helps practitioners develop their service and state action models. The paper includes a single-page quick reference guide that summarizes action language syntax. See also PathMATE Design Templates and Components: Developer's Guide.
|
|
|
|
|
| TOP OF PAGE |
Template Based Translation
Complete Control Over Generated Code
Template Based Transformation explains how to generate high performance code from UML models and PathMATE templates. The code generation process produces optimized code that retains the simplicity, maintainability, and extensibility of a modeled system. For additional discussion, see the companion paper, Design Pattern Templates: A Strategy for Optimizing Embedded System Performance.
|
Design Pattern Templates
A Strategy for Optimizing Embedded System Performance
Design Pattern Templates outlines a strategy that uses template based code generation to optimize system performance. Using the strategy, you define a set of patterns that allows you to select from a variety of implementation structures. The optimized system is just as maintainable and extensible as the original UML model. For an introduction to the process of generating code from UML models, see the companion paper, Template Based Translation: Complete Control Over Generated Code.
|
UML to C
High Performance Mappings for Embedded Systems
Embedded systems deployed on highly constrained platforms must meet requirements that run counter to the object oriented and abstract world of UML software modeling. To transform UML models into the high performance systems required in automobiles, a set of mappings is required. This paper outlines a strategy for transforming UML models into a C implementation that meets the requirements of automotive systems: reduced use of dynamic memory, pre-allocated and statically initialized structures, and rapid reconfiguration to varying target processor topologies.
|
Implementing UML Statechart Diagrams
The UML Statechart Diagram is a powerful tool for specifying the dynamic behavior of reactive objects. UML Statecharts extend Moore state machines to offer many convenient modeling features, such as composite states, exit actions, actions on transitions, and guards. These advanced features allow developers to model more complex behavior in a compact form. Although convenient for modeling, these features can be quite daunting when you consider how to implement them. This paper introduces a set of standard C++ classes that implement UML Statechart Diagrams associated with UML classes.
|
|
|
|
|
| TOP OF PAGE |
Rearchitecting With UML
This paper presents a case study applying model-based development to maintaining, extending, and replacing an existing code base for a next generation process control system. The piecemeal replacement strategy first breaks the application down into logical components with well defined interfaces, then focuses on improvement or replacement within the component boundaries, using UML models. The models provide a robust foundation for software development in the face of requirements changes, strict performance and scalability goals, and hardware changes.
|
Effective MDA: Architecture for High Performance Systems
How do you make sure the architecture of your high performance system is robust and durable? You can rely on the uncertain magic of a talented architect, or your team can follow a step-by-step, time proven process. Effective MDA outlines this process - domain modeling – and explains why domain-based architectures are more durable than other approaches for structuring high performance systems.
|
Developing Reusable Components
This paper outlines effective methods for partitioning a software system into subject matter domains. When you organize your model into manageable domains, you can simplify internal component design, respond easily to changing requirements, and create reusable components for future products. The techniques described in this paper are applicable to systems that use either a functional or an object-oriented approach.
|
Topology Independence
Software Reuse Across Embedded Product Lines
Traditional practice handcrafts software for each processing node in an embedded system. This approach becomes unmanageable - and expensive - as developers apply the same feature set to new products, each with a different processor topology. The practice is inefficient because it interweaves topology-specific software elements with the feature logic, and that defeats large-scale reuse of the software. This paper details an effective, model-based strategy for developing software components independently of processor topology and implementation language. Then it shows how to deploy sample features to two different target topologies in automobiles to illuminate the flexibility and reusability of the software across varying deployment strategies.
|
|
|
|
|
| TOP OF PAGE |
Agile Model-Based Development
Agile software development is an approach to constructing software that is
designed to be responsive to change in the business environment. The
purpose of this paper is to examine an alternative to code-based agile
processes - an agile process based upon model-based development. The
primary goal is to demonstrate that model-based development can actually be
more agile with respect to the primary goals of agile software development
than the OOP-based (code-based) processes.
|
How to Streamline Your Software Development Projects with Eclipse
Model Driven Architecture offers big gains for embedded systems developers, but the problem of integrating the tools required for MDA has not yielded a simple solution. Developers need a UML editor, a transformation engine, a compiler, and a code debugger. A model-level debugger and hardware simulators also aid the process. Eclipse, an open source framework, can solve some of these integration problems and streamline the development process. This paper explains how Eclipse helps embedded systems developers with design, model transformation, debugging, and system deployment.
|
Reviewing MDA Work Products
This paper complements How to Apply Model Driven Architecture: Rigorous Software Development with Domain Modeling. It covers the nature, scope, and frequency of the review sessions that promote teamwork and quality in MDA development projects. Primary points of discussion include how to conduct review sessions, differences between internal and external reviews, and how work product reviews fit into the overall MDA process.
|
MDA Modeling Conventions
This guide contains common rules and conventions to help you model high performance systems. Use these conventions to ensure that the abstractions you develop for your models are consistent, understandable, and valid.
|
|
|
|
|
|
|
|
|
|
