friends.praxeme

 

PxFAQ – Why are CRUD operations generaly located in Set Business Logical Machines?

Related questions:

  • Why separate Elementary and Set machines/operations?
  • Would it be interesting to add a CRUD Business Logical Machine next to the Elementary and Set ones?

It is clear that we are considering things in the Logical Aspect and that no justifications will come from Technical Aspect.

First shot

CRUD operations are not high level operations. They are instead mandatory to conduct higher level operations related to real world ones. We do not create objects for no reasons. The operation is triggered by an intention from the user. For example the creation of a Contact object in a PIM is the consequence of the intention to store the data and comments for a new person we have met in a certain context. Hence CRUD operations are not of a sufficient abstraction level to be considered business operations and this explains why they are usually not located in elementary machines.

Business operations on an object reflect the transformations the object can support according to the rules reflecting its behavior in the real world. But CRUD operations do not reflect a transformation, either because the object initially does not exist or finally does not exist anymore, or because reading does not change the object itself.

So, CRUD operations do not change the object itself but they do change the collection of objects. They have a transformation action on the set of all existing objects. This action may include changes in some
aggregated information like global amounts or statistical data or, simpler, the number of such objects, and even the state of the collection: “we have reached a threshold on the number of clients”. These data relate to the collection, not to individual objects. Hence CRUD are Set operations and pertain to the Set Business Logical Machine, and there is no need to increase the complexity by adding a new machine.

Fine tune

UPDATE is a special case : it is intended to change something in the object even if it is not a real transformation. By placing it in the Set machine we create a lot of connexions between the two machines because a lot of the UPDATE operation uses will come from the Elementary machine and its high level operations. So it seems appropriate to place the UPDATE operation in the Elementary machine.

Last, DELETE may be seen as the ultimate operation an object uses to commit suicide, or as a euthanasia request. The former vision places the DELETE operation in the Elementary machine, the later in the Set one. Placed in the Elementary machine, the DELETE operation MUST inform the Set machine of the change in the collection to trigger new calculations on the set.

Praxeme and Complex Systems

This is a follow-up to a conversation that started during the meeting of the “Collège des contributeurs” last week. Although I do not have the time to post a proper discussion, I’ll start with a few headlines to “get the ball rolling” : start a discussion. Hence I’ll use an “outine style” and leave the need to “fill in” each point for later occasions.

Four themes that came up:

(1) Praxeme is a model well-suited to recognize the enterprise as a system. It is actually very well spelled out in the short 10 pages paper that we were discussion (about “transformation”). The enterprise is a reflective system (a system = set of entities with dynamic interactions and a finality, reflective = that recognizes itself as a system).

(2) The enterprise is a complex system, hence the need for tools, methods and training. We all agreed that “system design” is not taught enough in the French educational system. “Systémique à la Lemoigne”, although very relevant (cf. my post in French), is not the best way to start learning about “System Thinking”.

(3) What is a complex system ?  Complexity arise when the finality of the system cannot be (simply = in an analytical way) deduced from the finality or behavior of the parts (cf. the concept of emergence). A complex system can be understood through simulation or experimentation, not through rational top-down analysis.
What makes a system complex ? Ususally we find one of the following (or more):

  • Human interaction within the system
  • Time scales and delays
  • Heterogeneity and number of stakeholders

“Dynamic Systems” science provides a lot of insight about these complexities (cf. the study of delays or feedback loops).

(4) Although a large ERP is more “complicated” than “complex”, the information system of a large company is complex. Because of the time scale (accumulation process and slow rate of change), because of the human factor (and all the wonderful “governance” issues)

So what ? what struck me during the meeting is that the “Enterprise Transformation 10 page paper” could be a vehicle to explain the concept of complexity to managers and propose methods such as Praxeme as a practical framework to address those issues. I have been an advocate for positining the CIO as the “complexity officer” for a while (cf. my last book or a recent post), but there is even more value to bring the message directly to the CEO.

Regards,

– Yves

PxFAQ: What is this strange thing called Logical Aspect?

Related questions:

  • Can we use upstream models directly in implementations?
  • What is the interest of the Logical Aspect if I want to build an SOA?
  • We put important efforts in upstream aspects, can we make some savings in the logical one?

The logical aspect is sometimes considered useless and we hear some people willing to save the time and budgets required to build the logical models. Obviously this is a great error. Because services are defined in the logical model by deriving upstream models, this model is fundamental as a basis for implementations, for multiple reasons:

  • It represents the structured description of the system. Upstream models (semantic, pragmatic and geographic) are formalized transcripts of what the enterprise is and needs. They don’t show the structures needed to represent the enterprise as a system. The logical model describes the architecture of the enterprise system in the same way as the design models (blueprints, plans, miniatures…) describe the architecture of a house.
  • It is an important component for decoupling. It’s role is to decouple the life cycles of the real enterprise and the virtual representation that lives in the Information System. Information system is made of people and technologies that evolve very fast and in a very non regular rhythm. On the other hand, the enterprise itself evolves slowly but in a more constant way. At times, when the business context changes quickly the enterprise is able to absorb the changes with limited efforts even when the information system, and especially the IT thing, is not agile enough to quickly follow the train (of course this is a very short summary of what happens in each enterprises). The resulting fact is that life cycles are very different. Hence it is very dangerous to link them and try to force the nature of things.  Query the business and the way it’s done when only a technology change is needed is a waste of time and money, and a big risk.
  • Logical model is the template used to build the information system. It includes strategic views as well as needs and goals, because they are derived from upstream models. Moreover some strategic decisions make their way up to the logical models. For example, the decision to build a cross enterprise SOA is not taken by the logical architects. It’s an enterprise wide decision and must be taken by all interested parties.
  • Logical model is a very important bunch of information to store and make available across the whole enterprise. It is very clear and precise as a description of what things should be and can be used in a number of ways after the main designs and built are over (explain how things work independently from technologies, compute impacts of business moves, authorize technological moves without changes in business, adapt quickly IS to strategic moves, etc…). Therefore it is an important part of the knowledge managed by Knowledge Management systems.

PxFAQ: What are the services we *need*?

Related questions:

  • How to find them?
  • How to assert that they are the right ones?
  • How to respect the decoupling principle?

By giving clear procedures to deduce services from business inputs, Praxeme solves the problem of finding the right services in the only available way: changing intuition only procedures to analytic thinking. By structuring precisely the considered system in separated yet linked aspects, Praxeme guaranties that the separation of concerns and the decoupling principles are respected. Moreover, the Enterprise System Topology (EST, the collection of the height aspects) guaranties that none of the important domains are forgotten and that the models are complete enough to prove that the system respects the primitive needs and goals expressed by the business and the regulations.

Services start their life in the Logical Aspect as an architectural decision. SOA in this matter must be considered as an architectural style. It is obviously independent from technologies because services can be implemented in a lot of them (POJO, J2EEE, .NET, php, Rubis/Rails, and even REST (if we admit to distort the initial REST concepts)…) and it is not very wise to have to change services when we want to change technologies that evolve a lot faster than the services themselves. In the logical aspect, services are built by deriving upstream aspects. This means that far from guessing the collection of services, Praxeme gives rules to deduce services from previous work, either inner services (the core stratum) or organizational ones (the organization stratum). Note that this does not imply that the process is completely automated. Logical model building still needs human decisions and innovations may also reside here.

BPM and SOA

We see more and more attention on relations between SOA and other parts of IT, with important questions like the one raised in the following blog post: http://www.jpmorgenthal.com/morgenthal/?p=103.

Relations between SOA and BPM is like relations between bass guitar and drums. They live separately and have their own rules, but they can produce great music together.

Praxeme establishes clearly the relations. Processes are part of the Pragmatic Aspect, describing complex relations between actors and the system. With the help of business objects and operations that are part of the Semantic Aspect, processes are then derived into the SOA architecture style which is an architectural choice operated via the Logical Aspect. This is summarized by the following diagram which is part of the Enterprise System Topology:

Upstream Aspects of the Enterprise System Topology

More informations on Praxeme and SOA:

http://www.praxeme.org/DocumentsEnAnglais/SLB15-SOAMessages_EN.pdf

DNA evidence

Often people ask me why I don’t like the use of DNA and other biological markers as identities. My answer can be expressed in two points:

  • Biometric data cannot be repudiated. If your biometrics are compromised you cannot change them like you can do when your personal certificate (or password) is compromised.
  • Biometric data are not secret. You expose them every time, when living your normal life. This is especially true for fingerprints and DNA samples.

Danger of point two is linked to the ability to fake biometrics and impersonate someone else. This was already possible for fingerprints and even eye pupil (retina scans can not yet be obtained without a special gear and the will of the victim) but seemed impossible for DNA samples. This no more true:

http://arstechnica.com/science/news/2009/08/dna-samples-used-by-crime-labs-faked-in-research-lab.ars

The problem does not come from the fundamental idea that DNA is uniquely identifying someone but from the process used to determine the DNA print inside a sample. And there is a solution, but it seems costly…

Security is a strategic concern

Here is an interesting point of view on security business today from an IBM Security Strategist: http://www.networkworld.com/news/2009/081709-8-dirty-secrets-of-the.html

Among the eight points some are tightly related to enterprise strategy and enterprise architecture. Points 2, 6 and 7 focus on external concerns, regulations and security product vendors, but  others may be summarized like this: what do I need as a company when speaking of Security? Moreover, how do I manage to know that? This kind of question is all about strategy and point 8 is a clear conclusion: “Technology without strategy is chaos, Corman said”.

But security strategy has no reasons to be designed apart from the enterprise strategy. Risk evaluation (point 5) and risk priorities (point 4) should be part of the enterprise strategy and risk mitigation (point 3) should be part of the enterprise architecture as a result of good practices, not as a resullt of late add-ons: security concerns should be included as a primary requirement of all designs, starting from the enterprise level studies.

Bruce Schneier on Risk Intuition

Here is a very good post of security guru Bruce Schneier on how we as individuals are good at evaluating risks: http://www.schneier.com/blog/archives/2009/08/risk_intuition.html. We often hear that people do not follow rules because they do not understand risks and Schneier shows us that the error is to forget that we do not live in a world where risks are clearly separated: we evaluate not only risks one teach us but also those that exist in true life and are linked to them. I especialy appreciate his conclusion:

So whenever you see someone in a situation who you think doesn’t understand the risks, stop first and make sure you understand the risks. You might be surprised.


Get out of the immaturity model (part 2)

[Part 1]

Here are some points to focus on to try to get out of the immaturity model. Some are obvious. Some may sound like weird ideas. But do not underestimate culture: obvious points may not be obvious for everyone and weird things may well be weird only for those who see them for the first time.

1 – Stop designing only by intuitions, start using analytical processes

Good intuition, or deus ex machina, may be an accelerator to make good designs. This is not untrue. But relying only on good intuitions is dangerous for more than one reason:

  • We cannot count on intuition. Sometime it comes, sometimes it does not. When intuition is not there, or if the intuition is badly oriented, the design is also a poor one, or even a complete failure.
  • Good intuition is dependent on people. If you have the right guy at the right place at the precise good moment, it may work like a charm. But how to do that apart from randomizing the design process? Some may say that selecting the best person for each task is an answer. Well, it’s right to some degree. But the selection process is very hard, the costs are high, and you can not be sure that this best guy will be there at the right moment, after all. There is a tradition to manage risks by people, and of course this is not the case in industries like nuclear plants or health care.
  • Good intuition is not repeatable. The same person, even if it’s the best guy described above, may have different intuitions at different moments. How to be sure that one idea is a correct one, not speaking of the best one?

Intuition must be used with opportunism inside an analytical design process. The process must include ways to evaluate the correctness of the intuition and its adequacy with the current task and expected result.

2 – Stop considering blueprints as useless artefacts, start designing with models

In IT, blueprints are models. Without models, design can not be fixed when problems are solved. Without models, solutions are searched, found and tuned each time the problem occurs. Models have two main purposes:

  • Establish clearly the results of the designing stages to avoid multiple thinkings about the same concern.
  • Act as a non ambiguous documentation for further references.

They need some work and we have the bad habit to save time by avoiding this work. It’s a bad trade off; we pay higher prices by not having them when we measure all the costs of chaotic realisations, duplicated works and maintenance or evolution difficulties.

3 – Stop changing bad pragmatism into a virtue, start using theories and deriving solutions from established concepts

Pragmatism is the process that considers a good practice as a theory. In our business, a practice that has worked in a context is considered as an always-working practice, in all other contexts. This is very dangerous because the context is all. The execution of something is very dependent on the context, the environment in which it is executed, therefore eliminating context may lead to unpredictable results.

Because this kind of pragmatism seems a shorter process (the generalization phase is eliminated) it is considered simpler and cheaper. This is false, obviously. Promoting directly a local practice to other situations leads to a lack of knowledge in how the thing works, which brings a deep lack of control on it. Every time this approach requires special hacks, to react to otherwise predictable failures: they increase the complexity of the result and the overall cost.

4 – Stop thinking only with technologies, start using technologies as implementations of higher levels designs

Technology is not an answer to real life problems. Using technology is (well, often). The difference is important: using a technology implies the “for what” and the “How”. Exhibiting a technology as an answer without the studies to support the claim is like faith. But we don’t need faith in IT, we need science because we have to predict things. We have to show guarantees to our users and demonstrate our products and ideas before using them for real.

5 – Stop mixing abstraction levels, start to enforce the separation of concerns principle

Different abstraction levels respond to different concerns and have different life cycles. Mixing concerns and forcing a cycle into another one create dependencies that increase the system’s complexity and reduce control on it.

A clear separation of concerns is the solution to quickly changing ideas and technologies. If one abstraction layer has to be modified the adjacent layers can be used to limit the scope of the changes. This, for example, prevents from trashing all the system because the technical platform has to be changed.

6 – Stop building on sand, start to build on robust foundations

The metaphor is obvious: building a house on sand creates a high risk for the house and its occupants. Building an IS system on poorly designed requirements creates a high risk for the system to quickly become unusable (sometimes as soon as the first deployment). Building an IT implementation on poorly chosen technologies and weak architecture creates a high risk for the system to collapse when the context changes. Strong foundations are made of good architectures at all levels including enterprise level. And good architectures are made with methodologies, not just intuitions. Each product must be the result of a derivation process determining the goals to achieve and the way the product is used must be precisely related to the goal it targets. This is the base for building robust foundations.

7 – Stop denying human nature, start to learn humility

That’s the first condition for being able to built the discipline and improve one’s craft.

Sharp expertise in narrow domains is important but not enough. Every practitioner must be able to see things they build from a higher point of view in order to understand how its part is integrated in the wider scope of he system. This is important to acquire autonomy and be able to react correctly to unpredictable issues and bring guarantees in the process. This higher level of understanding is mandatory to efficiently articulate the number of expertises required to achieve a complex result. Learn and understand other disciplines and be prepared to share expertises without fear to become less knowledgeable. This is how practitioners will become able to work in highly skilled teams required to build complex systems.

Get out of the immaturity model (part 1)

“IT is a young discipline” syndrome

For as long as I have worked in IT I have heard this dogmatic explanation. It is used for all sorts of issues ranging from hardware failures to heavily bugged software including huge and astonishingly complex IT solutions without strong relations with business problems. Each time, the maturity idea was part of the explanation with the sense of “Don’t blame us for this failure, you know IT is so young, we have still to find our way…”. Failures, bad practices, big fiascos, stupid errors, are considered normal in IT because they are accepted as a mandatory part of the learning curve. It is also admitted that, being a new discipline born in the twentieth century, IT can not benefit from knowledge elaborated in other older disciplines. This is very pretentious and dangerous and by doing so IT has been making the same errors again and again during the last 30 years.

Examples? Oh, so easy, boy!

  • Software licensing that guarantees nothing not even that the software will run, and preventing so much, including lending to relatives. Do you imagine not being able to lend your car to a friend or buying a fridge that may work, or not, without being able to call for refund, replacement or repair?
  • All parts of the system depend on all other parts. Well, not really, but you never know so you have to be prepared to the fact that a change in one part will create failures in other parts. Try to imagine the maintenance of an Airbus A380 built that way…
  • Where are blueprints ? In IT where we are trying to build more and more complex systems, we don’t have blueprints! Blueprints, or plans, are the representation of an architecture. Does that mean that we do not have architectures? Well, nearly. Think of it: it is now often considered a waste of time to even think about drawing blueprints. Well, you know, blue, this is not a good colour anyway…
  • Documentation for software is reduced to a description of menu entries paraphrasing the title: “Files/Open: let you open a file.” Wow! Astonishing, really! But if you need to know how such a file is formatted and built? Well, just dig in the file and the code that writes it. Do you imagine car builders opening the engine to find precisely what voltage or fuel type a car they have built uses?
  • Security gear is added on top of systems, not built inside. This suggests inevitably that security gear is optional which leads to a variety of failures we are accustomed to. Can you imagine a nuclear plant with security systems designed after the main design or even added after the plant’s build?
  • Worse: if someone, let’s call her an auditor, requests proofs that an IT system is respectful of rules from real life, we can not answer. Rules do not appear clearly in systems, they are diluted across all sorts of artefacts including expressions that are complete re-wording of the rule, and each artefact only contains part of it. Would you entrust a health care machine built that way?

This is no longer acceptable

IT technologies are said to change very fast either hardware and software. And it’s true. So do aeronautics or health care technologies. We cannot accept badly designed IT systems because they are more and more involved in physical technologies and risks using badly designed IT system increase in our day-to-day lives. The conclusion is obvious: get out of the immaturity model and act as grown-ups.

[Part 2]