The goal of our research in languages is to help synthesize tasks whose timing characteristics are consistent with their specifications. To this end, we have developed a real-time programming language with high-level timing constructs, which allows the programmer to embed real-time requirements within a program. Our programming language is called TCEL (Time Constrained Event Language), and its semantics characterizes timing relationships between the observable events in a program [TCEL94]. Compiler transformations are then used to ensure that the code's execution time is consistent with its requirements. We have implemented a prototype TCEL compiler, which is a modified version of the Gnu C compiler. The compiler's front-end recognizes TCEL's timing constructs embedded within a C module, and passes them through as new RTL instructions. The next pass partitions the generated RTL module into task units; this is done by traversing the control-flow graph, and finding the nodes containing ``observable'' instructions: input-output operations, entry guards, etc. If an application overloads is CPU resources, we carry out transformations on the generated tasks. Within a single task we use a variation of trace scheduling to shrink the time overloaded time frames [PLDI93]. But if the entire, multi-tasking application is overloaded, we use program-slicing to produce sub-threads specialized for critical IO [RTSS93]. The objective here is to ensure that these threads are as lightweight as possible, and less susceptible to timing errors. On the other hand, unobservable instructions are postponed to run in less constrained frames.