Tom Graves / Tetradian

Time to get back to the themes from the post ‘More on that enterprise-architecture ‘help wanted’‘, with a focus on toolsets and metamodels.

The usual approach to toolsets – just about any kind of toolset, as far as I can tell – is to describe the overall context, knock up a metamodel, and then build a toolset that works with that metamodel.

That’s fine as long as we don’t need to use the content for anything else, in any other way, or (in all too many cases) in any other toolset. If we do need to do anything like that – and frankly, most of us do – well, then, we have a problem…

What we actually need is a toolset that can do any kind of modelling and simulation that we could possibly want. Given the nature of Reality Department, we’re not likely to get it… Oh well. But if we can’t have that One Toolset To Rule Them All, then perhaps a good second-best is a metamodel (or metametamodel, or whatever layer we need to go to) that underpins a file-format that can move anything that we need to share across all the disparate toolsets. And that, I believe, is doable. Hence this series of posts.

Let’s start right at the roots.

(And please watch for anything that I’ve missed, or that I seem to have got wrong – because that’s the way we’ll get this to work right, for everyone.)

Let’s start with the idea of a ‘thing’. This ‘thing’ could be or represent anything at all: an object, a piece of information, a perceived connection, an idea, a question, whatever. It’s just, well, something. Anything.

Given a collection of ‘things’, we then might want to describe perceived relationships between various of those ‘things’.

And we then might want to model those ‘things’ and relationships between ‘things’ in a structured or semi-structured way, to aid in sense-making and decision-making. (We then might also want to describe explicit viewpoints and views that determine the scope and role of models, as per IEEE1471 / ISO42010.)

This gives us the core of what we need to support here: entities (‘things’), relations, and model-types.

(I think that part is straightforward, but if not, please say so?)

Way back when, whilst we were designing an information-system for an aircraft tear-down, my colleague Graeme Burnett said that for anything of interest, anything in scope, we need to be able to ask of each ‘thing’:

• Tell me about yourself, and about what happens to you, with you, by you?
• Tell me what you’re associated with, and why?

Which in a sense leads us to the usual metamodel set, but with a few extra twists:

• entities and their attributes
• relationships and their attributes
• lifecycles and other types of change of entities
• flows and other types of change between entities
• questions about entities, relationships, attributes, flows, lifecycles and other changes

(What else needs to be added to this list? What have I missed so far?)

We need these items to be able to be portrayed in any representation (in both the visual sense and technical sense), including plain-text. This means that any representation needs to be separate from any entity or relationship or other item, yet needs to be associatable with it. In other words, we can’t link a metamodel rigidly with a notation, or vice versa, as with UML or BPMN or Archimate, for example – we must be able to re-use the same entities and relations and so on in multiple notations.

Some examples of how we might want to re-use the same entities might include:

• enterprise-architecture notation such as Archimate in Archi, or other notations such as UML, BPMN and so on
• enterprise-architecture metamodels such as in Troux Semantics
• systems models such as in Southbeach
• narrative questions such as in Southbeach MyCreativity
• context-maps such as in CMapTools
• social-networks for shared-concepts such as in Cohere
• personal sensemaking such as in Compendium
• support ‘barely repeatable processes’ such as in Thingamy
• partial-duplication for what-if experiments and for as-is versus to-be comparisons
• modelling of flows between entities

(Any other items that we ought to add to this list?)

As indicated in that list, we need to be able to support a wide variety of views and model-types. But the key point here is that there’s actually only one type of entity – or rather, every different entity is based on and resolves to the same core entity-type. The same applies to relationships: although there are many different apparent types, ultimately they all resolve back to the same core relationship-entity. That’s what would enable their portability between views, notations, model-types and applications.

This also implies that there’s no fundamental distinction between a ‘type’ and an ‘instance’. The only difference is that a type is instantiable, and an instance isn’t: we convert an instance to a type by making it instantiable, and we create an instance by making a non-instantiable copy of a type.

(Is there any part of the above that seems unworkable or doesn’t make sense?)

We need to be able to support several different levels of model-validation:

• free-form (no validation), as in Visio
• partial or variable validation, as in Archimate (or most forms of architecture-development)
• strict formal validation, as in BPMN to BPEL conversion

(Free-form and strict are relatively easy to implement; partial or variable validation can be a lot harder! Partial or variable-validation also means that we need to support null-entities or placeholders to indicate ‘dangling’ relations or items that have yet to be defined.)

We need to support to keep the information clean, including:

• explicit identifiers (distinct from editable names)
• standardised explicit change/lifecycle, as per CRUD or REST
• versioning
• deduplication, merge and split
• change of base-type for entity or entity-instance
• resolve of dangling links (i.e. links where the ‘far-end’ entity has been deleted)
• entity owner(s) – or preferably a complete RACI set for each entity

(What have I missed here?)

If I’ve got this right – and I’ll admit it’s a big ‘if’ – then conceptually we need only one core entity-type, and one core-relation-type, to cover all potential uses.

If so, then that would open an enormous range of possibilities for enterprise-architecture and for many other disciplines as well.

There are a number of tweaks and tricks to make this work in practice – particularly the concept of ‘tags’, which I’ll explain in the next post, and likewise a fundamental reorientation of the relationship between entity-types, relation-types and model-types – but in essence that seems to be enough to get started.

Comments, anyone, please?

What do I do, and how do I do it? What’s the nature of my work, and the methods that I use? And for that matter, why?

That’s perhaps the shortest summary to a request by Anthony Draffin, in a comment to my previous post ‘Not quite bus-pass day‘:

On a selfish note… It’s apparent that the common thread to dowsing, printing and enterprise architecture is your ability to look at a field holistically and apply logical thought to extract inconsistencies and errors, as well as looking at new ways of doing something more efficiently to meet the original aims. That’s a rare skill. Have you given thought to documenting how you go about doing this? While I imagine it’s the application of a number of taught skills, the way you put these together must be far from ubiquitous. Have you considered teaching this? Personally, as a 27 year old, I want to soak up as much of your approach and thought process as you’re willing to offer.

(Warning, this is going to be another (very) long one, mainly because there’ll be several case-studies.)

Read more…

Given the responses to my previous post ‘Guess I could do with some help here…‘, seems it’d be useful if I clarify a bit more what kind of help I most need. (Or we need, rather, as an industry and discipline: probably the only ‘I’-part here is that I seem to be one of the few at present who’s asking these questions?)

To be honest, we don’t need much help in thinking about the nature of enterprise-architecture or the like: that’s already well covered, and it’s actually quite straightforward anyway.

Where we need help is in rethinking the toolsets that we use for enterprise-architecture and the like.

To me it’s clear that if we’re to make sense of the enterprise, and support viable decision-making about the true whole-enterprise-scope within which our organisations operate, we’re going to need some kind of holographic approach to modelling.

We already have plenty of frameworks for enterprise-architecture. We also have plenty of methodologies to work with those frameworks. Each of those is constrained to some variously narrow view into this holographic space, and usually constrained by placing some particular point as ‘the centre’ – hence IT-centrism, business-centrism, health-and-safety-centrism and so on. And those constraints are useful in practice: no doubts whatsoever about that. So to my mind there’s nothing whatsoever that’s inherently ‘wrong’ about any of those frameworks or methods, other than their own occasional internal inconsistencies and than that they too-often position their own very limited perspective on reality as ‘the only possible’ view on reality. That’s the only problem there, and it’s very easy to fix, by acknowledging the value of a single viewpoint as a viewpoint yet also insisting on cross-viewpoint generics. We can choose anywhere as ‘the centre’, for some given purpose, yet must also insist that everywhere and nowhere is ‘the centre’, all at the same time.

Hence, as such, we don’t need any new frameworks or methodologies for enterprise-architecture. We have more than enough of them already, to be honest.

What we do need are better ways to manage and make sense of the information we have about this ‘enterprise-hologram’.

Which is where toolsets come into the picture. And that‘s the part that I really need help on – or we need help on, rather, because it’s definitely too large a context for any one person, or even any one group, to tackle on their own.

What we need most is clarity on the question we’re aiming to address. I think it’s an Einstein quote that says “if I had an hour to solve a problem, I would spend the first fifty-nine of those minutes on the question, and only the last minute on the answer” – because the right answer tends to fall out all by itself when we have clarity on the question.

One thing we do know, though, is that there are many different players all trying to tackle different aspects of the same enterprise-holograph – for example:

• enterprise-architecture and all the other domain-architectures and solution-architectures – an emphasis on structure and purpose, and how they link together to deliver useful value
• knowledge-management – an emphasis on how knowledge-items link together (especially narrative-knowledge, stories and ‘subjective truth’)
• change-management – how everything changes and can be changed over time
• process-management – how activities link together, and entities flow between them, to add value across supply-chains, value-networks and so on
• service-management – the human and technical aspects of keeping everything going and ‘on purpose’
• futures and other business-intelligence – how to trawl through the enterprise-space for sensemaking and the like
• simulation, ‘gamification’ and other skills-development – how to apply ‘what-if’ to any part of the overall context
• skills-management – identifying the skills needed, and the training and/or recruiting needed to cover present or future gaps
• performance-management – identifying required metrics and their impacts (especially, to avoid ‘gaming the system’)
• governance – identifying requirements and responsibilities, assuring assignment and ability to comply, and verifying compliance

In principle, yes, they’re all views or viewpoints into the same overall context. Yet each of those views also carries information or requirements that are specific to that view alone – in other words, more like an orthogonal dimension. And there are a lot of those distinct dimensions in there – an n-dimensional space, where n could literally be any number. (Certainly a lot more than are accessible in the simple flat images so typical of so many current ‘EA’-toolsets, anyway.)

Then there are all the different uses for all those distinct views: an architectural view shows us relationships between structure and purpose, for example, but do we need that view to decide on future strategy, to plan investment, to compare different implementation-options in trade-off analysis, to guide scenarios and substitutions in planning business-continuity and disaster-recovery? The views we’d use might at first seem similar, but the focus and emphasis and model-dynamics in each case might be very different.

At first glance this all might seem impossibly huge. Yet it’s not as hard as it seems. Most of the technology we’d need to deal with all of this complexity does already exist. Despite the huge spread of the overall toolset-ecosystem, most of the key software components we’d need are already easily available, at little or no direct cost, running on a wide-range of easily-available existing devices. Conceptually speaking, the underlying data-structures are straightforward enough: for example, it could be done with little more than freeform tagging in an object-database of some kind, with some kind of filters applied to the tagging. The same applies to search, and filtering: pretty much everything we need already exists somewhere, if we knew where to look. And even if display-technologies are not yet quite capable of showing a true n-dimensional holographic space, they’re certainly capable of simulating one. Given the right people and the right ideas, the technology side really isn’t all that hard these days.

But if the technology isn’t hard, the user-experience part is hard. And seems to me that that’s where we most need to focus our attention at the moment.

In many cases, we simply don’t have the right metaphors for model-relationships:

• some of it can be usefully described as a matrix – but it’s definitely more than a simple matrix as per Zachman
• there are some contexts in which a metaphor of hierarchical layers will sort-of make sense – but it’s definitely more than a simple ‘stack’ as per TOGAF or Archimate, or even a multi-axis matrix-stack as per CapGemini IAF
• there are flows of information and materials – yet it’s much more than a simple supply-chain
• there are identifiable relationships, including realisation, aggregation and so on – yet much of it tends to follow a modal logic of possibility rather than solely a simple true/false logic of presence or absence
• there are identifiable trails of derivation and decomposition – yet there’s more to it than a simple Zachman layering, or the classic ‘current state’ versus ‘future state’

And perhaps more important, we don’t yet have adequate user-interface metaphors:

• drag-and-drop for entities can be misleading – is it a class or an instance? how do we link back an instance back to a parent class? are we editing the instance only, or the whole class? are we affecting other instances elsewhere? or other versions of the same nominal instance? what happens if the parent disappears over time, but the instance continues as re-linked to something else?
• notations can be confusing – especially where the same nominal entity would appear in multiple views with different notations or visualisations or images
• aggregation (as in Zachman primitives versus composites, TOGAF ABBs versus SBBs [Architectural Building Blocks versus Solution Building Blocks]) can be very confusing – especially where entities can recombine in many different forms, and at different levels of abstraction or realisation
• zooming (as per Prezi) works well to describe a ‘containment’ or hierarchical concept of structural-decomposition – but it’s hard to make sense, if entities aren’t fully ‘contained’, or if there are more than two orthogonal axes
• timelines (as in Gantt-chart relationships, or Apple OS-X Time Machine backup/restore) provide a good means to step through time-related views – yet the views themselves may change over time
• multi-axis user-controls work well for up to three or four exactly-orthogonal dimensions – but become exponentially harder to use with increasing numbers of dimensions and other variables, and probably cannot cope when the dimensions themselves blur into each other

In short, we urgently need new user-interface metaphors to navigate through n-dimensional holographic space, where the nature of the space itself may change as we go.

(Oh, and it has to be easy to use, too, such that both the navigation and what’s visible in the view will make immediate sense to anyone. Of course.)

To use another Einstein quote, “Everything must be made as simple as possible, but not more simple”. Simple to use; yet actively dissuade overly-simplistic ‘solutions’ such as IT-centrism and the like.

That’s the challenge.

And that’s also where Agile and the like come into the picture – and, most of all, people who are experienced in Agile-style software-development for toolsets and the like. We seem to have quite a lot of methodologists and the like around here, who tend to be great on the theory. But what we need most are developers who know how to think seriously-sideways and put it into practice.

We can’t just talk it into existence: we need to get past the ‘talking about it’ stage now. Given the blunt fact that we’re very unlikely to get it right first time, we need something to play with, to test in real-world practice, to review and rethink our ideas, to help us clarify what the question really is that we’re facing here.

More thinking-about-thinking, about the theory and the like, well, yes, we’re always going to need it, it’s always going to be a ‘nice to have’, and so on. But right now, we’ve done more than enough thinking-about-thinking: it’s time to get down to the doing, of creating this new kind of toolset.

Anyone interested in helping with that? Please?

In case you hadn’t noticed, I’ve been kinda pouring out the posts on enterprise-architecture and the like, over the past few weeks or so… (A few people have complained about the overload, and probably with good reason, too! Oh well. My apologies, anyway.)

What’s happening for me is that it seems all of the work I’ve done on enterprise-architecture theory and practice over the past several years is suddenly coalescing into something big. It feels like I have a handle, or hook, or something, onto a radically different approach to how we do architecture-work in an enterprise-context, and in particular how we document that work and use that documentation to drive and support more-viable enterprise change.

The practical problem is that it’s all crashing around in my head, coming at me from all sorts of different metaphorical directions – metamodels, toolsets, methodologies, metaphors, the lot – and I’m having real difficulty getting it all down into a usable form. I tend to work solo most of the time, but in this case, frankly, it’s become way too large to handle all on my own. I can’t hold all of it in my head at once: it’s too big, too complex, needs way too many different skillsets and experiences, some of what I’m trying to do is likely way too complicated at present, and it’s almost certain that some is just plain wrong.

Hence, to quote the famous phrase, “I guess I could do with some help here…”

Please?

To give an idea of the scale of what I’m trying to bring together at present, there are around 300 posts on enterprise-architecture here on this website (excluding the weekly ‘A week in Tweets’ posts), of which perhaps half – maybe more – describe some new idea or concrete item of research on EA and related themes. There are eight finished full-size books on enterprise-architecture so far in the set, and at least another two or three under development at present. There’s another website just on metamodels, and another weblog on ‘big-picture’ business-themes. There are fragments of notes and experiments scattered around on seven different computers here, not to mention ten years’ worth of paper-notebooks and sketch-pads, and discussion-notes and emails from colleagues and conferences and the like over most of that time-period, too. And all of it seems to be coming together all at once. Yikes…

The real focus, as has come up in the most recent posts, seems to be about techniques and toolsets, to take any starting-point – such as a business-model in Business Model Canvas – and expand outward to tackle all of the whole-enterprise issues, including themes such as quality, security, sustainability, continuity and so on. Here are links to some of those posts:

• From business-model to enterprise-architecture
• Upwards and sideways from business-model
• Why business-model to enterprise-architecture?
• Where marketing meets enterprise-architecture
• The Enterprise Canvas – a really simple summary

There’s stuff about metamodels to move beyond ‘classic’ IT-centrism:

• Meanderings on metamodels
• More metamodel stuff
• Unravelling the anatomy of Archimate

There’s stuff about Agile in relation to enterprise-architecture – in particular a metaphor of ‘backbone’ that I still haven’t seen discussed elsewhere:

• Agility needs a backbone
• Architecting the enterprise backbone
• Tackling uniqueness in enterprise-architecture

There’s also a real need to address the human side of enterprise-architecture, including architecture-as-story and the almost-unacknowledged issue of narrative-knowledge (as opposed to IT-based information) in enterprise-architecture:

• Two points of view on (enterprise)-architecture
• Modelling people in enterprise-architecture
• People, power and enterprise-architecture
• The relationship is the asset
• Where have all the good skills gone?
• Who are your anti-clients?
• The enterprise is the story

And perhaps the real core of what’s happening for me now, around toolsets to cover that whole scope:

• The toolset-ecosystem
• Next-generation toolsets for enterprise-architecture?
• Enabling enterprise-architecture conversations

So: that’s the range of topics that I’m struggling with at the moment. Because it’s so huge, different parts of it keep drifting in and out of cognisance at any given time, so it’s difficult to maintain a sense of the whole. And the problem is that it does need to be tackled as a whole if we’re to avoid the same kind of trap that earlier forms of EA fell into, first with IT-centrism and process-centrism, and now all too often with business-centrism. The only thing that will work is to create something – a methodology, a metamodel, and a toolset-ecosystem, all linked together – that will fully support the awareness that in enterprise-architecture, everywhere and nowhere is ‘the centre’, all at the same time.

To be honest, I need help in all aspects of getting this down into usable form. But where I most need help is around the overall toolset(s). I think that the ideas are just about ready now for a proof-of-concept: but I doubt that I still have the technical skill to do much if any of it on my own. (The last significant software project I developed on my own was a wiki-based ‘engine’ that was used for a number of system-prototypes such as the SEMPER diagnostic: but it was back in the days of PHP4,and way too crude for todays’ standards.) To cover the whole toolset-ecosystem we’ll need whatever-it-is to compatible in some way or other with all of this scope:

• large cross-enterprise repository-based formal EA system (like Troux Metis)
• team-driven repository-based formal modelling system (like BizzDesign)
• single-user formal modelling system (like Sparx or ArchiTool)
• free-form desktop, notebook and/or web-based modelling system (like Visio) but can do round-trip to formal modelling
• tablet-style with gestural interface (like a cross between Prezi and BMTBox app on iPad)
• handheld, mostly browsing, but also able to feed back updates/suggestions

and

• paper-based, whiteboard, driven from book or ebook, etc

So: if you’re interested in ‘pushing the envelope’ for EA, you’re keen to work on some kind of collaborative project, and have some expertise in system-prototyping, user-experience design, workflow, graphics or anything of that kind, please get in touch with me? Because, yeah, I could do with some real help here…

Thanks in advance, anyway.

What is ‘Why?’ And why, anyway?

“Oh no, not again“, do I hear you cry? Actually, it’s not as bad as that: it’s not going to be yet another of those long tedious technical posts – honest!

(It is a sort-of technical question, I’ll admit. And, in the event, quite long. But interesting to just about everyone, I hope.)

What do we mean by ‘Why’? It’s a question that’s been puzzling me for quite a while – not least because enterprise-architecture is in some ways all about the shared ‘why‘ of an enterprise, and how we express that ‘Why’ in practice.

That kind of ‘Why’ is energising, and engaging. “Start with Why“, says Simon Sinek – and in terms of how things really happen in enterprise, he’s right. If we start with why, things do indeed happen, and usually happen well.

But then I look at the ‘Why’ column in Zachman: ‘Why’ is business-rules, it says. Gosh. Wow. Exciting… (To be honest, my heart just sinks. Doesn’t yours?) Business-rules? – seriously, where’s the fun in that? Kind of the exact opposite of engaging, really. Something’s gone missing there, clearly…

That’s not quite fair, of course. Up at the top, Zachman describes ‘Why’ as a list of Goals. Not quite as unexciting as business-rules. (But close…) Yet there’s something kinda odd here… kinda like a sudden sideways jump… different things all mixed up together in the same space…?

And I hit up against the same problem when working on the Enterprise Canvas concept, a year or so ago. The same Start with Why: the ‘vision’ for the extended-enterprise is the core ‘Why’ from which everything else flows. That ‘Why’ is emotive, it means something: for the right kind of ‘Why’, people are willing, even eager, to get out of bed way too early on a cold dark dreary workday morning. It matters. It sits above everything else. And yet, to make sense of the content and activities of the service that we’d represent on an Enterprise Canvas module, there’s that same dull boring ‘Why’ again: decisions, principles, rules and regulations, all that kind of stuff. Where’s the fun gone? How come we’ve lost the why from the Why?

I’ve been bouncing up against an answer on this in several previous posts over the past while, such as one about principles in enterprise-architecture, and another on the relationship between architecture, design and implementation. But perhaps a better answer came up over the past couple of days, when trying to unravel the anatomy of Archimate and, in particular, struggling to make sense of the split between what in Archimate they call Intentional Concepts versus Extensional Concepts.

Intentional Concepts are, as the name suggests, about intent. Extensional Concepts are about what we do with that intent – about how we extend that intent out into real-world practice. In Archimate, Intentional Concepts are entities such as Value, Meaning and Reason. And the important point is that these are viewed as separate from ‘the action’. Yet down in the details of that ‘the action’, we again come across another kind of ‘reasons’ – all those business-rules and so on. (Archimate doesn’t model any of that as yet, but that’s another story.) So again we’ve got this kind of sideways jump: ‘Why’ is above everything, as Intent; yet it’s also just another part of that ‘everything’, as Extension, the ways things work together.

The obvious answer: we’re dealing with two different kinds of ‘Why’. Or two different sides of the same ‘Why’, perhaps.

One side of Why creates a question: literally, it starts a ’quest’. For most of us, that’s the exciting bit.

The other side of Why is the answer to the question, the end of the quest. That was the question, here’s the answer: The Decision. End of story. For most of us, that’s when the fun ends: a sense of relief, perhaps, that there’s no more need to quest, but also, well, no more need to quest… Final. That’s it. Full Stop. (or Period, if you speak the US version of English). An ending, that somehow ends up in a bunch of rules, with No Questions Allowed any more. A Why To End All Whys.

Kind of like the braces round a mathematical function: a=func(x,y) and all that. The opening-brace ( begins the question: what’s x? what’s y? what do we do with them? – exciting, new, gosh, wow! And then we hit the closing-brace ) that ends the question: its kind of ‘nothing more to say’, really. We have the answer, the decision. Nothing more to do. Oh. Oh well. (Except that in much of maths, and in computing too, we have parentheses within parentheses within parentheses: q=some(func(x,y), also(y,z, andalso(b,c))) – quests within quests! Fun within more fun – hooray! )

So we do have two different kinds of ‘Why’ – and they go into different places in our architecture.

One kind of ‘Why’ – the question, the ‘(‘ – goes above the Zachman space, goes above the Enterprise Canvas, goes into Archimate as intention. Think of it as a row above everything, or a backplane, or something like that: whichever way we view it, it pervades everything.

The other kind of ‘Why’ – the ‘)’, the decision – goes into the Zachman space as just another column, goes into Archimate as extension. Each decision is specific, explicit: it literally cuts off other choices in that context. We can connect it to things, show how it affects other things, but it doesn’t pervade everything in the way that the question does.

In that sense, it does make sense to put them in different places. (And also – very important – not to forget the intention. Zachman ignores it, or loses it somehow in its strange sideways jump; Archimate all but abandons it, when it squeezes all of its Intentional Concepts into the literal meaninglessness of Passive Structure; and Business Model Canvas doesn’t even bother, but seemingly assumes that the only ‘Why’ that matters is ‘How do we make money?’ The ‘questing Why’ is literally emotive, the source of all motivation: if we don’t explicitly include it in our enterprise models, we’ve just shut out any reason for anyone to be engaged in our whatever-it-is. Perhaps not a wise mistake…?)

In another sense, though, it’s still the same ‘Why’. Just different faces – or phases – of the same quest. That’s where so much of the confusion comes, because often where we place it is more about how we choose to look at it than anything else. Looking ‘downward’, we see a stream of decisions: “because so-and-so… therefore… therefore… therefore…”. Looking upward, we see a stream of reasons: “because… because… because…” – ultimately ending up in the the unquestionable ‘Because!’ of the enterprise-vision or whatever. (I tend to place only that ultimate ‘Because!’ and its immediate implied-values as that uppermost layer of the enterprise-model; everything else ends up at various levels of that Extensional side-column of ‘Why’.) The Knowledge Genes structure also describes this Janus-faced relationship well, though in a different way: move leftward towards the question of Why, rightwards towards the decisions of How. The same ‘Why’, and yet different; a different ‘Why’, and yet the same.

Two kinds of ‘Why’.

That are also the same ‘Why’.

Now why is that, I wonder…?

The Archimate notation aims to be the standard to be used by everyone in enterprise-architecture and related fields. But what exactly is its anatomy – its underlying structure? And if it’s aimed at enterprise-architecture, what is it about that structure that makes it seem only to support IT-architecture, and in such an awkwardly IT-centric way?

(Apologies, folks, because, yes, this is going to be another one of those very long, very technical posts… Skip it if you’re not interested, of course, though I believe this actually is important for anyone involved in enterprise-architecture and the like.)

Read more…

What do enterprise-architects do?

At first glance it’s not an easy question. We talk a lot, with many different people, about lots of different things; but we don’t seem to do much. We tend to use a jawbreaking jargon, about narratives of knowledge, terminology, taxonomy, and things with a 2.0 in the name; we mumble about models and methods and mash-ups, or mutter about meta that might not matter to anyone else at all. We might do a drawing or two, but we probably don’t design much – domain-architects do that instead. And we don’t drive the enterprise, or the organisation – that’s the CEO’s job, and definitely not ours. So what value do we add to the enterprise? What do we do?

A nice answer came up this morning: we deal with the is-ness of business.

What is anything? Does it exist? How does it exist? Why does it exist? Do we want it to exist? In what ways does it exist in relation to others? And what is this ‘it’ anyway?

That’s sounds a bit like philosophy, doesn’t it? But what’s that got to do with anything? Business is not exactly famed for its focus on philosophy: it’s much more concerned with getting the job out of the door – and with good reason, too.

Yet making sense of things certainly does matter in business. Communication is a key concern here: to make sense of what’s going on, or what we want to happen, we need to agree on what things are, how we describe them, and how we describe the arrangement of their relationships with each other. (Otherwise known as the ontology, terminology and taxonomy of those things.) If we don’t get clear on that, we end up with separation between silos, or ‘wicked-problems’ such as the infamous ”business/IT-divide’. Worse, we end up with strategies that don’t make sense, to everyone, or to anyone.

So whilst it might sound like philosophy – and about as far from the real work as it’s possible to get – in reality these seemingly absurd abstractions are right at the root of everything. Making sense of sense-making, and all that. Without it, nothing is going to work – or work well, anyway. Especially in any large organisation.

That’s why there’s a real job, called ‘enterprise architect’, just to deal with all of that that ‘is-ness’.

And that’s what we do: the is-ness of business.

Just seemed a nice way to put it, anyway.

The past few posts in this series have focussed on moving ‘downward’ from the business-model, towards implementation, such as might be modelled in Archimate notation. That’s an aspect of the business-architecture / enterprise-architecture interface that makes immediate and practical sense to most people.

Yet to complete and verify the business-model and its proposed implementation, we also need to look upward into the extended-enterprise, and sideways into other aspects of the business-architecture space – otherwise the business-model could well fail in ‘unexpected’ ways. This post explores how to do that exploration, using the Enterprise Canvas frame as a checklist and guide.

(This is an adaptation of material that’s explained in more detail in my books The Service-Oriented Enterprise and Mapping the Enterprise, but there should be enough here to use straight away without needing to refer to either of those books.)

This’ll be another long one, so continue after the ‘Read more…’ break.

Read more…

Yes, I admit it: I’ve been kinda pouring out the posts lately. Sorry…

But why all this fuss about business-models and enterprise-architecture? What’s the point about the bottom-line not being the baseline to work from? If everyone’s selling something to someone, is there really any difference between a for-profit and a non-profit business-model? And who would want to go from Business Model Canvas to Archimate, anyway? Is anyone interested in any of this technical stuff?

I suppose it all comes down to this quote from Chris Potts:

The devil is in the detail, but the angel is in the architecture.

People like building business-models. It’s wonderfully abstract, and it’s fun – like playing with model-trains, where the passengers are only imaginary and the trains really can run on time. Unfortunately (or fortunately?) the real world is a bit different from that…

Real-world detail can break the best-looking business-model without even breaking out a sweat. We need to know that detail – or at least have a better sense of that detail – before committing ourselves and others to a lot of hard work and ultimate heartache.

Yet we also need to avoid drowning in the detail – otherwise we’ll never get started. Analysis-paralysis, and all that.

Which is where architecture comes into the picture. Formal discipline, yet without overt formality. Patterns help us break through the problems. We simplify, without being simplistic. And we model to reduce the muddle, to cut through the chaos and complexity of all that devilish detail.

Perhaps even more, it’s about the story: the story of each action, and the story of the enterprise itself. If we get clear on the story, the sensemaking becomes a lot simpler.

As I understand it, architecture comes down to a single idea: everything works better when they work together, in pursuit of purpose, a clear aim in mind. Everything connects with everything else. It’s the detail of how everything connects with everything else, of how we get everything to work with everything else, that I’ve been focussed on here.

A lot of detail, I know: but sometimes that is the nature of the beast. Fact is that architecture isn’t all nice pretty abstracts and nice pretty pictures – sometimes there is a lot of petty picky detail, and sometimes we just gotta face that fact… sorry…

Hope it’s been useful to someone, anyway?