Information

All trainings, as a series of blog entries, can be found at the link training.

The entire code, of course, can be found at github. All my projects are based on the GPL3 license.

If you really want some training, feel free to write to me. See the tab contact.

Completed training

List of completed trainings with links:

  •  

Paid training offer

For companies that want to improve the skills of their employees, I have prepared a special training offer. Training takes place only remotely because I need access to my computer and code. Trainings can be easily recorded. The price of the training is determined individually.

Here is a list of prepared training courses:

This is a complete training package including:

  • A thorough discussion of C language mechanisms (e.g. implicit type casting) and all useful keywords (e.g. const register, restrict)
  • Overview of useful language functionalities (FAM, Compund Literals, Generic, constexpr, auto)
  • An introduction to GNU C as the great dialect of the language used in the Linux Kernel
  • Overview of different programming styles and their discussion (MISRA, Linux Kernel)
  • Writing readable code: KISS and DRY principles
  • Writing code in an object-oriented style while maintaining the SOLID principle
  • Introducing encapsulation to C code (private structure fields)
  • Creating APIs according to the principle: zero abstraction cost (required in Embedded C)
  • Ways to test software written in C (also with mocks)
  • Overview of useful program verification tools (valgrind, fsanitizer, gcov)

The whole thing takes about 40 hours. Each point is discussed in detail using numerous examples. Most code that requires benchmarks has extensive test sets that show the impact of the mechanism on the speed of our code.

Due to such a broad scope of the training, I allow you to select any subset of the points that I will prepare. 

Unfortunately, this training requires basic (well, maybe a little more than basic) knowledge of the C language. If you have a lot of Juniors in your team, consider purchasing the Fundamentals of C training.

This training is dedicated to teams that have 90% stylistic comments during code review (e.g. remove spaces, change the name, add indents).

During the training, we will answer the following questions:

  • What does the hierarchy of code review elements look like?
  • How to approach the topic of code review?
  • Why does a Junior MUST participate in a code review?
  • How to write comments correctly during a code review?
  • Why should code review take a lot of time?
  • How to set up a good code review process?
The training lasts approximately 3 hours (one meeting).

This is a training fully devoted to testing code written in C. To fully understand this training, a very good knowledge of the C language is required. If your team does not have it, consider purchasing the Modern C or at least C Foundations training.

The training includes:

  • Introduction to software testing
  • Unit tests
  • Testing static functions
  • Mocking functions, including system ones
  • Inverted dependencies in our code
  • Discussion of the gcov tool for checking the coverage of our code with tests
The training lasts approximately 4 hours (one meeting).

The C99 standard is the most widely used C standard (also in Embedded). Therefore, knowing it is crucial. If you have always wondered what the compilation stages look like, how VLA works and why you cannot compare numbers with the sign (int) with those without the sign (unsigned), then this training is for you.

The training includes:

  • Preprocessor overview
  • Overview of compilation stages
  • Overview of all keywords
  • Overview of C language mechanisms (e.g. casting)
  • Introducing KISS principles and a clear code writing style
  • Standard library overview
  • Explaining the memory model and working with it (stack vs heap, padding)
The training lasts 8 hours (4 meetings).

 

I became a SCRUM Master during the pandemic, at a time when suddenly everyone started working from home instead of offices. It was a challenging period, as everyone knows. I was facing another professional challenge. As a new SCRUM Master, I had to re-establish the process. Of course, I didn't reinvent the wheel, but I implemented the SCRUM framework in such a way that we didn't feel at all that we were working from home. Just a few elements allowed us to achieve as much as 88% predictability in estimates and a consistent 12% increase in team productivity.

The whole process was jokingly named KScrum in the company, which means the implementation of the SCRUM framework by me (Kukos). I had the pleasure of introducing my methods in subsequent teams, and the results were always positive.

During the training, I will present my way of implementing SCRUM. I will also show you how to easily collect KPIs.

The training lasts approximately 3 hours (one meeting).

By name, the training resembles a course that everyone must complete during their IT or related studies. This is just a coincidence of names. Of course, the training will not focus on the theoretical superiority of quick sort over bubble sort, or on the method of finding a path in a graph. My training in 100% focuses on useful algorithms and data structures needed in the life of an Embedded C Developer.

The training includes:

  • Introduction to asymptotic notation and its application in practice
  • Code profiling tools overview
  • Search algorithms (linear and binary)
  • Sorting algorithms (insort, mergesort, quicksort, countsort)
  • Matrix multiplication algorithms
  • Vector vs list structure
  • BST vs. RBT structure
  • RBT vs. B+ structure
  • LSM vs. B+ structure
  • HashMap structure

The training lasts 10 hours (5 meetings). Each point contains a detailed theoretical and practical discussion (e.g. cache and pipeline) along with benchmarks.

If the offer interests you, please contact me. Contact.