oowiki

accumulated_requirements_for_the_fulloo.info_site

2014-01-14T22:25:59+00:00

* It needs a Wiki * Permalinks are important * It would be very attractive to pre-pay several years of guaranteed service * It should be code-friendly * It should support a dynamic FAQ (maybe through the Wiki) * ...

can_a_context_have_state

2014-01-26T21:05:17+00:00

It can. The Dijkstra example is a good example of such a supporting data structure. Nodes are one kind of object in the Dijkstra algorithm. There are some per-node data that are germane only to the algorithm but rarely to the domains of node-ness, or of any particular kind of node, in their own right. The data is factored out into the Context.

can_a_role_be_played_by_several_different_objects_in_a_given_context_instantiation

2014-03-11T13:35:58+00:00

No. All Roles are bound as an atomic operation before an Interaction starts. And the Role being an alias for a single object, means that there can only be one object per Role during an Interaction. Why is switching (rebinding during Interaction) a problem? It creates a conflict with the mental model. Objects in a certain context must be the same as they were at all points during an Interaction. If you write a Use Case for example, any object referred to in the beginning must be the same at the…

can_i_rebind_roles_to_objects_multiple_times_over_the_lifetime_of_a_context_object

2015-11-27T03:49:16+00:00

2014-12-05 13:57 GMT+01:00 James O Coplien : Jim Coplien asked Rune, on 5 December 2014: Can you please explain for us why you made such rebinding illegal? :-) I sense some unclarity about this. ;-) ---------- I gave an example in Oslo on why I think rebinding conflicts with my personal mental model of a context. If you, Trygve and I are discussing DCI we can take certain things for granted. We have a pretty good idea of where we differ in opinions and where we share menta…

can_i_use_dci_in_a_system_with_parallelism_or_asynchrony

2015-04-22T21:59:51+00:00

Most programming approaches (procedural, object-oriented, functional, applicative, logical) assume nothing about the threadedness of the environment. Most technologies in CS in fact require additional support for multi-threading. DCI provides no explicit facilities for either multithreading or parallelism. Neither does procedural programming or object-oriented programming. Parallel and multithreaded programs nonetheless exist in both procedural and object-oriented programming languages. There i…

can_i_use_dci_in_java

2016-02-24T13:01:11+00:00

At runtime (program execution), DCI is about attaching and detaching RoleMethods to objects, while preserving object identity. This makes it tricky to implement DCI in any statically typed language, however many of those languages have features to make it look like a type has other member methods than what's defined in its class or structure:

can_roles_be_unbound_in_a_context

2014-02-03T15:41:51+00:00

All Roles should be bound as an atomic operation before an Interaction starts, which leaves no place for unbound Roles. If you run into that problem, it could be a sign that the scope of the Context is too large, or other problems with the underlying mental model.

code_examples

2024-12-29T02:30:55+00:00

Beginners should start with the code examples on the main website at . Community Examples Simple Shopping Cart Written for the ScalaDCI library Author: Marc Grue

existing_dci_implementations

2026-02-18T12:20:05+00:00

See also: Code Examples for examples in some of these languages. Smalltalk Author: Trygve Reenskaug C++ See also the book Lean Architecture: for Agile Software Development Author: James O. Coplien

faq

2014-12-05T14:09:16+00:00

* What is DCI? * How does DCI relate to MVC? * What is the relationship between classes, objects, Roles, and Contexts? * What are the typical rules I need to pay attention to when writing DCI code? * Why isn't it DCI if you use a wrapper object to represent the Role? * Why can't I reuse a Role across multiple Contexts? * Can a Role be played by several different objects in a given Context instantiation? * Can I rebind roles to objects multiple times over the lifetime of a Context…

how_do_i_code_recursive_system_operations_in_dci

2014-12-05T14:04:47+00:00

There is nothing special about recursion in general in DCI, it can be done where it's deemed useful. It's important to remember however, that Roles cannot be rebound during a System operation and its following Interaction. If you do a recursion on a whole System operation though, it's common that you want to rebind Roles at the recursion point. There are a few ways of doing that:

how_does_dci_relate_to_mvc

2014-02-23T09:10:20+00:00

DCI is complementary to model–view–controller (MVC). MVC as a pattern language is still used to separate the data and its processing from presentation. Illustration from Lean Architecture (p. 238)

i_found_a_library_that_claims_to_do_dci_how_can_i_know_that_it_does

2014-04-07T08:21:38+00:00

Stay alert for a wrapper solution for the Roles. Unfortunately many libraries claiming to do DCI ignores that object identity must be preserved for Roles. Ask the library author about wrappers if you're unsure, and if the answer isn't fully clear about preserved object identity for Roles (which isn't the same as object equality), the library is probably not doing true DCI.

if_a_dci_context_should_map_to_a_user_mental_model_does_it_mean_that_dci_cannot_be_used_for_programming_at_a_lower_level_than_what_interacts_with_a_user

2014-03-11T14:08:36+00:00

DCI supports human mental models. These include end user mental models and programmer mental models. If you can think of an internal Use Case, for example in a banking system, transactions and audit logs, then DCI can handle it. That is one set of mental models, one Context. It is likely at a lower level than a bank account user.

is_there_a_glossary_for_the_dci_terminology

2014-01-19T18:40:17+00:00

Yes there is:

is_there_any_situation_where_dci_isn_t_appropriate_to_use

2014-04-07T08:19:56+00:00

Operations that are atomic and scoped to an object don't need DCI, for example simple CRUD functionality. DCI works best with system operations involving multiple objects. See for example how the Lean Architecture book distinguishes between Atomic Event Architectures and DCI architectures.

isn_t_dci_just_another_software_design_pattern

2014-03-11T13:58:29+00:00

As you may have guessed, no. :-) Organization " The difference between DCI and traditional object orientation is that the latter organizes concepts at the extremes either of a rather free-form network structure or of a single, punitive hierarchy of forms. The DCI paradigm strives to express a network model rather than a hierarchy, but provides disciplines for intentionality of form rather than leaving it to emergence."

it_seems_like_many_implementations_are_using_abstract_syntax_tree_rewriting_to_enable_dci._how_does_it_work

2014-01-22T11:13:26+00:00

AST rewriting can emulate the DCI execution model by rewriting the RoleMethods and the calls to them as private class methods in the Context class. Some pseudocode: Context OKCorrallShowdown { role Shape { void move(Point) { } void draw() { } }; role Cowboy { void move(Point) { } void draw() { } void shoot() { } }; // Constructor void new(Person x) { Cowbo…

should_the_actors_for_a_use_case_be_represented_as_roles_in_the_dci_context_for_that_use_case

2014-03-11T14:22:43+00:00

The short answer is “it depends”. First of all, it depends on whether the use case in question is a “user goal”-level use case (to use Alistair Cockburn's terminology) or an internal system use case (“subfunction” level) for which the actors are internal system objects rather than external actors like users (actual people) or external systems, as they are for “user goal” level use cases. The former type are the more well-known type, and typically consist of a sequence of steps that a user perfor…

start

2017-12-10T17:26:24+00:00

---------- Here you will find the more dynamic aspects of the fulloo.info web site: * FAQ (Frequently Asked Questions) * Upcoming Events * Existing DCI Implementations * Code Examples * Videos * Accumulated Requirements for the fulloo.info site * Back to fulloo.info

upcoming_events

2014-10-22T15:13:58+00:00

Post any information about DCI events on the mailing list so it can be added here. Mental Models / Play Workshop * What: Architecture is Child's Play * When: 12 March 2014 * Where: Bergen, Norway * More About:

videos

2017-12-10T17:38:50+00:00

A taste of trygve James Coplien Foo Café, 2017 A Glimpse of Trygve: From Class-oriented Programming to Real OO James Coplien ACCU, 2016 Symmetry in Design James Coplien Domain-Driven Design Europe, 2016

we-can-do-better-than-message-sequence-charts

2014-01-21T08:57:30+00:00

I know I'm in the minority but was never a big fan of MSCs, ping-pong diagrams or other things in that family. To me, they convey far too little information to be support enabling specifications. In good requirements engineering it's all about detail, detail, detail — and in the end that can be conveyed only verbally, with instant feedback. Time put into pretty pictures tends to infuse delay and inertia into the process, because people are disinclined to change pretty pictures. A good requiremen…

what_are_the_typical_rules_i_need_to_pay_attention_to_when_writing_dci_code

2014-01-15T16:43:33+00:00

These are the kinds of things that Marc Grue is looking at. * Role constructs may not be nested inside of another role. * Should all Context classes be at the same scope? * A Role method may invoke only other Role methods, and the Role of the invoked method must be in the same Context as the invoking role method

what_is_dci

2015-04-05T13:47:04+00:00

Object-oriented programming was supposed to unify the perspectives of the programmer and the end user in computer code: a boon both to usability and program comprehension. While objects capture structure well, they fail to capture system behavior. DCI (Data-Context-Interaction) is a programming paradigm through which the end user mental model is more fully reflected in readable code. The vision of DCI is to become a unifying foundation for programming in both introductory and advanced programmin…

what_is_the_advantage_of_distributing_the_interaction_algorithm_in_the_rolemethods_as_suggested_by_dci_instead_of_centralizing_it_in_a_context_method

2014-10-21T23:36:05+00:00

It is really a design decision. It is always possible to centralize the interaction code by rewriting the RoleMethods to become instance methods in the Context. The Roles are instance variables in the Context. The method names may have to be changed to avoid name clashes, and any occurrence of 'self' in the code must be replaced by the corresponding role name.

what_is_the_best_dci_language

2014-01-25T09:53:15+00:00

Your favorite language, of course! :-) Naturally it should have some notion of objects, since DCI is about networks of collaborating objects. Furthermore, these objects will have functionality (methods) attached to them at runtime, so the language must support some way of extending types, while not breaking object identity at the same time. Some examples of how this is done with statically typed languages like C# and C++ can be found here: Can I use DCI in Java.

what_is_the_relationship_between_classes_objects_roles_and_contexts

2014-11-09T04:48:24+00:00

In contemporary object-oriented programming languages, classes are the fundamental building block for objects. This “class-oriented” approach has long been promoted as object-orientation, but is highlighted by DCI as a too limited view on objects. Objects span over more than a single class, which has been acknowledged in mainstream languages by the rise of features like extension methods, traits and mixins.

what_should_i_do_if_different_users_have_different_mental_models

2014-02-10T05:21:38+00:00

This question arises out of a confusion about the DCI design process. The mental model on which a DCI program is based is not merely discovered, but is also formed and refined during the design process, based on input from all the stakeholders, as well as the programmers. The following quote from Trygve describes this principle, which is rooted in the Lean Architecture philosophy:

when_using_dci_with_mvc_is_it_ok_to_let_views_and_controllers_play_roles_in_a_context

2014-01-19T23:04:29+00:00

A View is an object, so a View can play a Role. RoleMethods could actually update the View, this is more direct than using the observer pattern, for example. Since Controllers are objects too, naturally they can play a Role as well. This could be useful if the Controller has some state that will change its behavior, for example Controller.ModelState in ASP.NET MVC.

why_can_t_i_reuse_a_role_across_multiple_contexts

2014-03-11T12:59:53+00:00

---------- Why can't I reuse a role across multiple contexts? This has been discussed many times on the Email list; a review of the treatment of the topic there might also be informative. A Role is a name with associated responsibilities. That name makes sense only in a Context. A Shape can move and draw in a graphical context; a Cowboy can move, draw and shoot in a Western movie context. Having a role — named however you like — that can draw and shoot does not make it a candidate for reuse i…

why_isn_t_it_dci_if_you_use_a_wrapper_object_to_represent_the_role

2014-01-26T21:10:41+00:00

Explaining it kind of spoils the fun... There are several ways to explain this. Let me try this way. I'm winging it, and this won't pass for a published paper. And it's a difficult topic, and even more difficult to explain it to someone who doesn't already know it. I'll do my best.

why_must_roles_be_stateless

2014-01-26T21:11:54+00:00

i.e. why are they allowed to contain only methods, and not their own data properties? We all know that RoleMethods can invoke (data) methods of self. If RoleMethods don't invoke data class methods then they can stand alone: there is no need to inject them into any object. (Remember that we decided to call this the “data class” rather than the “domain class.”) Turned around, the object must supply the implementation of the data methods expected by the Role. So there is a method symbiosis between…