Yegor Bugayenko

The problem isn't that those principles are bad - they're useful - but the languages we're attempting to use them from are not sufficiently expressive enough to follow them all in a practical way. "Design patterns" and DRY don't mix very well - because the act of implementing a design pattern is largely repetitious. We create XFactory, YFactory, ZFactory for example, with largely the same structure but slightly different logic - then someone takes DRY to the extreme and tries to abstract it away into a FactoryFactory, using reflection or some other tool to get around the host language's lack of expressivity.

This is where the mess begins, because it becomes so cryptic to figure out how to use the FactoryFactory to create your own Factory to create some other types you need. It may be trivial to people who've been hacking with the same languages and frameworks for years, but the principle of least surprise is abandonded for new users attempting to use a framework for the first time.

Functional programming suffers from the same overuse of idioms which are unwelcoming to novices, and often throws away some useful ones in favor of ease of use. FP doesn't necessarily dismiss OOP, and it's often used in combination with functions to write practical programs.

Functional programmers don't see OOP as a problem - it's a very practical tool. The problem is that it's the wrong tool for many problems - particularly if you're just computing functions[1]. That a lot of developers are…

"OOP" is itself such an overloaded term that a Smalltalk coder and a C++ coder and a Python coder can each say she works with objects, and yet have entirely different design and organization. By formalizing his definition of OO, Yegor (who is a firebrand for sure[0], but says enough interesting things that I've read a couple of his books and several blog posts) is dispensing with "no true Scotsman" fallacies: if he claims language <X> is not OO per his formal definition, we can take it or leave it.

For what it's worth, Alan Kay himself has said things like, "I invented the term Object-Oriented, and I can tell you I did not have C++ in mind." He has declined to formally define what he means, but has said, "OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things."[1] Even without a formal definition, most languages purporting to be OO clearly fail a common sense interpretation of his criteria. Kay himself mentions Smalltalk and Lisp being the only systems he's aware of that meet his criteria; I tend to think Erlang is spiritually close, though would have to defer to Alan (I find it interesting, too, that the first Erlang VM was written in Prolog).

[0]https://www.yegor256.com/2017/07/18/sexual-harassment.html

[1]http://www.purl.org/stefan_ram/pub/doc_kay_oop_en

Other people have already mentioned Joe Armstrong's 2003 thesis, and I recommend that too.

I very much appreciate Armstrong's sometimes contrarian criticism of the tech industry, and I hope I managed to match the tenor of his frustration when I wrote "Joe Armstrong figured out the right way to do everything, and nobody cared"

http://www.smashcompany.com/technology/joe-armstrong-figured-out-the-right-way-to-do-everything-and-nobody-cared

About this:

"I mentioned how nervous I was; me, sitting on a panel with such other esteemed and brilliant folks"

I feel the same when I get put into lists with folks like Joe Armstrong. I've made no significant contributions to the tech industry, whereas other folks have made historic contributions. I'm flattered by stuff like this:

https://www.yegor256.com/2016/08/15/what-is-wrong-object-oriented-programming.html

But it is crazy. I don't belong on a page that includes Joe Armstrong, Rich Hickey and Alan Kay.

I was reading through one of the linked articles of why the author doesn't like using null or static objects:

https://www.yegor256.com/2014/05/13/why-null-is-bad.html

https://www.yegor256.com/2014/05/05/oop-alternative-to-utility-classes.html

Apparently he replaces null with null objects or throwing exceptions, and creates objects for every static method. Go figure.

Actually, there are a few gems:

> The Map interface (no offense to its authors) has a design flaw.

> It is a good practice to make your code as fragile as possible, letting it break when necessary.

> The method is basically asking the object about its… race. Black objects go right while white objects go left. That’s what this instanceof is doing, and that’s what discrimination is all about.

While I have no direct experience in their system, Zerocracy[0] appears to exactly match your requirements, modulo your salary or hourly rate. Yegor Bugayenko, aka yegor256[1] online, is very prolific in writing and talking about Zerocracy, among many other topics, e.g.[2] Zerocracy imposes penalties for talking to other developers, instead of communicating solely via tickets and other shared documents, which must limit the politics you detest.

[0]https://www.zerocracy.com/toc.html

[1]https://www.yegor256.com/about-me.html

[2]https://www.yegor256.com/2014/04/20/how-hourly-rate-is-calculated.html

While people may dismiss such a system for now, Yegor's prediction is that essentially all software will be delivered this way in ten or twenty years.

Yes, AOP == Aspect Oriented Programming

Logging systems can usually be enabled by package/namespace, and frequently to the class level. I've used AOP to log out the trace of the code (not just the call stack), but can turn it on or off as needed. Authentication acting strange? Enable those logging aspects and browse the log to see where things are behaving strangely, and it may not be in the stack trace of the exception that gets thrown somewhere else. Logging methods and some arguments is hugely helpful; it's like automatic debugging.

A quick googling found: https://www.yegor256.com/2014/06/01/aop-aspectj-java-method-logging.html and https://nearsoft.com/blog/aspect-oriented-programming-aop-in-net-core-and-c-using-autofac-and-dynamicproxy/