From RTSC Central

[offline version]

RTSC Module Primer

Producing and Consuming Spec'd Modules

This Primer puts RTSC modules front-and-center. Initially focusing on how you (playing the role of "client") would consume RTSC modules within C programs, we'll eventually explain how you (playing the role of "supplier") could just as easily produce C-based modules of your own—consumed in turn by others as part of a larger RTSC application.

Along the way, the Primer will introduce two special-purpose languages which (working hand-in-hand with standard C) forge a symbiotic alliance of programming capabilities that RTSC names eXpanDed  C:

• XDCspec serves as RTSC's specification language—used here to define a module's programmatic boundary (what others term its API) as a formal contract between client and supplier; and

• XDCscript serves as RTSC's meta-language—used here by suppliers and clients alike to streamline host-based production/consumption of spec'd modules targeted for a range of execution platforms.

Acknowledging general industry trends towards employing flexible, re-usable software components—but also recognizing the challenges of achieving these ideals with C alone—the eXpanDed  C model exemplified throughout the Primer effectively takes the ever-familiar C programming language to entirely new heights.

As an overarching objective, RTSC promises a higher-level form of C programming—one suitable for developing, delivering, and deploying real-time software components—but without sacrificing overall system performance through additional runtime overhead.

Who's the audience

Needless to say, we assume you know C. But we also assume you're a software practitioner quite comfortable with the overall flow of building and running C programs—especially on embedded hardware platforms. At the end of the day, RTSC starts with concepts and processes already familiar to C programmers—and then takes these to an entirely new level.

We don't, however, expect you've had any prior experience (or even exposure) to object-oriented programming using languages such as C++ or Java; and we certainly don't presume any knowledge of software components from an academic perspective. By the same token, those of you with some general background in modern software design techniques should find many of the premises underlying RTSC modules familiar, natural, and almost obvious.

But as we already said, RTSC starts and ends with C. For embedded C programmers who often ask "what's next" as applications grow ever larger and more complex—and who harbor concerns about the steep learning curve and potential performance pitfalls of moving (say) to C++—RTSC may fill a necessary void for you.

What we'll cover

We've structured the Primer as a series of lessons that successively build upon one another, constantly reiterating and reinforcing concepts and idioms fundamental to producing and consuming RTSC modules.

Except for the first and last lesson, the remaining lessons each center around a small self-contained example that illustrates common programming idioms used when either producing or consuming any RTSC module. Lessons 1-4 initially focus on the client perspective of a module, illustrating general programming patterns for using arbitrary RTSC modules within a standard C program; we'll also examine a generalized build-flow for such programs that you can easily instantiate with existing tools such as make.

As a bridge to the supplier's perspective of RTSC modules, Lesson 5 first introduces select aspects of the all-important RTSC package—essential for building as well as delivering modules to the client. Lessons 6-9 then proceed to specify and implement a graduated series of modules—some already used from the client's perspective in earlier lessons.

How to proceed

Iteratively.... This Primer actually packs quite a bit of (new) information inside each successive lesson, warranting several passes through the material. Start by simply navigating from one lesson to the next, picking up what you can by quickly skimming the content. And even when you circle back for a more thorough reading of each lesson, don't feel compelled to run any of the programming examples at that time—you can always operate in "read-only" mode and still learn quite a bit about RTSC modules.

You might also find it helpful to break the Primer in half, first tackling the material in Lessons 1-4 on the client's view of RTSC modules before advancing to the supplier's perspective in Lessons 5-9. Having said that, we do not recommend skipping the latter half of the Primer:  producing a flexible yet efficient RTSC module is simply too important—and too easy—for you not to master.

Though we have made the examples available as a separate download, you can generally just "copy-and-paste" source code fragments directly off the page:

#include <stdio.h>
 
int main()
{
    printf("Hello World\n");
    return 0;
}

Throughout the lessons, we'll refer to individual lines in these examples using symbols like 1 or 2. Besides matching the corresponding labels tagging the example code, these symbols serve as live links that will return you to the original example should it have already scrolled off the screen.

  FYI.... We'll occasionally interject some additional commentary on the material at hand in this format, usually providing deeper insights into a particular aspect of RTSC. In some cases, these inline comments provide a glimpse into the larger world of RTSC programming for which this Primer will prepare you.

And finally, you'll find virtually no links to other RTSC documentation until the final Lesson; we just want you to stay focused on the material at hand before jumping off elsewhere. At the same time, if you are looking for an overview of RTSC from 10,000 feet—something to read before hitting the ground—the Rhetorical RTSC white-paper found here should satisfy you. Otherwise, if you're a C programmer ready to read some code, proceed onward.

[offline version]