It's kinda ironic that a guide to minimalism, written in 2002, obviously has in mind a language like Java or C++ (the vocabulary used makes it crystal clear)... Languages which are not exactly known for their lack of verboseness ; )

I know that for many here Java/C++/C# + ORM + XML + SQL is "The one true way of life"...

But I moved on: I do really believe pg's point about "Beating the average" and trying to "think outside the (Java/C# ORM XML SQL) box"...

For example, I'd personally much rather see posted and upvoted recent writings about languages offering, say, lockless concurrency (Clojure) or specifically preventing "type inheritance" (hence forcing you to use composition instead of inheritance) (Go), etc.

I mean, it's cute to see a 2002 presentation about ways to deal with late nineties issues but honestly I think the world should start to move on.

I don't doubt there are a lot of older codebase around that would benefit from this but what about people would start to use HN to try to move the world forward?

I don't see how lockless concurrency is related to writing less code. OTOH I do see how proper use of SQL, which you so hastily left behind, is directly related and beneficial.

Form your post it seems like you're not so much interested in "less code" type of things regardless of their age, and more interested in new things for the sake of their newness, and in "moving on" away from the old things, whatever they are.

Don't get carried away with that.

Composition over inheritance shouldn't be a dogma since inheritance is really a form of composition. It allows the composition of a class implementation/interface from multiple other classes. Obviously composing code without using the provided language features for virtual dispatch can be more flexible, however inheritance has the advantage of being able to succinctly define types that are just parametrizations of other types.

  class SortedList
    cons(var key=(i) -> i)
  
  //Does it really matter if you write

  class AgeOrderedPeople extends SortedList
    key(person)
      person.age

  //or

  AgeOrderedPeople = partiallyApply(SortedList, key=(person) -> person.age)

when trying to parametrize behavior?

What's truly ironic is when people who blindly denounce inheritance then proceed to write things like

  sorted_people = people.sort((p) -> p.age)

inline, in 12 different places or slightly better

  sorted_people = (people) -> people.sort((person) -> person.age)

Java and C++ have their faults, but I'm not really sure what's wrong with C#, since it's probably the best designed of the current statically typed languages that have mainstream adoption. It has the right mix (if a little OO biased) of OOP and FP, awesome reflection (using a special type interface an AST can be captured at compile time from a lambda expression), a powerful generic system (covariant, contravariant, generic constraints, method type inference, works at the bytecode level), properties, local type inference, syntactic sugar for generators, syntactic sugar for limited continuations (essentially break methods in two, the request code and the response callback while coding it as if it were synchronous), and a fairly sane library. And all of the slides apply to C#, which in mundane but complicated code bases is probably much more productive than the sexier languages out there.