2015-12-31

Platform concept

platform, noun pre-existing piece of software to provide comprehensive functionality to other software pieces (i.e. applications) during some phases of their lifecycle

Note: Good platforms make simple things simple and complex things possible.
Note: "Piece" is a unit of deployment.
Note: All platforms are digital.
Note: Types of platforms mentioned below may be mixed in a particular software product.

Functional platforms (configurable monoliths)

Origin: corporate functions automation
Typical characteristics: generic solutions have to be configured for needs of a particular business
Typical provisioning: SaaS or PaaS or on-premises or hybrid
Typical creator: FOSS or COTS
Examples: ERP, CRM, ECM
Note: Also called "Vendor platforms"

Intermediation platforms

Origin: portalsTypical characteristics: middleman between service consumers and service providers
Typical provisioning: IaaS or on-premises
Typical creator: home-made
Examples: Uber, Airbnb, Facebook, Alibaba, Paypal
Note: The owner of an intermediation platform helps to match demand and supply without any ownership over supplied resources (Uber does not owe cars, Airbnb does not owe hotels, Facebook does not generate any content, Alibaba does not produce consumer goods).
Note: Also called "Digital platform" or marketplace.

Business execution platforms

Origin: corporate functions automation
Typical characteristics: a coherent set of functionality sufficient to run business in a particular business domain as a set of solutions which are assembled from microservices.
Typical provisioning: hybrid or on-premises
Typical creator: FOSS or COTS
Examples: Ыalesforce
Note: Business execution platforms may be collected from previously mentioned platforms.

Potential industry-sector synergy

Any corporate within the same industry-sector do, in principal, the same things but in slightly different way. If a corporate unified business execution platform enables synergy between diversity and uniformity then the same platform may serve the whole industry-sector (public services, healthcare, smart-city, etc.).

2015-12-15

This pattern summarises the essential capabilities to be delivered by enterprise architecture as a practice:

Architecture Design (AD)

Architecture Governance (AG)

Innovatives and Optimisation (IO)

Architecture Design or Delivery (AD) – do right things

Architecture Design defines (at the scale of an enterprise) how solutions to be designed, delivered, operated, monitored, evolved and decommissioned (covering of their full life-cycle). EA has to deliver an overall solution for the whole enterprise. It is possible only as a set of smaller ("normal") solutions. Thus EA must control/influence them.

P.S.

In ballet, adagio refers to slow movement, typically performed by a group of dancers with the greatest amount of grace and fluidity than other movements of dance.

Adagio in music (from Wikipedia):

True and heartfelt transfer Adagio is the touchstone of the art performance of each musician and singer. However, the Adagio is a clear indicator of the degree of true talent, a sign of the composer's talent, because the adagio (which are total internal consistency and richness of musical thought) exposes the talent and skill of the composer.

In acrobatics adagio is the performance of partner acrobalance poses and associated movements that involve stationary balances.

may use (via IoT) some sensors (physical world to digital world adapters) and “materialisers” / "actuators" (digital world to physical world adapters) - of course if they understand this process and agree to act particular roles

A real-life example – a stadium during a football match is full of fans. Each of them has his/her own needs and behaviour. Perfect peak performance case which can be economically reasonable only via on-demand provisioning of processes and microservices.

2015-11-27

The illustration below is an example of dependencies between stakeholders, their interest/concerns and models. This example was used in a discussion about smart-cities.

As with the complexities between the components within the smart city system-of-systems, so are the interrelations between stakeholders of a city intricate and highly complex. Mapping out the dependencies between stakeholders allows one to better understand the impact and effects of decisions and changes from one stakeholder to another.

2015-10-31

1Introduction

One of the fundamental tendencies in the modern IT and sister domains is the intersection of many, previously, independent methodologies and disciplines. If somebody wants to address holistically (i.e. enterprise-wide) the operations excellence then it is mandatory to deal with business architecture, operation models, BPM, SixSigma, Lean, EPM, ERM, CoBIT, ITSM, SOA, agile, and many others.

Historically, all these methodologies and disciplines were developed in isolation and, some of them are presented differently by various schools and “bodies of knowledge”. Thus, any transversal communication is hampered by the absence of common agreements for the many of used concepts.

In accordance with ISO 1087-1, concept is unit of knowledge created by a unique combination of characteristics. Concepts are mental representations or entities that exist in the brain. Concepts are not necessarily bound to particular languages. Concepts are, however, influenced by the social or technical background which often leads to different categorizations. Concepts in order to be communicated, stored, etc. indeed require a linguistic form.

To understand how concepts related to each other it is necessary to use descriptive (linguistic) statements which serve to differentiate concepts. Ideally, IT and sister domains need a single concept system which is a set of concepts structured according to the relations among them. Then various designations (graphical and verbal) can be defined to represent concepts.

Following international terminological standards, the “intensional definition” approach is used below. It describes the intension of a concept (set of characteristics which makes up the concept) by stating the superordinate or broader concept and the delimiting (indispensable for distinguishing) characteristics. (See the last chapter for some basics of the terminological science).

The following is an example of an intensional definition for the concept 'incandescent lamp': incandescent lamp is electric lamp in which a filament is heated by an electric current in such a way that it emits light.

The following relationships are used for constructing concept systems (see ISO 1087):

generic relation or genus-species relation

partitive relation or part-whole relation

associative relation or pragmatic relation

sequential relation

casual relation

2 Additional type of relation

In IT and sister domains, there are many complex concepts. Because of the complexity, different people consider the same concept from different perspectives and for different concerns. Without providing an explicit context (perspectives and concerns), it is not possible to understand adequately different people.

This is a similar situation when the architecture of a system is discussed because different people see this system differently. To avoid potential confusions, the architecture description is built on viewpoints or ways of looking at systems ("a viewpoint frames a concern" – see http://www.iso-architecture.org/ieee-1471/ads/ ). Also, viewpoints are designed for the purpose of communicating and focusing on certain aspects of an architecture.

The aim of this article is to demonstrate that some competing definitions for the same concept are just different viewpoints. Usually, one of those viewpoints is the “meta” (the most comprehensive) one and all the other viewpoints are “periphery” (or simplified versions) ones. Using this additional type of relation between concepts (called ‘projection’) will help to build a commonly agreed concept system for the IT and sister domains.

Below there are several examples of using ‘projection’ relation.

3 Concept ‘system’

3.1 Meta viewpoint

A system is a set of interacting or interdependent components (parts or elements) forming a complex/intricate functional whole. [ adopted from https://en.wikipedia.org/wiki/System ]

This viewpoint emphasis “working together” of parts which makes "The whole is more than the sum of its parts".

3.2 Nomenclature viewpoint

This viewpoint considers primarily individual elements (components or parts) – like seeing the trees not the forest. This viewpoint mentions the structural perspective, i.e. “A system has structure, it contains parts (or components) that are directly or indirectly related to each other”. Moreover, to some extent, this viewpoint ignores the fact that “a system has behaviour and it exhibits processes that fulfil its function or purpose”.

3.3 Artefact-centric viewpoints

Considering that, parts of systems are different artefacts (or types) such as processes, services, etc. then a particular viewpoint may concentrate only on a particular artefact. Examples of these viewpoints are:

The system-in-scope is a system of business entities (or data structures)...

4 Concept ‘capability’

4.1 Meta viewpoint

Capability is a measure of the ability of a component (or a system) to achieve a particular result.

This viewpoint emphasis the performance (planned, demonstrated and potential) of a component to perform its function (or ability to do something). Compare: 1) Can you play football? Yes, of course! 2) Can you play football at the level of Champions League? Of course not!

Obviously, the top management of an enterprise perfectly knows what their enterprise can do and their main concern is how well their enterprise doing that. Another concern is the following question which was asked by the President of a development bank: “The bank is doubling its funds, shall we double our IT department as well?”

4.2 Functional viewpoint

This viewpoint is not aware about the performance aspect of capability (maybe because it is usually not shared publicly).

4.3 Other viewpoints

availability of resources to achieve a particular result

availability of skills to achieve a particular result

5 Concept ‘business process’

5.1 Meta viewpoint

Business process is an explicitly defined coordination for guiding the purposeful enactment of business activity flows.

In other words, a business process is an agreed plan which may include some variants and may be adapted during its execution.

This viewpoint emphasis an intentional, systematic and shared design of future work which is the primary concern of any business process owner. Thus any business process owner must be capable to logically explain WHY his/her business processes as they are. (An explanation "we always do like that" is not acceptable.)

5.2 Observer viewpoint

Business process is a collection of related, structured activities (or tasks) that produce a specific service or product (serve a particular goal) for a particular customer or customers. [ see https://en.wikipedia.org/wiki/Business_process ]

This viewpoint is typical for an external observer for whom the design of future work and "WHY of processes" are not fully known.

6 Concept ‘architecture’

6.1 Meta viewpoint

Architecture is a fundamental orderliness (embodied in its components, their relationships to each other and the environment), and the principles governing the design, implementation and evolution, of a system. [ adapted from ISO/IEC/IEEE 42010 ]

Instance – the architecture of a specific enterprise or some specific part of an enterprise.

Representation – the representation or description of an instance of an enterprise architecture.

Discipline – the set of skills and knowledge required for the competent practice of enterprise architecture.

Practice – the use of these skills and knowledge in the actual performance of the activities of enterprise architecture.

Representing – the act of representing an instance of an enterprise architecture.

Profession – a collegial ecosystem that maintains and enforces a set of constraints (usually implying mastery of a specific set of skills and knowledge to some minimal level of competence, and conformance to certain standards of behaviour) on the practice of the discipline.

Enterprise architecture (EA) is a well-defined practice for conducting enterprise analysis, design, planning, and implementation, using a holistic approach at all times, for the successful development and execution of strategy. (See https://en.wikipedia.org/wiki/Enterprise_architecture )

essential characteristiccharacteristic which is indispensable to understanding a concept

delimiting characteristicessential characteristic used for distinguishing a concept from related concepts

NOTE The delimiting characteristic support for the back may be used for distinguishing the concepts

intension
set of characteristics which makes up the concept

extension
totality of objects to which a concept corresponds

concept system
system of concepts
set of concepts structured according to the relations among them

definition
representation of a concept by a descriptive statement which serves to differentiate it from related concepts

intensional definitiondefinition which describes the intension of a concept by stating the superordinate concept and the delimiting characteristicsdesignation
representation of a concept (3.2.1) by a sign which denotes it

NOTE In terminology work three types of designations are distinguished: symbols, appellations and terms.term
verbal designation of a general concept in a specific subject field

NOTE A term may contain symbols and can have variants, e.g. different forms of spelling.

Corollary 2 All the enterprise-wide functions must be aligned to optimised the use of BPM.

Corollary 3, ICT, as the most common enterprise-wide function, must have all its functionality “in tune” to optimise the delivery of process-centric solutions. Namely: Governance, Security, Software development practices, Operations, Monitoring, Support, Maintenance & Small enhancement, User Experience, Data Architecture, Use of the selected BPM-suite tool, Overall continual improvement.

Corollary 4 An enterprise needs a small group of agreed minds to architect and guide others to execute this digital transformation.

17th law of BPM

Thou shalt consider business process model as a description of WHY this process is as it is depicted in its diagrams.

2015-06-02

All business processes within an enterprise form a complex structure. Everyone heard about hierarchical (pyramidal) structures of business processes with an enterprise.

In one extreme, it is recommended to model all business processes within an enterprise and then start to improve them (which a good deal for consultants but didn’t help to the majority of enterprises). In other extreme, it is recommended to implement many small process-automation projects.

In particular I like very much Rotem’s definition of the four principles of Change Driven Design:

1. Areas of change should be contained.

2. Things that are more likely to change should be easier to change.

3. Things that are less likely to change should not depend on things that are likely to change.

4. Change should entail extending the system rather than refactoring.

END quote

RE item 2: Many types of changes must be anticipated in the architecture and thus they are easy to do. Other changes must be possible. For example, [REF1] states that business-process-centric solutions have several types of artefacts: event, business-process, rule, role, activity, data, document, audit trail, and KPI. Their changes are anticipated and these artefacts are structured as shown below.

All artefacts are available as microservices – see below (only 4 lower layers are shown).

Techniques for composition of microservices: DSL (BPMN, DMN), interpretive general languages (Groovy), compiled generic languages (Java). Off-The-Shelf (OTS) microservices can be used as necessary, e.g. business process engine for BPMN.

RE item 4: Technical changes should be fused with business changes in accordance with the PDCA cycle.

[Plan] measure how the work is done,

[Plan] observe the business environment,

[Plan] decide in what areas the solution should advance,

[Do] implement the decisions taken,

[Check] validate the effect of those decisions, and

[Act] refactor some microservices to adopt internally the improvements.

2 Terminology

2.1 Process

Many articles about microservices mentioned “process”. I believe they mean “computing process” (e.g. an instance of JVM) which should not be confused with “business process”.

2.2 Orchestration

Another confusing term is “orchestration”. In some articles, it means “container orchestration layer” which allows one to specify how the microservices are handled in fault tolerant and in scaling up and scaling down.

O’Reilly book “Migrating to Cloud-Native Application Architectures” (http://pivotal.io/platform-as-a-service/migrating-to-cloud-native-application-architectures-ebook ) says “The ESB becomes the owner of all routing, transformation, policy, security, and other decisions governing the interaction between services. We call this orchestration, analogous to the conductor who determines the course of the music performed by an orchestra during its performance. ESBs and orchestration make for very simple and pleasing architecture diagrams, but their simplicity is deceiving. Often hiding within the ESB is a tangled web of complexity.” I think, this is a wrong analogy. The conductor delivers only one symphony at a time. ESB delivers many symphonies at the same time. Not surprising that it such “centralised orchestration” is difficult.

In other articles, it means one of two BPMN ways to compose business processes – orchestration as a strong coordination and choreography as weak coordination. This orchestration is a domain bounded because it is carried out in the scope of a particular business process.

2.3 Microservice or Autonomous Component (AC)

Microservice is a unit of functionality which is

explicitly-defined for a potential consumer how to use it (yes, there is a formal contract)

universally-accessible for its consumers via standard protocols (not just REST)

In addition, microservices are:

design-interdependent (design-time dependency in accordance with the overall design of a software-intensive solution)

operationally-independent (i.e. unavailability of a particular microservice may be compensated without total unavailability of the whole solution)

contractually-dependent (run-time dependency in accordance with the formal contract)

“Unit-of-functionality” means Single Responsibility Principle (SRP). Thus a microservice with a greater and single responsibility may be composed from microservices with lesser and single responsibilities.

Obviously, microservices is that old-known services should be.

2.4 Microservice architecture

Microservice architecture (as well as SOA) is an architectural style for constructing software-intensive solutions from a set of universally interconnected and interdependent services/microservice.

The artificial separation “SOA is for integration between applications” and “microservice architecture is for applications” has no sense anymore because the integration between two “microserviced” applications is the same as integration between microservices within each of “microserviced” application.

3 Review of some posts

Several articles about (mainly negative) about applicability of microservices.

A very good article showing that the current “microservice architecture” is a bit weak to be considered as a real architecture (thus provide a solid based for industrial delivery of software-intensive solutions).

Of course, it is very difficult to maintain an application with a rather weak architecture. Just a few points.

Structure is necessary instead of a flat microservice-to-microservice topology. It helps to testing, integrity and reducing the level of complexity.

Strongly and statically typed language is preferable for interfaces, i.e. between microservices. Weak and dynamic type language is OK within microservices.

Monitoring and testing may merge: testing becomes on-going, and monitoring becomes more functional.

Real architecture must enable quick deployments of new versions of solutions.

RE “So my primary guideline would be don't even consider microservices unless you have a system that's too complex to manage as a monolith. The majority of software systems should be built as a single monolithic application. Do pay attention to good modularity within that monolith, but don't try to separate it into separate services.”

This is yet another confirmation that the current “microservice architecture” is a bit weak to be considered as a real architecture. There are two viewpoints: a) external service provider viewpoint who is engaged for a well-defined scope and b) enterprise-wide viewpoint for considering software-intensive systems within an enterprise TOGETHER. The different between them is like seeing the trees or the forest.

Obviously, some initial efforts are necessary to establish microservice-centric environment and practices. These efforts will pay-off after several applications.

In addition, each subsequent solution is cheaper because it reuses the same tools, the same services, the same architecture.

O’Reilly book “Migrating to Cloud-Native Application Architectures” http://pivotal.io/platform-as-a-service/migrating-to-cloud-native-application-architectures-ebook says “The ESB becomes the owner of all routing, transformation, policy, security, and other decisions governing the interaction between services. We call this orchestration, analogous to the conductor who determines the course of the music performed by an orchestra during its performance. ESBs and orchestration make for very simple and pleasing architecture diagrams, but their simplicity is deceiving. Often hiding within the ESB is a tangled web of complexity.” I think, this is a wrong analogy. The conductor delivers only one symphony at a time. ESB delivers many symphonies at the same time. Not surprising that it such “centralised orchestration” is difficult.

In other articles, it means one of two BPMN ways to compose business processes – orchestration as a strong coordination and choreography as weak coordination. This orchestration is a domain bounded because it is carried out in the scope of a particular business process.

Microservices communicate with each other through language and platform-agnostic application programming interfaces (APIs). These APIs are typically exposed as Rest endpoints or can be invoked via lightweight messaging protocols such as RabbitMQ. They are loosely coupled with each other avoiding synchronous and blocking-calls whenever possible.”

The first of these two paragraphs says that each microservice is “independent” from other microservices and the second paragraph says “microservices communicate with each other” thus there is some dependency.

Certainly, microservices are interdependent by design and operationally-independent. It seems that microservices may refer to each other indirectly via a “naming service” (some kind of URI to URL mapper or like in CORBA). Therefore, a microservice may employ other microservices to complete its work. In extreme, a microservice may be an assembly of microservices. Article http://microxchg.io/2015/slides/02_01_DomainServiceAggregators.pdf provides an example of data aggregation with a business domain.

Yes, size in LOC does not matter. There is only one limit – SRP. Interesting, that no limitations on “size” of this single responsibility. Thus a microservice with a greater and single responsibility may be assembled from microservices with lesser and single responsibilities.

From https://genehughson.wordpress.com/2015/02/06/wait-did-i-just-say-knuth-was-wrong/ “In the comments, it was suggested that granularity was irrelevant as multiple granular microservices could be composed to form a coarser-grained microservice that would provide a more appropriate level of abstraction. My response was that while this is theoretically true, aggregating service calls in that manner risks issues due to network latency.”

In addition for my comments to that blogpost, I would like to add that designing microservices as distributed autonomous components (each with own computing process) is forcing to consider (up-front and not as refactoring) a proper error-recovery which is much more difficult than the error-handling when components are in the same computing process.

From https://www.voxxed.com/blog/2015/01/good-microservices-architectures-death-enterprise-service-bus-part-one/ “Microservices and their granularity are ideal for the development and maintenance of the service. But that does push complexity more towards the app itself. A complexity that those apps cannot manage as they are often executed on platform with constrained resources (battery, network, CPU). Combining services in a higher level logic to serve the purpose of apps or business processes proves to be faster to develop and easier to maintain.”

If application as a unit of deployment (even decomposed into a few tiers) is no more the physical boundary then boundaries becomes logical and they are coming from the business – business functions, business services and business capabilities. Note they are actually just different viewpoints – see “Common understanding of #bizarch (business architecture) and #BPM” http://improving-bpm-systems.blogspot.ch/2015/01/common-understanding-of-bizarch.html . Less IT applications and more business-process-centric solutions.

From http://nealford.com/memeagora/2015/03/30/architecture_is_abstract_until_operationalized.html “Continuous Delivery and the DevOps movement illustrated the pitfalls of ignoring the effort required to implement an architecture and keep it current. There is nothing wrong with modeling architecture and capturing those efforts, but the implementation is only the first step. Architecture is abstract until operationalized. In other words, you can’t really judge the long-term viability of any architecture until you’ve not only implemented it but also upgraded it. And perhaps even enabled it to withstand unusual occurrences.”

Correct, but slightly simplified observations – actually, 3 (three) major upgrades are necessary to demonstrate that architecture is good. Rationale: it is recommend leaving a solution team before the 3th major upgrade of this solution.

As microservices become place-independent, it is necessary to have a good “naming service” (as we had in CORBA) to allow mapping of microservice’s URI to new URL. Such “naming services” is also known as discovery services.

From http://cloudramblings.me/2015/03/20/microservices-martin-fowler-netscape-componentized-composable-platforms-and-soa-service-oriented-architecture/ “Part of the problem with API management and micro-services or with the mediation / message broker middleware technologies is that these can impose a software layer that is burdensome on the micro-services architecture... Let us say an approach to implementing micro-services would be to put them into a traditional API Management service as offered by a number of vendors. There would indeed be an overhead introduced because the API Layers impose a stiff penalty of authentication, authorization, then load balancing before a message can be delivered. What is needed is a lightweight version of API Management for some trusted services behind a firewall that are low risk and high performance.”

5 Characteristics of cloud-scale applications

From http://devops.com/blogs/containers-designed-antiquated-application-architecture/ “Cloud-scale applications by nature are stateless with any application state being managed by cache or database services. The compute unit of measure is the process not the CPU, which enables greater scalability. .... They scale across network architectures easily allowing businesses to run in private data centers and leverage cloud for excess capacity when needed.”

From http://12factor.net/backing-services “Twelve-factor processes are stateless and share-nothing. Any data that needs to persist must be stored in a stateful backing service, typically a database.” and “Treat backing services as attached resources”.

6.2 Performance

easy moving an individual containerized copy of the microservice between nodes (thus moving a microservice close to its consumer upto his/her mobile device)

on-demand creating an individual containerized copy of the microservice (but the run-time knowledge about the context is mandatory)

creating an individual containerized copy of the microservice for a particular consumer to diminish the security overhead (but the run-time knowledge about the context is mandatory)

6.3 Lightweight security

predefined state which is created by embedding security keys into an individual containerized copy of the microservice (but the run-time knowledge about the context is mandatory) thus achieving self-containment of PEPs

This architecture implements business solutions (instead of IT applications because the boundaries of IT applications are not relevant any more) as a coordinated collection of autonomous components. Each AC is a unit of functionality (as SRP) which can be executed in its own computing process (thus a unit of deployment which can be deployed in a separate host somewhere). An AC may be an assembly of several ACs. In general, ACs are structurally interdependent, behaviorally (or operationally) independent and contractually dependent.

Below, several typical ACs are described from the “being cloud-friendly” viewpoint through the following characteristics:

Contracting ACs: Use of some resource-access ACs and short-running ACs.

Example: Web-client or Fat-client for a document management system.

Note: Operation are usually short-running human and short-running automated ones.

Functional role-based portal (FRBP) AC to select a function and execute it with some data/documents as a user-facing AC. It provides two types of operations: 1) static list of functions what this role may do and 2) dynamic list of activities what this role has to do. A function is a set of activities.

Note: There are two types of operations: 1An operation may be short-running human, short-running automated and long-running one. The latter is a coordination of short-running ones and other long-running ones.

a) The functional-role-based-portal AC offers to a user some functions to initiate (as a static list). Each of functions is an explicit-coordination-operation AC which comprises several human-operation ACs and automated-operation ACs. Human-operations ACs are to be executed by users and they are dynamically listed for each users.

b) All explicit-coordination-operation ACs are implemented as DSL-script. The DSL-manager AC provides a list of functions which are offered for users. The DSL-processor AC provides a list of activities which have to be executed by some users.

c) A user executes a function which is implemented as a DSL-script; the DSL-manager AC instantiates an individual copy of this explicit-coordination-operation AC via the DSL-processor AC. (Covered by markers 1-3.)

d) The first of two operations within this explicit-coordination-operation AC is the automated-operation AC which uses several other ACs; the explicit-coordination-operation AC instantiates an individual copy of this automated-operation AC and individual copies of two of ACs used by it (“Utility” and “Resource assembly access”). Then the automated-operation AC is executed (Covered by markers 4-6.)

e) The second of two operations within this explicit-coordination-operation AC is the human-operation AC; the explicit-coordination-operation AC instantiates an individual copy of this human-operation AC and an individual copy of the other AC used by it. (Covered by marker 7).

f) The human operation AC must be completed by a user and it informs the explicit-coordination-operation AC. (Covered by markers 8 and 9).