What's wrong with OOP and FP

== Yin Wang ==
https://web.archive.org/web/20140129112028/http://yinwang0.wordpress.com/2013/12/24/oop/
https://web.archive.org/web/20140118083122/https://yinwang0.wordpress.com/2013/11/09/oop-fp/ links to https://web.archive.org/web/20140331152020/http://norvig.com/design-patterns/design-patterns.pdf first style classes. 
https://web.archive.org/web/20140119021519/http://yinwang0.wordpress.com:80/2013/11/16/pure-fp-and-monads/ In general, functional languages are pleasant to work with because they support first-class functions, which are a very powerful modeling tool. But if you pursue the extreme — to use a purely functional language, you get adverse effects similar to OO design patterns. In a conventional OO language, having to use OO design patterns makes hard things even harder; but in a purely functional language, having to use pure functions to model side-effects makes trivial things hard and hard things impossible. So speaking of the two evils, OOP is the lesser one because at least easy things are still easy in them. The problem with pure FP is: there exists things that are not pure.
https://web.archive.org/web/20140216125355/http://www.olimon.org/uan/frege-writings.pdf
https://web.archive.org/web/20140108195719/http://mitpress.mit.edu/sites/default/files/titles/content/sicm/book.html
--------------------------------------
https://web.archive.org/web/20140113165340/http://yinwang0.wordpress.com:80/2013/03/31/purely-functional/ To write programs in a purely functional programming language is much like living in a wired world. In such a world, there are no electromagnetic waves nor sound waves, so you don’t have wifi, cell phones, satellite TV, radios, etc. You don’t even have light or sound. In other words, everything is blind and deaf.
All information must pass through wires or pipes, connected by switch boxes which we call “monads”. You must carefully route all the wires and pipes and connect them correctly before any information processing device, including your eyes and ears, can properly work. Links to http://existentialtype.wordpress.com/2011/05/01/of-course-ml-has-monads
== Design patterns ==
* https://web.archive.org/web/20140129112028/http://yinwang0.wordpress.com:80/2013/12/24/oop/ 
* https://www.amazon.com/Little-Java-Few-Patterns/dp/0262561158
The programmer’s world is full of fads and superstitions. Every now and then there will be somebody who come up and announce: “I can save the world!” No matter whether the ideas are good or not, there will always be followers, and the ideas soon become their religion. They then develop their community or camp, try to let those ideas dominate the world, and try to make the ideas live forever. Object-oriented programming (OOP) is such a religion which claimed to be able to save the world from the so-called “software crisis”. As a hindsight after so many years since it was introduced, not only didn’t OOP save us, it brought us more confusion and harm than benefits. Unfortunately its dogmas and mispractices have become wide-spread and deeply intrenched. In this article, I hope to provide my viewpoint into this matter and try to find out the lessons that we can learn.
For the purpose of code reusing, OO encourages a level of abstraction which makes programs hard to understand and hard to analyze. I often see Java programs with multiple levels of inheritance, overloading and design patterns, but actually doing very little. And because there is so much code that doesn’t do useful things, it is really hard to find out which part of the code is doing the thing you want. It is like going through a maze. Another nice word for this is “robustness”. If I have to go into all this trouble to make code reusable or robust, I’d rather just make copies of the code and modify them, but keep each copy simple and easy to understand.
When I first heard about design patterns I was already a PhD student at Cornell doing some PL research. I mostly used Standard ML and Haskell. After hearing my friends’ high opinions of the Design Patterns book (the “GoF” book) I developed curiosity, so I borrowed one from the library. Within a few hours I found a mapping from all the weird names it introduced to the programming techniques I had been using all the time. Some of them are so fundamental and they exist in every high-level language, so they don’t really need names. Most of the advanced ones (such as visitor) are transcriptions of functional programming concepts into a convoluted form in order to get around OO language’s limitations. Later on I found that Peter Norvig gave a talk on design patterns as early as 1998, pointing out that almost all of the design patterns will be “transparent” once you have first-class functions. This confirmed my observations — I don’t need them.
Every time I remove a design pattern (some other people wrote), the code becomes simpler and more manageable. I just removed the last visitor pattern from my Java code a few days ago and I felt so relieved. They gave me nothing but extra work when they existed. They hindered my progress. By deeply understanding how OO languages are implemented, you can write more advanced things than those provided by design patterns but without actually using them. I owe these insights to some functional programming people. If you really want to understand the essence of OO design patterns and how NOT to use them, this little book may be a good starting point.
At both Cornell and Indiana, I have been teaching assistant for introductory programming courses in Java. I still remember how confused the students were. Most of them had trouble understanding things such as the meaning of “this”, why everything needs to be put inside classes, why make every field private and use getters, the difference between a method and a static method, etc etc.
There is a good reason that they don’t understand — because OO is not how things work. Most of the time I feel that I was teaching design flaws and dogmas to them. Many of them learned very little in the end. Worse, some of those students really believed in OO. They ended up being proud of writing over-engineered and convoluted code. They no longer see things or write programs in straightforward ways. This is sad. I feel that we are no longer educating students as creative and critical thinkers, but mindless assembly line workers.
https://www.reddit.com/r/programming/comments/1qg5x8/whats_wrong_with_oop_and_fp/
=== Clean coder ===
http://blog.cleancoder.com/uncle-bob/2014/11/24/FPvsOO.html Demonstrates how the "object" metaphor cloaks that procedural is all we have. 
=== links ===
* Oop
* Encapsulation is impossible
* https://yinwang0.wordpress.com/2013/12/24/oop/ On object oriented programming. OOP’s definition of an object is “a combination of data fields and associated procedures known as methods“. Can you really fit everything into this model?
First let’s look at the real world and see if this definition can capture everything. Cars, trees, animals may sometimes be thought of as objects, but what about a change of the objects’ position, its velocity and duration? What methods do they have? Well, you may define classes called Velocity or Time, with methods such as addition, but do velocity and time really contain the things that you call “methods”? They don’t. They are just your imagination. You can add the velocities or time, but how can velocities or time contain the addition procedure? This is like saying that the bullets contain the gun.
Category:Oop
Category:Functional programming
Category:Haskel
Category:Haskell
Category:Oop design patterns