Category Archives: Enterprise Architecture

January 24, 2018 · 12:15 am

Tokenize Every Little Thing (ELT)

[Since first writing this article in January 2018, I’ve concluded that Ethereum is not capable of being a platform for Tokenizing Every Little Thing. Ethereum is a one-trick pony x 1500 when it comes to creating large-scale decentralized applications (i.e. Ethereum/Solidity smart contracts are best for creating single, simple entities like alt-coins). Checkout slide 56 of this presentation: NEO Blockchain Vancouver 20180315 Meetup. The NEO Blockchain and NEO Smart Economy is the best available 3rd generation distributed application platform on the planet and improving every day. Michael Herman, March 17, 2018]

[Also checkout the webcast The NEO Smart Economy, Smart Processes, and Smart Data. Michael Herman, April 9, 2018]

Just over one year ago, I introduced the concept of graphitization and talked about #Graphitization of the Enterprise. I opened the article with the challenge:

Move beyond digitalization of the enterprise to graphitization of the enterprise.

For 2018 and beyond, the challenge is simpler but more difficult:

Tokenize Every Little Thing (ELT)

To provide more context, let me first quote from the introductory paragraphs of the #Graphitization article.

Here’s a great diagram that explains this concept [graphitization]. (click on the diagram to enlarge it)

Figure 1. The New Model of IT

Graphitization of not only all of your corporate information assets across all of your constituencies and stakeholders – at the data, application entity, and business object level – but also the graphitization of all of the interconnections between every business process, application system, infrastructure component, cloud service, vendor/service provider, and business role that uses, manages, or stores corporate information (Crossing the EA Chasm: Automating Enterprise Architecture Modeling #2).

Use graphitization to make your existing corporate information more available, more usable, and more informative. Graphitization enables you to “Keep Calm and Have IT Your Way“.

What is #Graphitization?

#Graphitization is a data science and enterprise architecture-inspired framework and process model for modeling, ingesting, organizing, analyzing, and visualizing any domain of endeavor by using graphs – networks of connected objects and relationships with each object and relationship annotated with additional descriptive information (metadata).

Why #Tokenization?

Given the burgeoning preoccupation of the world’s business, finance, government, and technology sectors with blockchain technologies, cryptocurrencies, and token-this and token-that, the buzzword for 2018 will be #Tokenization …the creation of tokens (multiple versions of tokens) to represent every thing on the planet …Every Little Thing (ELT).

While individuals, startups and larger organizations are trying to dream up the next big, one-off, token or crytocurrency, why not just admit that, “in the end”, everything will be represented by a token?

Why try to knock these off one at a time (e.g. Bitcoins, Ethers, altcoins, CryptoKitties, letters of credit, auctions, escrow agreements, electronic health records (EHR), electronic medical records (EMR), etc.) when the ultimate goal to to create a universal interconnected graph of ELT (Every Little Thing) in the universe?

Why #graphitize the enterprise when you can #tokenize the universe?

What is #Tokenization?

Let’s get a little computer-sciency for just a minute. A common task to to take an input stream (a string of characters, a stream of data, a data file or database table), analysis it, and convert it into a collection or sequence of higher-level tokens for further analysis (a process that can be applied recursively). Here’s an explanation from Wikipedia…

In computer science, lexical analysis, lexing or tokenization is the process of converting a sequence of characters (such as in a computer program or web page) into a sequence of tokens (strings with an assigned and thus identified meaning). A program that performs lexical analysis may be termed a lexer, tokenizer, or scanner… [https://en.wikipedia.org/wiki/Lexical_analysis]

…and later in the same Wikipedia article…

Tokenization

Tokenization is the process of demarcating and possibly classifying sections of a string of input characters. The resulting tokens are then passed on to some other form of processing. [https://en.wikipedia.org/wiki/Lexical_analysis#Tokenization]

Coming up for air… Why not represent ELT that happens in the universe as a stream of blockchain transactions?

the events in your life?
everything that occurs during a Presidential election?
the 24-hour cycle of one day changing into the next?
the activity-by-activity and task-by-task execution of a business process?
a stream of events from your Internet-of-Things (IoT) enabled car, toaster or refrigerator?

Jim Gray and TerraServer

In one of his several presentations on Scalable Computing (circa 1999), Jim Gray (relational database pioneer and Turing Award winner) describes the TerraServer project in the following way:

[Users navigate] an ‘almost seamless’ image of earth.

SkyServer was a similar project quarterbacked by Gray:

TerraServer allowed access to newly-available satellite imagery with resolution of 1.5 meters/pixel. SkyServer, a collaboration with Alexander Szalay and his colleagues at Johns Hopkins, allowed access to astronomical data from the Sloan Digital Sky Survey. SkyServer led to additional work with astronomical data, … [https://amturing.acm.org/award_winners/gray_3649936.cfm]

Tokenize Every Little Thing

With the advent of blockchain technologies (in particular, the Ethereum extensible blockchain platform), why can’t we embark on a grander mission to tokenize Every Little Thing? …and including all token-pair relationships (TPRs).

What will it take?

What needs to change in the Ethereum blockchain platform? Will Ethereum be able to scale to support modeling, ingesting, organizing, analyzing, and visualizing of Every Little Thing (ELT)?

On your mark, get set, …

Best regards,
Michael Herman (Toronto)

mwherman@parallelspace.net

Other Important References

Gordon Bell, MyLifeBits MSR Project (early 2000’s). I remember Jim Gray telling this story but I had trouble finding a proper reference because I thought it was Gray’s story instead of Bell’s. I now know better but I’ve already finished the above article. A Wikipedia MyLifeBits reference can be found here. YouTube videos can be found here, here, and others over here. Channel 9 videos: Part 1 and Part 2. Computerworld article (2008). Business Inside article (2016).
Gordon Bell’s MSR web page.

3 Comments

Filed under Architecture Reference Models, blockchain, Business Value, Data Science, Enterprise Architecture, Ethereum, Every Little Thing, graph database, Graphitization, How do we think, Nethereum

Tagged as Bitcoin, challenge, CryptoKitties, EHR, ELT, EMR, Ether, Graphitization, Jim Gray

May 8, 2017 · 1:37 pm

#Graphitization of the Amazon Leadership Principles (introducing Personal Leadership Principle Maps) – Iteration 1

PLEASE POST A COMMENT ABOUT WHY THIS PAGE IS IMPORTANT TO YOU.
This particular page is 1 of my top 5 most viewed pages (ever) and I’d like to understand why. Thank you!

[Click on any figure to enlarge it to its full, original size.]

The motivation and goals for Iteration 1 of this project are simple:

Make the Amazon Leadership Principles visually more understandable and more memorable
Introduce the concept of a Personal Leadership Principles Map where one’s personal career and personal belief system is mapped to each of the Amazon Leadership Principles
Promulgate the use and application of #Graphitization beyond its traditional roots in Enterprise Architecture.

This article is structured as follows:

Appendix B – Amazon Leadership Principles is copy of the original text (non-graphitized) version of the Amazon Leadership Principles from the Amazon Jobs website.
Appendix A – Amazon Leadership Principles (and Subprinciples) contains an ArchiMate enterprise architecture model that depicts the (and then decomposes) the 14 Amazon Leadership Principles into multiple levels of subprinciples. Scroll down to the bottom of this article to check it out.
NOTE: The underlining in Appendix A attempts to highlight the individual Subprinciples and Relationships found in the text description of each of the 14 Principles.
The first real section Amazon Leadership Principles, Core Entities, and Relationships presents a new innovative way to learn, remember, understand, and apply the Amazon Leadership Principles as highly visual web (or mesh or graph) of principles, concrete entities, abstract entities, and relationships.
The last section (just before Appendix A), entitled Personal Leadership Principle Maps, depicts how the experiences and accomplishments of one person’s career (mine) can be (formally) mapped the Amazon Leadership Principles.

Let’s start the journey. If you’re not familiar with the Principles, start by reading:

Appendix B – Amazon Leadership Principles; then
Appendix A – Amazon Leadership Principles (and Subprinciples)

All of the figures in this article represent different graphitized views of the Amazon Leadership Principles (click here) …all built from a single underlying graph model (which, in total, is referred to as the #Graphitization of the Amazon Leadership Principles).

Visually, the model is expressed using the ArchiMate 3.0 visual language standard for enterprise architecture. The model was built with the latest version of Archi 4.0, the open-source, free enterprise architecture modeling platform.

If you would like to work directly with the ArchiMate model for the Amazon Leadership Principles,

The latest version of the Archi .archimate model file created for this article be downloaded from here.
The individual views of the 14 Amazon Leadership Principles can be downloaded from here: https://www.facebook.com/mwherman/media_set?set=a.10155018158800932.1073741988.635655931&type=3

This article concludes with a list of possible Next Steps for Iteration 2.

Enjoy.

Amazon Leadership Principles, Core Entities, and Relationships

The text of the Amazon Leadership Principles references specific:

Roles
Concrete entities,
Abstract Entities, as well as, more importantly,
Relationships between these entities

These are collectively referred to as the Core Entities. Roles include:

Leader
Owner
Customer
Competitor
Partner
etc.

Concrete Entities include:

The Amazon Organization (presented by an employee directory or org chart)
Employee Team (same including virtual teams documented in project documents)
Standards (assuming they are written down or, in other words, documented)
Products
Services
Processes
etc.

Abstract Entities include:

Speed
Calculated Risks
Decisions
Actions
Inputs
Results
Bold Directions
Capabilities
etc.

Relationships include:

Leaders obsess over Customers
Leaders pay attention to Competitors
Leaders earn and keep Customer Trust
Constraints breed Resourcefulness
Constraints breed Self-Sufficiency
Constraints breed Invention
etc.

All of the entities and relationships are depicted in Figure 1 below (assuming none or only a few have been overlooked). (Click the figure to enlarge it.)

The entities and relationships were deduced by inspection and analysis of each of the 14 Amazon Leadership Principles (classic business analysis, more or less).

Figure 1. Amazon’s Principles, Core Entities, and Relationships: The Core Model

The existence, enablement, creation and/or execution of each group of relationships gives rise to (or realizes) one or more of the 14 Principles (and/or their Subprinciples). When these realization relationships are added to the Core Entities depicted in Figure 1, Figure 2., the “Complete Model”, is the result. (Click to enlarge.)

Figure 2. Amazon’s Principles, Core Entities, and Relationships: The Complete Model

To simplify the understanding of the model, 14 new views were created – one for each of the 14 Principles – each overlayed on the original Core Model (Figure 1). Figure 3 is an example drawn from one of these 14 views: Principle 1. Customer Obsession.

Figure 3. Amazon’s Principles, Core Entities, and Relationships: Principle 1. Customer Obsession

Located in the lower-left side of Figure 3, the Customer Obsession Principle is realized by:

a) a Leader’s focus or “obsession over Customers”, and
b) a Leader’s “attention to the Competition”.

Figure 4. below is an animation of the Complete Model overlayed, principle-by-principle, against the Core Model.

This slideshow requires JavaScript.

Figure 4. Amazon’s Principles, Core Entities, and Relationships: Principle-by-Principle Animation overlayed against the Core Model

The individual views of the 14 Amazon Leadership Principles can be downloaded from here: https://www.facebook.com/mwherman/media_set?set=a.10155018158800932.1073741988.635655931&type=3.

So far, we’ve addressed the “what” of the Amazon Leadership Principles depicted as a #Graphitization model projected as a number of different views.

In the next section, the Amazon Leadership Principles are used as a framework for cataloging one’s lifetime experiences and accomplishments. Personal Leadership Principle Maps is an Amazon Leadership Principles application – it’s the Amazon Leadership Principles put into action.

Personal Leadership Principle Maps

Have you been living an Amazon Leadership Principled career/faith/life?

Figure 5. is a copy of my Personal Leadership Principle Map (PLPM).

ArchiMate Assessment entities are used to model specific experiences and accomplishments.
ArchiMate Outcome entities are used to model specific evidence, learnings, or proof that one has been able to apply the specific principle in their career, faith and/or life.

Figure 5. Amazon’s Principles: Michael’s Experiences and Accomplishments

In my case, for Principle 7. Insist on the Highest Standards, I have specific experiences related to the recent Toronto Salesforce 2017 Tour, working at Parallelspace Corporation, the IBM Canada Toronto Software Lab, and at Microsoft.

Specific evidence includes:

Parallelspace trust framework (Relationships-Reputation-Trust)
Working as an ISO-9000 Quality Analyst and a certified Quality Assurance Auditor
A concept I call focusing on the success of an Individual Individual
Various and diverse experiences working for Microsoft as a full-time employee (blue badge) and as a Microsoft partner

Next Steps for Iteration 2

Possible next steps include:

Federation of Personal Leadership Principle Maps – at the Employee Team, business unit, or Organization level to discover the aggregates collective experiences and accomplishments for the purpose of rebalancing hiring objectives (Principle Gap Analysis), accumulating customer as well as competitive intelligence, etc. to support Customer Obsession, Ownership, Invent and Simplify, etc. goals and objectives. Identifying the best sources of experiences and accomplishments for specific Principles based on a Team’s or Organization’s previous roles, education, or training.
Use of both the Core Model and the Complete Model as well as the Federate Personal Leadership Principle Maps to create a graph database repository to real-time query analysis and visualization (e.g. using the Neo4j graph database).
To support Amazon’s operational data analysis needs (e.g. Amazon Marketplace 3rd Party Retail Data).
Apply the Parallelspace principles

References

Continuous Transformation and Transformative Change are key principles of the Total Enterprise Architecture Model (TEAM) (click here)
To dig deeper, check out Graphitization of the Enterprise (click here)
[Enterprise Architecture, Big Data, CRM, ERP, …] Tools and Methods Don’t Generate Business Value (click here)

Appendix A – Amazon Leadership Principles (and Subprinciples)

Below is an ArchiMate enterprise architecture model that depicts (and then decomposes) the 14 Amazon Leadership Principles into multiple levels of subprinciples (as appropriate/as required).

These are based on the text-based defintions of the 14 Principles found in Appendix B – Amazon Leadershp Principles.

Figure 6. Amazon’s Principles (and Subprinciples)

Appendix B – Amazon Leadership Principles

The following Leadership Principles are taken directly from the Amazon Jobs website.

The sequential numbering (in parenthesis) was added by me.
The underlining attempts to highlight the individual Subprinciples and Relationships found in the text description of each of the 14 Principles.

Leadership Principles

Our Leadership Principles aren’t just a pretty inspirational wall hanging. These Principles work hard, just like we do. Amazonians use them, every day, whether they’re discussing ideas for new projects, deciding on the best solution for a customer’s problem, or interviewing candidates. It’s just one of the things that make Amazon peculiar.

Customer Obsession (1)

Leaders start with the customer and work backward. They work vigorously to earn and keep customer trust. Although leaders pay attention to competitors, they obsess over customers.

Ownership (2)

Leaders are owners. They think long term and don’t sacrifice long-term value for short-term results. They act on behalf of the entire company, beyond just their own team. They never say “that’s not my job”.

Invent and Simplify (3)

Leaders expect and require innovation and invention from their teams and always find ways to simplify. They are externally aware, look for new ideas from everywhere, and are not limited by “not invented here”. As we do new things, we accept that we may be misunderstood for long periods of time.

Are Right, A Lot (4)

Leaders are right a lot. They have strong judgment and good instincts. They seek diverse perspectives and work to disconfirm their beliefs.

Learn and Be Curious (5)

Leaders are never done learning and always seek to improve themselves. They are curious about new possibilities and act to explore them.

Hire and Develop the Best (6)

Leaders raise the performance bar with every hire and promotion. They recognize exceptional talent and willingly move them throughout the organization. Leaders develop leaders and take seriously their role in coaching others. We work on behalf of our people to invent mechanisms for development like Career Choice.

Insist on the Highest Standards (7)

Leaders have relentlessly high standards – many people may think these standards are unreasonably high. Leaders are continually raising the bar and driving their teams to deliver high-quality products, services, and processes. Leaders ensure that defects do not get sent down the line and that problems are fixed so they stay fixed.

Think Big (8)

Thinking small is a self-fulfilling prophecy. Leaders create and communicate a bold direction that inspires results. They think differently and look around corners for ways to serve customers.

Bias for Action (9)

Speed matters in business. Many decisions and actions are reversible and do not need extensive study. We value calculated risk taking.

Frugality (10)

Accomplish more with less. Constraints breed resourcefulness, self-sufficiency, and invention. There are no extra points for growing headcount, budget size or fixed expense.

Earn Trust (11)

Leaders listen attentively, speak candidly, and treat others respectfully. They are vocally self-critical, even when doing so is awkward or embarrassing. Leaders do not believe their or their team’s body odor smells of perfume. They benchmark themselves and their teams against the best.

Dive Deep (12)

Leaders operate at all levels, stay connected to the details, audit frequently, and are skeptical when metrics and anecdote differ. No task is beneath them.

Have Backbone; Disagree and Commit (13)

Leaders are obligated to respectfully challenge decisions when they disagree, even when doing so is uncomfortable or exhausting. Leaders have conviction and are tenacious. They do not compromise for the sake of social cohesion. Once a decision is determined, they commit wholly.

Deliver Results (14)

Leaders focus on the key inputs for their business and deliver them with the right quality and in a timely fashion. Despite setbacks, they rise to the occasion and never settle.

Best regards,

Michael Herman
Enterprise Architect and Data Scientist
Parallelspace Corporation
M: 416 524-7702
E: mwherman@parallelspace.net
B: http://hyperonomy.com
L: https://www.linkedin.com/in/mwherman/recent-activity/posts/
Skype: mwherman2000

Living at the intersection of Enterprise Architecture, Enterprise Knowledge, and Data Science

3 Comments

Filed under ArchiMate, Architecture Reference Models, Business Value, continuous transformation, Definitions, Enterprise Architecture, graph database, Graphitization, How do we think, ModelMate, Process, Product Management, Uncategorized

Tagged as Amazon, Core Entities, Entities, graph database, Leadership, Map, maps, Neo4j, Principles, relationships, Subprinciples

April 10, 2017 · 11:17 am

What are the differences between improving the design (and operation) of a smart city, an aircraft engine, a muscle car, a large enterprise, and an economic system …at hyperscale?

Original title: What are the differences between improving the design (and operation) of a smart city, an aircraft engine, a muscle car, a large enterprise, and/or an integrated commercial global cloud services platform …running at hyperscale?

Question: What are the differences between improving the design (and operation) of:

a smart city,
an aircraft engine,
a muscle car,
a large enterprise, and/or
an econonic system
…running at hyperscale?

Answer: None.

Scroll down to see the use cases; then the list of resources at the bottom of this article.

Use Case 1: Aircraft engine
Use Case 2: Muscle car

Figure 1. Continuous Transformation Model: Aircraft Engines and Muscle Cars

Use Case 3: Smart city
Use Case 4: Large enterprise operating at hyperscale

Figure 2. Continuous Transformation Model: Smart Cities, Large Enterprises, and Cloud Services Platforms

Use Case 5: Economic systems

Figure 3. Continuous Improvement Framework applied to Economic Systems

Diving Deeper: #Graphitization

To go deeper, checkout #Graphitization of the Enterprise (click here) as well as the list of references below.

progressive-ea-model-1-0-9-peam3-ea-chasm-auto-dots

Figure 4. #Graphitization Continuous Transformation Model

Figure 5. Continuous Transformation Framework: Process Model

References

Michael Herman, Blockchain Developer, Enterprise Architect and Data Scientist: #Graphitization Inventor (click here)
Continuous Transformation and Transformative Change are key principles of the Total Enterprise Architecture Model (TEAM) (click here)
To dig deeper, check out Graphitization of the Enterprise (click here)
[Enterprise Architecture, Big Data, CRM, ERP, …] Tools and Methods Don’t Generate Business Value (click here)

Best regards,

Michael Herman
Enterprise Architect and Data Scientist
E: mwherman@parallelspace.net
B: http://hyperonomy.com
L: https://www.linkedin.com/in/mwherman/recent-activity/posts/

Living at the intersection of Enterprise Architecture, Enterprise Knowledge, and Data Science

1 Comment

Filed under ArchiMate, Architecture Reference Models, Crossing the EA Charm, Data Science, Enterprise Architecture, Graphitization, How do we think, IoT, Space Flight

Tagged as aircraft engine, AWS, Azure, cloud services, Google, Hyperscale, jet engine, muscle car

February 28, 2017 · 11:25 am

Michael Herman: Award-winning Author, Invited Speaker, Illustrator, and Trainer

Feel free to contact me at:

Michael Herman
mwherman@parallelspace.net
(416) 524-7702

PARTIAL PORTFOLIO

All of the publications below are full-length white papers or technical notes – unless noted otherwise (e.g. presentations, training materials, online product help).

Tzunami K-Wise Deployer

Client: Tzunami

Tzunami Inc. Evaluation Guide: Using K-Wise Deployer™ for Rapid Content Migration into Microsoft SharePoint Products and Technologies (50 pages)

#Graphitization of ArchiMate: Getting MMOR from ArchiMate using the ModelMate Master Online Repository

MMOR (pronounced “more”) is an online, queryable version of an updated, corrected version of the ArchiMate 3.0 relationship matrix – originally described in the article The Graphitization of ArchiMate.

The source data for MMOR is based on Gerben Wierda‘s recent (February 2017) blog article The ArchiMate 3.0 Relations Table….

This article provides an overview – a teaser, actually. I’m working on a more in-depth description that I’ll publish next week. HINT: If you poke around on hyperonomy.com – digital intelligence, you’ll find the “WIP” draft.

Logging into MMOR (pronounced “more”)

MMOR Url: http://hobby-icgaeohcoeaggbkeabhldpol.dbs.graphenedb.com:24789/browser/
MMOR Username: ModelMate_Master_Datasets10
MMOR Password: YqeZAH4ODEJqglkEsK5p

The above app url, username and password provide you with read-only access to the MMOR graph database – you can’t hurt anything. Please go ahead and try it using some of the sample queries I’ve documented below.

CAVEAT: There are zero guarantees on my part in terms of the availability, reliability, or performance of this hosted solution. I’ll be making changes with no advance notice.

Running Queries

To run a query, follow these steps:

Connect to the MMOR app and login (see above)
Copy & paste each query (one at a time) into the query box (next to the ‘$’ sign)
Click the “Play” icon to run the query

Figure 1. Copy & paste each query (one at a time) – then click Play (click to enlarge)

TIP: After you’ve run your first query, in the bottom-right corner of the visualization, turn Auto-Complete to the Off position by clicking on the icon.

Figure 2. TIP: Turn Auto-Complete to the Off position

Sample Query A: Node Prototype, Technology Landscape View

Return and visualize the relations in the MMOR where the source element is a Node and the (source and) target elements are members of the Technology domain, both Core as well as Derived relations are included, and the source and target elements are different (i.e. ignore self-referencing element relations).

MATCH path = (source:ElementProtoype_ArchiMate30_TheOpenGroup) 
            -[relation]->
             (target:ElementProtoype_ArchiMate30_TheOpenGroup)
WHERE source.DomainQualifiedLabel IN ["TechnologyDomain_ArchiMate30_TheOpenGroup"]
AND   target.DomainQualifiedLabel IN ["TechnologyDomain_ArchiMate30_TheOpenGroup"]
AND   type(relation) IN ["CoreRelation_ModelMate30_Parallelspace",
                         "DerivedRelation_ModelMate30_Parallelspace"]
AND   source.QualifiedName <> target.QualifiedName
AND   source.QualifiedName = "Node_ArchiMate30_TheOpenGroup"
RETURN path

NOTE: In the above Cypher Query Language (CQL) query, note the use of the following ModelMate Namespace Naming Standard used for:

Element prototype types on the source and target elements (e.g. ElementPrototype_ArchiMate30_TheOpenGroup, Node_ArchiMate30_TheOpenGroup)
Each element’s domain (e.g. TechnologyDomain_ArchiMate30_TheOpenGroup)
Categorizing relations (e.g. CoreRelation_ModelMate30_Parallelspace, DerivedRelation_ModelMate30_Parallelspace)

The general format used for the ModelMate Namespace Naming Standard is:

[typeclassname]_[typeclasscategory]_[typeclassoriginatingbody]

e.g. ApplicationComponent_ArchiMate30_TheOpenGroup

Figure 3. Sample Query A: Results (click to enlarge)

NOTE: The black arcs are Core relations; the red arcs are Derived relations. In the current version of the MMOR, there’s approximately an order of magnitude more Derived relations vs. Core relations.

NOTE: In Figure 3, note the use the ModelMate convention for naming relations based on a specific verb taxonomy that immeasurably improves the readability, a Stakeholders’ opportunities for further reflection and refinement, and the composability of higher-level Domain-Specific Languages (DSLs) for enterprise architecture based on using ArchiMate as a lower-level intermediate language:

Sample Query B: Core Relations, All Domains Landscape View

Return and visualize all of the Core relations in the MMOR.

MATCH path = (source) 
            -[relation:CoreRelation_ModelMate30_Parallelspace]-> 
             (target)
WHERE id(source) <> id(target) 
RETURN path

Figure 4. Sample Query B: Results (click to enlarge)

NOTE: It may look pretty but it’s not very useful from a functional perspective. To fix this, try grabbing the Passive Structure elements and dragging them to the left; the Active Structure elements, moving them to the right. The Behavior elements can be left in the middle. They will act as if they are connected to the Passive and Active Structure elements by elastics or springs. You can also manually position the Behavior elements similar to what you did with the Structure elements. Go ahead and try it for yourself.

There are several additional visualization tools in the market that work substantially better than the default browser app that ships with the Neo4j graph database. Check out this page: Graph Visualization for Neo4j. Linkurious is one of my favorite graph visualization apps.

Sample Query C: All Elements Prototypes, Statistical Matrix

Return and display a statistical matrix describing the element prototypes in the MMOR.

MATCH (source), (target)
WHERE id(source) <> id(target)
RETURN DISTINCT labels(source), count(*) AS Count,
avg(size(keys(source))) as AvgPropertyCount,
min(size(keys(source))) as MinPropertyCount,
max(size(keys(source))) as MaxPropertyCount,
avg(size((source)-[]->(target))) as AvgRelationsCount,
min(size((source)-[]->(target))) as MinRelationsCount,
max(size((source)-[]->(target))) as MaxRelationsCount

Figure 5. Sample Query C: Results (click to enlarge)

NOTE: The use of multiple Cypher Query Language (CQL) labels to support multiple-inheritance at the element prototype level. For example, using the first row of data in Figure 5:

the generic element prototype (i.e. Element_ArchiMate30_TheOpenGroup),
ArchiMate domain (layer) type (e.g. MotivationDomain_ArchiMate30_TheOpenGroup), and
ArchiMate aspect type (e.g. MeaningAndValueAspect_ArchiMate30_TheOpenGroup);
in addition to the element’s specific ArchiMate prototype (e.g. Value_ArchiMate30_TheOpenGroup).

Downloadable Files

You can also download file-based versions of the MMOR Master Datasets from GitHub in the following file formats:

CSV text file
Microsoft Excel workbook
Microsoft Access database
Neo4j Cypher Query Language (CQL) file.

In addition, there is a ZIP file containing all 4 file formats.

https://github.com/mwherman2000/ModelMate30_Parallelspace/tree/master/Parallelspace_ModelMate_MasterDataset_Complete10

Best regards,
Michael Herman (Toronto)
Parallelspace Corporation
mwherman@parallelspace.net

*ArchiMate is a registered trademark of The Open Group.

2 Comments

Filed under ArchiMate, Crossing the EA Charm, Enterprise Architecture, Enterprise Architecture Chasm, Master Data Management, Master Metadata Management, ModelMate, ModelMate Information Architecture for ArchiMate, ModelMate Information Architecture for Languages, The Open Group

Tagged as ArchiMate, cypher, MMOR, ModelMate Master Online Repository, Neo4j

February 8, 2017 · 4:44 pm

Crossing the EA Chasm: #Graphitization of ArchiMate 3.0 – Iteration 2

First Draft: April 5, 2017

This article documents a number of parallel efforts to improve the usability, understandability, utility, and correctness of the ArchiMate 3.0 Specification. In particular, this article extends a well-received previous article Crossing the EA Chasm: Graphitization of ArchiMate 3.0 – Iteration 1 where I posed the question:

Wouldn’t it be nice to have an authoritative reference for ArchiMate 3.0, more specifically, a repository for the enterprise architecture language‘s elements and relationship matrix, that is queryable.

This article documents the current iteration of the ModelMate project, Iteration 2, whose goal is to create an improved queryable repository for a corrected version of relationship matrix (more correct relative to the Appendix B tables in the current ArchiMate 3.0 Specification).

Background

Over the past few months, I’ve written several articles commenting on the current state of the ArchiMate language for Enterprise Architecture including:

In addition, there are almost weekly postings about usability issues or errors with the Specification in the Linkedin ArchiMate group, the GitHub Archi issues log, LinkedIn Pulse, and the Google ArchiMate group; as well as other forums [1][2].

The recent effort, called the ModelMate project, is a focused effort to create a more broadly applicable, usable, useful, ArchiMate-based, extensible language environment for enterprise architecture as described in these 4 articles:

Current Scenario

The current scenario is highlighted by the following points taken from the above references:

“[People should be] encouraged to try to model these examples for yourself: to start learning how to “think in ArchiMate” as your second or third written language.” The way the ArchiMate language is currently designed and, more importantly, described makes this difficult.
In an abstract sense, the extension of the ArchiMate language is supported but, in reality, few if any broadly adopted extensions have appeared in the market. A better approach is described here: Crossing the EA Chasm: ArchiMate 3.0, fix it or re-purpose it?
There is no single, authoritative, machine-readable version of the ArchiMate 3.0 relationship matrix; let alone one that is easily accessible and queryable.
The Open Group’s insistence on using abstract terminology to name element types and relation types presents users with additional challenges.

Problem Description

At a data level, the root causes of the problems with the ArchiMate 3.0 relationship matrix in Appendix B of the ArchiMate 3.0 Specification include:

No machine-readable version of the tables are available for external validation for correctness
The tables contain errors in the approximately 11,000 relations that are represented in the tables. Is is estimated that there are few hundred to a few thousand errors present in the current ArchiMate 3.0 tables
The tables contain all possible (valid) relations but do not differentiate between Core relations and Derived (non-Core) relations.

All three issues are critical for the ArchiMate 3.0 Specification and these tables to be trusted and more generally useful.

In addition, the Derived Relation Derivation Algorithm has never been published by The Open Group. Attempts to create an alternative algorithm have highlighted that the text of the ArchiMate 3.0 Specification is neither consistent nor complete when it comes to identifying the set of Core Relations and a correct and complete Derviation Algorithm.

Lastly, when dealing with 1000+ Core Relations and several thousand Derived Relations (8000-9000 or more), it’s difficult to analyze and visualize what the ArchiMate 3.0 relationship matrix looks like in total, or when subdivided by Domain (Layer) or Aspect, or when focused on a specific element prototype (e.g. Node).

Solution Overview

The goal of this solution is to publish a very detailed, rich, unnormalized version of the latest and greatest ArchiMate 3.0 relationship matrix in multiple formats; including:

CSV text file
Microsoft Excel workbook
Microsoft Access database
Neo4j Cypher Query Language (CQL) queryable graph database file

When loaded into Microsoft Excel, the CSV and Microsoft Excel workbook format files appear as shown in Figure 1 (below).

Figure 1. ModelMate Master Datasets: Excel 2016 and CSV File Formats

The Microsoft Excel (and CSV) format file can also be used with the Microsoft Excel Web App (Figure 2) and the Microsoft Excel format can be used to create custom SharePoint lists (Figure 3).

Figure 2. ModelMate Master Datasets: Excel 2016 format file in MIcrosoft Excel Web App

Figure 3. ModelMate Master Datasets: Custom SharePoint List created from Imported Excel 2016 Format File

When loaded into Microsoft Access, the Microsoft Access database format files appear as shown in Figure 4 (below).

Figure 4. ModelMate Master Datasets: MS Access Database file format

To create a queryable graph database version of the ArchiMate 3.0 relationship tables (in effect, the entire ArchiMate 3.0 metamodel), the Cypher Query Language (CQL) file depicted in Figure 5. was created.

Figure 5. ModelMate Master Datasets: Neo4j CQL File

Figure 6 is an example of the output from a single line CQL query run against the ArchiMate 3.0 graph database (implemented using Neo4j). If you look closely at the CQL statement at the top of this screen shot (click Figure 6. to enlarge it), you’ll see that it is selecting all of the relationships across all of the element prototypes in the Technology/Infrastructure domain of the ArchiMate 3.0 metamodel that connect to the Node element prototype.

Figure 6. ModelMate Master Datasets: Graph Mining Analysis Sample

File Downloads

You can download the files referred to in this article from the GitHub repository. Click here to download the ModelMate Master Datasets files.

In addition, there is a Neo4j Cypher Query Language (CQL) file available for download that will ingest all of the element prototypes and relations into a graph database using a single Neo4j shell invocation. From the Windows Powershell or Windows Command Prompt, use:

“C:\Program Files\Java\jre1.8.0_91\bin\java.exe” -classpath “C:\Program Files\Neo4j CE 3.0.6\bin\neo4j-desktop-3.0.6.jar” org.neo4j.shell.StartClient -c dump > MasterDataSet.cql

Lastly, there is Microsoft Access 2016 database version of the CSV file that is available for download if you prefer using Microsoft Access SQL queries or graphical SQL queries.

Solution Details

Below is a copy of the workflow and dataflow used to create the Parallelspace ModelMate Master Datasets. It’s not as messy as it looks – it’s true mashup and a valuable one at that. It’s primarily the result of the truly ad-hoc collaboration between 3 enterprise architecture professionals with an interesting mix of diverse goals (Gerben Wierda, Ed Roberts and myself); each of us with our own set of preferred development technologies and goals (with Excel being the greatest common denominator (GCD)).

Figure 7. ArchiMate 3.0 Relationship Matrix Resolution Process

The numbered steps in Figure 7. are explained below:

Data Sources. There are many sources of information about the ArchiMate relationship matrix in addition to the Appendix B tables in the ArchiMate 3.0 Specification. The list in Figure 7. is a fairly complete. Key data sources include the GitHub Archi repository for the most widely used ArchiMate modeling tool for enterprise architecture and Gerben Wierda’s multiple ArchiMate resources publishing under the Mastering ArchiMate brand.

“MA Core Set” Spreadsheet. Wierda worked to consolidate various data sources from Step 1 above to create the “MA Core Set” Mastering ArchiMate relationship matrix (plus a number of other relationship matrices that Wierda used for comparative analysis and troubleshooting purposes). The “MA Core Set” represents the “seed” or Core Set of (non-derived) ArchiMate relations. Wierda created this Core Set over several iterations reviewing the word-for-word text of the Specification, the inheritance diagrams, as well as incorporating his extensive practical knowledge and experience documenting ArchiMate in the book entitled Mastering ArchiMate – Edition II.

The “MA Core Set” tab in the AllowedRelationsArchiMate30VBA-public.xlsm Excel spreadsheet also includes additional columns that are reserved for calculating and storing an intermediate 3-column, reverse-transposed version of the relationship matrix (Step 3 below).

CreatePrologList() Visual Basic for Applications (VBA) Macro: This macro is used to perform the actual reverse-transposition of the “MA Core Set” relationship matrix into the 3-column format which including a column for storing the relation(source,target) 3-tuple formatted data (in Prolog format). The 2-D relationship matrix is the input to the macro (along with some additional master data tables that are part of the VBA code). The 3-tuples are the essential output of the VBA macro (stored “in-place” in the first 3 columns of the spreadsheet).

CoreSet.prolog File. To proceed through to the next step of the workflow, the Prolog format data is copied from the spreadsheet and pasted into a plain text file called CoreSet.prolog, for example (or any other filename you would like to use).

Derivaton.py Python Script and outfile.csv. The Derivation.py script contains is the “magic sauce”. Written by Wierda, Derivation.py reads the CoreSet.prolog file and executes a complex and detailed algorithm to expand the Core Set of ArchiMate relations read from the CoreSet.prolog file into a number of alternative output formats, including CSV and Prolog formats.

To support the ModelMate project, a version of Derivation.py was modified to output a number of additional CSV columns (outfile.csv). Columns:

SourceElement
TargetElement
Relation
RelativeStrength
IsInputRelation
StandardVersion
ScriptVersion

Outfile.xml File. Steps 6 and 7 are part of a sequence of activities that were used to create a relationships.xml file that is compatible with the relationship configuration requirements of the Archi modeling tool. This process, originally implemented by Ed Roberts, owner of Dallas-based Elparazim, uses Excel to load the outfile.csv save it out as an outfile.xml file.

For Step 7, Ed Roberts wrote an XSL Transform script that when applied to the outfile.xml file creates the Archi-compatible relationship.xml that is used by the Archi model to automatically configure the element-element relations supported in a given version of Archi (e.g. Archi 4.0).

Steps 8-10 mark an alternative data flow created to support the needs of the ModelMate Master Datasets project.

In Step 8, the contents of the ModelMate-compatible modified CSV output from Step 5 (outfile.csv) is copy-and-pasted into the Parallelspace_ModelMate_MasterDatasets_CoreAndDerivedNN.xlsx Excel workbook (where NN is a version number).

A matrix of automated Excel functions in the Complete spreadsheet merge the elements and relations master data attributes from the Elements and Relations spreadsheet with the data from the Derived spreadsheet to compute the corresponding column values in the Complete spreadsheet. Think of the Complete spreadsheet as a super-unnormalized version of the relationship matrix. The InInputRelation column values indicate whether a specific relation (and it’s companion source and target elements) are Core relations or Derived relations.

The workbook contains 4 spreadsheets (Derived, Complete, Elements, and Relations):

Derived spreadsheet – copy-and-pasted version of the outfile.csv from Step 4. The “input” spreadsheet.
Columns:
1. SourceElement
2. TargetElement
3. Relation
4. RelativeStrength
5. IsInputRelation
6. StandardVersion
7. ScriptVersion
Complete spreadsheet – leverages the master data in the Elements and Relations tabs to expand the columns in the Derived spreadsheet to include additional metadata property columns for the source and target elements as well as the relations. The “output” spreadsheet that will be saved as a CSV file in Step. 9.
Columns:
1. SourceElement
2. TargetElement
3. Relation
4. RelativeStrength
5. IsInputRelation
6. StandardVersion
7. ScriptVersion
8. RelationName
9. RelationLabel
10. RelationQualifiedLabel
11. RelationForwardVerbLabel
12. RelationReverseVerbLabel
13. RelationQualifiedForwardVerbLabel
14. RelationQualifiedReverseVerbLabel
15. SourceName
16. SourceLabel
17. SourceQualifiedLabel
18. TargetName
19. TargetLabel
20. TargetQualifiedLabel
21. SourceDomainName
22. SourceDomainLabel
23. SourceDomainQualifiedLabel
24. SourceAspectName
25. SourceAspectLabel
26. SourceAspectQualifiedLabel
27. TargetDomainName
28. TargetDomainLabel
29. TargetDomainQualifiedLabel
30. TargetAspectName
31. TargetAspectLabel
32. TargetAspectQualifiedLabel
Elements spreadsheet – master data attributes and values for each element prototype.
Columns:
1. ElementCode
2. ElementLabel
3. ElementName
4. ElementQualifiedLabel
5. DomainName
6. DomainLabel
7. DomainQualifiedLabel
8. AspectName
9. AspectLabel AspectQualifiedLabel
Relations spreadsheet – master data attributes and values for each relation prototype.
Columns:
1. RelationCode
2. RelationName
3. RelationQualifiedLabel
4. RelationForwardVerb
5. RelationQualifiedForwardVerb
6. RelationReverseVerb
7. RelationQualifiedReverseLabel

In Step 9, columns 4-32 of the Complete spreadsheet are saved as a separate CSV format file (using the same versioned file name as the parent workbook but with a suffix of .csv).

Also considered part of Step 9, the CSV file is imported into an empty Microsoft Access database. The datatype of the InInputRelation is changed to be a Yes/No (boolean) field. The database file is given the same name as the CSV file but with a suffix of .accdb.

Step 10 uses a series of Cypher Query Language (CQL) script files to create and populate a Neo4j graph database – to enable simple but powerful ad-hoc queries against the ArchiMate 3.0 relationship tables/metamodel.

Step 10.1. Merge all of Source and Target Element Prototypes

Script 1. Merge Source and Target Element Prototypes

Step 10.2. Label Elements with Element, Domain and Aspect Names

Script 2. Label Elements with Element, Domain and Aspect Names

Step 10.3 Create the Metamodel Relationships

TODO

Results

Use Cases

This section documents the results of the following use cases (queries against the Neo4j graph model):

All Business domain source and target element prototypes and all related Core and Derived relationships
All Core relationships where the source element prototype is from the Business domain
All Core relationships where the source and target element prototypes are from the Business domain
All Application domain source and target element prototypes and all related Core and Derived relationships
All Core relationships where the source and target element prototypes are from the Application domain
All Core and Derived relationships where the source and target element prototypes are from the Technology/Infrastructure domain
All Core relationships where the source and target element prototypes are from the Technology domain
All Core relationships where the source and target element prototypes are from the Technology domain and are identical to each other
All Core relationships where the source and target element prototypes are from the Technology domain and are different from each other (non-self referencing)
All Core and Derived relationships where the source and target element prototypes are from the Technology domain and are different from each other (non-self referencing)
All Core and Derived relationships where the source and target element prototypes are from the Technology domain and connected to the Node element prototype
All Core relationships where the source and target element prototypes belong to the Passive Structure aspect
All Core relationships where the source and target element prototypes belong to the Active Structure aspect
All Core relationships where the source and target element prototypes belong to the Behavior aspect

Use Case Results

Click on any of the figures to enlarge them in a separate browser tab.

Business Domain Use Case Results

Use Case 1: All Business domain source and target element prototypes and all related Core and Derived relationshipsUse Cases

Figure 8. is the result of an ad-hoc CQL query against all element prototypes in the Business domain; more specifically, where both the source and target element prototypes are in the Business domain.

Figure 8. All Business domain source and target element prototypes and all related Core and Derived relationships

Use Case 2: All Core relationships where the source element prototype is from the Business domain

Figure 9. is the result of an ad-hoc CQL query against all Core relationships where the source element prototype is from the Business domain.

Figure 9. All Core relationships where the source element prototype is from the Business domain

Use Case 3: All Core relationships where the source and target element prototypes are from the Business domain

Figure 10. is the result of an ad-hoc CQL query against all Core relationships where both the source and target element prototypes are from the Business domain.

Figure 10. All Core relationships where the source element prototype is from the Business domain

Application Domain Use Case Results

Use Case 4: All Application domain source and target element prototypes and all related Core and Derived relationships

Figure 11. is the result of an ad-hoc CQL query against all element prototypes in the Application domain; more specifically, where both the source and target element prototypes are in the Application domain.

Figure 11. All Application domain source and target element prototypes and all related Core and Derived relationships

Use Case 5: All Core relationships where the source and target element prototypes are from the Application domain

Figure 12. is the result of an ad-hoc CQL query against all Core and Derived relationships where the source element prototype is from the Application domain.

Figure 12. All Core relationships where the source and target element prototypes are from the Application domain

Technology Domain Use Case Results

Use Case 6: All Core and Derived relationships where the source and target element prototypes are from the Technology/Infrastructure domain

Figure 13. is the result of an ad-hoc CQL query against all Core relationships where both the source and target element prototypes are from the Technology/Infrastructure domain.

Figure 13. All Core and Derived relationships where the source and target element prototypes are from the Technology/Infrastructure domain

Use Case 7: All Core relationships where the source and target element prototypes are from the Technology domain

Figure 14. is the result of an ad-hoc CQL query against all Core relationships where both the source and target element prototypes are from the Technology domain.

Figure 14. All Core relationships where the source and target element prototypes are from the Technology domain

Use Case 8: All Core relationships where the source and target element prototypes are from the Technology domain and are identical to each other

Figure 15. is the result of an ad-hoc CQL query against all Core relationships where both the source and target element prototypes are from the Technology domain and are identical to each other.

Figure 15. All Core relationships where the source and target element prototypes are from the Technology domain and identical to each other

Use Case 9: All Core relationships where the source and target element prototypes are from the Technology domain and are different from each other (non-self referencing)

Figure 16. is the result of an ad-hoc CQL query against all Core relationships where both the source and target element prototypes are from the Technology domain and are different from each other (non-self referencing).

Figure 16. All Core relationships where the source and target element prototypes are from the Technology domain and different from each other (non-self referencing)

Use Case 10: All Core and Derived relationships where the source and target element prototypes are from the Technology domain and are different from each other (non-self referencing)

Figure 17. is the result of an ad-hoc CQL query against all Core and Derived relationships where both the source and target element prototypes are from the Technology domain and are different from each other (non-self referencing).

Figure 17. All Core and Derived relationships where the source and target element prototypes are from the Technology domain and are different from each other (non-self referencing)

Use Case 11: All Core and Derived relationships where the source and target element prototypes are from the Technology domain and connected to the Node element prototype

Figure 18. is the result of an ad-hoc CQL query against all Core and Derived relationships where both the source and target element prototypes are from the Technology domain and are connected to the Node element prototype.

Figure 18. All Core and Derived relationships where the source and target element prototypes are from the Technology domain and connected to the Node element prototype

Aspects Use Case Results: Passive Structure, Active Structure, Behavior

Use Case 12: All Core relationships where the source and target element prototypes belong to the Passive Structure aspect

Figure 19. is the result of an ad-hoc CQL query against all Core relationships where the source and target element prototypes belong to the Passive Structure aspect.

Figure 19. All Core relationships where the source and target element prototypes belong to the Passive Structure aspect

Use Case 13: All Core relationships where the source and target element prototypes belong to the Active Structure aspect

Figure 20. is the result of an ad-hoc CQL query against all Core relationships where the source and target element prototypes belong to the Active Structure aspect.

Figure 20. All Core relationships where the source and target element prototypes belong to the Active Structure aspect

Use Case 14: All Core relationships where the source and target element prototypes belong to the Behavior aspect

Figure 21. is the result of an ad-hoc CQL query against all Core relationships where the source and target element prototypes belong to the Behavior aspect.

Figure 21. All Core relationships where the source and target element prototypes belong to the Behavior aspect

Feedback

Please add your comments and feedback to the end of this article.

Best regards,
Michael Herman (Toronto)
Parallelspace Corporation
mwherman@parallelspace.net

*ArchiMate is a registered trademark of The Open Group.

1 Comment

Filed under ArchiMate, Architecture Reference Models, Automated Enterprise Architecture Modeling, Crossing the EA Charm, Definitions, Domain Specification Languages (DSL), Enterprise Architecture, Enterprise Architecture Chasm, graph database, Graphitization, ModelMate, ModelMate Information Architecture for ArchiMate, ModelMate Information Architecture for Languages, Progressive Enterprise Architecture Map (PEAM), The Open Group

Tagged as Archi, ArchiMate, Graphitization

January 27, 2017 · 2:58 pm

Crossing the EA Chasm: ArchiMate 3.0, fix it or re-purpose it?

It is the end of January 2017 and, recently, there has been a lot of discussion in the LinkedIn ArchiMate group about the ArchiMate language for enterprise architecture (EA), its “idioms”, usability, adoption, etc.

In addition, in the article Crossing the EA Chasm: Reflections on the Current State of ArchiMate, I asked some questions related to ArchiMate’s purpose and whether it is adequately addressing all of enterprise architecture’s stakeholders’ needs. Crossing the EA Chasm: Re-visioning the ArchiMate Specification is a related article.

These discussions led to this short-form question, the key topic for today:

ArchiMate 3.0, fix it or re-purpose it?

Fixing ArchiMate

On the “fix it” side of the discussion, people will literally be working to fix the language forever. The Open Group is committed to supporting these kinds of efforts; it’s the foundation for why they exist.

But is there a better, compatible approach? I think there is.

Re-purposing ArchiMate

As a starter, let’s look at the evolution of and technology hierarchy that supports high-level programming languages. Pick your favorite language. Many of you will choose Java; I’m a C# person. (It doesn’t really matter.)

Before the advent of managed, cross-platform execution environments (like the Java VM and the .NET Runtime that provide memory management and garbage collection, advanced exception management, data protection, secure execution contexts, etc.), prior languages like C and C++ followed a simple compilation model as illustrated in Figure 1.

Figure 1. C/C++ Compilation Model

This scenario is synonymous with the current lower-level language support available in ArchiMate 3.0. There’s effectively one language level and that’s all you have.

The C# (.NET) compilation model ups the ante by introducing a cross-platform intermediate language (Microsoft Intermediate Language (MSIL)) as shown in Figure 2. Java achieves something similar using Java bytecode.

Figure 2. C# Compilation Model: Role of the Microsoft Intermediate Language (MSIL)

Re-purposing ArchiMate as a Lower-Level Intermediate EA Language

In an approach similar to the way the .NET Framework uses MSIL, ArchiMate can be re-purposed as the lower-level intermediate language for creating higher-level EA languages.

The article Modeling a Company and Its Locations, Markets, Employees, Investors & Roles: Proposals, Wishes & Dreams is a small but real-life, practical example of how this can be executed to create a new EA language for describing Business Organizations (as illustrated below in Figure 3).

Figure 3. Business Organization EA Language, an ArchiMate 3.0 Specialization

This approach more easily and more formally supports the concept of domain-specific languages (DSLs) for enterprise architecture.

As The Open Group moves ArchiMate forward, the published higher-level EA languages can incrementally adopt the new changes – in the same way the Java JIT compilers and Microsoft JIT compilers are updated to adopt new instruction sets from Intel or AMD.

Making It Real

The Archi modeling tool can ~~easily~~ be adapted to serve as the reference implementation for these new EA languages. This is relatively easy to accomplish because all of the ArchiMate relationships remain the same; and, at least initially, it’s ~~simply~~ a matter of extending Archi’s existing ArchiMate elements with families of new elements that address the scope of each new EA DSL. It is a SMOP.

More food for thought… Please post your comments below.

Best regards,
Michael Herman (Toronto)
Parallelspace Corporation
mwherman@parallelspace.net

*ArchiMate is a registered trademark of The Open Group.

4 Comments

Filed under ArchiMate, Architecture Reference Models, Automated Enterprise Architecture Modeling, Crossing the EA Charm, Domain Specification Languages (DSL), Enterprise Architecture, Enterprise Architecture Chasm, The Open Group

Tagged as ArchiMate, Architecture Reference Models, Domain Specific Languages, DSL, ModelMate, MSIL

January 25, 2017 · 4:39 pm

Modeling a Company and Its Locations, Markets, Employees, Investors & Roles: Proposals, Wishes & Dreams

This article presents some new approaches for modeling answers to the following frequently asked question:

How do I model X in ArchiMate?

NOTE: You are encouraged to try to model these examples for yourself: to start learning how to “think in ArchiMate” as your second or third written language. Archi is a great free tool for learning the ArchiMate language. You can download the Archi .archimate file containing the model used for this article from here. You can download the latest version of the Archi 4.0 modeling tool from here (which includes full support for the ArchiMate 3.0 language).

ArchiMate 3.0 is used as the baseline enterprise architecture modeling language for this discussion; especially the new Grouping element.

The Proposals

There are 2 new proposals described in this article: one more generic and one more specific.

Proposal 1: A new (general) approach for visually presenting answers to the question “How do I model X in ArchiMate?” using a metamodel-level reference model modeling strategy
Proposal 2: A specific approach (reference model) for modeling a Company and its Locations, Markets, Employees, Investors, etc. and their Roles.

The second proposal is an example or use case for the former.

Proposal 1: Modeling of Best Practice Modeling Patterns

Proposal 1 is illustrated in Figure 1 and Figure 2. These figures illustrate a general approach for modeling and visually presenting answers to the question “How do I model X in ArchiMate?”.

Rather than provide simple, less-informative, textual answers such as “use Business Collaborations to model Companies” or in ArchiMate 3.0, “use Groupings to model Companies”, why not:

Leverage Specialization relationships to model, name, and visually illustrate, in these examples, alternative representations of a Company element
From a presentation perspective, place the new best practices modeling pattern on the left – side-by-side – with the portion of the applicable elements of the base-level ArchiMate metamodel on the right

as illustrated in Figure 1 and Figure 2.

NOTE: Proposal 1 is illustrated with 2 examples. The merits of the individual examples are discussed below in Proposal 2. The comparison of these 2 examples is not part of Proposal 1.

Figure 1. Metamodel-level Reference Model for a Company using Business Collaboration

Figure 2. Metamodel-level Reference Model for a Company using Grouping

Proposal 2: Specific approach (reference model) for modeling a Company

Proposal 2 asks the question: Of the 2 options presented above (or any additional alternative options), which option represents a best practice reference model for modeling a Company and its Locations, Markets, Employees, Investors, etc. and their Roles.

The only tangible difference between the modeling strategy in Figure 1 vs. Figure 2 is:

Figure 1 derives Business Organization from Business Collaboration
Figure 2 derives Business Organization from Grouping (a new element introduced in ArchiMate 3.0)

These choices, in turn, have a secondary effect in terms of the valid set of relationships that can be used to compose or aggregate the elements that comprise a Business Organization.

To aid your consideration, Figure 3 provides a more concrete example using the second option: using Groupings to represent Companies (my current preferred solution).

NOTE: The goal of these models is to model the active structure of a Business Organization which excludes concepts like Business Processes and Business Services.

Figure 3. Proposal 2 Example: Bridgewater Associates

What do you think?

Please add your comments, thoughts, and questions below.

Best regards,

Michael Herman (Toronto)
Parallelspace Corporation
mwherman@parallelspace.net

*ArchiMate is a registered trademark of The Open Group.

8 Comments

Filed under ArchiMate, Architecture Reference Models, Automated Enterprise Architecture Modeling, Crossing the EA Charm, Definitions, Enterprise Architecture, Enterprise Architecture Chasm, Graphitization, ModelMate Information Architecture for ArchiMate

Tagged as ArchiMate, Architecture Reference Models, Grouping, ModelMate, proposal, specialization

January 22, 2017 · 11:55 am

RE: Managing Master Data With ArchiMate

In the Linkedin ArchiMate group, Gunther BONNARD recently asked the following question (January 20, 2017 Inauguration Day):

Managing Master Data With ArchiMate

I am looking for an easy way to manage Master Data (Business Objects) with ArchiMate. I was wondering which association to use to link MD with the business capabilities in charge (“accountable”) of the MD and the same problem to link data object that realize the MD with the application (that create the MD). …any ideas?

…with the following additional clarifications:

How can I model that a business object “belongs” to a capability or a data object is under the responsibility of an application component? I have this issue because I need to manage what is the “master” of the data (without using functions) …

For example, I would like to model that:
– the business object Client belong to the business capabilities CRM
– the application SalesForce is the master of the data object Client …

What follows is more of an approach than a definitive answer. Please add your feedback, questions, and comments at the bottom of this article.

Start by exploring the context of the question …a simple business analysis task. What is the scope of what Gunther is talking about? …key concepts or objects, important relationships, etc.
Ask clarifying questions.
Start sketching the context in ArchiMate. “Learn to think in the ArchiMate language” …like learning to think in a second or third language. (Archi makes this easy to do or use a commercial modeling tool.)
Go beyond the boundaries of the immediate problem to help ensure you understand the broader context. It will make your eventual answer more correct and increase its longevity and utility.
- Are you answering the right question?
- Think of physical or real-life examples. Then create higher-level abstractions.
Your sketch doesn’t have to be perfect or “correct”. It needs to be what you need it to be to help you think about and answer your question.
It is the “thought process” that is forced to take place while you are creating your sketch that is the most important activity of the overall process (like whenever you’re forced to write something down on paper or on your device).

Here’s the ArchiMate 2.1 sketch I came up with:

Figure 1. Master Data Management: Ownership and Responsibilities (Sketch 1)

Don’t work on your sketch for “days”; at most an hour or a couple hours. That’s why it’s called a sketch.

My Thought Process

These are the questions and notes that came to mind while I worked on the above sketch:

Need to maintain clarity between the concepts of Master Data and Master Data Definitions (aka Master Data Management and Master Metadata Management, respectively). Gunther is asking about Master Data in his posting – not Master Data Definitions (even though they are closely related). I should have asked a clarifying question about this to get confirmation.
Typically, Salesforce applications are not traditional applications built by traditional application and technology roles BUT for this example, we’ll assume they are.
Salesforce applications are not Software Components. They are configuration artifacts stored in and processed by the Salesforce platform to realize Application Functions (and Application Services) and custom Data Objects.
Salesforce has a strong underlying concept of Master Metadata Management (even if they don’t use this term). It’s the core of the platform (IMHO).
Customer is one class of Master Data data. “Customer 123” is a Master Data data instance. Create this sketch using classes of Master Data data – not instances (unless you’re creating a secondary view to show an example of Customer Master Data data instance).
Business Roles are associated with Business Capabilities
- which in turn aggregate Business Processes
- that access Business Objects
- “ArchiMate 101”
Revisit the question while you’re creating the sketch: Should Business Capabilities own Master Data? My answer to this question was: No. I think Business Capabilities can be associated with classes of Master Data.
I believe Business Roles (and Business Actors assigned to these roles) should own Master Data. Master Data is created and managed by Business Processes but it is not owned by these Business Processes. I believe this contradicts the definition of (or purpose for) having Master Data.
Classes of Master Data are defined by Master Data Definitions. Sketch these as Technology Artifacts UNLESS you are trying to model a Master Data Management/Master Metadata Management application. If you’re doing the latter, no problem but I don’t think that this is directly related to Gunter’s original question.
Modeling a Salesforce “Org” as a Software Component is a bit of a stretch but it’s the best choice I could come up with. Salesforce Org’s aren’t software.
The Business Capabilities and Business Roles you choose (and classes of Master Data) and their interrelationships will be specific to a particular company.

Once you’re happy with your detailed sketch, then you can use ArchiMate derivation to work backwards to create more focused (smaller) views that more specifically illustrate the answer(s) to your question.

If you want to do a full RACI treatment, then consider an approach like the one illustrated in this article: ARMs for Metadata-Driven LOB apps: SharePoint 2013/SharePoint 2016.

Homework: Data Lakes

What if Customer was an aggregated, virtual Master Data class drawn from multiple applications and data sources both inside and outside your organization? …rather than a single data source or application? How would you represent this in your ArchiMate sketch?

That’s my 2 cents (Canadian). 🙂

Michael Herman (Toronto)
Parallelspace Corporation
mwherman@parallelspace.net

*ArchiMate is a registered trademark of The Open Group.

2 Comments

Filed under ArchiMate, Architecture Reference Models, Crossing the EA Charm, Enterprise Architecture, Master Data Management, Master Metadata Management, Salesforce

Tagged as ArchiMate, Data Lake, Master Data Management, Master Metadata Management, metadata, Salesforce

January 13, 2017 · 3:12 pm

Crossing the EA Chasm: Re-visioning ArchiMate 3.0 Relations as Verbs

[Updated: February 6, 2017]

In the article Crossing the EA Chasm: Re-visioning the ArchiMate Specification, I proposed a new architectural framework for re-visioning the current ArchiMate 3.0 Specification.

In this article, I propose using the following list of verbs to either augment or replace the existing ArchiMate relationship names in the Specification and move towards a more humane, more understandable, more usable, and more acceptable language for enterprise architecture.

Table 1. Proposed List of Verbs to Augment or Replace
the Current ArchiMate 3.0 Relationship Names

An interesting observation: Note the verbs that start with “Is*”. They appear in either the “Source-Target” (ForwardVerb) or the “Target-Source” (ReverseVerb) columns but not both for a given relationship. This wasn’t deliberate – this is just the way it turned out. Does this indicate anything about which direction is the natural direction for the relationship to point to?

What do you think of this proposal? Please post a comment below, email me, or post a reply in the LinkedIn ArchiMate group.

To learn more about the background and history of this proposal, check out:

Best regards,
Michael Herman (Toronto)
Parallelspace Corporation

mwherman@parallelspace.net

*ArchiMate is a registered trademark of The Open Group.

3 Comments

Filed under ArchiMate, Architecture Reference Models, Business Value, Crossing the EA Charm, Enterprise Architecture, Enterprise Architecture Chasm, ModelMate, ModelMate Information Architecture for ArchiMate, ModelMate Information Architecture for Languages, The Open Group

Tagged as ArchiMate, Architecture Reference Models, Crossing EA Chasm, ModelMate, Relations, relationships, Verbs

	[OLD] Web 7.0 DIDCom… on Web 7.0 DIDComm Agent Architec…
	Welcome to Web 7.0!… on Web 7.0 DIDComm Agent Architec…
	Web 7.0 DIDComm Agen… on Web 7.0 DIDComm Agent Architec…
	Web 7.0 DIDComm Agen… on [OLD] Web 7.0 DIDComm Agent Ar…
	Web 7.0 DIDComm Agen… on Welcome to Web 7.0! (over…

	[OLD] Web 7.0 DIDCom… on Web 7.0 DIDComm Agent Architec…
	Welcome to Web 7.0!… on Web 7.0 DIDComm Agent Architec…
	Web 7.0 DIDComm Agen… on Web 7.0 DIDComm Agent Architec…
	Web 7.0 DIDComm Agen… on [OLD] Web 7.0 DIDComm Agent Ar…
	Web 7.0 DIDComm Agen… on Welcome to Web 7.0! (over…

Category Archives: Enterprise Architecture

Share this:

Amazon Leadership Principles, Core Entities, and Relationships

Personal Leadership Principle Maps

Next Steps for Iteration 2

References

Appendix A – Amazon Leadership Principles (and Subprinciples)

Appendix B – Amazon Leadership Principles

Leadership Principles

Customer Obsession (1)

Ownership (2)

Invent and Simplify (3)

Are Right, A Lot (4)

Learn and Be Curious (5)

Hire and Develop the Best (6)

Insist on the Highest Standards (7)

Think Big (8)

Bias for Action (9)

Frugality (10)

Earn Trust (11)

Dive Deep (12)

Have Backbone; Disagree and Commit (13)

Deliver Results (14)

Share this:

Diving Deeper: #Graphitization

Share this:

PARTIAL PORTFOLIO

Microsoft Live Communications Server

Microsoft SharePoint Products and Technologies

Microsoft Exchange Server

Metalogix Replicator for SharePoint

Microsoft “Alchemy”

Parallelspace Vulture

Tzunami K-Wise Deployer

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Recent Posts

Categories

Meta

Archives

Recent Comments