Відео

A neat excurse intro history but come on. You answered why in the beginning: it's complicated. And at the same time there was no answer at all. "fp is not popular because oop took the spotlight", is that it?

FP sure has its use cases but it being the norm??! NO!

@6:50 Tbh, Swift seems to be a pretty great programming language these days lol.

because it is easier to think top-down in responsibilities and actions (criss-cross) rather than in stream-lining (one-way).

"Object orientation"

Cause its dumb

I believe C#(Microsoft in general) is moving fully towards "Functional". I've watched many Zoran Horvat videos and can see the progressive morphing of DotNet into Functional. I'm starting to tinker with F# as well. Just my opinion, and I suggest watching Zoran videos if you're a C# person.

In the first ~15 mins, he kept bringing up that "if X language (that has exclusivity or a killer app) was functional, everyone would use it". I strongly disagree. Maybe it ends up being true, but only if the fact that it's not OO doesn't push people away from adopting the language. As a junior dev in particular, I generally tended to avoid the unfamiliar. If Swift or ObjC were functional, maybe devs with a OOP background would look at it and think "No thanks, I'mma stick to Android or multi-platform options". Rails manages to draw so many people into Ruby in part because Ruby is so damn easy to learn. If JS was functional, would it have still beaten out Flash? Would yet another alternative have cropped up? You can't just make such a fundamental change and assume that the result would remain the same just because it was helped by external factors.

"C with classes" doesn't sound like a serious naming attempt, so people didn't get it as a thing. So when he came out with C++ people thought: "Finally a _real_ system" Imagine talking to your colleagues and somebody says: "I am using C with classes now."

If one has a function with multiple arguments, then by decomposing a function with multiple arguments into multiple functions with one argument each, it has the effect of being able to then compose those functions into a series of chainable functions, thereby increasing re-use and decreasing the complexity of each function, making each easier to reason about.

I really don't understand the compromison here. OOP is all about data (program state) and the functions are typically also about data (for the most part). Hence you can also call OOP as "data-oriented" programming. Classes are nothing but abstract models of real-world entities (their attributes and operations). The point is, OOP = I'm all about data. Functional programming on the other hand is all about behavior (functions). In fact, most of the time data is immutable in functional programming and the same input will always yield the same output. The use case of functional programming is exploring data for analytical or mathematical purposes (AI models, data statistics, etc.) So, functional and OOP are not in the same category. One is designed for data, and one designed for behavior. Maybe this whole time the presentation was taking about Procedural Programming rather functional programming? That would make more sense, because procedural programming is also about data (believe it or not) but with the emphasis that code is organized in procedures rather than objects (with the difference that is in procedures, it contain behavior only and the associated data lives outside of the procedure in comparison to objects where data and behaviors are "encapsulated" into a single unit called an "object".) I could be wrong but that's my take on it.

Great talk! I think emphasizing the projectional AST editor would have helped some of the questions.

Very well presented, really enjoyed the pace and content.

15:46 I disagree that the web platform is a guaranteed success. If it where not as accessible it could easily be replaced (just like Flash or Silverlight). JS did dominate because it was approachable and also OO (DOM) is a major aspect.

I wonder if we could take the best of both worlds and bake it into a very strict language that could achieve anything of both worlds though.

good thing != popular thing. a lot of suff is loved by many that aren't competent enough to understand what is really good or not. javascript is popular because everyone study it as "beginner" language, it's easy and so on. it' one of the most horrible language ever concived. but a ton of people will defend it. because they know that thing.

Because computers are procedural by nature. Assembly, the direct representation of binary code, it’s procedural. We can abstract away and program functionally, but at the end of the day, programming is procedural in nature

Because trying to bend over backwards to avoid state on what is fundamentally a state machine is a bit much. That being said, it's not really an either or situation. Knowing a bit of both is rather useful.

but later all apps need state and FP becomes crap!!!! just a decoration in the mental state of people who think it makes them better than others to use FP. it does not work in the real world in isoation = sugar = the king goes naked.

In case you’re looking for the Stroustrup interview, thats an O not the number zero, and the title is “The Design of C++ , lecture by Bjarne Stroustrup.”

Why the Elm Guys dont substitute Scala with OcaML

Imagine If Java would have been Haskell😮😮😮

Because it's shit

Because ots stupid for big projects

Functional languages are "purist" or more informatively "extremist". More acceptable languages would allow you to code using OO, functional, imperative, and declarative as you see fit for a particular problem. Scala tries to do that. I think it does it quite well.

Functional isn't the norm because programmers can't do math anymore. Functional isn't the kind of thing they teach at two week boot camps.

Python's popularity and code both are same slow and steady. No hate

Because the best ideas it has to offer have been ported to numerous modern languages/frameworks, which still allow and support other paradigms in parallel. Why tie one hand behind your back?

You can do some sort of encapsulation in C though. Static functions and anonymous structs. Anonymous structs don't stop you from actually "touching" the contents, but neither does python, if you are persistent(or rather _Classname__persistent). Basically, create .h file, define a struct there with all needed fields, create init/deinit functions(alloc with good ol' memset/free), create all the functions that do actual job, make all other implementation detail functions static. Compile .c file without linking, than link it with the project and bam. You have some sort of object, constructor, destructor, 'methods'. Inheritance would be a bit more difficult though.

😌

I've always struggled with Lisp... I suppose it's the parenthesis, but I've always looked at Lisp code and wished it looked more like something else. ????? It's an interesting thought that if Brendan Eich had got his own way and made what became JS a dialect of Lisp would I have managed to get over my foibles and would happily be coding away in Lisp today.

Whats wrong with CSS ??

Semantics, Compilers and Frameworks, oh my! I am still in Kansas. Super huge, neat stuff tho :)

Rust is the future.

seems like java created a hype train too strong

44 years later and the best piece of software is still visicalc / excel

And programming languages exists for only one tging-not for human study machine language, it exists for make lightly transfer human thinking process in machine code. That's why exists compilers.

Why not norm? It's not obvious. That's all. Every man and woman thinking by objects. But functional style of programmig very cool. I mean synthesis of oop and functional in ddd. Awesome technic

Clearly the industry has been working with none functional programing for decades

Rust and JS together are particularly responsible for pushing FP as an OOP alternative.

The speaker didn't mention that before Microsoft came out with C# they tried to do something called J++.

A lot of these seems like hamfisting the square peg through the round hole, especially the "C++ definitely not success because of OOP" when OOP was the reason it exists instead of just using C. Sure, adding more features to C with Classes is nice, but there is this immediate assumption that is the cause and not it having gradual and consistent developments while also being a relatively good language. The golang section makes me think the speaker has spent very little time with golang. Golang works with a lot of the inheritance style, but technically its not inheritance because the the details of how it functions, but the entire point of that is to enable inheritance behavior. And his explanation of the function swapping as a function of a specific struct vs just a specific function really seems to demonstrate this. Speaker also seems to not be consistent in what he means with OOP - in some cases it seems he is asserting its when you have the encapsulation of private fields, and in other cases it seems he means its the extendibility of other classes. Lastly - favor composition over inheritance isn't the motto because inheritance is bad, but because it does a lot (and in many cases you can only extend one class). Inheritance has its time and place and it is good - its just silly to reach for that tool if composition will do that trick just as well for the particular problem at hand.

Thanks for an excellent review of history of software development. Object Orientation won the acceptance wars more than 20 years ago. Scalability and concurrency in functional programming is very impressive. But the new proposal is up against incumbency and resistance to change.

5:20 All of these projects are now dead or proprietary 😭

The elitism of the FP community has a lot to blame. Hardcore functional programmers think it's all monads, and for example the Erlang/Elixir and Orleans community seems isolated, even though the actor models seems a great fit for distributed systems. But even Erlang community development was arrested due to pay walled training among others. Elixir seems to be doing better but I still hear too often wild claims like people saying you can implement s production ready map reduce with the standard library, like shuffling or distributed fault tolerance is trivial. Also, Spark and Flink are profoundly functional as they based on functional constructs and rely on lack of side effects for fault tolerance, but they are treated as something separate. Too much purity in a community is alienating. And in the end what I need is a language that I can use to get a job, sorry for sounding like a poor dummy

Good review. I think OOP is the norm because most programmers like to over enginere and overcomplicate things. Also, we are easily influence by other programmers, and rather use "good practices" without critically thinking.

Functional languages all have the same basic flaw: That's not how computers work. Sure you can force a computer to implement the desired operations, but it is less efficient (under the best circumstances) than procedural languages that more closely align with what the hardware is actually doing. This rules out functional languages in any circumstance where performance might be critical. A good example of this is in embedded systems, where excess compute power is a waste of money and thus affects profitability. If I'm going to sell 1M units of something, then its worth an awful lot of developer time to use a 1$ cheaper microprocessor, and it turns out that in most embedded use cases, its actually much easier to write procedural code than it is to write functional code. Functional language developers also fundamentally misunderstand what computers are for. Computers are not primarily used for calculating results of functions. Rather, computers are about controlling the real world, storing information and sorting data. Calculating results strictly from current inputs is a very small piece of that. In other words, the "side effects" that functional languages poo-poo so much are the only real reason that computers even exist. Pure functions are the aberration, not the norm. For that reason alone, functional languages will never become commonplace.

wow. wow. wow. wow. wow. wow. wow.

He underestimated the _massive_ amount of money poured into IT from big tech that want to control the dev environment. ALL languages that are - or have been - backed by a big corporation are just that - a random language promoted by a corporation, good for them, bad for everyone else. We all know which corporate backed languages we should avoid, but not all have the option to avoid them.

I can explain OOP and the principles of imperative programming to my mom. I can't do that with functional programming. In short, it's a bit alien.