The constant assumption is that C only supports procedural programming, however if we observe the C ecosystem it becomes clear that its really not the case.

Unix Supported Paradigms

1. Event driven programming
2. Asynchronous programming
3. Data Flow – pipes
4. Parallel programming – fork, threads
5. Exceptions – signals
6. Modular programming – dlopen, plugins via dlls
7. Message Oriented Programming – sockets

C Supported

1. Generic Programming – void* , preprocessor, varargs
2. Generative / Macro programming – preprocessor, lex-yacc, autogen, gsl, gpp, m4 which generate C code
3. Object oriented programming – custom vtables which favours composition over inheritance, also see this, gobject and enlightenment support mixins as well … not to mention other techniques like decision tables
4. Automata programming – gotos and arrays of labels, SMC
5. Stack programming ~ inline assembly
6. Functional programming – function pointers and libcello, tagged unions, coroutines

External Libraries

1. Actor model ~ zeromq + supervisor
2. Literate programming – noweb
3. Logic programming – Databases
4. Garbage collection – use gcc builtin defer and external garbage collector
5. Array programming – C memory model, numpy
6. Audio programming – LV2, openal, puredata
7. Graphics programming – opengl
8. Differential programming
9. Coroutines
10. STL

While C++, Java, Objective-C may claim to be descendants of C they really are more like PL/I and multics in spirit because of too much centralised planning and perfectionism; techniques which have persistently been shown to be disasters is software projects. Why C ? Well …

1. The other communities have shown a profound lack of integrity and sleazy sales tactics (vague promises, fud, us vs them, eee) in their marketing. The adoption was forced on programmers in a top down way by non-programmers and licenses than by voluntary adoption by teams or natural market competition. They also setup a false dichotomy and rhetorical gimmicks of high level vs low level, strong vs weak as opposed to broad vs narrow.
2. Other languages are complex, difficult to explain to beginners and encourage pedantic, patronising thinking. They also copy the worst traits of mathematics – namely abstraction for abstraction’s sake and bad naming conventions. Like physics, chemistry programming deals in concretions. Like electronics it is better for programming to be bottom up.
3. Other communities are obsessed with superficial and subjective arguments – code cleanliness, code purity as opposed to code reliability. They merely look modern, but they are not modern in the sense of empirical and science but aesthetics. None of the languages have come close to implementing a server like apache or the tcp/ip stack. The benchmarks compare apples to oranges in sweetness and in the case of C++ inline functions to function call overhead.
4. Completely failed predictions … 0 modern operating systems are written in C++ and Java. Their success lies in using XML based guis which you can also do in C. Blender is written in C.
5. Better programmer happiness. More hobbyists pick C than any other language. Large open source codebase.
6. Code longevity, portability and less API/ABI breakage
7. Mono-thinking cultures are simplistic and inherently less creative, less innovative while suffering from philosophical hammers.
8. C and programming languages written in C dominate the web, embedded space and performance metrics while others are slow. If you are looking for performant web servers checkout – lwan, kore, open resty, onion
9. Extremely rich tooling and cross platform support.

What can C programmers improve ?

1. Better naming conventions
2. Use garbage collection for non critical tasks
3. Use namespaces and nested functions
4. Better security with bounds checking and garbage collection

compose new post
go to top
go to the next post or comment
go to the previous post or comment
toggle comment visibility
cancel edit post or comment
Would love your thoughts, please comment.x