70% theory + 30% practice
SW testing fundamentals
Testing throughout the life cycle
Test design techniques
Tool support for testing
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
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.
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.
Software Engineering, Requirements Engineering and Testing
Software Engineering 5 days
Day 1: Project Management
Project versus line management and maintenance and support
Project definition and project forms
Management – general rules and project management
What is special for IT projects?
Basic project process
Iterative, incremental, waterfall, agile and lean project process
Project documentation and other artefacts
Soft factors and peopleware
PRINCE 2, PMBOK, PMI, IPMA and other project standards
Day 2: Business Analysis and Requirements Engineering Fundamentals
Defining business goals
Business analysis, business process management, business process improvement
The boundary between business and system analysis
System stakeholders, system users, system context and system boudaries
Why are requirements necessary?
What us requirements engineering
The boundary between requirements engineering and architectural design
Where is requirements engineering often hidden?
Requirements engineering in iterative, lean, and agile development and in continuous integration – FDD, DDD, BDD, TDD
Basic requirements engineering process, roles and artefacts
Standards and certifications: BABOK, ISO/IEEE 29148, IREB, BCS, IIBA
Day 3: Architecture and Development Fundamentals
Programming languages – structural and object-oriented paradigms
Object-oriented development – how much is history, how much is the future
Modularity, portability, maintainability and scalability of architectures
Definition and type of software architectures
Enterprise architecture and system architecture
Programming mistakes and how to avoid and prevent them
Modelling architecture and components
SOA, Web Services and micro-services
Automatic build and continuous integration
How much architecture design is there on a project?
Extreme programming, TDD and re-factoring
Day 4: Quality Assurance and Testing Fundamentals
Product quality: what is it? ISO 25010, FURPS etc.
Product quality, user experience, Kano Model, customer experience management and integral quality
User-centred design, personas and other ways to make quality individual
Quality Assurance and Quality Control
Risk strategies in quality control
The components of quality assurance: requirements, process control, configuration and change management, verification, validation, testing, static testing and static analysis
Risk-based quality assurance
Boehm’s curve in quality assurance and in testing
The four testing schools – which suits your need?
Day 5: Process Types, Maturity and Process Improvement
The evolution of IT process: from Alan Turing through Big Blue to lean startup
Process and process-oriented organization
The history of processes in crafts and industries
Process modelling: UML, BPMN and more
Process management, process optimization, process re-engineering and process management systems
Innovative process approaches: Deming, Juran, TPS, Kaizen
Is (process) quality free? (Philip Crosby)
The need and history of maturity improvement: CMMI, SPICE and other maturity scales
Special types of maturity: TMM, TPI (for testing), Requirements Engineering Maturity (Gorschek)
Process maturity versus product maturity: any correlation? any causal relationship?
Process maturity versus business success: any correlation? any causal relationship?
A forsaken lesson: Automated Defect Prevention and The Next Leap in Productivity
Attempts: TQM, SixSigma, agile retrospectives, process frameworks
Requirements Engineering - 2 days
Day 1: Requirements Elicitation, Negotiation, Consolidation and Management
Finding requirements: what, when and by whom
Defining system context – defining requirements sources
Elicitation methods and techniques
Prototyping, personas, and requirements elicitation through testing (exploratory and otherwise)
Marketing and requirements elicitation – MDRA (“Market-Driven Requirements Engineering”)
Prioritising requirements: MoSCoW, Karl Wiegers and other techniques (including agile MMF)
Refining requirements – agile “specification by example”
Requirements negotiation: types of conflicts, conflict-solving methods
Solving internal incongruence between some types of requirements (e.g. security versus ease of use)
Requirements traceability – why and how
Requirements status changes
Requirements CCM, versioning and baselines
Product view and project view on requirements
Product management and requirements management in projects
Day 2: Requirements Analysis, Modelling, Specification, Verification and Validation
Analysis is the thinking and re-thinking you do between elicitation and specification
Requirements process is always iterative, even in sequential projects
Describing requirements in natural language: risks and benefits
Requirements modelling: benefits and costs
The rules for using natural language for requirements specification
Defining and managing requirements glossary
UML, BPMN and other formal and semi-formal modelling notations for requirements
Using document and sentence templates for requirements description
Verification of requirements – goals, levels and methods
Validation – with prototyping, reviews and inspections, and testing
Requirements validation and system validation
Testing - 2 days
Day 1: Test Design, Test Execution and Exploratory Testing
Test design: after risk-based testing, choosing the optimum way to use the time and resources available
Test design “from infinity to here” – exhaustive testing is not possible
Test cases and test scenarios
Test design on various test levels (from unit to system test level)
Test design for static and for dynamic testing
Business-oriented and technique-oriented test design (“black-box” and “white-box”)
Attempting to break the system (“negative testing”) and supporting the developers (acceptance testing)
Test design to achieve test coverage – various test coverage measures
Experience-based test design
Designing test cases from requirements and system models
Test design heuristics and exploratory testing
When to design test cases? – traditional and exploratory approach
Describing test cases – how much detail?
Test execution – psychological aspects
Test execution – logging and reporting
Designing tests for “non-functional” testing
Automatic test design and MBT (Model-Based Testing)
Day 2: Test Organization, Management and Automation
Test levels (or phases)
Who does the testing, and when? – various solutions
Test environments: cost, administration, access, responsibility
Simulators, emulators and virtual test environment
Testing in agile scrum
Test team organization and role
Test automation – what can be automated?
Test execution automation – approaches and tools
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
REQB Foundation - przygotowanie do egzaminu
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
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
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