SST demonstrates that you only need a few lines of code and a little discipline to bring the structural advantages of a preemptive, prioritized scheduler to almost any environment. While SST’s oddities may be unsettling at first, its scheduling policy can easily be exploited to greatly reduce the amount of explicit synchronization needed in the typical reactive program. On balance, SST demands more design effort and real-time design skill than other schedulers, but rewards that investment with cleanly structured programs that can run in the most limited environments.

While SST is different, it isn’t that different. The insight you gain through mastering task communication and synchronization in SST will all transport to other concurrent environments. Regardless of the concurrency model, different rate threads need to be decoupled by queues, separate S/R chains should be separated, locked critical sections introduce jitter, and tasks must be synchronized. At the implementation level, every RTOS or scheduler deals with these issues almost exactly as you do in SST at the application level. In my opinion, knowing what’s “under the hood” is always a good thing.