Software Engineering starts where programming stops. In this course you will learn a solid foundation in Software Engineering. It builds a bridge from programming to solid engineering practices. The course gives you an overview of basic concepts and vocabulary typically used in the field. During the course, you will learn to use many techniques to plan, implement and validate software projects and to evaluate and improve development processes.
This course is intended for software developers with various backgrounds who know at least one programming language.
Day 1: Process
What is Systems Engineering?
What is Software Engineering?
Why is Software Engineering difficult?
Software Engineering Processes
What is a Software Development Process?
Processes for building High-Integrity Systems
Standards & certification systems
What are High-Integrity Systems?
The role of QM culture
Reasons for errors
Critical systems standard
Day 2: Planning
Elicitation/analysis of user requirements
Specification of software
Tools to manage requirements
Textual modeling tools
Principles of OO design
Planning an architecture
UML graphical representations
Non-UML graphical representations
Day 3: Code
How to take a design into code
Programming best practices
Abstraction of code
What is Configuration Management?
Configuration Management in ISO9000 and CMMI
CASE tools for planning, design & QA
CASE tools for writing software
Version control with SVN
Code for High-Integrity Systems
Reducing the impact of errors
Typical problems with code for High-Integrity Systems
Code quality metrics
Code size metrics
Code complexity metrics
Day 4: Verification & Validation
Fundamentals of VV
Independent Verification & Validation
Design and requirement reviews
Other V & V methods
Testing High-Integrity Systems
Documents regarding safety
Argumentation for safety
Reviews of High-Integrity Systems
Costs of V + V
Automatic vs manual tests
Types of tests
Day 5: Management
What is Project Management?
Standards (PMP, PRINCE2)
The function of process evaluation
Acting on the metric
Process evaluation standards & frameworks (CMMI, ISO 9001, TickIt+)
Process evaluation meetings
Summary and Conclusions
Efficient Requirement Management using Agile Methods and Agile UML Modeling
This training course aims at helping product managers, products owners, business analysts, system architects and developers understand how to efficiently Manage Requirements on the basis of the product vision till guiding developers accurately in implementing them.
More in detail, this course aims at assisting product managers in better defining the value propositions of their products on the basis of strategies and stakeholder needs. Business Analysts and product owners understand how to describe requirements of the product backlog then discover appropriate epics and user stories of the system while contributing to the required value creation. Along interactive case study exercises, participants learn how to describe in detail such requirements in order to validate correct understanding of needs and prepare system acceptance tests. Thus, only using a very common and productive UML profile, they learn to structure requirements in order to communicate efficiently with architects and developers through an iterative requirement gathering process.
Anyone interetsted in the Requirements Management Process
What is the Requirement Management Process ? Why Agile ?
Business agility and agile software delivery : Definitions
Linking Agile to Business : Business Motivation Model vs. Business Model Canvas,
How to effciently use the Value Proposition Canvas for defining the Product Vision ?
Business agility vs. agile software delivery principles
What is Agile Not ? Impacts of alignment with strategies and capabilities
Requirement Management in an Agile Context
Scrum Life Cycle : Issues about completeness of requirements and traceability
How productive models enhance communication in 'Agile' ?
Business Extensions of Agile : Structuring Business Value Contribution of a User Story
A Panorama of UML diagrams for modeling requirements
Frameworks for tracing requirements toward software implementation and tests
The 5 levels planning of an agile project (from Clarifying the Vision and Product Backlog to Tasks… and the Architecture Walking Skeleton)
Managing Requirements within Agile Methods (Scrum, DAD) vs. the Unified Process (RUP)
Roles, teams, environments
Presentation of the Case Study for Structuring requirements and managing them using an iterative process
How to describe the business vision and needs via traceable models ?
Qualification of the requirements : The Kano model vs. the Value Proposition Canvas
Structuring the Vision of the Product on the basis of strategies, environmental forces and trends
Value proposition, key activities, key resources, revenue streams and cost structures,
Discovering the business scope of the product using the customer needs, gains and pains
Describing business use cases using 'value streams' and 'value stages'
Bridging the business scope of the product with expected 'value contributions'
Case Study : Describing the vision of the product
How to describe user needs via agile use case modeling (epics and user stories) ?
Agile Estimating and Planning
Building and managing the product backlog / granularity of requirements
Ahead of the sprint planning
Creation of the sprint backlog
Agile User Story Pattern : system scope (the subject), actors, use cases, user stories, acceptance criteria, the INVEST model
The Walking Skeleton using Disciplined Agile Delivery : From Processes to Technology
How to find out epics and user stories on the basis of value streams ?
Value contribution of epics and user stories
Writing tasks : granularity and size using the SMART model
Case Study : Discovering epics and user stories on the basis of value streams
Validating and testing correct understanding of detailed specifications
Using an incremental requirement gathering process and the sprint backlog
Rules for efficient epic, user story and architecture descriptions
Diagrams for validating epics and user story descriptions
How to choose the right diagram ?
Refining features using use cases and relationships modeling
Testing correct understanding of requirements using Test-Driven Requirements
Given/When/Then structures and Operation Contracts for guiding developers in implementing requirements
Coverage analysis and change management
Case Study : Validating, testing and communicating detailed requirements to developers
Steps of efficient requirement gathering and system analysis processes
Traceability between requirements and analysis models
Patterns for gathering and testing requirements
Notice: The above training-mentoring sessions are conducted interactively using examples from Requirement Engineering and Modeling tools in order to ensure good level of traceability between requirements and underlying solutions. Concepts are first explained using basic examples and are then followed by solution drafts to your potential case. After this session, we can also accompany you by reviewing and validating your solutions depending on your needs.
System Engineering using SysML and UML 2
Helping Analysts and Designers of the System Engineering domain to understand how to efficiently gather requirements then go through the embedded software design implementation on the basis of system specifications using UML 2 and SysML.
This 3 days training aims at assisting system analysts to express efficiently their needs and designers to make the appropriate architectural design of the system on the basis of these needs.
The resulting system architecture provides a good level of agility to the embedded system software in face of changes as it allows a coherent traceability of the business rules encapsulated in system functions and those of the usage choices (use cases) of the end-users toward the software implementation level.
The System Development Life Cycle with the Harmony Process (IBM/Telelogic)
Overview of the UML/SysML diagrams used in requirements gathering, system analysis and design of the System Engineering domain
A Method based Framework for requirement gathering, system analysis and design
Gathering Requirements and Transforming them into System Specifications
Making business and system requirements traceable using the SysML requirement diagram
Define the scope of the system composed of functions and use cases that invoke these functions
Model the Life Cycle of the System that orchestrates transitions between its states where functions are triggered
Prepare test cases using scenarios that realize Use Cases and System Functions
Case Study : Model the System Scope and the usage of the system functions on the basis of requirements
Transforming System Specifications into Design Level Components
Model the Block Diagram of the system and refine it using internal blocks
Elaborate the Communication Architecture between Sub-System using Parts, Ports and Interfaces
Case Study : Elaborate the block and Internal Block diagrams on the basis of system specifications and by considering design level choices
Model the description of white box Interactions at the design level
Case Study : Model interactions between blocks and Internal Blocks on the basis of design level choices
Mapping of Operations on the Components (Parts) of Blocks
Elaborate the Parametric Diagram of the System Functions
Case Study : Update the Block and Internal Block Diagrams on the basis of design level scenarios
Steps of requirement analysis and system specifications in system engineering
Traceability between requirements and the software
System Integration and Acceptance Tests of the requirements
Notice: The above training-mentoring sessions are conducted interactively using Requirement Engineering and Modeling tools like Enterprise Architect (EA) in order to ensure good level of traceability between requirements and underlying solutions. Concepts are explained first using basic examples and are then followed by solution drafts to your own problems. After this session, we can accompany you by reviewing and validating your solutions depending on your needs.
Embedded C Application Design Principles for Automotive Professionals
A two day course covering all design principles with code examples coupled with recent industurial technology; very useful for automotive software developers
What is design?
Design tools overview
Defining design goals
Software Engineering Challenges
Docker with Swarm
Docker is an open-source platform that automates the building, shipping and running of software applications inside containers.
Swarm is a tool that controls a cluster of Docker hosts and exposes them as a single "virtual" host. By pooling together numerous Docker engines, Swarm allows IT operations teams to transparently scale up their software deployment to many hosts.
IT managers and operations teams
Format of the course
After introducing basic software containerization concepts, we discuss how Docker hosts can be deployed across multiple machines using Swarm. Participants carry out live exercises on their workstations to put into practice the concepts learned. By the end of the course, students will be able to deploy Docker with Swarm in a real-life environment.
What is Docker?
Docker & Linux Kernel Technologies
Why containers over [x,y,z]?
Creating a Swarm
Configuring a Swarm
Deploying & Updating Services on Swarm
Docker Swarm for System Administrators
Service Discovery & Load Balancing
Docker Swarm Schedulers
Running Cronjobs on Swarm
Keeping your Swarm Secure
Preparing your Infrastructure for Swarm
Keeping it all secure
Preparing your Application for Swarm
12-Factor Applications: Build Once, Deploy Anywhere
Continuous Delivery to Swarm
Introduction to OMRON PLC programming
This course introduces the student to the basics of Programmable Logic Controllers (PLC). After the discussion of the fundamental concept of PLCs the basic Ladder Diagram instructions are learned and practiced in Industrial Automation tasks.
- Electrical Specialists
- Mechanical Engineers
- Programmers with interest in Industrial Automation1. Introduction
- Fundamental concept of PLCs
- Application fields
- Different PLC types
2. Programming OMRON PLCs in Lader Diagram (LAD)
- The programming software
- Hardware setup
- Memory areas
- Basic bitlogic LAD instructions
- Latch circuit
- Controlling pneumatic cylinders with PLC
- Individual exercises
70% theory + 30% practice
SW testing fundamentals
Testing throughout the life cycle
Test design techniques
Tool support for testing
Continuous integration with Jenkins
Software developers involved in agile development
Format of the course
This course covers the concepts, tools and techniques needed to carry out continuous integration of your software projects in an Agile environment. Participants carry out a series of hands-on exercises throughout the course to apply their knowledge in real situations. Interaction among instructor and participants is encouraged. Real-world cases are discussed and specific issues and questions are addressed and resolved in class.
The course is as follows...
Introduction to Jenkins
Why continuous integration?
Distributing builds accross different systems.
Setting up Jenkins
Installing Jenkins plugins
Building with Jenkins
Testing with Jenkins
Deploying with Jenkins
Automating with Jenkins
Reporting in Jenkins