Thinking outside the Bento box

Operator overloading is just a shortcut to using real functions.
Function overloading is merely generic function interface, saving the time to type the real function name.
Macros just produce code you could write yourself easily.
Classes don't have any advantage over structs. Their methods are less flexible than function pointers and arrays of function pointers are better than multiple dispatch.
Namespaces introduce complexity trading off the ability to use names globally for a restricted subset of it.
Module systems are rigid and inflexible compared to textual includes. What we need is binary resource includes.
Type-safety without escapes is useless: almost every language has a form of casting to another type.
Sometimes a generic type is the elegant solution, sometimes a specific type is needed. Having forced type-safety or forced dynamic types is counter productive.
Type inference is for programmers never bothering to specify a type.
Garbage collection overhead is traded for just not bothering to call free/delete or not using stack allocation freed at end of function.

>>2
SICP - this book is intended for beginners, since those who are advanced enough will only be wasting their time reading this book.
If you're a beginner, starting with SICP is like discussing the next major physics theory without learning any physics. You'll learn to philosophize and throw around grand but meaningless ideas.
Starting with C and Assembler is a better way. You'll learn the internals first, find out what's behind the abstractions. You'll know how procedures are actually called, and what some of the issues are.
In fact, towards the end of chapter 4, the authors themselves admit that their simplistic view of computers and languages is severely deficient if they want to descirbe things properly, so in charter five they introduce register machines.
No wonder so many students I've talked with complained. They couldn't understand what all of this encapsulation meant, since they had no idea of the basic underlying process--simple pushes onto a stack and jmp instructions. The way they presented structures such trees and lists, with pairs, is also a very braindead approach. C pointers are much more intuitive and flexible.
Aside from the book's wrong approach, it's also terribly written. I tired to like it, but books can only be so boring before you start to feel aversion towards it.
The book promises to make a better programmer out of you, to teach you how to think about programs, but this promise is not kept.
Those things which it presents that are relevant to overall philosophy of programming are already widely known as it is. The other things they present are completely useless. In short, you will not gain any valuable insight and won't see any revelations or any radical and vastly superior methods of thinking about programs. It's just mundane drivel here.