Warning: SAM is still in a early development phase. Please refer to the roadmap to see what is actually available and what remains to be implemented. If you are willing to support and accelerate its development feel free to contact me.
This web site is still not public, you should even not have been able to crawl to there!
SAM is a tool to describe and generate actor based code in C for realtime safety critical multicore systems.
SAM makes hard problems easier.
SAM removes the burden of annoying structures and makes low level code easier to write, read and maintain.
SAM brings a software religion based on actors to the world of embedded critical software. Imperative or object oriented paradigms are no longer the only religions.
SAM aims at simplicity and safety in a world that tends to be ruled by complexity.
SAM is a way to write and cleanly separate high level software architecture and low level implementation, without loosing traceability between both levels. It provides:
easy and full segregation of pieces of code that may run asynchronously on different threads or cores (think “asynchronous components” for conceptual simplicity and sequence “synchronously these components” for execution efficiency and predictability)
safe lockless communication data structures between actors
actor like API implementation
With SAM, building complex softwares is just a construction game. A high level DSL describes actors and combines them into asynchronous components while remaining fully portable and platform independent. Manual code is limited to the low level implementation of single threaded algorithms and target dependant sequencers calling the generated components.
SAM provides several mechanisms to generate safe code:
type safety in specifications and implementations (strong typing)
generic types in specifications and strong statically defined types in the implementations
The high level DSL is scriptable in 
.
LuaX based on Lua, a standard and well-known scripting language, augmented with a bunch of useful libraries. LuaX is easy to learn and easily extensible.
The code generator produces clean safe portable C sources.
As a joke (or maybe not) SAM could be considered as an implementation of a strong static duck typing system… Duck typing in the high level DSL and static strong typing in the low level generated C code.
SAM comes with a set of products and services:
C is widely used in embedded softwares but is not made for safety because of many flaws:
void *
is bad, casts and unions are dangerous tooSAM brings a higher level of abstraction above C
