Video gallery

Feabhas has built a strong reputation for helping developers and engineers to improve their embedded software skills through face-to-face training courses.

Subscribe to our YouTube channel


you tube smaller.png

Watch our videos here

If you'd like to learn more about what we do or you want to brush up on your embedded software development knowledge, please watch these videos.

An introduction to Feabhas

A brief introduction to concepts in Modern C++

Templates are an extremely powerful - and terrifying - element of C++ programs. We say "terrifying" - not because templates are particularly hard to use (normally), or even particularly complex to write (normally) - but because when things go wrong the compiler's output is a tsunami of techno-word-salad that can overwhelm even the experienced programmer.

The problem with generic code is that it isn't completely generic. That is, generic code cannot be expected to work on every possible type we could substitute. The generic code typically places constraints on the substituted type, which may be in the form of type characteristics, type semantics or behaviours. Unfortunately, there is no way to find out what those constraints are until you fail to meet them; and that usually happens at instantiation time, far away from your code and deep inside someone else's hard-to-decipher library code.

The idea of Concepts has been around for many years; and arguably they trace their roots right back to the very earliest days of C++. Now in C++17 we are able to use and exploit their power in code.

Concepts allow us to express constraints on template types with the goals of making generic code easier to use, easier to debug and easier to write.

In this video, Glennan Carnie will look at the basics of Concepts, their syntax and usage. The aim is to get you started, not to make you an expert on Concepts or generic code.

Effective requirements; or why user stories and use cases are not enough

With the growth of UML during the late 1990's and early 2000's Use Cases became the most prominent approach for gathering and documenting requirements. Their simplicity enabled easy adoption for many projects. With the advent of Agile development, Use Cases have been largely replaced with the User Stories. Agile evangelists claim User Stories drive the product backlog and that it can be thought of as a replacement for the requirements document. In this video, Niall Cooling reviews the shortcomings of Use Cases and User Stories in the context of Requirements. He then addresses the need for understanding the hierarchical nature of requirements and intent specification. Finally, he clarifies where Use Cases and Users Stories fit into the gathering and documenting process.

Understanding the C runtime memory model

In this video, we look to take a deep-dive into understanding how a running C program uses the available memory, and how as programmers we can affect that model.  Niall Cooling discusses both compile-time and run-time memory, showing how the compiler and linker come into play. He covers both how and when memory is allocated, initialised, used and released. Importantly, he distinguishes between hosted programs (typically running on Linux) and freestanding (better known as deeply-embedded or bare-metal) programs, both with and without threading. Niall also differentiates the use of memory based on processor architectures. Finally, he looks at where memory issues arise and why most embedded C coding standards, such as MISRA-C, ban certain memory usage models.

An Introduction to Docker for Embedded Systems

Niall Cooling introduces Docker and how it can be used in an embedded development workflow.

Mutex vs Semaphores

In this 45 minute video, Niall Cooling of Feabhas explains

  • the history of the binary and counting semaphore and some of the associated problem areas
  • how a different RTOS construct, the mutex, may overcome some, if not all, of these weaknesses
  • mutual exclusion problems and how to address them for both circular deadlock and non-cooperation

Are You Anti-Agile?

In this video, presented by Glennan Carnie, we explore the fundamental nature of embedded software and why the ‘classic’ definitions of Agile may not be appropriate for many embedded systems.

Incorporating and integrating work from Michael Jackson, Eddie Obeng, Philip Armour and more, we present a coherent framework for assessing project risk, development methodologies and processes based on both customer problem domain and solution technologies.

Measuring Software Quality

“Quality” is one of those definition-free words that everyone thinks they understand and uses liberally to convince others that they are conscientious and rigorous when it comes to embedded software development.

However, without a true understanding of “quality” – that is, what it requires you to do, why you should do it, and the consequences of doing it – it remains a meaningless buzzword.

In this 30 minute video, Feabhas MD Niall Cooling, describes a quality framework, addresses the tools and techniques available to measure and enforces the different aspects of software quality.

Demystifying C++ Lambdas

Lambdas are one of the features of Modern C++ that seem to cause considerable consternation amongst many programmers.

In this 45 minute webinar, Feabhas Technical Consultant Glennan Carnie, will have a look at the syntax and underlying implementation of lambdas to try and put them into some sort of context.

How Agile compares to other embedded software development methodologies

In this recording of a live training session, Niall Cooling examines the embedded software development cycle using Agile, compared to other methodologies such as the waterfall, v-shaped or spiral models.

Agile and Acceptance Test Driven Development (ATDD)

In this recording of a live training session, Niall Cooling examines the Agile practice, Acceptance Test Driven Development (ATDD). He shares his thoughts on this and Agile techniques such as LEAN and KABAN when it comes to applying them to embedded.

Hitex Webinar Agile for Embedded

Guest presenter Niall Cooling, provides an overview on how modern Agile techniques are changing the way embedded software is being developed. First, we shall clarify the Agile landscape, covering both process based aspects, such as Scrum and various techniques, including Test Driven Development (TDD) and some of the underlying foundation principles, such as Continuous Integration (CI).