What have we learnt about C?

• a good general purpose programming language (providing the necessary features to define and store data, perform calculations, and provide control-flow to sequence our programs), and

• an excellent systems programming language (providing well-defined and well-documented interfaces to system-level APIs for system-calls and support functions).

• well designed,
• clearly written and (hence) easy to read,
• well documented,
• use high level programming practices,
• written with portability in mind, and
• are well tested.

• C has programming features provided by most procedural programming languages - strongly typed variables, constants, standard (or base) datatypes, enumerated types, user-defined types, aggregate structures, standard control flow, recursion, and program modularization.

• C does not offer OO's classes or objects, nested functions, subrange types, run-time error detection, container data-structures (lists, dictionaries, tuples, sets), and only recently added a Boolean datatype.

• C does, however, have separate compilation, conditional compilation (through its pre-processor), bitwise operators, pointer arithmetic, and language independent input and output.

Why do we teach C?

• small, imperative, procedural language

• available on very wide-variety of hardware architectures, from IoT devices to supercomputers

• well defined by (formal) accessible standards

• three contemporary compiler suites, each available on three contemporary platforms

• well supported by 3rd-party cross-platform open-source and proprietary libraries

• used to implement most operating-systems and other programming languages and libraries

• provides software bridges to, and connecting, other programming languages

Features of C common to most programming languages

• base data types - integers, characters, floating-point

• conditions (though evaluated as integers, 0 is false, anything other is true)

• expressions with type promotion (integers and floating-point)

• control flow - if/else, switch; for, while, do...while loops

• aggregate data-structures; one- and multi-dimensional arrays, structures

• functions, accepting parameters, return value and pointer parameters

Less common C features supporting systems programming

• systems programming demands speed and consistency
  (compilers can generate very efficient code, and support system-specific function calling conventions)

• close mapping to underlying processor instruction set
  (pre- and post- increment operators, standard string- and memory-based function map to single instructions, pointer dereferencing, pointer arithmetic)

• representation/access to hardware characteristics, fixed-sized data objects
  (well-defined integers of different lengths - 8, 16, 32, and 64 bits)

• permits direct access to process's own memory through pointers

What's (still) missing from the C language?

The role and responsibilities of an OS

• manage and arbitrate access to hardware resources - CPU, memory, devices

• manage and arbitrate access to software abstractions - processes, file-systems, users

• support efficient context switching between processes, possibly supporting different per-process and per-user priorities

• impose limits and accounting of resource usage, per-process and per-user (e.g. varying scheduling timequantum, maximum execution time, maximum number of processes, maximum amount of memory, maximum open files)

• support constrained and exclusive access to resources (e.g. read-only, read-write access)

• permit sharing of resources when requested (shared access to memory, use of dynamically loaded libraries)

• permit requests to obtain, increase, or relinquish resource ownership

The interface between an OS and programming languages

• interface is well-defined and documented using C headers files and online documentation

• well-defined, orthogonal set of system-calls

• system-calls receive a small number of fixed-sized parameters (integers and pointers that can be passed in CPU registers)

• system-calls return results through returned integer or reference parameters

• fixed-sized identifiers and parameters handled by the kernel

• variable-sized objects handled by user-level libraries

• collections - processes, memory, files, directories, users, networking

• consistent use of file-descriptors for all 'types' of files and devices

C programs as good OS citizens

• consistently indicate their success or failure with their exit status

• consistenly accept command-line arguments
  (options, then filenames or data)

• may receive more persistent configuration via environment variables
  (conveniently managed by interactive shells)

• consistent representation of system-specific errors setting errno and reporting of error messages using perror()

• consistent default data streams, stdin, stdout, stderr which may be redirected using shells

• many utility programs perform as filters independently of how their input and output is obtained
  (command-line, keyboard & screen, redirected files, or pipes)