Now, KISS approach to programming languages is a funny notion, at least if you consider programming languages to be an abstraction layer to a CPU's instruction set, etc. If you do not define "KISS" more closely. I am just saying here, that an oxcart is KISS applied to a car to its fullest.
Now another interpretation of KISS could be something like "smartly done without needless ornaments and not overly complicated". Especially one could argue, that there should not be too many specific cases for similar things, etc. Usually math is quite good at boiling down stuff to its essence, and - o wonder - mathematicians have spent some time thinking about programming and computers as well.
For programming, 2 quite famous abstract models exist:
- One is the turing machine which defines a machine and a simple instructional model that is able to compute everything a computer could do.
- The other one is the Lambda-Calculus by Church et. al. that is equivalent in power
Fun thing is: While the turing machine is quite simple in its layout, it is not a system that is easy to handle and I do not think it qualifies for "smart KISS". But Lambda Calculus has more to do with programming languages that we know -- and with Lisp and Scheme pioneering features of the lambda calculus it has made its way into a lot of languages.
Lisp and Scheme are REALLY simple, at least syntax wise. Syntax is a major problem with programming languages (which is probably why they are reinvented all the time). In the case of C++ it is almost unhandable for the human brain to predict how some source lines are interpreted by the compiler.)
Lisps are reducing the syntactical complexity altogether by introducing one common form for commands:
(command param1 param2 ...)
This can be a method call, such as
(max 1 2 3 4)
as well as a if branch, loop etc.
(if (< 1 2)
(all code here is pseudo-Lisp/Dialect agnostic)
(command param1 param2 ...)
can also be interpreted as a list
(item1 item2 item3)
And that is the basis for Lisps simplicity and beauty. Because nested lists (like in the
if statement example) constitute trees and those can be easily understood both by the machine and by the human in front of the machine.
Another feature of Lisps are macros I won't go into the dirty detail here, but since there is no syntactic difference between normal function calls and "Syntax (e.g.g for loops, variable declaration, etc., everything the parser has to handle in other programming languages) you can create your own syntax. Macros are in essence Manipulations of the Tree that constitutes your program.
I think Lisp has a KISS to programming. That you can manipulate syntax by using macros has lead to a phenomenon that Lisp has evolved quite dynamically. Need a new Language feature like - lets say object orientation - just write a OOP system with macros!
While C was extended roundabout 2 times with OOP features (C++, Obj. C) Lisp was extended multiple times, in the end there was a winner.
That is another quirk about Lisp, it evolves (see Clojure and Clojurescript for interesting new Mutation of lisp).
For its KISS properties Lisps is favored as teaching languages by some. Like Fogus outlines in his blueprint of an educational language (http://blog.fogus.me/2013/01/21/enfield-a-programming-language-designed-for-pedagogy/ )
To start, I’m strong believer that when learning new, and at times complex topics it’s outright detrimental to overload students with frivolous syntax rules. Therefore, Enfield is designed with minimal syntax rules and what’s more minimal than a Lisp like syntax.