Recorded live on twitch, GET IN / theprimeagen MY MAIN YT CHANNEL: Has well edited engineering videos / theprimeagen Discord / discord Have something for me to read or react to?: / theprimeagenreact
I used to compare my workflow to yours thinking I was doing terrible because you don't look too old, then I realized you were already programming professionally when I was 7 and that kinda changes things lol
"If more people will write in OCaml then, people will write in OCaml more." That's a good point actually. And now I want to try to make a game with Raylib in OCaml lol
I never understood either. As far as FP languages go, OCaml is actually a fairly simple language too. It's orders of magnitude simpler than Haskell, Scala or Rust (if you count that as FP), which are all more popular.
@@AlJay0032 Rust isn't FP. It's a cleaner C++ with concepts from Haskell, but it's not designed to be used as a FP language. You can write some functional code with it, but that's really not what it's good at. Haskell had a lot of great ideas, people just overall kind of hate FP for doing real work.
When people say that humans think imperatively, they are greatly oversimplifying things. Once I know how to make a peanut butter and jelly sandwich, I'm not painstakingly walking through the steps in my mind in great detail in order to make one. All of that gets abstracted away into a series of composed actions that yield the same result in the end. And of course, at that point, the same process can be easily adapted with little effort to the creation of any type of sandwich. How is that not more analogous to a declarative/functional approach? I want to make a sandwich, so I make a sandwich. I don't explicitly tell myself "Okay, now remove the lid on the jar of peanut butter, now put the lid down on the counter, now grasp the jar in one hand and pick up the butter knife with the other." etc. Rich Hickey (the creator of Clojure) did a great talk called "The Value of Values" where he argued that imperative programming was, at one point, pretty much the only type of programming you could do if you wanted to make anything useful. Why? Because the hardware was so limited in resources that for any sufficiently important task, you had to build your mental model around those limitations. But as things have progressed, the situations in which that level of thinking is required has become more and more niche. He flatly acknowledges that if you're a systems programmer, or otherwise need to prioritize and optimize for performance, then obviously you still need to be engaging in what he calls "place oriented programming," e.g. a paradigm oriented around the manipulation of state. But for the vast majority of us, it doesn't currently make any sense, and introduces all sorts of problems that make our lives harder as programmers. And the main reason why we stick to this is because we began from a place of necessity, and then tricked ourselves into thinking it was actually the ideal way of doing things all along.
I think the problem why Functional programming is less popular is in part that they don't have anyone like a Bob Martin (love him or hate him) out there trying to explain how to do it. It's always discussion on pure functions, and Monads and endofunctors and oh gosh i just want to know how to do this thing i know how to do proceduraly/imperativly.
That’s why people should read grokking simplicity which does a really really good job at teaching functional programming without saying monad/functor and all of the seemingly scary stuff. Eric Normand always does a great job teaching in general…. A lisp programmer but this particular book uses JS to be friendly to everyone
Monad and Product are related to the type system and not to functional programming. Functional programming languages (e.g. lisp) can also be dynamically typed.
I feel like a lot of people take a look at Haskell and think that it's representative of FP as a whole. It's really only Haskell (and it's offspring) that require a bachelors in category theory, lol. I mean, Clojure is just as functional as any other FP language and yet, it contains no algebraic data types at all.
I remember programming in 2009. I taught myself to code back then with bash scripting and C. I 'member loading Puppy Linux on a USB thumb drive in the school library to test some network sockets stuff. Good times, simpler times. I found very quickly that a basic-ish language called "AutoIt" was the fastest way to develop GUI apps on Windows, and I even was able to do TCP, UDP, keylogging, and a bunch of other stuff with it, too. I think at one point I even made a tool that would send screenshots across a LAN, though I never managed to optimize it enough to be anything close to real-time -- iirc I ran up against the limits of the language, then pivoted to the LAMP stack.
When talking about paradigms, as with language syntax, people just like what they're used to. In order to fully grok functional programming you need to unlearn and relearn so much, there's no other way but to bang your head against the wall a thousand times, just like you did when you learnt programming for the first time, it's just that people forget their struggles learning programming, because looking back everything was so simple. I saw this many times when I was a teacher. I don't think functional programming is so much harder than the imperative styles after seeing many good software engineers fail their first programming course at college the first time around... which is a whole semester's worth of classes just to talk about what for loops and if statements are
I mean, you can write of functional programming in JavaScript, not everything, but you can have a core of your app that is functional. It just takes a little more effort since it doesn’t have the same features out of the box like a true functional language but it can be done.
Is SML/NJ still a thing? Back in the days it was better and more advanced than OCaml and it allowed you to write imperative code if you really wanted or needed to. One issue I have with Ocaml is that today languages need compiler support for concurrency or at least threads. Ocaml doesn't have that, like most other languages, if they have it at all (see Python) it is like a wart that was retrofitted as an afterthought.
OCaml 5 recently released with proper OS-level thread support, although parallel garbage collection is always tricky - at some point, the GC is going to have to pause all threads at once to make sure shared data structures are in sync, so it's usually best to communicate between threads with immutables and message passing to minimise the duration of the sync, and OCaml's message feature is marked as experimental. I'd much rather deal with haskell's transactional memory feature until that matures.
OCaml has historically had very bad tools for dealing with actually using the resources of the machine and has (as far as I know) had no answer to STM, lightweight threads, transactional variables and queues that build on top of these two things, which has made it hard to compete with Haskell which has had these for many years. So for someone actually working with these things, there just isn't that big of a space for OCaml to be the more appropriate choice. I've used OCaml in production a few times and it has always been a worse experience for solving real problems than Haskell because of a runtime that just doesn't provide modern facilities (see above) or even the comparatively poor level of the CLR which you get with F#. This probably made F# a much better choice than OCaml for our choices as well, in all likelyhood. It's funny seeing OCaml getting a resurgence because I suspect these things haven't actually been solved yet either. I'll go on record as saying that despite the low usage numbers of OCaml it's been my impression that it's vastly overrated by people who have never actually done anything in it, or lack experience with languages that provide better facilities. If I'm going to accept a barren runtime for efficiency's sake I'd take Zig or Odin any day since they're going to be better at providing a real, deterministic efficient experience anyway. The space that OCaml supposedly fills according to proponents is usually either wrong or basically useless since it's just the worst of all worlds.
I agree 100% the elephant in the room is really that it's harder, just like Linux, Vim, Emacs, perhaps even Powershell? But you don't need to know what a Monad is though or be good at math. I think that is a myth. FP is inspired by lambda calculus and category theory/set theory but most of the academic stuff can really be dropped without any loss in expressiveness. If you do Haskell you however will need to learn to use monads, but most people already do use things like Optional, Async, Result and lists(yes lists are monads too) without knowing anything about category theory.
There is a good comment there that definitely still applies - OCaml doesn't have a language spec, the compiler is the language spec. That means the language changes under your ass without warning in breaking ways regularly. Makes it hard to recommend over Haskell, Clojure, F#, CL unless your team is ass-deep in the compiler's guts the way the Jane Street folks are.
@@gamekiller0123 it's a bit different, when a language has a spec, the spec changes as the language evolves but it's a deliberate well-documented thing. When there is no spec, you have no real way to know whether some behaviour is an intended feature, unintended feature, or a bug, and it can change at any time in opaque ways. You're building on sand. That doesn't matter for hobby programming, but it does if you're making a product.
What's the difference between having a spec or not? If the spec is updated regularly you still have the problem. Or are you reading every update in a spec?
A lot of people here are hating on abstractions. Even boolean algebra is not how the cpu works. There are millions of transistor connected in a manner to basic operations possible. So replicating that complexity everywhere would be stupid.
Most languages get popular because there's a killer library or tool that people want to use. OCaml is generically good, but it doesn't have a true killer app like Haskell's software transactional memory. OCaml is the language people reach for when they need to make their own custom tooling. As a result, it has some really powerful, specialized tools that have very niche use cases, but nothing that a large percentage of developers would really want. Most of the languages that got big also had great learning materials, or were at least pitched as something easy to learn and use. OCaml's educational materials are pretty bad and seem to assume that you already know functional programming and just need to learn how OCaml does things. I'm not confident that I could have learned functional programming and OCaml from the materials that currently exist. (Hopefully that's something you can help fix.) Still, I'm hopeful that all the recent changes will inspire someone will make something really cool. New multi-core runtime, algebraic effects system, good Windows support, the new features Jane Street is testing out. Lots of exciting stuff. And as a result lots more publicity on the crazy tools that people have already made with it. CompCertC, MirageOS, Coq, and the rest aren't things most devs will use. But I can't really imagine anyone making them in *any* amount of time in most other tools.
There’s an amazing Cornell course available for free with an online book and hundreds of accompanying videos, which is kept completely up to date. But I’ll admit I didn’t exactly find it with great ease. The most easily findable book is probably “Real World OCaml,” and I definitely felt like it suffered from moving too fast and assuming prior FP experience. It’s more of an intermediate resource. One of the problems I see with a lot of FP learning materials is that they tend to focus on comparing FP against imperative, instead of just teaching you FP from the ground up. It’s nearly impossible to find resources on F# that don’t assume you’re already a professional C# dev.
@@macaroni_italic I'll check it out. I hope it is as good as you say. I'm tired of telling people, "I really like OCaml, but you should probably learn Haskell because the learning resources are better."
@@macaroni_italic I skimmed the course. Going by the chapter headings, it seems like a good introduction. But it doesn't get to the advanced features of the language like GADTs, existential types, polymorphic variants, and the rest. From the portions I looked it, what it covers, is covered well. And it covers a lot of important topics like property testing. But it does need a follow up that handles the more advanced stuff and helps,you understand when, how, and why to use it.
@@MaxHaydenChiz My take is that it's enough to get a person who's new to functional programming started, and then you can confidently go into other materials like "Real World OCaml" without getting lost.
@@macaroni_italic I agree that it seems to be a great start. Sorry if that wasn't clear. And you can get a lot of substantial programming done with what it teaches you. But I'm not sure that RWO will help you understand the advanced features if you don't have some general familiarity with the concept.
I took a bet on learning Rust because of the cultish support it is receiving, that may be a more decisive factor then anything else. I honestly can’t say whether it is sensibly better than the competition. I just know it looks less messy than C++
I'd say Rust is better than C++ for the majority of people and companies. I programmed both in C++ and in Rust a lot. I still feel that Rust misses variadic generics and `std::get` for tuples but C++ misses proper metaprogramming. The biggest issue now is the ease of search for talent. It's being resolved, which is amazing.
@@isodoubIet You can use { ; } instead of whitespace and put parentheses everywhere. It will look like lisp, but it will work. And if you're really hell-bent on it, you could even use tuples instead of currying
@@mskiptr " You can use { ; } instead of whitespace " Technically yes, but nobody does, which means all code out there I might import, use as reference, or work on, is using semantic whitespace, so the fact that this is at all available is a problem. " And if you're really hell-bent on it, you could even use tuples instead of currying" Currying is not bad. Currying is good. The fact that type expressions associate in the opposite order to usual expressions is the problem.
The name of a language also plays a role in it’s popularity. Ocaml sounds weird to me, so I’ve never even looked at Ocaml source code and probably never will, just because the name is weird. Btw, people who don’t like assembly will never become good programmers.
i wish ocaml had better build tooling. dune feels lacking to me, which is a shame because it’s objectively the coolest named build tool. wish it could be overhauled into something similar to cargo
Luckily people giving the job interview also don't understand OOP. It's just 1 of those words that acts like a secret handshake, just like "clean code". I actuality read Uncle Bob's Clean Code and replied to a job interview that had clean code as requirement. They didn't know what function hoisting in js was so they were very confused at the fact that I was doing the Clean Code as instructed by the book. Which made me confused as to why they put Clean Code as a requirement to start with. Apparently they were talking about just basic indentation and naming variables somewhat sensible, this was a Medior position.
Most people's version of "OOP" is just glorified procedural programming. OOP certainly comes in handy. But for most projects, its best as a seasoning rather than the full meal.
@@IBelieveInCodePeople who "throw away" OOP don't understand it and are actually using it. OOP isn't classes and inheritance, it's design patterns and SOLID design principles. Unfortunately, most devs still don't know SOLID.
OCaml absolutely deserves more attention. Fingers crossed! Haskell has a tendency to attract an insufferable set of people, which I'm getting tired of. It's like the BMW of programming languages :)
@@adriancruz2822 function = some discrete entity in a language. functional programming = how you program; a programming paradigm. A programming paradigm has formal rules and definitions to program in a certain way. Languages have to support or provide certain features to allow you to code using a programming paradigm or allow you to program in a certain way. Just because a language has functions doesn't mean you can do functional programming in it (C is a good example).
it's confusing because people make blanket statements about what is or isn't functional programming - filter/map/reduce and functional composition are functional programming techniques, so you are "doing functional programming", how the hell else would you describe what you're doing? there are plenty of overlaps between most languages, and most popular languages today can be described as "multi paradigm" or "multi discipline" - you can practice or lean towards certain paradigms, techniques, or disciplines, in pretty much any mainstream language. You don't need to torture your brain with immutability and monads for 8 years in university before you're allowed to "do some functional programming". Just my opinion, but most of the purist FP languages aren't popular because they're too complicated and not very useful in practice. It's not an exclusive club - take what you can use, take what you like, and apply it where it makes sense. :-)
@@adriancruz2822 Imperative programming is oriented around telling the computer *how to* do X. Functional programming is oriented around *simply telling* the computer to do X. Map/filter/reduce are examples of how the raw details of iteration over collections get abstracted away under functional programming. You don't care about index variables or clever loop conditions. You just call map on a collection, pass in a function that will do Y to every element of the collection, and you're off to the races. Those higher-order functions aren't all there is to functional programming, but they're a good representation of the difference between it and imperative programming. FP tries to avoid digging into implementation details as much as possible. Rather, you just combine functions to produce the desired values.
Some years ago I started ocaml, but I went to Haskell and F# . But F# its basically ocaml with more stuff and other functionalities. Ocaml is so underrated like Erlang. Been doing lot of stuff with FP languages last years, and Haskell and F# are part of my life basically. I started with C , 28/30 years ago, still love C for sure 👌
F# is awesome. I wish learning resources were more plentiful and better designed, but I'll admit it's probably the language I'm most interested in picking up right now.
FP checklist (if you haven't seen it yet): - -20 years of Excel- - some Lisp experience (idk which one tho) - some Haskell-like experience (a day of Elm, then some PureScript, Haskell or Idris) - some Erlang experience (probably Elixir)
@@anon-fz2bo Excel is the most popular purely functional language on the planet. Change my mind (it even got =LAMBDA([p0, p1, …] ) recently) Of course a day of Elm ain't Haskell. But it very quickly gives you a solid understanding of the basics. You can easily build a mental model for how evaluation works, understand why execution is just an implementation detail and so on. It's small (focused), well-documented and easily approachable. That's what matters for beginners. After a day or two, you can move on to the real deal. You got shadowhammered btw (had to jump through some YT hoops to see your reply)
C++ was the most popular language before Java and I don't think it ever had huge corporate backing. Objective-C (and really, even C#) never really came close to Java's level of popularity despite Apple (and Microsoft) being bigger companies than Sun. The two current most popular languages are JavaScript and Python, neither of which are really backed by specific corporations but rather embraced by then because they're already hugely popular. Honestly I think every single language that gets hugely popular gets there based on either killer apps or on solving specific shortcomings of the previous language without being too different. For C it was a killer app (Unix), for C++ it was higher levels of abstraction upon C, for Java it was (memory) safety over C++, for JavaScript it was a killer app (the web) and dynamism over Java, and for Typescript it's (type) safety over JavaScript. Perl, Python and Ruby are kind of exceptions in that they were just flexible enough to find different niches over time and accumulate popularity, although even then only Python seems to have survived the purge that was Node.js on all backend web languages, by finding a niche in data science and ml.
I despise Java. I was initially enthused about it when I saw it as a client side language for code that could be moved around the Internet easily. When it became the COBOL of the 2000s, I gave up on it. It amuses me that Javascript became the language for mobile code. I have some hopes for Web Assembly. So... Lua is used as a scripting language embedded in things. I think it's terrible for that for a variety of reasons. I'm a huge fan of Factorio, and it has an amazing modding system that I think is really hampered by the fact it uses Lua. If there were a nice way to use Web Assembly for stuff like that, it would be fantastic.
I really have to doubt the notion that people naturally think in 'procedural'. And even if true FP is way better for top-down and bottom up programming
@@aoeu256 Hey, thanks for the reply! I'm not familiar with Eff, though that sounds interesting (need to look up what "algebraic side effects" are, though). Unfortunately, I constantly lament the fact that, as much as I love Lisp (I got pretty good at one point writing Emacs Lisp, though I admit my macro fu is weak), Lisp lacks something that I feel is one of the features I liked most about ML: its strong static type system. I sometimes wonder why they haven't come out with a Lisp that has this feature (or maybe that's just SML/OCaml/Scala etc., just sans macros).
Spot on! The first language I was exposed to was Basic on a Commodore64. Haskell is so hard for me I periodically pick it up and throw it away, yet it fascinates me.
when people apply functional programming techniques (immutability, pure functions, functional composition, etc.) they're not "doing functional programming"? I mean, what else would you call it. I think we have to use that description, and I think purely functional programming languages should probably be qualified as "purely".
In 40 years, maybe. I don't think people realize just how much code is written in C++. These are not code bases you can rewrite when a new shiny comes along. For example Unreal is *millions* of lines of C++, and probably another million more for the GPU drives and drawing libraries. The game logic itself you can write in higher level languages.
@@kurt7020 You know zig support c/c++ you can call them to and from zig and also comes with tools to convert C/c++ to zig. Like unity before had JavaScript scripting and they decided to stop supporting that so they made a converter to convert js project to C# so is there a chance if you can just convert you c/c++ to zig. the main feature of popularity for rust is memory safety so is that much improvement of rust/zig worth the switch even with these converter
12:35 I had to learn Java at university and oh god what a waste of life time that was. From a total beginner to whatever the hell I am now a decade later, my hatred for Java may be the only constant. We did C/++, Assembly, JavaScript, PHP, C# and a few other things here and there, and I enjoyed every single one of them more. I'd sooner do web dev in assembly than look at a Java project and wonder why the hell 90% of the program is running out of a config file rather than in actual code.
I think most of it here is very true e.g the reason why Javascript became popular was the frameworks like Node.JS, React and AngularJS and despite it not being a typical enterprise language and having strange rules. Typescript already tries to change this but in general it doesn't guaranty that your place is safe when strange things happens e.g Java . The reason it didn't apply for PHP back then it came with all it was meant for and also being the first language for webserver backend. Functional Programming I lernt it with Scala on my university I was horrible at it XD but I know why it is hard your function is basically your mathematically definition and instead of loop you use recursion. Scala is also OOP at the same time means doing mathematically definition and recursion on lists and objects. Its so strange and different from what you usually do as programmer its needs a complete different way of thinking. Its closer to writing a mathematically prof with Hoare logic that your program is correct.
Clojure definitely seems to have these same problems. I've never met anyone who said it was their first language. Even with being built on the JVM (and thus having access to the entire Java ecosystem), and a lot of concessions to allow for more imperative styles of programming in a functional language, it remains consistently niche.
@@ThePrimeTimeagen I don’t think it’s purely an issue with the language. But I think that when there’s something that comes somewhat naturally to me that also does everything I need (like c++, rust, c#, etc), I don’t find a lot of motivation to learn the languages that don’t feel natural.
@@KayOScode I mean, ultimately procedural is what the machine is doing so there's IMO a sense in which it's objectively more natural. That you can express any computation in functional form to me is more a curiosity than anything.
@@ThePrimeTimeagen I vote crappy learning path and teaching materials. Evidence: university A/B tests of course sequences. Students whose first introduction to programming is with FP end up better at imperative programming by their 3rd semester than students who did 3 semesters with the same imperative language. Further evidence: Excel is the most popular programming language for people who don't think are doing programming. Large excel programs are generally functional.
wait, i have a usefull comment: the haskell sdl bindings make me want to go back to assembly language, they are so stars damn horrible. What the heck kinda function name is "$~!"?
And maybe it is not just about libraries but also about a programming paradigm which is easy to understand for beginners? Look at early PHP. Look at C. Structural imperative. And people tend to understand imperative stuff using intuition, like they understand cooking recipies: you have this steps, you can go sideways using "if" or go somewhere else by calling a function or a procedure, you can repeat a fragment using loop. You can start writing programs in hours. In object-oriented or functional you need to think first and very often learn some idioms, operators and syntactic notation.
Some months ago I started to search about F#, as C# dev I was curious about that. Then I loved the concept about think in this functional way and also use composition to express real world models. But I figured out that probably F# wasn't a good choice, then I watched the your "ocaml... rust with garbage...." video and I loved because it combines all nice features that I saw in F# + and very powerful memory management, also I agree with you about something that have Rust best features but without the Foundation. I'm starting ocaml these days watching your live streams and also doing it by myself. Let's make ocaml popular !!!
@@scosminv I also didn't understand why the order of my project files influences on namespace resolution and it is very annoying. And ocaml looks funnier than F#. But I have interest in learn functional programming, I know that F# could be more useful since I'm C# developer. I also seen a lot of videos from Scott Wlaschin and also read his book about DDD with F#. But in my point of view the ecosystem behind F# is very strange and difficult. By the other hand with just some commands I was programming and following the ocaml getting started tutorials, while F# gives me a lot of confusion and I felt very lost.
Imo a big problem for Ocaml is that it is just getting native windows support this year. Ocaml hasn't really been able to create software for the most popular os for most of its life
The main reason why people hate functional programming is because of the difficulty to understand applicative order, recursion and lamda calculus after learning imperative programming (if you did not not touch recursion it is even worse) because the way of thinking changes. I know it well because they tried to teach me scheme after c, c++, c#,Java, python. Why do you do that to your student!!!! They told me how it is better to write functional programming and how the code is beautiful and short after passing hours and hours on imperative programming and oop. How do you want that I like the prefix syntaxe and all the parenthesis (if (= x 0) (do something) (else)). Variable are immutable what nightmare. They should first teach functional programming.
