I would partially agree, although I don't know many implementations.
It's a state that cannot be naturally duplicated, alright, a "single source of truth". But lazy instantiation is nothing more than a very important and very common second. The pattern itself lies in preventing public-level instantiation (i.e. in Java it could translate to a class with a private constructor, private instantiation and access to the instance through a class-level/static getter, and also making it a final class).
I found the presentation quite useful, and have a few thoughts on the points I found.
First, my thoughts on Design Patterns as defined by the GoF.
As recurring concepts which have been identified, named, and allow for higher-level discussion and solving of software architecture and design problems (I think this view of mine might be a bit short-sighted), they are great tools and vocabulary.
However, they are known to reflect shortcomings, specially in object-oriented languages as opposed to functional ones (haven't read much about them, and I don't know much about functional programming and haven't yet read my copy of SICP, so I probably lack some fundamentals on the subject).
I like the point about design patterns not being "patterny" enough, I think that was one point in the presentation.
Although design patterns sure aren't too be taken simply as implementation recipes (is it too far a stretch if I think of them as a kind of "framework" or "frameworks"? Not sure about the inversion of control aspect, though) and there is no fixed Observer, or name-your-pattern implementation, it certainly would be more useful if they could be implemented only once instead of repeatedly for each new project.
This is not "human", and that sounds fair enough to me.
Some are actually reusable, such as certain library implementations or language constructs (I'm thinking of Java's foreach, I'm not familiar with Perl).
I think that depends a lot on what constructs or building blocks the language provides. The first few pages of SICP make such a point about powerful languages.
So it would be great if design patterns could be provided and reasoned upon as powerful language constructs (i.e. which are provided by the syntax). The higher level we can reason upon and solve problems, the better.
So many things are patterns beyond the GoF ones. Paradigms, for one thing. Variables.
The other point I found is about how Christopher Alexander wanted the clients of the building to reason upon architectural issues at various levels and how this also applies to software development. This could map either to the developers or to the end-users in my opinion (not to mention the hardware designers). Either way, I think this emphasizes the importance/need of higher-level constructs (such as the concept of information hiding applied to higher-level building blocks) than we usually reason upon when developing software.
These were the useful points I could find.
I'm afraid, though, that I don't have enough conceptual building blocks myself to reason further upon it.
Finally, sorry about the lots of "reasoning upon".
Whether their products are good or not is beside the point.
They do everything they can to have your PII and this is something people should care about.
Things like 'accidentally' collecting your BSSIDs for Google Maps or providing Google Fonts not because they want a more beautiful Web, but to have a tracker on your site.
It's becoming increasingly difficult to avoid Google with the upcoming Fuchsia OS designed to work everywhere and replace Android and also Google's upcoming SoC.
Keep it simple and get the basics right. That's when having good education matters. College won't prepare you to the market in sense of cutting-edge technologies but will give you good basics on "boring" but essential knowledge that helps you think in terms of trade-offs and evaluate new technology properly. So you don't have to shoot yourself in the foot jumping into, say, an Electron bandwagon and writing big, resources-consuming applications when something simpler could suffice or adopting NoSQL and having to deal with the lack of ACID just because "shiny new tech" and "everybody is doing it".
I also would replace the Teamwork part of the article with achieving Modularity and Information Hiding.
Sounds like a game Jeff Bezos would have fun playing if it was about setting up a distribution center. Or rather, ordering production of the game and letting players figure out how he could improve its logistics.
DRY, also known as single source of truth, is one of the most important principles in SE. I just could not figure out what the single source of truth is in a factory pattern as is the electronic circuit factory. It implies centralizing the code which is responsible by the fabrication of the circuits, what would be their equivalent in the game? The conveyor belts?
Microservices, on the other hand, are overrated and unnecessary in most cases they are applied.
Also two regions in Brazil are interested in the incompletely-tested Russian vaccine. If it backfires, that could cause resistance in the population against a successful one. That's a good time for a right-wing negationist governant to be anti-commie.
It's a state that cannot be naturally duplicated, alright, a "single source of truth". But lazy instantiation is nothing more than a very important and very common second. The pattern itself lies in preventing public-level instantiation (i.e. in Java it could translate to a class with a private constructor, private instantiation and access to the instance through a class-level/static getter, and also making it a final class).