Mo+ is a leading edge technology that fully supports model oriented development, allowing software developers to powerfully scale the work they already do.
What is Model Oriented Development?
Model Oriented Development (MOD) is a process that allows you to utilize a simple, focused model for development purposes at any point in the development process. You translate model information into source code and/or documents using model oriented patterns
Why Consider Model Oriented Development?
You are a busy software developer. You work on legacy systems or you create new systems from ground zero. You are a proponent of or must conform to processes such as waterfall, scrum, or test driven development. You like or must work in specific programming
languages. You have time and other constraints in your daily work. Why would you consider adding something such as model oriented development?
Model Oriented Development (MOD) benefits your development work by being:
- Flexible - With MOD, you don't have to change your current overall development process at all. You can choose to utilize a simple, focused model early or late in your development process. You choose how little or how much to leverage your models
to generate and maintain code in the languages of your choosing. You seamlessly integrate your generated code with your custom code.
- Productive - Scale and leverage the work you already do. Instead of writing similar things many times, write a model oriented pattern for a component once, and apply that for all similar things in your work.
- Powerful and Robust - Plain old template/procedural based code generation tools too often fall flat when you need them to solve complex problems with business rules and exceptions. Well-written MOD tools, like Mo+, give you full access to your models
with the ability to indicate your rules and exceptions. Model oriented patterns give you the power to solve very complex problems! Your bug count tends to be lower in model oriented code since issues are usually encountered and resolved early.
- Reusable - Reuse your model oriented patterns written to your best practices not only on your current project, but for future projects as well! Reuse powerful team or community developed and reviewed patterns.
In short, model oriented development allows you to continue to do the work you already do, and it allows you to scale your work to do it better!
Requirements for Effective Model Oriented Development
For effective model oriented development, the following requirements are essential:
- You Need a Model - You need a model to represent what you want your system to be and to do. Without the ability to specify the structure and behavior of your system, you are limited in what you can do from code generation and other automation standpoints.
- Simple, Focused, Flexible Model – The model structure should be simple, flexible, and focused with essential information needed for model oriented development. Design, platform, and tier details often should be left out of the model and be handled
when you translate your model information into code and documents. Overall, you need the modeling effort to be low.
- Complete Access to Model – You need the ability to populate your models in any way you see fit. You need the ability to indicate exceptions or other conditions. You may need to create your own model structures. You need the ability to easily recognize
your model structures. You need flexible ways to browse, search, and retrieve your model data to perform your tasks.
- Maximized Code Generation – You need the ability to make the most of your model information, and maximize the quality (not necessarily the quantity) of your auto managed code and documents. Yet overall, you want the code generation effort to be relatively
- Seamless Integration with Custom Code – You need seamless integration of auto managed code and documents with your custom information. You need the ability to insert and maintain exceptions and specific business rules within generated documents.
You need generated and custom code and documents to coexist gracefully.
- Complete Control of Code Generation – You can’t afford to have all of your code regenerated every time as part of a team development effort. You need to have full control as to if, when, where, and how to update your generated code and documents.
- Best Practices – You want full control over your auto managed code and documents so that they meet your organization and industry best practices and other requirements.
There are three approaches that are proven to be effective for many software development applications:
, template based code generation
, and object oriented programming
is the first technology to merge these approaches, and evolve them into a truly model oriented approach for effective model oriented development.
uniquely combines focused and flexible models, a powerful model oriented programming language, and a complete integrated development environment to build and maintain models, and from those models create and maintain code and other documents
in many flexible ways.
Mo+ Solution Builder
is the IDE that lets software developers create and maintain enterprise solutions, software applications, source code, and other materials very quickly. Business analysts can also use the environment to rapid prototype applications
or produce other documents.
is short for Model Oriented Plus, and is the model oriented programming language that gives users the ability to perform a wide variety of tasks such as creating and maintaining models, documents, and source code in any language. The language
has some similarities to object oriented languages such as C# or Java, but has features directly geared towards model driven development.
Mo+ Solution Builder
uses the following other open source components:
- The Mo+ interpreter is powered by the Irony parser (https://irony.codeplex.com/).
- Template editing utilizes the AvalonEdit control (http://www.codeproject.com/Articles/42490/Using-AvalonEdit-WPF-Text-Editor).
- Document viewing is enhanced with AvalonDock (https://avalondock.codeplex.com/).
- Search and replace within template documents is enhanced by this Find/Replace Dialog (http://www.codeproject.com/Articles/173509/A-Universal-WPF-Find-Replace-Dialog).
Why Use Mo+ for Model Oriented Development?
In short, Mo+ is the only technology the "completes the loop" in unlocking the full power of model oriented development, allowing you to do things in a model oriented way that you simply cannot with other technologies. Mo+ satisfies all of the above
stated requirements with ease.
Object oriented programmers know the benefits of object oriented languages over procedural languages in creating large and complex software, benefits such as encapsulation, reusability, modularity, clarity, etc. Why shouldn't you have these same benefits
when managing templates for model oriented development? You do with Mo+!
While other code generation template approaches are procedural in nature, Mo+ templates (and the language) are model oriented by design. Mo+ templates can be used by other templates just like any other built in property or method. They can be used in expressions,
in creating content, and updating output. You can easily divide and conquer complex tasks and specify your conventions and best practices in reusable templates. This high level of reusability of Mo+ templates over other forms of templates will make it easier
to maintain and evolve your code to meet ever changing requirements.
To make your work even easier, we plan to continually build upon the set of template libraries (with community input and review) for different models, applications, components, and other documents in various platforms and languages.
How does Mo+ Solution Builder work?
Mo+ Solution Builder
includes features such as:
- The ability to view and edit models.
- The ability to load model information from database and xml sources in any way you want to, and give you the means to customize that model data.
- The ability to create, maintain, and integrate your model oriented work with your overall work, including source code in any language, other models, and other kinds of documents.
- The ability to create, edit, organize, and debug specification and code templates written in
Using Mo+ Solution Builder
, users can create models and output solutions very quickly using libraries of templates created internally or downloaded. The following diagram outlines the basic process of how this is done.
In a nutshell, the basic process of using Mo+ Solution Builder
to create models and output solutions is:
- Using the Solution Builder Interface, the user creates a solution model, optionally specifying where model information is going to come from as specification sources. For each specification source, the user chooses a
Mo+ template which outlines how to update model information from that source.
- The Specification Interpreter processes each specification source to evaluate the Specification Input (such as a database or XML file), and update information in the solution model, based on instructions in the corresponding templates. The Specification
Interpreter adds information to the model such as features, entities, properties, relationships, and methods, etc.
- The user can further customize the solution model, adding or modifying features, entities, properties, relationships, methods, etc.
- The user creates projects in the solution model, which specifies what kind of Solution Output to produce. For each project, the user chooses a
Mo+ template which outlines how to create and update Solution Output.
- The Code Interpreter processes each project to evaluate the Mo+ model, and update Solution Output, based on instructions in the corresponding templates. The Code Interpreter creates and updates information such as source code files, project
files, database tables or procedures, test cases, configuration files, and other documents.
- Using the Solution Builder Interface, the user can also create, edit, and debug
Mo+ Specification Templates and Mo+ Code Templates to tailor model updates or solution output updates.
- The user saves the Mo+ model as a Mo+ Model Doc. This document is simply an XML file that stores only the information that the user creates directly (not information interpreted from specification sources).
What can Mo+
do for you? Following are some key benefits:
- Scale your work - Instead of doing a similar piece of work 100 times, do it once with Mo+ and let Mo+ manage those 100 pieces of work for you!
- Reuse your work - Make model oriented building blocks that represent conventions and other rules once with Mo+. Reuse those building blocks many times to generate all kinds of components in your system. You can often reuse these same building blocks
and higher level templates to build different systems with different models!
- Increase your ability to make changes - When more of your system can be managed in a model oriented way, you can easily change both the model and how the way model oriented components are built and let Mo+ update those components automatically. Then,
all you have to do is change your custom code. If you have model oriented tests managed by Mo+, testing those changes becomes that much easier.
- Codify your best practices - Codify your best practices as model oriented building blocks, making your overall code (even custom code) more readable and consistent.
- Let you focus on your ideas - With all of the above benefits that greatly help manage the mundane and repetitive tasks, you have much more time to focus on your ideas!
When would you use Mo+
? Following are some key uses (use cases):
- When building a system from scratch - Build a system from scratch, using Mo+ to scale your work as you develop or use templates, and as you build up your model.
- When improving a legacy system - Create a model or import one from an existing source such as a database. Rework components in a model oriented way as you need to make feature changes and other improvements. Start with model oriented tests first
for immediate benefit!
- When building multiple systems - Reuse the templates you created or used for one system, and build other systems with different models. Your best practices and technical approaches implemented in a model oriented way make creating new systems that
- When rapid prototyping - Use a Mo+ sample pack to generate working applications right away with your model! Rework your model as you iron out requirements, then change templates or make your own to support the code you really need.
- When migrating a system to new technologies and approaches - Embody your technical changes as model oriented templates, allowing you to make these changes much faster.
To learn more about Mo+
and the Mo+ Solution Builder
, there are a number of tutorials in the documentation section (https://moplus.codeplex.com/documentation
). The lower numbered
tutorials cover simpler topics, while higher numbered ones delve deeper into features and capabilities.
Also, if you download and install the Mo+ Solution Builder
, there is on board help that provides a detailed how to and reference.
Read additional articles that provide more detail on Model Oriented Development, how Mo+ is more powerful than other approaches, and why you may want to incorporate MOD (and specifically Mo+) into your work.
These articles are listed under Articles
in the documentation section (https://moplus.codeplex.com/documentation
Become a Member!
The Mo+ community website at https://modelorientedplus.com
is now available to provide additional support for you. Mo+ members have access to additional forum support, documentation, member contributed templates and
other tools, and contests with cash prizes. Members can also vote on and contribute to the overall direction of the Mo+ language and associated tools. Become a member today!
A $300 mini contest to submit a Mo+ template is currently underway.
We intend to build upon the Mo+
foundation with you, the community, in the driver's seat. We want you to determine what the best features in the language and user interface should be. We want you to determine what the ideal model structures
should look like, what the best sample template libraries in various platforms should be from a best practice standpoint.
The membership web site (http://modelorientedplus.com
) is set up to make the best use of your feedback and contributions going forward. This CodePlex site will remain the place to get the software source and downloads,
tutorials, and sample packs.
For additional support:
• Create or join a discussion in the Discussions area (https://moplus.codeplex.com/discussions
• Post an issue in the Issues area (https://moplus.codeplex.com/workitem/list/basic
• Post an issue at Stack Overflow (http://stackoverflow.com
) Use the
tag when posting issues.
• Become a member at https://ModelOrientedPlus.com
for additional support and benefits.
Copyright (C) 2014
Dave Clemmer, Model Oriented Plus (Intelligent Coding Solutions, LLC)
is a registered trademark of Intelligent Coding Solutions, LLC.