Hacker News Reader

The Gang of Four book was written in 1994, and Java was released to the public in 1995. The patterns were actually developed by C++ programmers, and the authors sought to categorize and formalize them. The patterns are useful in the context of object-oriented programming in general, not just Java.

The language most of the examples are written in, C++, does allow multiple inheritance and metaprogramming, and a bunch of other stuff Java does not allow. The patterns are still useful in C++ despite those features, which is why C++ developers came up with them in the first place.

I realize i made an anachronical mistake. However the Design Patterns book and the 'design patterns' mindset is most popular with Java developers.

Sorry but I do stand on my criticism of Design Patterns as applied today.

> The language most of the examples are written in, C++, does allow multiple inheritance and metaprogramming,

You're being very generous with C++ if you consider it does allow metaprogramming. It does not, if we compare it with the languages that make good use of metaprogramming: Lisp, Scheme, Racket, and now Julia.

You cant move the goal post! C++ template is meta programming, as it's Turing complete. It's ugly and messy, but usable enough.

There is a ton of usability, scope, and power difference between the metaprogramming of C++ templates versus the metaprogramming of the Lisp family of languages (and Julia), which is what is usually considered as metaprogramming in the practical sense, languages that are arguably designed around metaprogramming as a fundamental feature.

Just as assembly language is also turing complete, but there is also a ton of usability difference between it versus C/C++, in favor of C/C++ and with little performance penalty.

More importantly than Turing complete, assembly language has complete access to the machine resources and data representations.

A language can be Turing Complete, yet do only pure calculation plus I/O strictly in Roman numerals on two predefined streams.

Good luck decoding a JPEG with that, right?

C++ template meta programming isn't Turing complete in a way that is useful.

Turing Complete means that you can calculate any partial recursive function (given some suitable input encoding).

For instance, in pure Lambda Calculus that has only functional terms (no numbers), we an make integers out of function using "Church numerals" and then calculate functions over these numbers. No amount of such calculation will produce an integer object, though.

Similarly C++ template cannot calculate any C++ syntax whatsoever, in spite of Turing Completeness. You get template functions and template classes; that's it.

>I'd argue that Design Patterns mostly appeared because of Java. [...] And such workarounds were collected, tagged, and proposed as Design Patterns

Fyi... "Design Patterns" in 1994 predates Java 1995.

Design patterns in some form have been around as long as computers have been around. Independent teams of programmers notice a repetition of code or a higher-level idea and they make it a convention. E.g. the "observer" pattern was something Smalltalk and Objective-C programmers did more than a decade before Java. Before "Design Patterns" became a meme/book, different teams used different vocabulary. Maybe they'd call it the "event watcher code convention" instead of "observer pattern". DP was a book of past practices gathered from the real world and it got everyone to converge on the same vocabulary to label what they were already doing.

Java has always allowed for class members using the "static" keyword.

The GoF book predates the public release of Java. The code samples in GoF are in C++ and Smalltalk.

Correct me if I'm wrong, but Java 8 does allow functions to be passed around. E.g., if a function takes as input a Runnable, I can pass a no arg lambda expression as input.

There are actually a bunch of different kinds of functions you can use in lambda expressions in Java 8 (43, to be exact).

https://www.tutorialspoint.com/java8/java8_functional_interf...

Beyond that, by at least 1.4 you could pass methods using the reflections API, though that was kludgy in a lot of ways.

You realize that Design Patterns: Elements of Reusable Object-Oriented Software was published in 1994 while Java 1.0 was published in 1996 right?

Better tell all those haskell developers to stop stealing the monad pattern from java.

https://github.com/iluwatar/java-design-patterns/tree/master...

And here is a second source if you don't believe me or iluwatar

>In functional programming, a monad is a design pattern that defines how functions, actions, inputs, and outputs can be used >together to build generic types,[1] with the following organization: > > Define a data type, and how values of that data type are combined. > Create functions that use the data type, and compose them together into actions, following the rules defined in the first >step.

https://en.wikipedia.org/wiki/Monad_(functional_programming)

Tail call optimization is a way for compiler to align functional recursive algorithm with stack-based procedural reality. Since Java is not a functional language and has sufficient expressive power to write iterations as... iterations, good programmer will just write a for loop and will not bother about a feature that is basically unnecessary in multi-paradigm language. Oh, by the way, recursion is a functional design pattern, isn't it?

> Since Java is not a functional language and has sufficient expressive power to write iterations as... iterations, good programmer will just write a for loop and will not bother about a feature that is basically unnecessary in multi-paradigm language.

Ok, so you think recursion is unnecessary in a multi-paradigm language.

Which implies also that multi-paradigm languages shouldn't be really multi-paradigm languages... Java, by the way, is hardly a multi-paradigm language.

And you imply that the reason one uses recursion is because one can't "write iterations as ... iterations".

You should realize that recursion is used whenever expressing the problem in a recursive way would make the problem easier to program and/or clearer to express, etc. Not because of recursion being fancy or fashionable.

Recursion is a computer science technique, not a "Design Pattern".

Kotlin is also a "non functional language" but does tail recursion optimization via tailrec keyword