Since 2003, I have been conducting corporate training programs on various subjects like Qt, OpenGL, VTK, GCF. At one point I was even teaching Linux Kernel and Device Driver Programming, thanks to my employment at Linux Learning Centre.
Over the past 13 years, I have been able to observe certain meta-data about the training that I personally offer and also the training that I have attended as a participant.
World over, technology training (more specifically training on programming languages, APIs and frameworks) has been following a certain pedagogical style. I don’t claim that every single training offering in the world is following only this style, but by-and-large one can notice this template everywhere.
Trainers often prepare slides that explain ideas, concepts, design elements & API. At the end of each logical bunch of slides, they showcase an example program that demonstrates the application of such ideas, concepts, design elements & API. The participants are then handed over a partially written code on which they have to apply their learning in order to solve a problem.
This model works great! I have been using it in a lot of training programs myself. For instance, in the recently concluded training program on OpenGL @ Havelsan, Ankara; I had put together slides that explain various concepts & techniques in OpenGL. Each logical bunch had an example program & programming challenge. I have used similar models for Qt training even, for example with Mindtree.
This model of training is perfect if the trainer doesn’t already know (or cannot know) the audience profile, the kind of applications they care about and the challenges they are facing at their work for which they are sourcing the training. If the trainer does have access to this knowledge, then this model of training falls short of fulfilling expectations.
Since 2011, I have been conducting training programs @ Cadence, Noida.
A little bit of history: Back in 2007, I was working as a consultant for Taray Technologies, Hyderabad. I worked with Ravi Vedula‘s team to help them make use of Qt 4.4 for creating a GUI for an FPGA editor called 7Circuits. For that era (perhaps even now) the GUI was simply off-the-charts. It showcased features and had the looks that most EDA tools couldn’t even dream of. I concluded my work with Taray by 2008, but the team continued working on the FSP product and made it stronger. In March 2010, Cadence acquired Taray & 7Circuits became Allegro FSP. Ravi introduced me to Vikas Kohli, Sr. Architect at Cadence sometime in April/May 2011. Vikas was excited about using Qt for a lot of other products within Cadence and thats how my association with Cadence began.
Initially I started working with them on 1-2 day consulting visits where I would basically help them with code-samples on how to solve specific set of problems that Vikas’s team was facing while using Qt. Later-on Vikas introduced me to other teams in Cadence. Over the last 5 years I have conducted 7-8 training programs on Qt, each of which had 15 participants.
Experiential Training – A brand new approach
Each training program at Cadence had its own combination of course contents & intention. So I did not have the luxury of using a common set of slides for all training.
Last year, when I was called to conduct a 4 day training program for Vikas’s team @ Cadence once again, I decided to take a brand new approach to training. Over email, I had conversation with Vikas and his team to understand why they want the training. Specifically, I wanted to know
- What challenges they are facing with respect to usage of Qt within their applications
- What are their expectations from the training itself?
- A brief description of the applications they are building, so that I could compose resonating examples and programming challenges.
As I started to put together all of the data I received as answers to the above, I figured that the team wants to get trained on
- Qt’s Object Model: Deep dive into signals / slots, the meta-object system & events sub-system
- Model/View Framework
- QtQuick & Mixing QML UIs with Widget UIs
Now, instead of “assembling” slides for the above topics – I decided to do something radical. I came up with a plan and proposed it to Vikas. He loved it and wanted to experiment with the new approach.
What I came up with was this: teach all of the above concepts in the backdrop of a project called “Google Drive Client App”. The idea is to have participants in the training program focus on building a desktop-client for Google Drive, using which they could browse/upload/download/update/share content on their drive. While the app is not something that they would ever (?) want to develop within Cadence, it does bring to surface many challenges that they would face while working on their projects.
With this approach, the participants are no longer focussing on understanding the API OR remembering concepts. They are focussed on building a fully functional app, while making use of mentoring support available from the trainer to get past challenges that they will face.
As a part of this application, the participants learned about
- Using the Network module in Qt (specifically QNetworkAccessManager and friends) for issuing calls to Google APIs.
- They would learn how to structure an application that deals asynchronous function calls
- They would learn how to send and receive large byte-arrays (while uploading and downloading files)
- Using QJson* classes for composing and parsing JSON documents
- Putting together a custom Jobs or Tasks framework for handling background jobs
- Such has fetch user info job, download folder structure job, upload a file job and so on
- Model / View framework in Qt
- How to dynamically build tree models to reflect folder structure of a user’s Google Drive
- Building sorting and filtering capability
- Using delegates in QAbstractItemView subclasses for customising item appearance and interaction
- Building models for usage in QML
- How to store persistent settings using QSettings
- Building UI using QtWidgets & QML & mixing them both in a single application
- Running jobs in threads
While participants actually learn all of the concepts & API, they do so in the backdrop of a project that is distinct from their daily work. There are several benefits to this
- When a developer works on a single project for a long time, he/she develops perceptual constraints that hinders new learning. A change of project can sometimes be very useful.
- Building a fully functioning app, gives a sense of purpose in the training. It makes the training more fun & worthwhile.
- Since all the programming challenges are attempted in teams of 2 or 3, the training reflects a “real” working environment for the participants.
- Not only have the participants learned the concepts & API, they have also learned how to use them in a “real app”.
Results & Feedback
Before going to the program, I created a group on KitApp PreSocial Messenger and shared QR code of the group with all the participants. Participants scanned the QR code and hopped on to the group. From Day #1, all of us were in a single chat group (without having shared any private social ids like phone number) and were able interact with each other. At the end of each day I would send a feedback form to the participants asking them how their experience of the training was. Here is what they had to say
Looking into the future
I think there is value in offering this kind of experiential training. Participants stand to complete the training having “experienced Qt” rather than just “hearing about OR knowing about Qt”.
While this model of training clearly has advantages, some customers may not prefer it for reasons like
- They cannot share any information about the kind of applications their developers are building
- They cannot wait for 1.5 months to source the training. (Because I typically take 45 days to put together a unique project & slide-deck for every customer depending on the kind of work they do)
- They are unwilling to pay the premium price that I ask for such customized training.
However, I am noticing that increasingly customers are willing to wait the time and pay the fees for such training; because they clearly see a value.
Training using Open-Source projects
There are so many open-source projects that use one or more of the frameworks and technologies I teach. For example, I could pick one or more projects in KDE and teach Qt concepts in the backdrop of those projects and have the participants fix bugs & submit patches to KDE applications.
Training using customer projects
Wouldn’t it be cool if we could train participants by having them directly work on their projects as they learn concepts and API in the training?
Of-course each of the above plausibilities present their own set of complications. But, I think its worth a try.