Whence, Angels?

As you’ve read over past couple of years, we’ve started investing in a hybrid Angel/VC model.  Lots of risk, lots of upside, and lots of fun new things to learn.  Applying Capability Driven Methods to management from the start has been both f…

Placing Architecture Properly into Scrum Processes

As I’m about to complete my share of a longer engagement on using Lean principles to improve the processes at an online services firm, it occurred to me that the efforts we undertook to properly embed Architecture practices into their Scrum process were novel.  I haven’t seen much written about how to do this in practice, and I imagine others may benefit from understanding the key connection points as well.  Hence this post.

First off, let me be clear: Agile software development practices are not at all averse to software architecture.  But let’s be clear about what I mean by software architecture.  In an agile team, most decisions are left to the team itself.  The team has a fairly short period of time to add a very narrow feature (described as a user story) to a working base of code and demonstrate that the story works.  The notion of taking a couple of months and detailing out a document full of diagrams that explains the architecture of the system: pretty silly. 

The value of software architecture is that key decisions are made about the core infrastructure of the system itself: where will generalizations lie?  Will a layered paradigm be used, and if so, what are the responsibilities of each layer?  What modules will exist in each layer and why will they be created? How will the responsibilities of the system be divided up among the layers and components?  How will the modules be deployed at scale?  How will information flow among the modules and between the system and those around it?

The way these questions are answered will indicate what the architecture of the system is.  There are many choices here, and the “correctness” of any choice is a balance between competing demands: simplicity, security, cost, flexibility, availability, reliability, usability, correctness, and many more.  (These are called “System Quality Attributes”).  Balancing between the system quality attributes takes thought and careful planning.

So when does this happen in an agile process?

Let’s consider the architect’s thinking process a little.  In fact, let’s break the software architecture process into layers, so that we can divide up the architectural responsibility a little.  You have three layers of software architectural accountabilities.  (Repeat: I’m talking about Software Architecture, not Enterprise Architecture.  Please don’t be confused.  Nothing in this post is specific to the practice of Enterprise Architecture).  All this is illustrated in the diagram below.  (Click on the diagram to get something a little more readable. 

image

At the top, you have the Aligning processes of software architecture.  These processes consider the higher levels of enterprise architecture (specifically the business and information architecture) to create To-Be Software Models of the entire (or relevant) software ecosystem.  If you’ve ever seen a wall chart illustrating two dozen or more software systems with connectors illustrating things like flow of data or dependencies, you’ve seen a model of the type I’m referring to.  Creating and updating these kinds of diagrams is a quarterly or semi-annual process and reflects the gradual changes in the strategy of the enterprise. 

In the middle, you have the Balancing processes of software architecture.  These processes consider the needs of a single system but only from the level of deciding why the software will be divided up into modules, layers, and components, how that division of responsibility will occur, and what the resulting system will look like when deployed in specific technologies in a specific environment.  All of this can be conveyed in a fairly short document that is rich in diagrams with a small amount of text explaining the choices.  This occurs once when a system is moving forward, and the software architecture can be developed alongside the first couple of sprints as input to the third and subsequent sprints.

At the bottom, you have the Realization processes of software architecture.  This is where the architecture becomes software, and this is where decisions are made about the choice of specific design patterns, the appropriate level of configurability vs. simplicity, and the ability to demonstrate whether the actual intent of the architecture occurs in practice.  In agile, this layer occurs within the team itself.  The software architect can offer advice about what patterns to use, but it is up to the team to realize that advice and/or decide not to implement it.  The team will very likely implement the software architecture as described, but may choose to improve upon it.

What does the process look like

There are many visualizations of scrum running around.  Some are described in books, others in papers or blog posts.  Most share some common elements.  There is a product backlog that, through the magic of sprint planning, the team extracts a subset for the sprint.  This becomes the sprint backlog.  The illustrations then tend to show the various rhythms of Sprint as cycles (sprint cycles and daily cycles), ending with a demonstration and retrospective.

In order to illustrate and train a team on all elements, including the business analysis elements, we chose to be a bit more explicit about the steps PRIOR to sprint planning, including the processes of creating and improving the stories prior to the start of a sprint.  (as above, click on the image to enlarge it).

image

Astute observers will notice that we added a step that we are calling “pre-sprint story review.”  This is a meeting that occurs one week prior to the start of a sprint.  It is called by the product owner and he or she invites “senior chickens” (architects, user experience leads, development and test leads, and any other “non-team” members that want a say in the sprint. 

In that week prior to sprint planning, those folks, working with the product owner, can improve the stories, add constraints, refine the description and acceptance criteria.  And here’s where the architects get to play.  Architects fulfilling the role of “Balancing” in the model above will have (or can create) an outline document describing the architecture of the software system, and can “link” that document to the SPECIFIC STORIES that are impacted by that design. 

(Note: assuming you are using a tool like Microsoft’s Team Foundation Server, that fully enables Scrum in multiple forms, this is a nearly trivial activity since a document can be easily linked to any story.  Enough advertising.)

So is an architect a chicken or a pig?  Answer: depends on what “layer” the architecture is at.  The top two layers are chickens.  The third layer, realization, is done by the team itself.  The person on the team may or may not have the title of “designer”.  (I’d prefer that they did not, but that’s just because I believe that ALL team members should be trained to fulfill that role.  In reality, the skill may not be wide spread among team members).  Therefore, the third layer is done by the pigs. 

I hope this provides some insight into how a team can embed software architecture into their scrum cycles.  As always, I’m interested in any feedback you may wish to share.

Data Management 3: Realization of Entities in applications

<p class=”p1″><span class=”s1″>This is the third blog post in the Data Management series. Last time we discussed the notion of subject areas and entities. This time we zoom in on the realization of these entities in applications.</span></p><p class=”p1″><span class=”s1″><img alt=”Content. Data Management part 3″ src=”http://www.bizzdesign.com/assets/BlogDocuments-2/20130611_BasvanGils/Data-Management-realization-of-entities-in-applications.png” style=”width: 501px; height: 334px;” title=”Data Management part 3: Realization of Entities in applications”/></span></p><p class=”p1″> </p><p class=”p1″><img alt=”Data Management. Coverage analysis” class=”left” src=”http://www.bizzdesign.com/assets/BlogDocuments-2/20130611_BasvanGils/Data-Management-Coverage-Analysis.jpg” style=”width: 150px; height: 114px; float: left;” title=”A “coverage analysis” will be the tricky part”/></p><p class=”p1″>One of the things we should be able to do is to create views that show which systems have data about a certain Entity. Similarly, we want to link our Entities to Processes. Going forward, we will use the term ‘Data Object’ to differentiate between the Entity in a business context and its data-counterpart.  The ‘Attributes’ of Entities (see also our previous post), are reflected as ‘fields’ in their Data Object counterparts.</p><p class=”p1″> </p><p class=”p1″> </p><p class=”p1″> </p><p class=”p1″><span style=”font-size: 11px; line-height: 19px;”>A “coverage analysis” will be the tricky part: suppose that we have a Subject Area called ‘Customer’. The key Entity in this Subject Area is also called Customer with Attributes such as name, social security number etcetera. Other Entities are such things as shipping address, E-mail address, etcetera.  There are two things we want to visualize for business stakeholders:</span></p><p class=”p1″> </p><ol class=”ol1″><li class=”li1″><span class=”s1″>Which information with respect to a customer is relevant from a process perspective? Only name? Only Social Security Number? Both?</span></li> <li class=”li1″><span class=”s1″>Which information about a customer is stored in a system? One system may store the E-mail address of a customer, whereas the physical address  may sit in another system</span></li></ol><p class=”p1″><span class=”s1″>We have call this a “coverage analysis” because: from a data governance perspective we want to make sure that all Entities in a Subject Area, as well as all Attributes of an Entity are represented somewhere in a System!</span></p><p class=”p1″><span class=”s1″>This type of modeling is quite ‘standard’ in ArchiMate. There are separate concepts for </span><strong><span class=”s2″>BusinessObjects </span></strong><span class=”s1″>and </span><strong><span class=”s2″>DataObjects</span></strong><span class=”s1″>. Also, there is a standard way of relating the two, using a </span><strong><span class=”s2″>RealizationRelation</span></strong><span class=”s1″>. </span></p><p class=”p1″><span class=”s1″>The fact that </span><strong><span class=”s2″>DataObjects</span></strong><span class=”s1″> have Fields is modeled using a </span><strong><span class=”s2″>CompositionRelation</span></strong><span class=”s1″> and more </span><strong><span class=”s2″>DataObjects</span></strong><span class=”s1″>. This is not a very ‘pretty’ solution. Especially when a data object has many fields, the visualization will quickly become cluttered. For example, 4 </span><strong><span class=”s2″>DataObjects</span></strong><span class=”s1″> with 3 Fields each ads up to at least 12 concepts and 12 relations which has a high visual complexity. Using graphical nesting will result in a much cleaner visualization.</span></p><p class=”p1″><span class=”s1″>The standard way of modeling the relation between a system (</span><strong><span class=”s2″>ApplicationComponent</span></strong><span class=”s1″>) and a </span><strong><span class=”s2″>DataObject</span></strong><span class=”s1″> uses the behavioral concept of an </span><strong><span class=”s2″>ApplicationFunction</span></strong><span class=”s1″>. The idea is that an </span><strong><span class=”s2″>ApplicationComponent</span></strong><span class=”s1″> has (internal) behavior to manipulate </span><strong><span class=”s2″>DataObjects</span></strong><span class=”s1″>. While it is correct, and often useful to model </span><strong><span class=”s2″>Application Functions</span></strong><span class=”s1″>, for most visualizations it is equally useful to hide them and use a short-cut notation as follows:</span></p><p class=”p1″><span class=”s1″><img alt=”A model of application functions” src=”http://www.bizzdesign.com/assets/BlogDocuments-2/20130611_BasvanGils/Data-Management-model-application-functions.png” style=”width: 599px; height: 262px;” title=”model Application Functions”/></span></p><p class=”p1″><span class=”s1″>With respect to the coverage-type analyses mentioned previously, this could be done and visualized in many different ways such as:</span></p><ul><li class=”li1″><span class=”s1″>Select a Subject Area or an Entity and list (color view) all Data Objects that are  associated with it</span></li> <li class=”li1″><span class=”s1″>Select a Subject Area or an Entity and show (color view) all Systems that manage a data object that is associated with this Subject Area or Entity. </span></li> <li class=”li1″><span class=”s1″>Select a Subject Area and highlight (color view) the entities that have an associated Data Object that is managed by some system</span></li> <li class=”li1″><span class=”s1″>Generate a CRUD-matrix that lists which Entities are accessed by which Process. Use the CRUD notation in the cells to show the nature of the access relation</span></li> <li class=”li1″><span class=”s1″>Select a Subject Area and create a CRUD-matrix as listed above</span></li> <li class=”li1″><span class=”s1″>Select a Subject Area and create a CRUD-matrix that shows which System manages (!) a Data Object that is a realization of an Entity that sits in that Subject Area. At the intersection of the columns and rows we should list the name of the Entity</span></li></ul><p class=”p1″><span class=”s1″>Modern tools such as BiZZdesign Architect make these analyses fairly straightforward and reusable. We mentioned techniques such as creating color views and generating tables. This functionality is available in our Enterprise Architecture tool BiZZdesign Architect, which can be downloaded here (30-day free, fully featured, trial license). If you would like a demonstration, please leave us a note!</span></p><p class=”p1″><span class=”s1″>As a final thought for this posting: note that this list has a mix of different types of visualizations, such as diagrams and matrices. This is partly because of communication preferences of key stakeholders, but also because some results are easier to interpret in different formats. </span></p><p class=”p1″><span class=”s1″>In the next posting we will dive into Data Governance with a strong focus on data stewardship (Data Stewards are generally considered to be the heroes of the field), so stay tuned!</span></p>

Categories Uncategorized

How to build a Roadmap – Gap Analysis

This post will discuss how to develop a robust gap analysis to identify any significant shortcomings between the current and desired end state. We use these findings to begin develop strategy alternatives (and related initiatives) to address what has been uncovered. The intent is to identify the difference (delta) from where we are to what we aspire to become. This exercise is critical to identify what needs to be accomplished.

NOTES – actors, agents and extras in the enterprise

If the enterprise is a story, who are the actors in that story? What are their drivers and needs? How do we model and manage the relationships between those actors in the story? (This is part of an overview and

Smart Agile Delivery

I was interested to read the recent McKinsey report on disruptive technologies. McKinsey identifies twelve potentially economically disruptive technologies including the Mobile Internet, Automation of Knowledge work, Internet of Things, Advanced Robotics, Next generation genomics and so on. The report also calls out general purpose technologies as ones that propel steep growth trajectories (think Steam or Internet) – that can be applied across economies and leveraged in many more specific disruptive technologies. Not surprisingly they don’t include software development in either list. The closest they come is with the automation of knowledge work, but this is restricted to artificial intelligence, machine learning and natural interfaces like voice recognition that automate many knowledge worker tasks that have long been regarded as impossible or impracticable for machines to perform.

Is this omission something we should be concerned about I wonder? While software development “practices” have been developing very rapidly with the adoption of Agile methods, it is a reasonable conclusion that software development “technologies ” are not undergoing dramatic changes that might qualify as disruptive. Yes there’s lots going on; in fact there’s a profusion of new languages, frameworks and databases, many open source initiatives, that are progressively specializing development technology. In addition there are significant advances in life cycle management and test technologies. But there isn’t any indication that these new technologies will have high economic impact in terms of dramatic improvement in productivity or quality. Or have a significant impact on the vast economic problem inherent in the worlds legacy systems. Rather there’s a huge proliferation of development diversity and some might say complexity.

Don’t get me wrong, I am not looking for a problem to solve. It’s clear that while smaller Agile projects are fine for tightly targeted problems, most organizations have struggled to scale Agile to larger projects and or enterprise class projects. The increase in dependencies and complexities become overwhelming and the probability of failure increases proportionately.

What’s needed, by larger projects is not process automation, but automation of the deliverable that allows the project to manage the dependencies at the model AND deliverable level. This raises the level of abstraction and can deliver dramatic productivity and quality improvements. As it happens there is a technology that can do this, but strangely it seems to be something that many people have already consigned to the trash heap of “been there done that”. I’m talking about Model Driven Development (MDD). There are many reasons why MDD has not succeeded in gaining widespread acceptance. It is actually extremely complex and requires considerable investment to establish. And in fairness it has been promoted primarily as a deliverable transformation and code generation tool. And many people will say, Oh NO!!! That’s just reinventing Case Tools all over again and we don’t want to go there.

But before we consign this technology to the trashcan of yesterday’s technologies, we need to take a hard look at what you can do if:
A. you have leaf node detail models in the asset repository that are tightly bound to execution deliverables.
B. you use best practice modern architecture with all functionality delivered as service bearing capabilities that minimize dependencies.
C. you can automate to a significant extent the population of the repository with harvested knowledge about legacy applications at that same leaf node level of detail.
D. you can run large scale, full life projects with full iteration of business, architecture, design and development models. (note here this doesn’t mean fully integrated and transformed models, we have gotten a lot cleverer over the years.)
In an Agile context this allows you to iterate functionality at extremely low cost, both in delivery and evolution life cycle stages. In fact experience shows it transforms the development project into an evolutionary approach in which you can really architect and build what you know and evolve to the optimal solution.

Model driven as a concept has been around a long time. Most developers (tell me they) don’t like model driven because it won’t handle complexities; because it diminishes developers’ jobs to be more mundane; that it produces poor code and so on and so forth. But the McKinsey report speaks to the inexorable progress of technology and the inevitability that as technology changes peoples jobs change or disappear. You are either on the train or under it.

Right now Agile MDD is probably only justifiable for the very large, complex projects. But as the case studies start showing higher success rates, with dramatic increases in productivity and quality, and the level of up-front investment is reduced as the capability is productized, we can expect to see the MDD project footprint to expand dramatically. Again the McKinsey report is incredibly bullish on the economic outlook for technology, and information technology in particular as the key general purpose enabling technology, and it’s clear that Agile processes alone are inadequate to support the ever increasing demand.

Being disciplined is for school kids; it’s time we got smart about how we deliver complex services and systems at scale.

McKinsey & Company: Disruptive technologies: Advances that will transform life, business, and the global economy. “Not every emerging technology will alter the business or social landscape—but some truly do have the potential to disrupt the status quo, alter the way people live and work, and rearrange value pools.”

Smart Agile Delivery

I was interested to read the recent McKinsey report on disruptive technologies. McKinsey identifies twelve potentially economically disruptive technologies including the Mobile Internet, Automation of Knowledge work, Internet of Things, Advanced Robotics, Next generation genomics and so on. The report also calls out general purpose technologies as ones that propel steep growth trajectories (think Steam or Internet) – that can be applied across economies and leveraged in many more specific disruptive technologies. Not surprisingly they don’t include software development in either list. The closest they come is with the automation of knowledge work, but this is restricted to artificial intelligence, machine learning and natural interfaces like voice recognition that automate many knowledge worker tasks that have long been regarded as impossible or impracticable for machines to perform.

Is this omission something we should be concerned about I wonder? While software development “practices” have been developing very rapidly with the adoption of Agile methods, it is a reasonable conclusion that software development “technologies ” are not undergoing dramatic changes that might qualify as disruptive. Yes there’s lots going on; in fact there’s a profusion of new languages, frameworks and databases, many open source initiatives, that are progressively specializing development technology. In addition there are significant advances in life cycle management and test technologies. But there isn’t any indication that these new technologies will have high economic impact in terms of dramatic improvement in productivity or quality. Or have a significant impact on the vast economic problem inherent in the worlds legacy systems. Rather there’s a huge proliferation of development diversity and some might say complexity.

Don’t get me wrong, I am not looking for a problem to solve. It’s clear that while smaller Agile projects are fine for tightly targeted problems, most organizations have struggled to scale Agile to larger projects and or enterprise class projects. The increase in dependencies and complexities become overwhelming and the probability of failure increases proportionately.

What’s needed, by larger projects is not process automation, but automation of the deliverable that allows the project to manage the dependencies at the model AND deliverable level. This raises the level of abstraction and can deliver dramatic productivity and quality improvements. As it happens there is a technology that can do this, but strangely it seems to be something that many people have already consigned to the trash heap of “been there done that”. I’m talking about Model Driven Development (MDD). There are many reasons why MDD has not succeeded in gaining widespread acceptance. It is actually extremely complex and requires considerable investment to establish. And in fairness it has been promoted primarily as a deliverable transformation and code generation tool. And many people will say, Oh NO!!! That’s just reinventing Case Tools all over again and we don’t want to go there.

But before we consign this technology to the trashcan of yesterday’s technologies, we need to take a hard look at what you can do if:
A. you have leaf node detail models in the asset repository that are tightly bound to execution deliverables.
B. you use best practice modern architecture with all functionality delivered as service bearing capabilities that minimize dependencies.
C. you can automate to a significant extent the population of the repository with harvested knowledge about legacy applications at that same leaf node level of detail.
D. you can run large scale, full life projects with full iteration of business, architecture, design and development models. (note here this doesn’t mean fully integrated and transformed models, we have gotten a lot cleverer over the years.)
In an Agile context this allows you to iterate functionality at extremely low cost, both in delivery and evolution life cycle stages. In fact experience shows it transforms the development project into an evolutionary approach in which you can really architect and build what you know and evolve to the optimal solution.

Model driven as a concept has been around a long time. Most developers (tell me they) don’t like model driven because it won’t handle complexities; because it diminishes developers’ jobs to be more mundane; that it produces poor code and so on and so forth. But the McKinsey report speaks to the inexorable progress of technology and the inevitability that as technology changes peoples jobs change or disappear. You are either on the train or under it.

Right now Agile MDD is probably only justifiable for the very large, complex projects. But as the case studies start showing higher success rates, with dramatic increases in productivity and quality, and the level of up-front investment is reduced as the capability is productized, we can expect to see the MDD project footprint to expand dramatically. Again the McKinsey report is incredibly bullish on the economic outlook for technology, and information technology in particular as the key general purpose enabling technology, and it’s clear that Agile processes alone are inadequate to support the ever increasing demand.

Being disciplined is for school kids; it’s time we got smart about how we deliver complex services and systems at scale.

McKinsey & Company: Disruptive technologies: Advances that will transform life, business, and the global economy. “Not every emerging technology will alter the business or social landscape—but some truly do have the potential to disrupt the status quo, alter the way people live and work, and rearrange value pools.”

An Integrated Electronic Health Record Needs Enterprise Architecture for Communicating Separation of Concerns

Achieving true progress in creating integrated AND interoperable electronic healthcare management and information systems is very much a real-world, current-day Enterprise Architecture (EA) challenge – and it starts with “separating the business and technical concerns” using standardized EA methods, vocabularies and reusable assets. The manner in which the challenges are communicated, in particular, would benefit all stakeholders and acquisition managers. 

An Integrated Electronic Health Record Needs Enterprise Architecture for Communicating …

A lot of activity and progress is underway around the world right now, and has been for some time, regarding integrating and sharing health data for healthcare management and delivery purposes. Many standards, reference models and authorities have arisen to guide implementation and use of IT for these purposes, for example health information exchange standards driven by the Office of the National Coordinator for Health Information Technology (ONC – http://www.healthit.gov/).  Many very new and modern health IT capabilities and products are available now, alongside systems and data that may have been first created over 30 years ago (particularly in the Federal Government).

In the media and within procurement activity, the swirl of misused phrases and definitions isn’t clarifying many approaches.  Records vs. Data vs. Information. Interoperability vs. Integration. Standards vs. Policies. Systems vs. Software vs. Products or Solutions. COTS vs. Services vs. Modules vs. Applications. Open Source vs. Open Standards. Modern vs. Legacy vs. Current.

In Enterprise Architecture (EA) terms, the messages regarding Integrated Healthcare IT requirements aren’t commonly being presented at a consistent level of abstraction, according to a consistent architecture model and vocabulary. As well, the audience or consumers of this information aren’t being addressed in ways most impactful to their specific needs and concerns.

What are the audience concerns?  IT system owners need to maintain data security and system performance, within technology and investment constraints. Doctors need consistent, instant, reliable and comprehensive visualization of data and the point of care. Government oversight bodies need recurring validation that money is spent wisely and results meet both mission and legislative requirements. Veterans, soldiers and their families need absolutely private, accurate, real-time information about their healthcare status – wherever they are. The pharmaceutical and medical device industries need timely, useful data regarding outcomes and utilization – to drive product improvement and cost-effectiveness. Hospitals, clinics and transport services need utilization and clinical workflow measurements to manage personnel and equipment resources.

The highest separation of concerns can be segmented by standard Enterprise Architecture domains or “views”.  A very generic, traditional model is the “BAIT” model – i.e. Business, Application, Information and Technology. Note that this is very similar to the widely-known “ISO Reference Model for Open Distributed Processing” (RM-ODP) Viewpoints – which underpin evolving healthcare standards including the “HL7 Services Aware Interoperability Framework” (SAIF).

The “Business Domain” encompasses the discussion about business processes, financials, resources and logistics, organization and roles.  Who does what, under what circumstances or authority, and how outcomes are evaluated and purchased.  The business drivers and enablers of successful healthcare delivery, one might say.  

The “Application Domain” concerns automating the “practice of healthcare”. Automated systems (and their user interfaces) are very helpful in planning, monitoring and managing the workflow, resources and facility environments, and of course processing data for clinical care, surveillance and health data management and reporting purposes. This is where healthcare expertise is codified in software and device configurations, where medical intelligence and knowledge meets computer-enabled automation. This domain is the chief concern of clinical practitioners and patients – where they can most helpfully provide requirements and evaluate results.  Software that’s built to process healthcare data comes in many shapes and sizes, can be owned or rented, are proprietary or completely transparent.

The “Information Domain” is in essence the “fuel” for the Application Domain.  Healthcare practitioners and patients care that this fuel is reliable, protected and of the highest quality – but aren’t too invested in how this is achieved, beyond required or trained procedures.  It’s like filling the car with gas – there’s some choice and control, but fundamentally a lot of trust that the gas will do the job.  For those whose concern is actually delivering gas – from undersea oil deposits all the way to the pump – this domain is an industry unto itself. Likewise, collecting, repurposing, sharing, analyzing information about patient and provider healthcare status is a required platform on which successful healthcare user applications and interfaces are built. This is what “Chief Medical Information Officers” are concerned with, as are “Medical Informatics Professionals”. They are also concerned with the difference between healthcare “records”, “archives” and “information” – but that’s a discussion for another day.

It is critical to note that “Information” is composed of data; core or “raw” data is packaged, assembled, standardized, illustrated, modeled and summarized as information more easily consumed and understood by users. Pictures, sound bites and brief notes taken by an officer at an accident scene are data (as are “Big Data” signals from public social media and traffic sensors); the information packages include the accident report, the newspaper article, the insurance claim and the emergency room evaluation.  These days, with the proliferation of data-generating devices and sensors, along with the rapid data replication and distribution channels available over the Internet, the “Data Domain” itself can be a nearly independent concern of some – providing the raw fuel to the information fire, oil for refined gas.

The “Technology Domain” is essentially all of the electronic computing and data storage elements needed to manage data and resulting information, operate software and deliver the software results to user interfaces (like browsers, video screens, medical devices).  Things like servers, mobile phones, physical sensors, telecommunications networks, storage repositories – this includes the machine-specific software embedded into medical equipment.

Sidebar: Data Domain Standards

Quite a bit of work and investment is required to collect, filter, store, protect and make available raw data across the clinical care lifecycle, in order that the right kind of information is then available to be utilized by users or software. Most importantly, reusable, open standards and Reference Implementation Models (RIMs) concerned with the Data Management domain are foundation requirements for any effective healthcare information system that participates in the global healthcare ecosystem.

A RIM is basically working software or implementation patterns for testing and confirming compliance with standards, thereby promoting creation of software products that incorporate and maintain the standards.  It’s a reusable, implementable, working set of code with documentation – focused on a common concern, decoupled from implementation policies or constraints. RIMs are useful for facilitating standards adoption across collaborative software development communities at every layer of the Enterprise Architecture.

For example, a data-domain RIM developed several years ago by Oracle Health Sciences (in a clinical research setting) focused on maintaining role-based access security requirements when two existing sets of research and patient care data were merged for querying.  The design of the single RIM merged the HL7 Clinical Research Model (BRIDG) with an HL7 EHR Model (Care Record) to support a working proof-of-concept – that others could adopt as relevant.  The “concern” here was data security – separate from the information and application-level concerns of enabling multi-repository information visualization methods for researchers.

The point of this discussion on EA-driven separation of concerns is illustrated as follows. When a spokesman (or RFP author) says “the system will be interoperable” – it’s likely that by “system” the meaning is some segment of the “Application Domain” being able to exchange objects from the “Information Domain”.  Instead, a better phrase might be “the software application will be able to share standardized healthcare information with other applications”. This keeps the principle discussion at the application and information-sharing software level, and doesn’t make detailed assumptions or predictions regarding concerns in the Business, Data or Technology Domains.  Those are different, but related discussions, and may already be addressed by reusable, standard offerings, RIMs or acquisition strategies.   

Taking this approach to broadly interpret the recent announcement that the DoD will seek a competitive procurement for “Healthcare Management Software Modernization” – it appears the focus of this need is the Application Domain – i.e. software packages and/or services that generate and use healthcare information while managing healthcare processes and interactions.

To support these new software application features, separate but related activity is required to address “modernization” concerns among the other EA domains – concerns relating to datacenter infrastructure, data management and security services, end-user devices and interfaces, etc.  Some of this activity may not be dedicated to healthcare management, but be shared and supported for enterprise use, for other missions. That’s why use of a current, relevant EA frameworks (such as DODAF v2.02 and the OMB “Common Approach” ) is so important, managing shared capabilities and investments.   

Using standard EA viewpoints to separate concerns will also expose reuse opportunities (and possibly consolidate or reduce acquisition needs), i.e. leveraging existing  investments that are practical enablers. Some examples might include the developing iEHR health record structured message translation and sharing services, plus HHS/ONC initiatives including Health Information Exchange Networks and the “VA Blue Button” personal health record service.   

Social BPM and Smart Process Apps Are Improving Productivity for All Process Participants

OT: OpenText recently contributed a chapter “How Social Technologies Enhance the BPM Experience for all Participants” to the book “Social BPM: Work, Planning and Collaboration Under the Impact of Social Technology”. What prompted OpenText to write about Social BPM?

DW: We are excited about exploring the technology and usage models found in social applications and the results that can be achieved by mapping them to the unique characteristics, diverse participants and emerging opportunities in Business Process Management (BPM).

Related posts:

  1. We’re talking Smart Process Apps — and so is Forrester. “Smart Process Apps are a reflection of innovations we have…
  2. OpenText Smart Process Applications: At the Intersection of Social Street and Core Systems Ave Last week, I helped kick off OpenText’s EIM Days in…
  3. OpenText Smart Process Applications: The Importance of Process On-Ramps and Off-Ramps Have you ever used your fingernail to turn a screw…

Related posts brought to you by Yet Another Related Posts Plugin.