You can use this reading list to plan a practical path from UML modeling in MDriven Designer to ViewModels, Turnkey, integration, and deployment.

How to use this list

Work through the sections in order. For each topic, build a small model while you study it; for example, use a Customer, Order, and OrderLine model rather than studying concepts in isolation.

Mark a topic complete only when you can explain it and apply it in a model, a ViewModel, or a running application.

Stage	Goal	Practical outcome
1. Model fundamentals	Describe the domain correctly.	Model a customer with attributes and orders.
2. Expressions and behavior	Calculate, validate, and control behavior.	Calculate an order total and prevent an invalid change.
3. User interface	Create a ViewModel that users can work with.	Open a customer view, show its orders, and provide an action.
4. Data and operations	Search, report, secure, and operate the application.	Find customers, control access, and understand server operation.
5. Development lifecycle	Change and deliver the solution safely.	Evolve a model and choose an appropriate development approach.

1. Model fundamentals

Start here before creating views or writing expressions.

Classes, instances, and attributes

• Learn the difference between a class (the definition) and an instance (one object created from that definition).
• Create a class with an attribute.
• Create an instance of the class in the debugger.
• Identify the available attribute types.
• Learn what a blob is and when an attribute can hold an image.
• Learn nullable values, null, and default string representation.
• Learn tagged values and code comments.

Example: Customer is a class; one customer named Alex is an instance. Name is an attribute. Decide whether Name may be null before using it in expressions or views.

Persistence and object lifetime

• Learn the difference between persistent and transient objects.
• Create an object, save it, restart, and verify the expected result.
• Learn how to delete an object and what deletion means for its relations.
• Study delete constraints and delete warnings. Confirm the behavior you need in the target runtime, including any limitations relevant to Turnkey.
• Learn aggregation and how it affects lifetime.

Example: if an OrderLine belongs to an Order, decide whether deleting the order must also remove its lines. This is a lifetime decision, not only a screen-design decision.

Relations and cardinality

• Learn what a relation represents and what happens when you assign or reassign a relation end.
• Learn cardinality.
• Model one-to-many, many-to-many, and self-relations.
• Learn when a many-to-many relation needs an association class.
• Learn derived associations and the meaning of isNavigable.
• Learn delayed fetch.

Example: a customer can have many orders, while each order has one customer. If an order is reassigned to another customer, understand which relation ends change and which objects remain.

Inheritance, packages, and diagrams

• Learn inheritance.
• Learn what a package is and how to use diagrams to organize a model.
• Learn what can appear on a diagram, including comments and references to other diagrams.
• Learn how to find elements in the model.
• Run model validation and investigate the types of errors it detects.

Example: place Customer, Order, and their relation on one diagram. Put unrelated administration concepts in another package so the diagram remains readable.

2. Expressions, calculations, and state

Learn how the model derives information and prevents invalid behavior.

OCL and collections

OCL is the expression language used to navigate and calculate from model objects. Study default string representation together with OCL so that you can recognize what an expression returns.

Work through these operations:

• allInstances
• select
• collect
• groupBy
• orderBy
• intersection
• difference
• union

Example: start with all orders, select the orders for one customer, collect their amounts, and order the resulting orders by a chosen attribute. Check whether each expression produces one object, a value, or a collection.

Derived and database-backed values

• Learn derived attributes and derived associations.
• Learn DefaultDBValue.
• Learn when delayed fetch affects how a relation is obtained.

Example: an order total can be derived from its order lines instead of being manually entered. Define what should happen when a line is added, removed, or changed.

State machines, triggers, guards, and methods

• Learn state machines and triggers.
• Learn guards: conditions that determine whether a transition may occur.
• Learn methods and how they differ from actions.
• Learn Action Language and side effects.

Example: an order may move from a draft state to another state only when its guard condition is satisfied. Keep the guard focused on whether the transition is permitted; put the required changes in the appropriate behavior.

Validation and constraints

• Learn validation in the model and in views.
• Learn constraints on classes.
• Learn opt-out constraints and actions.
• Learn how cross-reference usage helps you understand dependencies before changing an element.

Example: require an order to have a customer before it can proceed. Then identify where that rule is evaluated and whether an action may opt out of it.

3. Views, ViewModels, and actions

A ViewModel defines the information and behavior presented to the user. Study it after you can model the domain and express the required rules.

Views and navigation

• Learn the difference between a view and the domain model.
• Learn what an action is and how an action opens a view.
• Learn rooted and unrooted views.
• Learn modal views versus regular views.
• Learn how to initialize a view and obtain a result from a modal view.
• Learn global, class, and ViewModel actions.
• Learn vCurrent and other ViewModel variables.

Example: open a rooted customer view for one selected customer. From that view, open a modal view to collect a choice, then use the returned result in the calling view.

Designing the user interface

• Learn what a view can contain, including grids and comboboxes.
• Learn master-detail layouts.
• Learn read-only and visible expressions.
• Learn UI overrides, styles, and style expressions.
• Learn autoforms.
• Learn UI-first modeling and other ways to build ViewModels.
• Learn how ViewModels do more than display data, including DeepClone, transform, and DuckType concepts.

Example: show customers in a grid and the selected customer's orders in a detail area. Use a visible expression to show an order-specific section only when it applies, and a read-only expression to prevent editing when the current state does not allow it.

Finding and presenting large result sets

• Learn seekers, OCLps, and vSeekerResult.
• Learn how to combine multiple criteria and how alternative search conditions affect a search.
• Learn the difference between searching, filtering, and ordering.
• Read Documentation:Tables, search and ordering before designing tables that can contain many rows.

Example: let a user search customers by more than one criterion. When only part of a large result is loaded, treat ordering as part of the server-side search rather than sorting only the rows already shown.

Reports and execution behavior

• Learn report output for Word, Excel, PowerPoint, HTML, and XML.
• Learn the meaning of server-side, asynchronous, and serialized execution.

Example: before adding a report action, define its output format and whether the user must wait for the result or can continue working while it runs.

4. Security, integration, and operations

Study these topics when the core model and views are working.

Users and authorization

• Learn the difference between login, authentication, and authorization.
• Learn AccessGroups and how they control access to actions and information.
• Follow HowTos:Access Logged In User and Use AccessGroups for the focused guidance on accessing the logged-in user and using AccessGroups.

Example: authentication establishes who the user is; authorization determines whether that user may perform an action. Model and test both decisions separately.

REST and client behavior

• Learn how to expose REST services and consume REST services.
• Learn the difference between MVC and Angular in the context of the client approach you are using.
• Learn how /debug exposes diagnostic information, and use it only in an appropriate diagnostic context.

Example: define whether an external system needs to call your service or whether your application needs to call the external system. These are separate integration directions with different responsibilities.

MDriven Server and Turnkey

• Learn the role of MDrivenServer, client synchronization, slave servers, and history servers.
• Use HowTos:Configure and Maintain MDriven Server for installation, maintenance, and operational guidance.
• Learn debugging with the debugger and the role of OCLSingleton.
• For Turnkey-specific UI work, see HowTos:Apply Bootstrap Theme to MDriven Turnkey and HowTos:Swipe Actions.

Example: when diagnosing a behavior difference, identify whether it belongs to the model, the ViewModel, the client, or MDrivenServer before changing the design.

5. Development lifecycle and delivery

Finish the reading path by learning how the model is maintained over time.

Model changes and database evolution

• Learn the difference between the database and the model.
• Learn what happens when you change the model and evolve the database.
• Learn former names.
• Study a safe attribute type-change sequence: introduce a new attribute in parallel, move the data, verify it, and remove the old attribute only when it is no longer needed.
• Learn persistence mapping, including child and parent considerations.
• Learn reverse engineering.

Example: do not treat an attribute type change as only a rename. Keep both attributes while data is moved, validate the result, and then plan removal of the old attribute.

Development approaches and version control

• Learn the MDriven Framework workflow in Visual Studio: model to code and run toward MDrivenServer.
• Learn versioned development and CodeDress.
• Compare building the whole application in Visual Studio with using CodeDress together with Turnkey.
• Learn the model file format choices: one ZIP file or several smaller files.
• Consider how the selected format affects diffs in Git and SVN.

Example: choose a model file arrangement that lets your team review meaningful changes in its version-control system.

Suggested study sequence

1. Complete class, attribute, instance, persistence, and relation exercises in a small model.
2. Add inheritance, packages, diagrams, validation, and deletion behavior.
3. Add OCL calculations, derived values, state behavior, and constraints.
4. Create a ViewModel with a grid, detail area, actions, and visible or read-only expressions.
5. Add a seeker and review Documentation:Tables, search and ordering before testing with a large result set.
6. Add authorization, reports, and any required REST integration.
7. Learn MDrivenServer operations and plan model evolution and version control before deployment.

See also

• HowTos:HowTo
• HowTos:Taking It Further Still
• Documentation:Tables, search and ordering
• HowTos:Configure and Maintain MDriven Server
• HowTos:Access Logged In User and Use AccessGroups