Traditional Software Delivery

In an enterprise software delivery is traditionally undertaken by a software engineer / programmer / developer who will hand craft each program based upon:

• A design specification from an analyst

• Discussions with the designer

• Their own experience of the language or platform

• Their own understanding of the enterprise

• Interpretation and application of a code pattern and enterprise standards

And may iterate the output a number of times based on:

• Evolving requirements

• Quality issues identified through a technical QA process

• Defects or gaps identified by a test team or users

Once the engineer is finished an artefact they may start another of the same family, or potentially of a different family altogether.

Each time the engineer undertakes delivery of a new artefact they will improve their delivery a little from familiarity and from learning.

Inconsistencies within a code family arise because:

• Improvements by a software engineer typically won’t be retrofitted to previous examples of a pattern

• If two software engineers deliver different instances from the same family there will be limited fidelity between them.

So consistency is limited by the nature of this delivery approach and the engineers who specialise in it.

Enterprises will implement code patterns QA processes to various degrees to mitigate these risks, however pattern evolution and innovation is impeded because the expense of retrofitting innovation typically cannot be justified through either cost or priority.

‍

How does Enterprise Low Code differ?

Taking a Code Printing  approach with Enterprise Low Code means focussing on any code artefact as being a representative of a family.

The family is represented by a rigorous code pattern and a formalised design specification template.  For any member of the family the two are combined via a transformation algorithm to deliver a code artefact with 100% predictability and fidelity.

That means analysts can fill out the design template as a predictable process with only the information required specifically for the task. They can also be assisted by information merged in from other sources such as data structure definitions and API or micros service contracts rather than spending time on wordy descriptions of the requirements which may be misinterpreted.

Once a module is specified the analyst can immediately print and test the code artefact(s) arising from it without the handover and delivery delays associated with hand crafted delivery by a software engineer.

This approach encourages the best software engineers to place their whole focus on evolving and improving code patterns i.e. on hardening and innovating the code structure because:

• Software engineers have the bandwidth because are no longer involved in delivery of individual code artefacts

• Each improvement they make to a code pattern can be automatically applied to the whole family

And the delivery approach changes from:

• A few analysts bottle necked as they document, evolve and explain requirements to

• a number of software engineers who slowly iterate through the SDLC process and associated meetings and reviews

• with each set of requirements repetitively delivering different code that broadly addresses the same problem

• When a pattern change evolves for a module it results in inconsistencies and technical debt

Instead:

• Each analyst can rapidly specify, deliver and iterate their own code based on a best practice pattern

• There is no need for extended delivery timeframes and the possibility for different interpretations between analyst, engineer and test analyst

• Patterns are expected to evolve and improve so they can improve the whole family of code

This approach allows an IT organisation to always be working on what is important, on delivery and innovation, without constraint from a legacy code base.

It also facilitates speed, agility and flexibility in the enterprise.

See also: Why is In-House Low Code now feasible for an Enterprise?

‍

Transitioning Enterprise Delivery to Low Code

Follow these steps to transition pattern based delivery for an existing code pattern to Enterprise Low Code:

Step 1. Identify key delivery patterns, prioritised by total delivery effort (i.e. # modules* delivery effort per module)

Step 2. From sample specs and code define a Design Configuration Template and a Code Printing transformation Algorithm

Step 3. Specify structured configs for target modules using the Design Configuration Template, replacing place of unstructured design specs, and generate the code

‍

‍

Step 4. Identify test automation patterns and transition those also to printed code

‍

How do we get started with Enterprise Low Code for in-house patterns?

‍elfware is an IT automation company specialising in using Code Printing to accelerate delivery for enterprise clients in their own code patterns.

We leverage mojoh.io to rapidly print code artefacts consistent with client specific code patterns - a truly Enterprise Low Code platform.

We have headquarters in Sydney and clients across the globe.

If you’d like to learn more, visit www.elfware.com or contact us for:

• ‍Technical platform replacement
• Project rescue
• IT delivery acceleration