Enterprise Architect version 15.2

download
purchase

enzh-CNcsnlfrdehiiditkoplptruskessv

My Profile

Social Media Channels

facebook  twitter  youtube   linkedin

Monday, 11 January 2021 17:45

Model Based Software Engineering: How fast can we go?

Written by
Rate this item
(0 votes)

The need for speed

With the recent passing of General Chuck Yeager as well as the beginning of 2021, I thought it might be a good time to reflect on the never ending quest for speed. General Yeager, of course, was the man who broke the sound barrier in his Bell X-1 aircraft on October 14, 1947.

It’s always worthwhile trying to do things faster and better — that’s what drives progress and innovation. In the software industry we’re talking about a less death-defying problem than the airspeed pioneers faced, but an important one nonetheless: how fast we can develop software?

 

1 Chuck Yeager X 1 color

Chuck Yeager and the Bell X-1 that broke the sound barrier, Glamorous Glennis

Our primary mission at Parallel Agile is to help companies accelerate the development of high-quality systems — so projects are both faster and cheaper, without sacrificing quality. (Yes, it really can be done!). Maybe in a few years we’ll look back at today’s software engineering techniques with similar nostalgia as we’d look at 1940s subsonic aircraft design.

What makes software slow?

Let’s start by looking at what’s holding a typical software project back from getting itself done quickly:

 

2 speed limiters

Many factors can slow down your project — here are a few chronic causes of software getting done slowly

So, what makes software slow? First of all, the common perception that it’s not possible to develop with bigger teams because of communication overhead. Second, typical agile development processes tend to favor feedback over planning, resulting in under-planned systems that spend lots of time on retrospectives and refactoring. Additional factors relate to a general state-of-the-practice of most code being written by hand — often driven by a general mistrust of generated code. Everything from fundamental database access functions to basic UI functionality is most often still coded by hand. Add in modern requirements for data privacy and database security (things that often don’t fit well into 2 week sprints) and you’ve got lots of time spent writing code the hard way — labor-intensive development. Finally, with CI/CD we’ve got deployment pipelines that get executed on a continuous basis.

How do you go supersonic with your dev process?

So, what’s the right stuff that can help you accelerate your software project? Parallel Agile as a development process, and CodeBot as its primary enabler, offer a different vision for software engineering where the speed limiters shown above are systematically removed. You can remove some of the speed limiters and go faster than before, but it’s really removing the whole set of forced-slowdown practices that yields the most dramatic results.

3 removing speed limits

If your project is being slowed down by anything on the list above, we can help.

Project development is organized by scenario In the first place, from a process perspective, with Parallel Agile you organize your project with a developer responsible for each scenario (hence the “Parallel” part of PA).

 

4 one developer per scenario

It’s simple: assign a developer to each scenario (scale as needed)

You don’t have to work in small teams (although you still can if you prefer to). Communication overhead is reduced by virtue of a shared (executable) domain model among developers. Rather than time slicing development into 2 week sprints (with time on each end for planning and retrospectives), you can allow each use case to evolve along a simplified spiral model starting with proof of concept, moving on to minimum viable product (MVP) and then through as many optimization cycles as needed.

5 spiral

Each scenario (aka use case) evolves asynchronously along it’s own spiral model

How CodeBot shatters the team-size barrier

Back when General Yeager was pioneering flight faster than the speed of sound, it was a dangerous activity because aircraft tended to shake apart due to excessive vibration at Mach 1. But advances in aerodynamics eventually overcame the sound barrier.

What’s the analogy to large team software development? Consider the case where several use case scenarios make use of the same domain object. If you assign a different developer to each scenario, each of those developers needs a common understanding of the data structure (JSON) that comprises that domain object. If you allow each scenario to evolve independently you’ve got a communication and coordination problem to deal with. Having the domain model documented on a UML diagram helps, but it isn’t enough.

We discovered the solution to this problem during the early years of our research into parallel development — to be specific, between 2014 and 2016. During that time we were experimenting with an early version of CodeBot that generated a database access API (and API documentation) from a domain model. We discovered that our developers were able to collaborate easily, even when some were working on mobile apps and others working on web apps. Our first test project involved 47 graduate students working in parallel, on a location-based advertising system (LBA).

We also found that most of the evolution of domain class schema happened during Proof of Concept, and that using a NoSQL database allowed multiple developers to evolve the schema independently. Later, we added switchable schema validation to CodeBot, allowing more free-wheeling changes during prototyping but then providing the ability to lock things down as we moved forward into MVP. We also made updated API docs immediately available online. This ability to rapidly generate a new API along with updated API documentation as changes happen in the shared domain model allows projects to be staffed elastically — your team can be “right-sized” to the problem at hand rather than constrained by pre-imposed limits. This lets you go a lot faster.

6 executable domain model 1

CodeBot turns your domain model into a working database, accessible by a REST API, in moments

Inside the use cases: Getting WIRED

We’ve found that it makes sense to organize the project along use case boundaries, with larger teams of developers each working their own use case, interfacing to a shared domain-driven database API (or event-based model, etc). But what happens inside the use cases? Do we need to do a lot of formal use case modeling? Not necessarily…

We think the fastest way to proceed within each use case is to wireframe up the screens that participate in the use case, connect the wireframes to the executable domain model, and then code generate the screens. Think of this as Wireframe-driven, Iterative, Rapid, Enterprise-ready Development (WIRED).

7 wireframe MVC

You might recognize a Model-View-Controller pattern in CodeBot’s generated UI code

We use the CodeBot full-stack application generator to do this code generation for us. In fact, CodeBot is optimized towards PA’s highly iterative process. In short, you can use CodeBot to generate working user interface code (e.g. React JS) from wireframes, where the UI navigation or user flow is driven from a UML state machine, and the screens connect to the database using the API. It all happens automatically, and it happens very quickly with CodeBot UX.

 

8 wireframe to map

CodeBot UX is the fastest way to get from an EA wireframe to a running web application

 

Being Enterprise-ready means Security is baked in

To be Enterprise-ready in 2021, you need to deal with requirements for data privacy.  This means avoiding threats from hackers, making your applications fully security-aware, and implementing best practices for secure development. From an app development standpoint, dealing with security concerns slows you down, and complicates hiring and staffing your project as not all developers are expert at security-related issues.

9 access control

CodeBot-generated APIs come with an Access Control Layer that helps prevent unauthorized access

Over the last year we’ve spent massive amounts of effort building security infrastructure into CodeBot. Capabilities like server-side registration and login automatically generated as part of the API, fully-tokenized (JWT) access, and Role Based Access Control (RBAC) are built-in to the database access API as an access control layer when the model is code generated. The resulting time and cost savings all accrue to your benefit. And if you consider the cost of getting your database hacked…it’s a pretty easy decision to make.

Rapid Iterations come with auto-deployment

To fully realize the promise of agile, feedback-driven development, you need to iterate the project’s use cases quickly to gain immediate feedback from clients. CodeBot enables this capability through automatic deployment of both the UI and the back-end database/API.

10 deployment

With CodeBot UX you go from a UML model to a running (and hosted) web app in under 5 minutes

At present, CodeBot can generate and deploy a securely hosted full-stack web application from a UML model in approximately 4 minutes. This capability makes it quick and easy for each use case to evolve through its spiral model and to quickly test in the context of a deployed system.

So, how fast do you want to go?

Are you content with the pace of small-team, short-sprint agile development, or would you like to deploy a larger team on a more complex problem and get the project done more quickly? Are you happy with the pace of writing database access code by hand, and wrapping the common database functions in a REST API, by hand? Is it quick and easy to turn a set of wireframes into fully-functional user interface code, where the screens are automatically linked to the database? Are you happy with the pace of adding Security to your applications? And finally, does it take you longer than 4-minutes to build and deploy a fully-working application? If you’d like to get your projects done faster and less expensively, but without sacrificing quality… contact us at This email address is being protected from spambots. You need JavaScript enabled to view it..

Read 757 times Last modified on Wednesday, 13 January 2021 23:26
doug rosenberg

doug rosenberg

Parallel Agile, Inc. (Founder, Chief Technology Officer) - formerly ICONIX (CEO)
After running ICONIX for 35 years and writing 7 books on UML, use cases, and agile software development, Doug discovered a new way to improve productivity by leveragng parallel development, and founded Parallel Agile (www.parallelagile.com) in 2018 after 4 years of test projects at the USC Center for Software and Systems Engineering, where he's been working with Prof. Barry Boehm.   A new book "Parallel Agile - Faster Delivery, Fewer Defects, Lower Cost" is mostly written and will be released during 2019.   We're also developing a Parallel Agile Add-In for Enterprise Architect and are available for training and consulting.  
In his previous lifetime...
 
Doug Rosenberg founded ICONIX in his living room in 1984 and began training companies in object-oriented analysis and design around 1990. ICONIX specializes in JumpStart training for UML and SysML, and offers both onsite and open-enrollment courses.
Doug developed a Unified Booch/Rumbaugh/Jacobson approach to modeling in 1993, several years before the advent of UML, and began writing books around 1995. Design Driven Testing is his 6th book on software engineering. He’s also authored numerous multimedia tutorials (including Enterprise Architect for Power Users) and several eBooks, including Embedded Systems Development with SysML.
Doug has spent the last few years doing "deep dive" consulting into cutting-edge technology including cross-platform mobile app development, REST APIs, and NoSQL databases, and gaining first-hand experience on some "hardcore agile" projects of varying sizes.  He's also been working with dozens of graduate students at the University of Southern California Center for Systems and Software Engineering (USC CSSE), managing Directed Research projects and developing/piloting the Parallel Agile process.

www.parallelagile.com
Login to post comments