Training on agile project management, model driven design, and CodeBot driven implementation
Customized training to meet your needs
Summary
Parallel Agile blends the flexibility of agile with the discipline and precision of model driven design. Combine this with CodeBot's unique ability to generate database and user interface code from UML or SysML models. 
 
Our courses can be delivered remotely via Zoom or - when conditions permit - onsite at your facility.
 
We know that training isn't a one-size-fits-all endeavor.  Contact us and let's have a conversation about what you need and how we can help.
Courses Available

The modules listed in each of these courses can be mixed and matched to fit your requirements:

Introduction to Parallel Agile
  • Managing parallel development
  • Simplifying the Spiral Model
  • Domain Driven Design, and Design Driven Testing
  • CodeBot - generate a full-stack application from your domain model
  • CodeBot UX - generate fully functional web applications from wireframes integrated with your domain model and business rules
  • how to accelerate your project's schedule by deploying large teams working in parallel, with tactical use of CodeBot to move rapidly from a working proof-of-concept to production-ready software
Avoiding Common Scrum Antipatterns
  • Understanding the Agile mindset
  • Scrum as it should be: Exploring misconceptions about Scrum roles, events and artifacts... and how to approach each one properly
  • Scrum and Parallel Agile combined: PA with backlogs and a small team
Use Case Driven Object Modeling (ICONIX Process)
  • Requirements definition - domain modeling, use case modeling
  • Conceptual design - robustness analysis, preliminary design review
  • Design and coding - critical design review, getting from detailed design to code, code review and model update
  • Testing and requirements traceability (Design Driven Testing)
Intro to SysML: Modeling Software Intensive Systems
  • The Four Pillars of SysML - Requirements, Structure, Behavior, Parametrics
  • From system concept to requirements
  • Modeling the system block structure and system behavior
  • Defining constraints and parametrics
  • Simulating the model
  • Implementing and testing the modeled hardware and software

Who will benefit?
Developers, architects, development managers and technical executives
Prerequisites
Determination to accelerate your software projects without sacrificing quality
Sample Agenda for a 5 Day Workshop
Monday
Generate Database and API from Domain Model.
On the first day of class, you'll experience the power of the Parallel Agile CodeBot™ - a domain driven code generator that turns your Domain Model into an Executable Architecture. We'll spend a couple of hours brainstorming the domain model and then transform it into a working database (Mongo) with all database access functions code generated and wrapped in a Node JS API. API docs are automatically generated in Swagger as well as some client-side sample code in JavaScript, Java, Swift, and C#. And then it's almost lunchtime.

In the afternoon you'll identify User Stories, Epics, and Tasks and develop a visual model sprint plan using the Parallel Agile® Add-In for Enterprise Architect. You'll also develop a Use Case model. Then you'll allocate the development tasks to students and begin prototyping against the new API which can be hosted on AWS or on the cloud-server of your choice.
Tuesday
Prototype.
You'll come in Tuesday morning wondering whether that API that got generated yesterday really works, and energized when you start prototyping and discover that it does. When you prototype you're free to focus on sunny-day scenarios without the need for unit testing so you'll find that progress is rapid. Stakeholders can interact with your prototypes and feed you with more specific requirements.
Wednesday
Model Requirements and MVC Conceptual Designs.
On Wednesday morning you'll flesh out the functional requirements model of your system along with developing a detailed set of behavior requirements in the form of a detailed use case model with each use case defined in terms of its Models, Views, and Controllers. These behavior models will consider all of the rainy-day scenarios, corner cases, and edge cases that you got to skip when you were prototyping. All of this modeling work is done in parallel so you'll get a lot done in a day.

On Wednesday afternoon you'll update the domain model to reflect the feedback gained from the prototyping, and re-generate the database, API, and API docs.
Thursday
Detailed Design and Coding.
On Thursday you can do as much detailed design as needed using UML techniques like sequence diagrams and state machines, and when you're ready to start coding against the updated API. If you like to code unit tests, feel free to do that as well. Because the REST API is client-language neutral, you can develop in the languages of your choice.
Friday
Acceptance Testing.
If you were wondering why you modeled rainy-day scenarios on Wednesday and coded them on Thursday it's because on Friday you get to generate a set of acceptance test scripts that have been generated and give them to your QA department. You'll follow the Design Driven Testing process and use the ICONIX/Agile DDT add-in from Sparx Systems.
Ready to accelerate your project?
email us