The release of Enterprise Architect 17, Sparx Systems introduces an effective feature – Model Based Perspectives technology to model and publish custom Enterprise Architect perspectives directly from the diagram enabling organizations to tailor the modeling environment to specific user roles, scenarios, and security groups. This enhancement supports model governance, boosts user productivity, and simplifies complex modeling tasks by surfacing only the relevant technologies and features.

What are Model-Based Perspectives?

Model-based perspectives allow administrators and modelers to define customized modeling experiences. These configurations include toolboxes, ribbons, diagram types, and technologies, packaged as reusable “perspectives” aligned to specific use cases or security roles.

By filtering and tailoring the interface, perspectives reduce clutter and help users focus on relevant modeling tasks. They are especially valuable in large-scale architecture initiatives, where diverse teams work on different layers or aspects of the enterprise.

Key Capabilities

Tailored Modeling Interfaces

Modelers can focus on specific domains (e.g., TOGAF, BPMN, ArchiMate) without distraction from unrelated features. Administrators can configure the perspectives for individuals or entire security groups.

Ribbon and Toolbox Customization

Customize ribbon categories, groups, toolboxes, and technologies using ready-made templates or define your own. The interface dynamically adapts based on the active perspective.

Role-Based Access Control

Perspectives can be tied to user security profiles, ensuring only relevant tools and content are accessible—simplifying governance and enhancing user experience.

Getting Started: Creating a Perspective Workspace Model

Creating a Perspective Workspace involves several key steps, typically managed by an administrator.

1. Define Security Profiles

Create users and group them into roles using the Security feature in EA. These groups determine who sees which perspectives and interface configurations.

Figure: 1 Security Group profiles

2. Open the Model Perspectives Toolbox

Navigate to: Toolbox > Custom Technologies > Model Perspectives

Figure: 2 Model Perspectives toolbox

This toolbox provides access to customize following:

• Technology patterns
• Ribbon category definitions
• Ribbon groups
• Security group configuration element

3. Design Your Perspective Workspace

Create a package and apply the stereotype as «Perspective Workspace».

                           Figure: 3 Model Perspective Stereotype

This defines the scope of your configuration and adopts the characteristics of model-based perspective Within this package, which define the following:

• Technologies to be enabled
• Ribbon categories and groups
• Access rights and security group mappings

4. Build the Custom Model

Model your workspace with the tools required for the selected perspective incorporating domain specific modeling languages, ribbon category.

Figure: 4 Custom Model

Publishing and Activating a Perspective

Publish the Perspective

There are two ways to publish your custom perspective:

• Right-click the package and select Publish Perspective
• Use the Specialize menu > Publish Perspective

Publishing makes the configuration available to other users in your team or enterprise.

       Figure: 5 Activate Perspective

Activate the Perspective

Choose from:

• Activate Perspective Only – Loads only the associated technologies and modeling language sets.
• Activate Perspective and Security – Applies both the technology configuration and the security-based ribbon/interface layout.
• Once activated, users will see a tailored interface aligned to their tasks and role, complete with custom ribbons and restricted technology access.

Figure: 6 Tailored Interface & Perspective

• This clearly showcases the relevant technologies along with their designated ribbon categories, making navigation and understanding easier.

Use Case Example: APM Accelerator Perspective

Using Sparx’s APM Accelerator and the TEA Model as a pattern, organizations can configure a dedicated APM Perspective. This simplifies the EA interface for Application Portfolio Management (APM) teams by:

• Hiding unrelated technologies
• Streamlining ribbon sets
• Providing tailored toolboxes and diagrams for APM needs

This setup promotes efficiency, maintains consistency, and allows faster onboarding for APM users.

   Figure: 7 APM based perspective modeling

Final Thoughts

Model-Based Perspectives in Enterprise Architect 17 deliver significant value to teams looking to streamline their modeling environments. Whether you are enabling a business architect, application owner, or data engineer, Perspectives ensure that users engage with just what they need—no more, no less.

By combining interface customization with role-based access control, Sparx EA 17 becomes a platform that adapts to your organization, instead of forcing your teams to adapt to it.

Further Information

Please contact us or write an email to info@sparxsystems.in to have a live demo about the new EA 17 features and capabilities.

With the rise of intelligent and highly connected vehicle systems, architectural precision and regulatory alignment have become mission-critical.

As modern vehicles run on millions of lines of embedded C++ code, engineering teams are increasingly adopting model-based development to streamline design, ensure consistency, and generate production-ready code with confidence.

One tool that stands out in enabling this transformation is Sparx Systems Enterprise Architect (EA). It provides a powerful modeling platform with code engineering capabilities tailored to embedded systems and automotive-grade software development.

Customizing Code Generation for Automotive Standards

To meet the specific expectations of automotive software teams, we aligned the Sparx EA code generation templates with their internal C++ coding standards. This meant:

• Reviewing the way classes, interfaces, and behaviors were modeled

• Customizing how EA generates C++ code from both structural (class diagrams) and behavioral models (state machines, activity diagrams)

• Ensuring consistency with their existing architecture and development frameworks

By doing this, we made sure that engineers could generate production-ready C++ code directly from their UML Models, without needing heavy post-processing or manual adjustments.

Figure: 1 Sparx Enterprise Architect UML Model with Code Template Customization

Training Teams to Use the Customized Environment

After customizing the modeling environment, we conducted targeted training sessions to ensure the engineering teams were confident in:

• Creating consistent models using UML.

• Understanding how the code templates work behind the scenes

• Applying the right model structures for code generation

• Managing UML model-to-code synchronization effectively

The training focused on both modeling best practices and hands-on exercises, helping teams adopt a repeatable and reliable modeling approach that fits within their existing workflows.

Benefits Delivered using Sparx Enterprise Architect

Here’s what the teams gained from this effort:

Benefit	Description
Faster Code Generation	Engineers can now generate C++ code directly from accurate UML models developed in Sparx Systems Enterprise Architect, aligned with internal standards.
Improved Consistency	The output code follows a uniform structure, reducing integration issues and manual fixes.
Model as a Source of Truth	The Sparx Systems Enterprise Architect UML models now serve as live blueprints, fully synchronized with the underlying implementation.
Stronger Collaboration	Shared modeling practices helped software, system, and architecture teams work more effectively.
Reduced Learning Curve	With training and clear modeling patterns, new engineers onboard faster and make fewer errors.

Figure: 2 Generated Code from UML Behavioral Model using Sparx Systems Enterprise Architect Code Templates

Challenges Faced in Code Engineering

Challenge	How It Was Addressed
Complex C++ Template Customization	Required deep knowledge of EA’s code template scripting – solved through iterative refinement and testing.
Behavioral Model Integration	Translating state machines and activities into C++ logic demanded a clear structure, handled by defining modeling conventions.
Team Familiarity with EA	Addressed through structured training and examples tailored to real project scenarios.

Final Outcomes

By aligning the code templates with project expectations and equipping teams with the knowledge to use them effectively, we helped establish a robust, model-driven development environment. This allowed the engineering teams to:

• Deliver more consistent and maintainable code
• Catch design issues earlier through modeling
• Improve traceability from design to implementationCatch design issues earlier through modeling

This approach not only enhanced productivity but also laid the foundation for scalable and compliant embedded software development, especially critical in industries where quality and reliability are non-negotiable.

Struggling with code and model synchronization? Tired of manually aligning your C++ code with architecture models?
Reach out to Sparx Systems India (sales@sparxsystems.in) to streamline your engineering process with customized code generation and expert-led training using Enterprise Architect.