Displaying items by tag: domain modeling
Model Based Software Engineering: How fast can we go?
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?
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:
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.
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).
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.
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.
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).
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.
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.
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.
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..
CodeBot UX is available to early access users
FOR IMMEDIATE RELEASE: November 23, 2020
Urvashi Prakash Parallel Agile
This email address is being protected from spambots. You need JavaScript enabled to view it.
No Code App Generator, CodeBot UX is available to early access users
November, 2020, Los Angeles, CA: Parallel Agile’s full-stack application generator, CodeBot UX, is now available to early access users. With CodeBot you can already generate full-stack applications from a domain model, while its newly engineered UX components allow users a smoother and far more nuanced and centralized approach towards app generation.
Codebot UX supports Enterprise Architect UML models including class diagrams, state machines and wireframes. From these, CodeBot generates a database schema, API documentation, server-side code, client-side code including domain classes, CRUD functions and usage examples. While supporting both SQL and non-SQL databases, CodeBot also generates all three layers of the MVC framework.
CodeBot can also automatically host your generated web application in the cloud, at the click of a button.
According to Matt Stephens, Director of Development for Parallel Agile: "Our ability to link screens to an auto-generated database access API and to drive UI navigation from state machines effectively makes MBSE models executable, fulfilling a vision originally set out in 2002 when Steve Mellor wrote Executable UML".
With this early access release, the following React UI components are ready for users to try out: Panel, Button, Label, Text field, Table and Video Player.
CodeBot UX initially targets React, but will soon build equivalent user interfaces for React Native, Vue.js and Angular. Video illustrating CodeBot UX (MBSE: CodeBot for Software Intensive Systems) is available on YouTube.
Doug Rosenberg, Parallel Agile CTO, states: "CodeBot UX’s ability to generate working screens from wireframes to full stack code generation and automatically host the working application, introduces a new model-driven development paradigm where CodeBot effectively serves as a UML compiler, producing running applications directly from UML or SysML models."
More about the company:
Parallel Agile addresses the underlying technical issues with integrating work done by large teams in addition to the management issues – specifically enabling large teams of developers to collaborate efficiently and reduce schedule time on projects. The company offers training in UML, SysML, MBSE, and Agile development in addition to its full-stack application generator, CodeBot.
Early Access Program
Parallel Agile’s early access program allows CodeBot licensees to gain access to a growing range of new features and capabilities. New CodeBot customers can request early access when they purchase their license.
CodeBot UX is available immediately for early access users.
For more information on CodeBot, please visit www.parallelagile.com or email us at: This email address is being protected from spambots. You need JavaScript enabled to view it.
###
How To Go From Domain Model to Fully Deployed Microservice in 60 Seconds with Parallel Agile CodeBot™
APG Sparx Enterprise Architect Systems Engineering Course
APG is offering their Sparx Systems Engineering Course via web-based delivery on January 29th. Course will have live instructor with maximum of 8 students. Email This email address is being protected from spambots. You need JavaScript enabled to view it. for details and pricing.
Topics Covered:
· Build Domain Model |
· Model System Design |
· EA workspace configuration |
· Parts and values |
· Domains and blocks |
· Value types, units, and dimensions |
· Diagrams and elements |
· SysML block definition diagrams |
· Relationships and properties |
· Model Constraints |
· Capture System Requirements |
· Constraint blocks and binding connectors |
· Importing requirements from documents |
· Parametric simulation |
· SysML requirements diagrams |
· SysML parametric diagrams |
· Traceability matrices |
· Model System Interaction |
· Searching and navigating model |
· Ports, interfaces, and signals |
· Build Use Case Model |
· Flow properties and flow items |
· Use cases, actors, and packages |
· SysML internal block diagrams |
· Use case interactions and fragments |
· Model System Behavior |
· SysML use case and sequence diagrams |
· Activities, flows, synchronization bars |
· Model System State |
· Partitions, pins, decisions, guards |
· States, transitions, events |
· SysML activity diagrams |
· Guards, actions, activities |
· Allocations |
· SysML state machine diagrams |
Business Process Modeling with Structured Scenarios
This article (which actually represents the third incarnation of the ICONIX Business Modeling Roadmap), leverages two new capabilities from Sparx Systems, now available in Enterprise Architect. These are the Structured Scenario Editor and the Business Rule Composer. The article describes how these two quantum leaps in technology combine synergistically to enable a new process by combining business process modeling with behavioral code generation for business rules.