Introduction to model-based development for the upcoming generation
The software YAKINDU Statechart Tools is primarily designed for software engineers who are developing systems based on state machines. For a good reason: design, simulation and verification of state machines can be combined in an excellent way.
There are also other aspects of this software that different applications might take advantage of, like you can read below.
Teaching children statechart-based modeling
In our case, this different application was teaching children – girls between 8 and 18 years old – the secrets of statechart-based modeling and software development.
Two of the biggest obstacles any soon-to-be programmer must face are
- adapting to the abstraction level of the development tool they are using and
- learning the elements thereof.
For example, if we take C programming into account, not only should developers understand their program on the level of the C source code itself, but they would also need to be comfortable using functions, control flow modifiers, pointers, etc. These requirements result in a learning curve that is too steep for most people.
Lowering the hurdles to the world of programming
In contrast to this, the graphical user interface provided by YAKINDU Statechart Tools (YAKINDU SCT) is not only easy to get used to, but also, through its modeling language, easier to understand for people who are not very comfortable with programming. The reason is that state-based modeling is very close to our everyday lives.
Our specific use-case was designing a memory/"Simon says" game, using an ATmega328P chip in YAKINDU SCT, for which the participants assembled the peripherals (LEDs, buttons) on a breadboard in the second half of the workshop.
The goal was to build a working, playable game in about two hours, which of course is not much, especially with complete beginners in electronics as well as in programming.
Easy access to statechart-based development through YAKINDU Statechart Tools
That is why we needed a modeling tool to realize the game, for which we created the necessary avr-c functions prior to the workshops so that the students did not need to bother with that part. Then we gave them a statechart that was missing necessary features to work: some transitions were missing, the triggers were not present and so on.
Through this example, we introduced the basic concepts of statechart-based modeling.
After having developed the correct statechart (mainly by following instructions, but also by experimenting on their own, like customizing the number of levels in the game), we could simulate the outcome in YAKINDU SCT’s Simulation panel, then generate all the necessary source code files to use in our final project.
Experiences with statecharts shaping future generations of software developers
After assembling the physical device itself, students had the possibility to play with their very own device they programmed – which we hope will be a meaningful moment to remember later, when they might be working or studying in a field that is somehow related to statechart-based modeling.
Time was really an issue during the workshops. Initially, we planned the workshop to fit in into 2 hours, then extended it to 2.5 hours. We hope to take part in a similar occasion in the future with more time to have at our disposal.
At such an event, the entire software development workflow might be introduced to students, complete with the design of more abstraction levels, such as defining use cases, writing down features, etc.
Finally, the workshop could arrive at the statechart-based realization of the software. As a result, the concept and importance of modeling, being an important ingredient in the software development workflow, will remain in the students' minds. Therefore the next generation of software engineers will have this opportunity at hand.