Is there an authorative programming language feature list? [closed]

Question

I'm looking for things like Dynamic typing, Static Typing, Weak Typing, and Strong Typing.

As well as OO features like polymorphism, inheritance, nested classes, inner classes, abstract classes, pure virtual functions.

Also, things like reflection, static binding, dynamic binding, etc.

However, I'm not really looking for things like control flow, built-in types, or syntactic sugar ie. A[5] vs A.get(5). Though, it wouldn't hurt.

It would be awesome if something like this existed and also mapped these concepts to particular languages.

I know that many of these features are explained on Wikipedia already, but are not quickly accessible unless I already know what these features are (and I remember) or just happen to find an interrelated link. In fact the only time I use Wikipedia for something like this is if I just happen to see someone reference an idea, which I need to look up.

My main goal is to have a way for me to quickly discover or brush up my knowledge on these concepts and an authoritative list like this would be very helpful.

If something like this does not exist, why?

Is it because different programming languages decided to name some of these things differently but actually do the same thing? (ie. Pure virtual function (C++) vs. abstract methods (Java)) While others may name things the same, but do something slightly different? (The Protected keyword in Java vs. C++) Another reason might be is languages simply don't have enough features in common to compile a list like this and it's better to learn a language and it's features one at a time? In which case I'd probably compile my own "feature list" as I learned the language...

Thanks for reading! :)

Answer 1

Very good explanations of programming paradigms and the programming concepts from which those paradigms are built are found in Peter van Roy's works. Especially in the book Concepts, Techniques, and Models of Computer Programming by Peter Van Roy and Seif Haridi. (Here's the companion wiki.) CTM (as it is colloquially known in the industry) uses the multi-paradigm Distributed Oz programming language to introduce all the major programming paradigms.

Peter van Roy also made this amazing poster that shows the 34 major paradigms and their relations and positions on various axis. The poster is basically an incredibly compressed version of CTM. A more thorough explanation of that poster is contained in the article Programming Paradigms for Dummies: What Every Programmer Should Know which appeared as a chapter in the book New Computational Paradigms for Computer Music, edited by G. Assayag and A. Gerzso. It explains for example very concisely and easily understandable, what a programming paradigm actually is, what a programming concept is, and how the two are related.

Another great book that demonstrates several major programming paradigms is Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Jay Sussman. This book was the basis of MIT's Introduction to Programming (6.001) for undergrads for several decades. A course taught by Abelson and Sussman themselves was recorded at a corporate training for Hewlett-Packard in 1986.

You can find video recordings and course materials from the Spring 2005 course on MIT's OpenCourseWare website. Another recording of the course from MIT's short-lived ArsDigita University project. SICP has also been taught at other universities, in fact the 2010 course at Berkeley has just finished.

SICP, as it is colloquially known, is probably one of the best programming books ever written.

The main difference between SICP and CTM is the didactic approach: CTM demonstrates most major paradigms using an extremely powerful multi-paradigm language that already supports them (mostly Distributed Oz, but also some others). SICP OTOH demonstrates them by implementing them in a language that does not support them natively (a subset of Scheme). IOW: CTM would teach OO be showing programs written in an OO language, SICP by implementing an OO system in Scheme. Seeing Object-Orientation implemented in a dozen or so lines of code is friggin' awesome.

Design Concepts in Programming Languages (by Franklyn A. Turbak and David K. Gifford with Mark A. Sheldon) is another great related book.

Concepts of Programming Languages (by Robert W. Sebesta) explains, well, Concepts of Programming Languages, starting with Konrad Zuse's Plankalkül, continuing with the first real programming languages like Fortran, Lisp, Cobol, Algol, BASIC and on to C, C++, Java and Ada.

Concepts in Programming Languages (by John C. Mitchell) is another book that is often cited but that I haven't yet read myself, unfortunately.

Ditto for Essentials of Programming Languages (by Daniel P. Friedman and Mitchell Wand) aka EoPL.

Programming Language Pragmatics (by Michael L. Scott) is more about implementing programming language concepts, however it also talks about them in a way that is reportedly very accessible. (Again, I haven't read this one.)

Since you asked a lot about typing specifically, I would be remiss in not mentioning Types and Programming Languages (by Benjamin C. Pierce), or TaPL as it is usually called. This is basically the book about Type Theory as it relates to Programming Languages. Note, however, that its view on types is not uncontroversial: for example, it pretty much flat out denies the existence of dynamic typing.

To balance out that very strict definition by Pierce, you should definitely read the brilliant Typeful Programming by Luca Cardelli. In the paper, he argues that programming using types as a modeling and structuring construct instead of just mere safety net, is a programming paradigm in its own right. (This is for example in stark contrast to Peter van Roy's poster and book, which deliberately ignore typing completely.)

A really great resource is the Lambda the Ultimate weblog (which is actually where I got introduced to pretty much all of the above reading materials.)