Comparing 10 programming languages. I built the same app in all of them.

Sdílet
Vložit
  • čas přidán 3. 04. 2024
  • Many modern programming languages have some great features like null safety, exhaustive switch statements, error handling, strong type systems, immutability, great tooling and good readability and write-ability.
    I couldn't decide which language I preferred so I made a TCP server that does some basic file processing in all of them. Using no dependencies where applicable.
    I did this using Rust, Go (or Golang), Crystal, Kotlin, Julia, Zig, Nim, Gleam, Swift and Dart.
    Just for fun, I gave each language a 1 to 5 score in the categories of tooling, safety, readability and ergonomics.
    Just btw this is an incredibly biased video so please don't take anything personally.
  • Věda a technologie

Komentáře • 445

  • @ridwanulhaque5299
    @ridwanulhaque5299 Před měsícem +370

    "It is a skill issue but an issue nonetheless."

    • @sebastianpaulis7184
      @sebastianpaulis7184 Před 22 dny +6

      I died when I heard him say it

    • @angeldude101
      @angeldude101 Před 11 dny +12

      Hearing "skill issue" and it being treated like a real issue rather than an excuse to ignore a problem felt oddly refreshing.

  • @lpil
    @lpil Před 2 měsíci +444

    Gleam mentioned!!!

    • @marcellofonseca6065
      @marcellofonseca6065 Před 2 měsíci +28

      Great language! Thank you so much man

    • @ccriztoff
      @ccriztoff Před 2 měsíci +11

      Beyond cringe 😂 just learn Rust or Go

    • @jamlie977
      @jamlie977 Před 2 měsíci +13

      @@ccriztoff RUST MENTIONED! LETS GO

    • @ccriztoff
      @ccriztoff Před 2 měsíci +4

      @@jamlie977 Rusty and Crabpilled

    • @neociber24
      @neociber24 Před 2 měsíci +2

      I know this guy

  • @JosephCatrambone
    @JosephCatrambone Před měsícem +57

    Timestamps for folks:
    1:00 Golang
    3:25 Crystal
    5:47 Kotlin
    7:33 Swift
    9:28 Zig
    11:38 Gleam
    14:07 Nim
    15:30 Dart
    16:50 Julia
    18:01 Rust

  • @bjbboy71697
    @bjbboy71697 Před 2 měsíci +206

    As zig is pre-1.0, it moves very quickly and the LSP targets the nightly version so it probably didn't work for 0.11. Once it hits 1.0, the idea is to not change the language much and things will settle down a bit. Sorry you had a bad experience with Zig. It really is a great language. If you ever try again, use the nightly!

    • @tom-delalande
      @tom-delalande  Před 2 měsíci +56

      Thanks for the mention. If the tooling does work on nightly that's my mistake. I will definitely try it again, there's so much to like about it.

    • @arden6725
      @arden6725 Před měsícem +8

      that’s not true, the lsp has tagged builds for each release, including 0.11. As it is the lsp doesn’t work anywhere that comptime is involved, which is pretty much everything

  • @nERVEcenter117
    @nERVEcenter117 Před měsícem +61

    I use Nim at work for exactly a kind of use-case it excels in: Fast native-compiled statically-linked data processing that needs to be portable to embedded platforms (my giant program compiles as-is on ARM using musl-libc), with ergonomic Pythonic syntax that ensures you don’t need to worry about memory issues. It can be best described as either: Very fast native-compiled Python, or extremely, unrecognizably ergonomic C++. Take your pick.

  • @EightSixx
    @EightSixx Před 2 měsíci +68

    can't wait to see this when zig is at 1.0+ like the other languages on the list.

  • @blaisepascal3905
    @blaisepascal3905 Před 2 měsíci +56

    Julia and Nim, such wonderful but underrated languages. Both in my top 3!

    • @patrickmoehrke4982
      @patrickmoehrke4982 Před měsícem +3

      What is your other top 3?

    • @blaisepascal3905
      @blaisepascal3905 Před měsícem +13

      @@patrickmoehrke4982 ok, don't freak out. It's R, I am a researcher. And R do the job really well.

    • @patrickmoehrke4982
      @patrickmoehrke4982 Před měsícem

      @@blaisepascal3905 Haha I also use R! It doesn't get enough credit outside statistics and academia.

    • @spacelem
      @spacelem Před měsícem

      @@blaisepascal3905 same, I've been working in R for the last few years and it's wonderful for stats and plotting, but I was able to get some really complex genetic epidemiological modelling done with Julia pre-2020 which R would have choked on. Two languages that seem to scare people off, but are so nice to use once you get the hang of them.

    • @InfiniteQuest86
      @InfiniteQuest86 Před měsícem +18

      Yeah he basically ignored all the real use cases for Julia which makes it seem like a glorified bash. But try doing complicated math in bash and you'll quickly see where Julia excels.

  • @sp.n7401
    @sp.n7401 Před 2 měsíci +63

    Nim starts getting good when you look into metaprogramming. See some of the DSL libraries like Jester or HappyX. Also its ability to compile into C, C++, or JS makes it good for pretty much any domain.
    Also note Nim's memory management model nowadays isnt really a traditional GC, but the memory is automatically managed at compiletime.

    • @tom-delalande
      @tom-delalande  Před 2 měsíci +28

      It seems like need to put some more dedicated time into Nim. Thanks for the advice

    • @yuitachibana8829
      @yuitachibana8829 Před 5 dny

      Imo nim has the same problem with modern c++, too many ways to do 1 thing and unopinionated so each project has a completely different structure

    • @sp.n7401
      @sp.n7401 Před 5 dny

      @@yuitachibana8829 I think the standard library is very consistent with one way to do something. Where C++ feels like you have to read a book on every individual subsection, Nim is pretty straightforward and you can read anything that only uses std.
      That's what makes me appreciate Nim more and want to distance myself from C++. Plus, macros still use Nim's standard calling conventions so it never feels jarring.

  • @billygnosis
    @billygnosis Před měsícem +16

    Great video! I would like to see a follow-up video analyzing Elixir, F#, Haskell, PureScript, Clojure, and OCaml.

  • @Atmos41
    @Atmos41 Před 2 měsíci +51

    I don't really understand why Dart got such a low score. It feels like it gets a lot of things right, and I had a blast using it to maintain a production Flutter app. It feels like your grades don't align with your feedback :D

    • @AGAU1022
      @AGAU1022 Před 2 měsíci +18

      Dart got a high score and came in fourth.

    • @JavierGuerra_g
      @JavierGuerra_g Před 2 měsíci +16

      he actually didn't use the nice parts of Dart. the `..` operator is pure genius for initialisation, making dependency injection work without any clunky library or "bag of globals". the automatic parameters make robust initialisators look like magic. like with Zig, it requires more than just a glance to appreciate. I bet he had previous experience with some of the most highly rated ones, which helped him find the best parts of those.

    • @gaxkiller
      @gaxkiller Před měsícem +6

      I use dart since 5 years and I love it, I think he treated dart fairly. There is still stuff we want and don't have yet in dart. Static metaprograming (it is coming very soon), error as value not exception (no plan to change this at all, so you have to import fp library like fpdart and use either type). For some reason they don't want to let us configure line length on a per project basis, and default line length is 80... I find the pattern matching syntax to be a bit confusing (particularly when using switch expression) but it might be me I don't know.
      Except that, the toolings is just awesome. I use flutter (so dart) at work because I in charge of the mobile team, but I have to work with python for backend, I feel so miserable when I have to use python, the tooling is horrible, the language is horrible, nothing works, it is probably the worst language I ever used.

    • @gaxkiller
      @gaxkiller Před měsícem

      @@JavierGuerra_g It is the second time someone mentioned the '..' operator as an exceptional feature of dart and I don't get it, if you embrace immutability you cannot use this operator 99 percent of the time when initialising a class, or I am missing something. Could you also elaborate how it helps for Dependency injection please? Always eager to learn new stuff about this language I love, even if I would feel dumb having missed incredible feature usage for so long

    • @JavierGuerra_g
      @JavierGuerra_g Před měsícem +2

      @@gaxkiller there's so much to be said about how DI is great when you don't use a library and so disastrous when you do. and for most languages, the syntax gets in the way, making complex initialisations either complex and hard to read, or a whole API in itself. to make that last option somewhat more palatable, somebody invented "fluent APIs" which are nice, but tedious to implement, and create other limitations.
      in flutter, the '..' operator gives all the benefits of fluent without having to create all those initialiser methods, and thus you get those multi-line, deeply nested, but nicely-indented and very readable initialisation stanzas, where you can do all the DI you wish.

  • @Speykious
    @Speykious Před 2 měsíci +101

    My job literally involves Java 8 and JavaScript... I got called out so hard
    Sike! We use more and more Rust now because of me >:D

    • @residual-entropy
      @residual-entropy Před 2 měsíci +6

      lol I would be so happy to have a job writing Rust

    • @owndampu1731
      @owndampu1731 Před měsícem +3

      could be worse, my job is mostly Matlab/Simulink code generation. But I am also introducing more tooling in rust so at least thats nice

    • @residual-entropy
      @residual-entropy Před měsícem +2

      @@owndampu1731 I despise matlab, although someone in the research lab who I work with has to write Fortran lol.

    • @dotchris1111
      @dotchris1111 Před měsícem +1

      C89 and some pre-C89 and Java 8

    • @arandomzy
      @arandomzy Před měsícem

      Damn sucks that you downgraded!!

  • @virusblitz
    @virusblitz Před 2 měsíci +7

    Very agreeable takes, thanks for your efforts!

  • @rakaboy1619
    @rakaboy1619 Před 2 měsíci +44

    Zig fan here. The reason why you struggled so much with Zig might be this language's innate low-levelness. Sometimes writing Zig feels like writing LLVM IR, and for an untrained hand this is almost a chore. Tho it gets easier over time. Also comptime comptime comptime. It is incredible, and i get immeasurable high when it works the way i want. You can pretty much have every single feature of any language, have it as a zero-runtime, and have it not being a macro. This is nothing but witchery, atleast it feels like it.

    • @AGAU1022
      @AGAU1022 Před 2 měsíci +3

      He didn't struggle as much with Rust though.

    • @rakaboy1619
      @rakaboy1619 Před 2 měsíci +14

      @@AGAU1022 i dont think Rust is nearly as low level as Zig.

    • @beeplove7
      @beeplove7 Před 2 měsíci

      ​@@AGAU1022 Zig is pre 1.0, it is clearly not stable for now. Things move fast. People are bound to face issues but still many are adopting it. While Rust has been around for a while now. The creator of zig was frustrated to write his program in C++/Rust/C so he started creating zig. So can't really complain about a premature language

    • @androth1502
      @androth1502 Před 2 měsíci +13

      i find it odd that he had a hard time with zig, but no problem with rust.

    • @Darkev77
      @Darkev77 Před měsícem +6

      @@androth1502 so true lol, Rust group bias I guess

  • @b5matt
    @b5matt Před 2 měsíci +38

    Nim also supports checked exceptions btw. And the default GC is refcounting like swift.

  • @lucasmsoares96
    @lucasmsoares96 Před 2 měsíci +2

    You do an excellent job. All that was left to do was take into account the quantity and maturity of the library ecosystem.

  • @CristianMolina
    @CristianMolina Před měsícem +7

    Thanks for taking the time to do all this coding and evaluation. It's very nice to see the implementation in diff. languages. IMHO, Rust code is the most unreadable, by far.

    • @YT.Nikolay
      @YT.Nikolay Před 28 dny

      ChatGPT can convert the given code to any language that existed before 2019 ;)

  • @Leao_da_Montanha
    @Leao_da_Montanha Před měsícem +3

    hey tom I was thinking of this video and I just had the idea that if you extend those same examples trying to getting deeper into optimization for them, you would dive deeper into the languages, review what they provide for performance and so on. Lets be real that is the type of thing that everyone subscribed here would watch more than an hour easily. It would be epic, all of luck!

  • @dampfwatze
    @dampfwatze Před měsícem +6

    I like Dart the most! It has such clean and logical language features, it just feels nice to write! It doesn't have stupid pitfalls and shortcommings. Also, since it has a big Company behind it, it evolvs very rapidly and gets good improvenents regularly! Since version 3 it got big improvements on the functional side, with pattern matching and exhaustive switch statements. And it has null safety since version 2.

    • @olafschluter706
      @olafschluter706 Před měsícem +2

      The problem with dart is tooling. You can write a dart executable, but you cannot write a library with C ABI linkage (in fact you cannot write a library and ship it in binary form at all). Another drawback is that it is by nature a programming language for single-threaded applications. It has async/await, but running multiple threads using the dart standard features is awful.
      It's biggest plus in my eyes: when you come from Java, Dart is a weekend job to learn. It's a less verbose version of Java with Null-Safety and free-standing functions and variables.
      It does a pretty good job to support the Flutter Frontend Framework, where multi-threading isn't needed that much, but asynchronous operations are all over the place.

    • @dampfwatze
      @dampfwatze Před měsícem

      @@olafschluter706 Yes, that you cannot bind C libraries easily is a big problem that just did not get enough attention, also because it works in Flutter and Flutter was the primary focus for a long time. But the team behind Dart is actively working on a solution, it is called native assets and it is behind a experimental flag at the moment.
      Of course, that it does not support multi threading easily is a drawback. Though, the use of isolates encourages the use of message passing to pass data, which is often thought to be a safer method to handle data, than for example a shared state. But I do use Dart very often and I rarely find myself actually spawning additional isolates, because for the use cases Dart is designed for, it is often just not needed. Partly because async/await works so well. Of course for use cases like Webservers it would be beneficial to implement multithreading and I think a well designed Framework could very well work around Darts limitations. And comparing to other languages, it is not worse than for example Node.js (it works essentially the same), which is one of the primary Webserver runtimes today... Only God knows why... And for example Python cannot do any real multithreading at the moment, because of the GIL...
      Overall I think Dart has great potential to replace many current solutions like Javascript (in front and backend), Python (as a scripting language, for Webservers, or even for algebraic and ML use cases), Java, C# and probably more! It is just, that the Frameworks are missing...

    • @TarrenHassman
      @TarrenHassman Před 14 dny

      @@olafschluter706 Dart has multi threading using isolates. And there is even a simplified implementation for flutter called compute. I find it to be very straightforward and I used to write multi threaded code in C almost a decade ago.
      As for compiling to binaries, there is a dart2native package as well as flutter being able to compile into every native platform mobile, desktop, and web.

  • @Danielo515
    @Danielo515 Před 2 měsíci +1

    Thank you man, this was very valuable

  • @Sel178
    @Sel178 Před 2 měsíci +7

    Nice comparison! Good job. Try also OCaml next time:) I'm sure you will enjoy it as it's like a rust with GC.

  • @SnowTheParrot
    @SnowTheParrot Před měsícem

    Great video and thanks for trying all of these languages

  • @qwfp
    @qwfp Před 2 měsíci +1

    I appreciate you being clear and upfront about how you'll be ranking the languages. Also, you might enjoy Roc! Although TCP server might be too low-level (in Roc those things are usually handled by platfroms), so I would recommend making something else with it

  • @danstoian7721
    @danstoian7721 Před měsícem +5

    9:08 Sad truth😔I feel Swift is such a beautiful language with so much potential. And while it is open-source and Apple is doing something, it's not that widely adopted because:
    1) Still needs a good cross-platform IDE
    2) Apple Documentation is terrible
    3) It lacks APIs for so many general-purpose things

  • @Flourish38
    @Flourish38 Před měsícem +3

    Julia is my favorite language! I think you basically correctly described it, it's excellent for REPL programming and a few other things, but it's not the right choice for most projects.
    I especially like how you put it at rock-bottom on the safety scale! That is exactly correct, there are very few languages that will let you overwrite almost everything in the language, even to the point where there isn't really anything you can do but restart your REPL. It doesn't come up often, but when you want it, it's nice to have such a ridiculous brute-force solution.
    In my opinion, it is the perfect prototyping language. It lets you focus on exactly the things you care about specifying while ignoring ALL the rest, whether that be expressive types, data structures, performance (to an astonishing degree, actually), even concurrency... everything except for correctness. If you can write it in less than 1000 lines of code, and it doesn't have to be perfect, then you're going to have a good time with Julia.
    Also, the array broadcast notation makes me feel like I have superpowers. Working with collections in Julia is so freeing compared to everything else I've used.
    But yeah. Rewriting yet another Julia program in Rust right now (this time, for WASM support) :P

  • @darkfllame
    @darkfllame Před měsícem +2

    11:17 on the top, there is the compile command, below is in what module the error occured, below again is the error, basically, in zig, you can only access active field of unions, there are also tagged union which you can use switch on them. here you try to access "Pointer" while the union field "Struct" was active. what you can do is check if the field is active: if (taggedUnion == .Field) { . . . } or use a switch statement: switch (taggedUnion) { . . . }

  • @eduardabramovich1216
    @eduardabramovich1216 Před 2 měsíci +43

    Nim is way, way, waaaaaaaayyyyy faster than Python, so of course there is an advantage. Regarding Nim's identity, I've heard people saying that and I don't understand the point. What's python's identity? Everything, it's used for everything. Web, desktop, data analysis, data engineering, scientific dev, scripting, sec tools... But nobody complains about that.

    • @4idenn
      @4idenn Před měsícem +5

      Tbf these days I think Nim's identity is "the hacking language"

    • @pnk4996
      @pnk4996 Před měsícem +17

      Pythons identity is that it’s the most mid language ever

    • @SirRichard94
      @SirRichard94 Před měsícem

      And that's why I don't like either

    • @gaxkiller
      @gaxkiller Před měsícem

      Well, taking python as a reference speaks a lot, if you eat s**t everyday, dirt might taste good to you

    • @johndoe7017
      @johndoe7017 Před měsícem +5

      Yeah but that’s great, because you can learn one language and do anything you want. It may not be fast but being able to do anything is quite convenient

  • @Vogon42
    @Vogon42 Před měsícem +10

    I would have added performance as a criteria.

  • @cheesybrik9073
    @cheesybrik9073 Před měsícem +3

    I think you should look into nim more. While I do agree it has some strange stolen features that don’t feel like they mesh well together. It’s actively developed and isn’t afraid to add new patterns. Honestly I would love to see you’re criticisms more in the nim community and I would love if you got involved.

  • @munchymanjaro9070
    @munchymanjaro9070 Před 2 měsíci +17

    Pretty sure idiomatic Kotlin error handling is much closer to Rust then Java. You would use Result type to return error as value and throw for panic. I dont really know tho, I am in the process of learning Kotlin. Overall Kotlin seems like an extremely pragmatic yet expressive language, with a module system to avoid common oop pitfalls. With the mutliplatform enetring stability, it just might be a killer app of Kotlin ecosystem.

    • @MarcelRiegler
      @MarcelRiegler Před měsícem +4

      The MAJOR issue with Kotlin is exactly that there is no idiomatic error handling. The official Result Type was only added after years, and they threw out checked exceptions without giving us a good, standard library alternative.
      Meaning, everyone did their own thing. You also lack convenience of a "try-catch"-like structure for Result types, meaning you end up having to manually check every Result.

  • @neronim0
    @neronim0 Před měsícem +1

    Didn't understand a word you said. Video is great tho. Am in awe of your programming capabilities ^^

  • @vladimirkraus1438
    @vladimirkraus1438 Před 2 měsíci +16

    Very interesting video. Just an idea for next similar ones: you should also compare these with "classical" languages that everyone has to use at everyday work such as Java, JavaScript, Python or C#... This would give the insight about the language evolution from the classics to the modern ones.
    Btw. I am a Kotlin fan. As I do not mind using JetBrains tooling (which is perfect!) I would give it much more points in tooling category which would make it almost a winner. :)
    I was surprised by Gleam, I have never heard of it... but I will definitely find out more.

    • @ccriztoff
      @ccriztoff Před 2 měsíci +4

      Java, JavaScript and Python some of the worst shit 😂

    • @gaxkiller
      @gaxkiller Před měsícem

      @@ccriztoff Yes, I understand why he didn't even loose time trying them >

  • @Darkev77
    @Darkev77 Před měsícem +14

    Great video and overview, but Zig is really unfairly rated.

  • @danielkurz7806
    @danielkurz7806 Před 2 měsíci +3

    great video! It'd be interesting to compare the LOC it took in each language

    • @tom-delalande
      @tom-delalande  Před 2 měsíci +15

      Thanks! Great idea.
      Here are the lines of code (including any blank lines):
      Nim - 150
      Kotlin - 163
      Julia - 170
      Swift - 180 (with dependencies)
      Crystal - 187
      Dart - 190
      Go - 264
      Gleam - 278 (with dependencies)
      Zig - 338
      Rust - 354
      Anecdotally, Go and Dart definitely felt the quickest to write and Zig took me the longest.
      Interesting that I enjoyed some of the verbose languages. I wonder if that's just Stockholm syndrome and less lines is actually just easier

    • @danielkurz7806
      @danielkurz7806 Před 2 měsíci +3

      ​@@tom-delalande Thanks! Yeah very interesting, especially how few LOC nim took. I guess some of it could be attributed to "skill issues" :D But also more LOC could mean more resilient code because of error handling
      So yeah very cool

    • @gaxkiller
      @gaxkiller Před měsícem

      LOC is the most useless metric. You can write s**t very quick in python, with zero error reported by your IDE and zero error handling. But then you would need 123124124 LOC of unit test to be sure that true = true

    • @misalambasta
      @misalambasta Před 13 dny

      ​@@tom-delalande pin 📍

  • @stretch8390
    @stretch8390 Před měsícem +2

    Nice vid, informative: would love to see this across different tasks. Rust being a joy to read is a bit on the nose however.

    • @mikkelens
      @mikkelens Před měsícem

      Not sure what you mean about that last part. Is rust really bad to read? Compared to what?

    • @stretch8390
      @stretch8390 Před měsícem

      @@mikkelens obviously elements of personal preference, but Rust is well known for correctness not for being a joy to read. Ruby is a joy to read, APL is a nightmare, and Rust lies somewhere in between. My 2c.

    • @opposite342
      @opposite342 Před 24 dny +1

      ​​​@@mikkelens Rust is basically impossible to read if you are newer to the language, especially when it introduces new concepts like borrowing and lifetimes. Meanwhile, most programmers can just see Go and understand what it does even if they barely use the language.
      Other than that, it's preference. I come from a Python background, so I found nim to be easy for me to read while zig being the hardest in these examples. Other people may prefer verbose language with more information, or c-style curly braces. It's all what you grown familiar with.
      However, if you remove that, my point still stands that Go is probably the easiest in general for anyone to read here.

  • @alhzz
    @alhzz Před 9 dny

    I’ve working with Bun and I am really liking it. The tooling is awesome and not require external dependencies do to the basics. The websocket module is awesome and easy to use

  • @michaellatta
    @michaellatta Před měsícem +1

    I like swift, the keyword arguments in particular. But, the rust ownership model and errors as results/values are the best.

  • @lazyh0rse
    @lazyh0rse Před 2 měsíci +27

    One thing I did not like, is how readability is being rated?
    For me, readability is the ability to read a code from someone else and know what it does. Why for example, rust with it's vast syntax is more readable than go? I don't get the justification.
    If I write code in golang, I will know what it do instantly, if I show it to anyone, they will know exactly what it does without effort. I wouldn't be so sure of that in the case of rust. Some libraries in rust is unreadable compared to others. Everyone have their own writing styles. It should be less readable than go.

    • @AGAU1022
      @AGAU1022 Před 2 měsíci +4

      I was a bit confused about the readability and ergonomics ratings for Nim as well. I get that Nim is unsafe but it seems pretty readable and ergonomic and had the fewest lines of code.

    • @jamlie977
      @jamlie977 Před 2 měsíci +2

      readability is a matter of familiarity, I don't think it can be rated since it would be unfair, for example, i write Go more than Rust and i never wrote Gleam, therefore gleam is not as readable to me compared to rust and go and rust is not as readable as go, it's unfair to rank it

    • @lazyh0rse
      @lazyh0rse Před 2 měsíci +4

      @jamlie977 no body said x is unreadable, but it should be a meteric of how much experience it requires. A code written by a senior go engineer will be readable for a junior dev. But rust won't.

    • @jamlie977
      @jamlie977 Před 2 měsíci

      @@lazyh0rse i get you, that's why i said it's unfair for him to rank them based on readability as it's a matter of familiarity, if he doesn't have much experience with a language he would assume it's not as readable which might be false

    • @AGAU1022
      @AGAU1022 Před 2 měsíci +3

      ​​​​​​@@jamlie977 It's unfair to rank it by your own subjective ability to read the language. But there is objectively readability in the sense that some languages are easier to learn when adjusting for that bias, like for beginners who have no experience in any language, and juniors with no experience in either language. A language is objectively more readable (on average when including beginners) when it more closely resembles natural language expressions of the same logic, more real words and natural grammar, less esoteric abbreviations, esoteric symbol use, and bloated non-grammatical boilerplate to declare things that should just be a default. Basically: how easily can someone without experience read it out loud in a way that accurately conveys the code.

  • @jonjimihendrix
    @jonjimihendrix Před měsícem

    First 10 seconds had me dying laughing. Also subscribing. Love the deadpan humor.
    I’m Rust/Go as situation dictates. I love rewriting Python in Rust and running comparative benchmarks. It’s stupid how slow Python is.
    Also minor maintenance of legacy Java and C++.

  • @NoahNobody
    @NoahNobody Před měsícem +1

    Great choice of languages. I personally would have added C# and Elixir. I would love to see a followup video with the languages people have mentioned in the comments.
    I've been a php dev for a while, so I've been looking for a new language to pick up because I'm a bit bored. I was originally attracted to rust and gleam, but they were proving to be a bit of a challenge, so I went with Go because it seems to be learnable and popular. One day though I will pick up Rust or Gleam.

    • @gaxkiller
      @gaxkiller Před měsícem

      I was very interested in Elixir too, then I saw it is not statically typed. From personal experience, the developer experience regarding dynamic language is subpar vs statically typed language so I did not bother investing time in it. There are adding type step by step apparently but it did not solve the problem for other dynamic languages that did that.

  • @devflo
    @devflo Před měsícem +1

    Thank you for adding gleam🎉🎉

  • @veritatas678
    @veritatas678 Před měsícem

    Excellent video. That was fast and concieces

  • @willi1978
    @willi1978 Před měsícem +1

    which program used least time to run? guessing rust and zig are pretty fast

  • @captainnoyaux
    @captainnoyaux Před 2 měsíci +3

    Cool video, you could try Rescript or more FP oriented languages to see if it's more to your liking

    • @tom-delalande
      @tom-delalande  Před 2 měsíci +2

      I've been thinking about Rescript a lot, I'm tossing between trying to learn either that or Elm.

    • @captainnoyaux
      @captainnoyaux Před 2 měsíci +1

      @@tom-delalande both are awesome, I believe there is more people using Rescript nowadays thought (it might not be a valid criteria for you)

    • @Weathercold
      @Weathercold Před měsícem

      ⁠​⁠​⁠@@tom-delalandeyou should try Clojure, though you might not like it since it’s dynamic

  • @diadetediotedio6918
    @diadetediotedio6918 Před měsícem

    19:50
    Just a quick note, because I think you borrowed that from Blow (pun intended), but I also think while it can take "10% more time to write" (even when this statement is so blank) it also can make your code "10% or more easier to write bug-free" which will save you time. So I think it is a net gain generally, but this depends on the scope and the project.

  • @Akronymus_
    @Akronymus_ Před 27 dny

    With that feature list at the start, I was thinking f# would be a perfect match

  • @JayAdamsTecnology
    @JayAdamsTecnology Před 2 měsíci +5

    Swift’s sourcekit lsp works with dependencies after you build the whole project, because it does not have a background indexing unfortunately
    I use it daily with neovim, it’s still not perfect (for example renaming does not work and you have to rebuild the project sometimes for it to be able to use dependencies) but it’s good and definitely better than using an Xcode
    If you have any issues with setting it up with vim, I’ll be happy to help

    • @tom-delalande
      @tom-delalande  Před 2 měsíci +3

      Thanks for the help, I did rebuild the whole project. I think something went wrong with my tool-chain where the one used in the CLI was different to the one used by the LSP. I reinstalled Xcode from scratch and the whole toolchain. But I still couldn't get it working. I think this issue was a weird combination of Sonoma + something running on Rosetta + Xcode conflicting with the toolchain. I definitely will keep trying to fix it because I want to keep using Swift

    • @NamanGoel34
      @NamanGoel34 Před měsícem +1

      @@tom-delalandeAlso a correction: Swift doesn’t have exceptions. It has errors as values. But it has syntax sugar to make it look like exceptions. It has a similar syntax sugar around it’s Maybe type by giving you a first-class nullable type.

    • @NamanGoel34
      @NamanGoel34 Před měsícem +2

      @@tom-delalandeAnd a correction for what felt like an implicit assumption: Swift does not have a garbage collector. It uses automatic reference counting by default, and you can opt into some ownership features or unsafe manual pointers for performance.

    • @NamanGoel34
      @NamanGoel34 Před měsícem +1

      TLDR; I would argue Swift has the same level of safety as Rust. This was not true for multi-threaded swift until recently. Since v5.10, there is a flag for strict concurrency checking.

  • @maximmodestov1280
    @maximmodestov1280 Před 2 měsíci +115

    I'm confused. You are saying that safety is important for you, things like exhaustive switch statements, immutability, and null-safety. And then you give Go and Kotlin the same score 3. Even though Kotlin has many of the safety features mentioned while Go doesn't.

    • @jamlie977
      @jamlie977 Před 2 měsíci +22

      same, he said he dislikes Go's error handling but said gleam had it really good, it's almost as verbose as Go's way

    • @TJackson736
      @TJackson736 Před 2 měsíci +74

      The man explains why - he dislikes try catch and prefers errors as values. He is lazy and will ignore exceptions while writing code without the compiler complaining. Go enforces error handling, and Kotlin uses unchecked exceptions.

    • @jamlie977
      @jamlie977 Před 2 měsíci

      @@TJackson736 the toInt method for strings in kotlin may throw an exception yet he praised it even though it doesn't tell you that it's may throw an exception since it uses java.lang.Integer.parseInt under the hood, it's really weird how he hates unchecked exceptions but not always

    • @AndrewBrownK
      @AndrewBrownK Před 2 měsíci +2

      it would be much more difficult to compare if allowing dependencies, he might like the result type from ArrowKt

    • @ccriztoff
      @ccriztoff Před 2 měsíci +5

      Go is simply better though

  • @thavith
    @thavith Před měsícem +2

    I really want to use Rust or Swift (not heard of Gleam so will check that out). Having said that, I love JS for the work I do (Node / front), but tend to only use the ES6+ stuff (don't have to maintain older 'smelly' code so much).
    I should build a Swift version of Node (I am sure it exists out there somewhere)

  • @Luigi931
    @Luigi931 Před měsícem

    Thanks for this video! 👍💯

  • @ariaden
    @ariaden Před měsícem

    And then there is a third group, array (and/or stack) languages, like Uiua. The most elegant solutions, assuming your inputs are integer sequences copy-pasted into the interpreter.

  • @mayatrash
    @mayatrash Před 2 měsíci +19

    Im forever a Julia boi. I just love it. It is absolutely perfect. But maybe that’s because I’m a physicist. But it’s just a breeze.

    • @blaisepascal3905
      @blaisepascal3905 Před 2 měsíci +6

      Indeed, the fact that you are a scientist may be a bias... but, Julia is just amazing like you said!

    • @SystemAlchemist
      @SystemAlchemist Před měsícem +7

      As a physicist as well as a software engineer, I entirely agree. Julia just has the best syntax.

    • @stretch8390
      @stretch8390 Před měsícem

      @@SystemAlchemist begin and end are two words that don't do it for me personally.

  • @niomeda
    @niomeda Před 2 měsíci +7

    21:17 Bro insulted me without even knowing me 😀

  • @cameronleebell97
    @cameronleebell97 Před 28 dny

    Damn that closing statement hits close to home

  • @code_report
    @code_report Před měsícem +2

    I came across this video in the r/gleamlang subreddit. Fantastic work : ) I think Gleam might be my new favorite non-array language.

  • @elau1004
    @elau1004 Před měsícem +1

    Love your review.
    Could do video on V Lang? Thx

  • @cubemaster1298
    @cubemaster1298 Před měsícem

    I used a lot of Zig lately so I might be bias but giving one on tooling is questionable. Setting up a project with zig build is so much cleaner than using CMake, Make, pkgconf or any other external tool bs when I have to use C or C++. Also the LSP gives a tutorial even for Sublime Text on how to set it up even though it's not the most used editor. The error messages most of time are much more readable than what you get when a C++ template code fails.

  • @gavr_sas
    @gavr_sas Před měsícem

    can you add link to the repo, its very usable to learn some of this langs via another that you already know

  • @gusryan
    @gusryan Před 21 dnem

    Do you have the source for the Rust project available online?

  • @olafschluter706
    @olafschluter706 Před měsícem

    swift vscode: for the time being it is necessary to build the swift package at least once to make sourcekit-lsp recognizing and processing package imports correctly. Other than that, vscode is the better IDE than Xcode for using Swift unless you are really into developing apps for Apple's ecosystem, where you depend on all the Xcode features supporting UI and other Kits from Apple.

  • @Varpie
    @Varpie Před měsícem +1

    I wish Gleam had an option to compile into a static binary, instead of always requiring the runtime. I find myself moving more and more towards container-based deployment solutions, and while there are base images with a runtime, it bothers me to rely on heavier bases and have the runtime shipped with every container I have.
    I think that's something C# understands well, in order to have .NET 8 reliable for cloud native solutions they added the Native AOT feature, and I wish other languages relying on a runtime did the same.

  • @BlueIsLeet
    @BlueIsLeet Před 2 měsíci +1

    For Go you should have used scanner instead of reading the file and splitting by line

  • @iaconst4.0
    @iaconst4.0 Před 23 dny +1

    A question, Which is the fastest ??

  • @opposite342
    @opposite342 Před 24 dny +1

    "Nim is the least opinionated language" - I agree. Been using it for a bit.
    On the surface it's a statically typed python with even more stuffs like metaprogramming capabilities etc etc. I like the freedom but I also appreciate what other languages have to offer in this list.

  • @PySnek
    @PySnek Před měsícem

    Nim needs more love! It makes me so sad that it's still not used for more important projects.

  • @charlesbcraig
    @charlesbcraig Před měsícem

    I’m most excited about Gleam. Feels like the love child of Rust and F#

  • @blazefirer
    @blazefirer Před 3 dny

    damn the end was too real. I just finished watching this on my lunch break where I will have to go back to writing spring boot on java 8 and angular js 💀

  • @mharley3791
    @mharley3791 Před měsícem

    Honestly, I really like rust but working when I have to write a bunch of just regular regular code is absolutely by far. The best option for me. It’s easy, it’s readable, The standard library is great and super quick to just get things done.

  • @thomasgeorge5261
    @thomasgeorge5261 Před 2 měsíci +4

    Crystal not requiring brackets when calling a function is actually not a good thing - it means that passing a function as an argument into another function is harder, because by default the function will be called and the value passed in, so you need a workaround (as with Ruby). Crystal is not like Haskell where a function with no arguments is actually just a value

    • @dragonyeet2273
      @dragonyeet2273 Před měsícem

      The intention is that you should use blocks to pass functions. Thereby is is sorta by design that you shouldnt pass a function as an argument, instead it should be passed as a block argument.

    • @thomasgeorge5261
      @thomasgeorge5261 Před měsícem

      @@dragonyeet2273 how about if you want to pass multiple functions?

    • @dragonyeet2273
      @dragonyeet2273 Před měsícem

      @@thomasgeorge5261 , never had that scenario. Luckily is a block when it is parssed by a method a proc and you could pass multiple procs to a method using normal arguments. If I have a method called boo, it is a simple as foo = ->boo. And now foo is a proc of the method boo or a function pointer in other words.

  • @thedeemon
    @thedeemon Před měsícem +2

    With your preferred features, I guess F#, Haskell and OCaml could shine here.

    • @mikkelens
      @mikkelens Před měsícem

      I’d like all those way more if they weren’t GC’d. I want to try haskell just bc its haskell, but if I wanted to write something in a GC’d language I think I’d try Gleam instead

    • @mikkelens
      @mikkelens Před měsícem

      I’m implying here that 1) none of these could ever be compile time gc’d like rust and 2) I think runtime, stop-the-world GC is kind of unnecessary and bad, and 3) I see little reason to adopt a GC’d language in spite of this

    • @thedeemon
      @thedeemon Před měsícem

      @@mikkelens If you google "Oxidizing OCaml" you'll find some interesting work going on in OCaml moving it closer to Rust's memory ownership, borrowing etc. But I don't know any details on the status and progress.
      Regardless, all mentioned languages have modern generational & incremental GCs with very short pauses (OCaml was quite famous for its good GC on a single core). Unless you make video games or something like them, the fear of GC might be rather irrational. Gleam might enjoy Erlang's thread-local GC that doesn't stop the whole world, but it's still just interpreted bytecode, so overall performance of actual code might be much worse than in mentioned languages.

  • @ironuckles
    @ironuckles Před měsícem

    Weird that performance characteristics or build artifact size didn't factor into your grade for each language. Regardless, pretty cool, thanks!

  • @BboyKeny
    @BboyKeny Před 2 měsíci

    I like mundane programming for work, fun programming for side projects

  • @codingbycyril
    @codingbycyril Před měsícem

    11:18 I will explain the error in a simple way. Basically you were trying to access Pointer field when the @typeInfo(@TypeOf(memory)) was a Struct. Simply you were trying to access something that was not there. Hope it helps

  • @spacelem
    @spacelem Před měsícem +1

    I love Julia, it's my favourite language now (apart from maybe R or Scheme). I find it elegant and aesthetically pleasing. That said, I primarily do mathematical modelling and statistics, rather than making apps, so I don't really know what it's like from that perspective. The 1-based indexing is something you'll find in a lot of programming languages popular among mathematicians (see also Fortran, R, Matlab, GNU Octave, Maple, Mathematica, and Maxima), I guess we just prefer it that way.

    • @renato360a
      @renato360a Před měsícem

      As a mathematician, I don't. And I always prefer to index my sequences from 0. Whenever I read a text that features a sequence with index starting at 1 I have a harder time grasping proofs. Good thing about programming in mathematics is that languages tend to be functional, so you don't often try to directly access some index or do index arithmetic. Also, Python has 0-based indexing so that's cool for me.

    • @spacelem
      @spacelem Před měsícem

      @@renato360a every time I see Python's "range" function, and know you have to say "1 to n+1" to get "1 to n" (instead of 1:n like any 1-based language) it makes me irrationally angry. Especially when numpy's "arange" function has the exact same behaviour for non-integer sequences, which makes it so much more difficult to specify the end point. I don't like Python.

    • @renato360a
      @renato360a Před měsícem +1

      @@spacelem yes, I would expect that! 😅But that's a very rare case as I see it. 99% of the time I'm not specifying the starting point, so I'm just reading "range(n)" as "give me _n_ terms of a sequence", which if we start from zero, naturally should end at _n-1_ . For non integer sequences I tend to use "linspace" more anyway, which does include the endpoint.

    • @spacelem
      @spacelem Před měsícem

      @@renato360a I'm a mathematical modeller, dealing with epidemiological and genetic models. I frequently need to simulate from t=[0..T] (end points included), but also when doing intervals it might be X(t) for t=[t1.. t2], and the next interval I need X(t2) as the initial conditions (this is absolutely the case with my current project, which involves a virus spreading between chickens, which one group being added to the previous group for a period, then moved back, and being the source of infection for the next group).
      When doing sensitivity analysis on parameters I often need linspace or logspace (or their language equivalents). It's much easier to drop the final point if I don't need it than to try to guess a value past the end that doesn't get me too many points.
      When it comes to accessing data (so integer values for an index), I just like the 1st point to be x[1], and the Nth point to be x[N], not x[0] and x[N-1]. It's less to have to think about. I know there are times when 0-indexing has helped with certain algorithms in C++ dealing with n-dim arrays, but R or Julia usually already provide the tools to not need to think about it.

    • @renato360a
      @renato360a Před měsícem

      @@spacelem Hm. I guess it's more like to which camp does one belong to, Naturals start from 0 or from 1. Mathematicians don't make up our minds about it so you see models starting sequences from either. And you and I are from different camps...
      Personally I love subtracting 0 (does nothing) and hate subtracting 1 (shifts everything), so I'd much rather start at zero and end at N-1. A long time ago I had to get it through my head at great pains that when you subtract two integers, the result has to be increased by 1 to yield the total number of elements including the endpoints. That made it very natural for me to see a sequence to N-1 as having N elements.

  • @finndriver1063
    @finndriver1063 Před 18 dny +1

    +1 for Gleam, but wish Clojure had been in here. I guess 2007 is a too old, but 1.0.0 was much more recent.
    I think it would be interesting to compare some 'old' languages still in use, but with their newer features.
    Think Fortran, C, Common Lisp, Erlang, Haskell, Ada, Smalltalk, Pascal for example.
    For example, I think CL's tooling is superb, and Haskell's is now good even though it had a bad reputation. Smalltalk is OOP, but not as you know it, and Erlang has some of the cleanest loveliest code I've ever seen. Fortran is quick and I find it quite simple to read for whatever reason.
    If you need the list to be 10, then perhaps add Forth, Cobol, Eiffel or Prolog if you're up for a challenge.

  • @Septumsempra8818
    @Septumsempra8818 Před měsícem

    How would you make a cross-platform app? I need an android and iOS app, but only have time to learn 1 new language. Any suggestions? So far it's react native or flutter

    • @thedeemon
      @thedeemon Před měsícem +1

      Flutter seems like a good choice here.

    • @tom-delalande
      @tom-delalande  Před měsícem

      Kotlin also let’s you do this with Kotlin Compose. It’s in Beta for iOS but it looks very promising

    • @gaxkiller
      @gaxkiller Před měsícem

      Using Flutter for 5 years now, very pleasant experience (it uses dart in case you don't know). Just don't go with react native.

    • @cryogensxu
      @cryogensxu Před měsícem

      Kotlin if you're not scared of experimental WASM for web.
      Flutter if you want some footshooting

  • @Leao_da_Montanha
    @Leao_da_Montanha Před 2 měsíci

    datastar video coming up or you're waiting the v1 release?

    • @tom-delalande
      @tom-delalande  Před 2 měsíci +1

      I've never heard of this, but it looks interesting

  • @adicide9070
    @adicide9070 Před měsícem

    is there any reason you didn't refactor your code to avoid this insane nesting?

  • @maksymiliank5135
    @maksymiliank5135 Před měsícem

    11:23 zig has union types which are actually tagged unions under the hood. If you try to access a member of an union which is not active it will result in an error. You have to use a switch statement (an if statement would probably work too) to check which union member is active and only then you can use its payload. Example:
    const Event = union {
    key_down: i32,
    mouse_moved: struct { x: i32, y: i32 },
    };
    var event = Event{ .key_down = 65 }; // 'a' button pressed, .key_down is 'active', accessing any other union field is an error
    switch (event) {
    .key_down => |key_code| {
    // do something with the keycode
    },
    .mouse_moved => |pos| {
    // do something with the mouse position
    },
    }

    • @gaxkiller
      @gaxkiller Před měsícem +2

      That is called exhaustive pattern matching if you are interested about the name :) very good feature more and more language start to add or already have. Of course python is not one of those one lol

    • @maksymiliank5135
      @maksymiliank5135 Před měsícem +2

      @@gaxkiller yes exhaustive pattern matching is related to tagged unions but the error was specifically because of the access of inactive union member. Zig allows you to access a union field if it is active without pattern matching

    • @fredesch3158
      @fredesch3158 Před měsícem +1

      @@gaxkiller That's not exhaustive pattern matching, that's accessing the wrong field of the union.

    • @gaxkiller
      @gaxkiller Před měsícem

      @@fredesch3158 This problem does not exists in good language, not aware of that

    • @fredesch3158
      @fredesch3158 Před měsícem

      @@gaxkiller What? It definitely does, if you try to access the wrong field from a union this is a standard error? You smoking?

  • @flamingwoodz
    @flamingwoodz Před měsícem +1

    Gleam needs more packages and then I will use it all the time. But it's new so that should happen as more start to use it.

  • @nanashi2622
    @nanashi2622 Před měsícem +1

    Rust is just so much joy to use, that's why I use it in all my personal projects.

  • @eduardabramovich1216
    @eduardabramovich1216 Před 2 měsíci

    You are missing one language that aims to be a C-Cpp alternative: Odin, it looks a lot like Go, but with custom allocators for memory management.

  • @carlosmspk
    @carlosmspk Před 10 dny

    To be fair, I don't know if there was a much better way to handle that rust match nest. The language kinda seems to promote it

  • @asd121asd
    @asd121asd Před měsícem +1

    Dart is awesome and very underused, prob. because people think it can only be applied to Flutter

  • @magemor7827
    @magemor7827 Před měsícem +4

    Well, a 20+ minutes vidéo I actually watched from beginning to end, no fast forward, no need to rewind.
    That's become so f'in rare these days!
    Clear sections of the video where you setup your goal, testing protocol, evaluation criterias.
    Then doing it with examplification, biased opinions and objective comments both for each.
    Then a summary and an acknowlegement of your biases and a humble recommandation of which to choose in your opinion depending on your preferences.
    Rust only got an 18/20, but you get a 20/20 note as far as I'm concerned!
    *DING* Subscribed

  • @krtirtho
    @krtirtho Před měsícem +2

    It's kind of sad that Dart's sound null safety wasn't even mentioned. Also, Dart 3 has a much more modern syntax than Dart 2 with pattern matching, destructring etc...

  • @ArtemShoobovych
    @ArtemShoobovych Před 2 měsíci +2

    interesting how you mention errors being cryptic with pretty much every language, but yet you somehow managed to get away with never getting into borrow checker errors? is it because you clone everything?

    • @SirRichard94
      @SirRichard94 Před měsícem +1

      tbf rust errors are very descriptive and even suggest fixes.

  • @alomac8976
    @alomac8976 Před 2 měsíci +9

    You might(or might not) like D or Odin

  • @MiaChillfox
    @MiaChillfox Před měsícem +1

    Programming languages really are subjective.
    Most of the things you had as confusing about Crystal are super obvious to me and it's by far the easiest to understand/read language for me. Compared to Go or Kotlin which I find hard to read/follow.
    I feel like most modern languages requires an LSP to use, except for Crystal where I never use one, or really any other tooling other than syntax highlighting. Dart especially feels unwritable without an LSP.

  • @ult1873
    @ult1873 Před 2 měsíci +1

    11:19
    That's tagged union stuff (I didn't look at your code, oops). It's basically telling you, that you gave it icecream and now want to get back the lamp that you totally gave it.
    just C:
    union Vehicles { Car car; Wheelbarrow wb; Bicycle bike; };
    enum VehicleType { VT_CAR, VT_WHEELBARROW, VT_BICYCLE };
    struct Vehicle { enum VehicleType active_type; union Vehicles data; };

  • @MarcoAntoniotti
    @MarcoAntoniotti Před měsícem +1

    Nice. But flexibility and GC are good things… Plus Julia looks better than a crab 😊

  • @ErikBongers
    @ErikBongers Před měsícem

    Looking at these languages, I've been thinking about the "defer" keyword. Good or bad? Initially I thought, wow, good! Acquisition and release of resources next to each other. But then I realized that this code is non-linear or non-chronological (if you look at the example code in the go tour, it's embarrassingly obvious). In addition to that, it doesn't enforce releasing resources. You could still forget it and leak memory.
    Ok...what if we reverse it? By default we release the resource when leaving the code block (scope), and if we want to keep it we have to be explicit about it with some keyword, say..."keep".
    But the compiler will not know what function to call when releasing a resource. So, that seems a dead end...
    2nd try: what if functions that return allocated resources have a return type qualifier "resource".
    When calling such a function, you are required to call a "release" function to release the resource. But still the compiler needs to know what functions qualifies as a release function...
    And what if we want to keep the resource open after leaving the code block? Ah, yes, the "keep" keyword...
    But once you use the "keep" keyword, you're on your own...so, once again, nothing is enforced...your language isn't safer...
    Screw it, I'm sticking with Rust. It's a toxic relationship, but I need the Borrow Checker in my life.

    • @Varpie
      @Varpie Před měsícem

      defer is typically used with allocators, you'd define the allocator and defer at the same level, so it stays readable. It's non-linear, but a lot of code is, when calling code between functions it's not rare to go back up in the document. It's mostly a habit to take: at the start of your code, you have the allocation specific things, then you have the logic, rather than allocation, logic and in the middle of it some deallocation.

  • @JohanHidding
    @JohanHidding Před měsícem

    Nice comparison. It's a bit of a shame that the code looked almost identical in structure in most languages. When you know a language a bit better, it will influence your design strategy and change the overall form of the program. Looking at Julia for instance, no mention of multiple dispatch. Suggesting Julia for scripting halfway between Bash and other languages is absurd, considering JIT latency. Also, ties to underlying ecosystems like JVM or Zig's interface to C are glossed over as "not natively supported", whereas for many cases this ecosystem is a deciding factor for choosing a language.

  • @ashleydavis3318
    @ashleydavis3318 Před 16 dny

    i tried zig recently, and i completely agree. string manipulation is often the first thing people try with a new language, and it's easily the worst part of zig, which gave me a really bad impression. the concept is brilliant, but actually using the tools feels like pulling teeth.

  • @a0um
    @a0um Před měsícem

    I think 04:14 as well as other reasons justify Go’s approach to error handling.

  • @XoLucyna
    @XoLucyna Před měsícem

    Golang is really nice, but yea the error handling in everything is kind of a burden sometimes or else overall its a nice language.

  • @coolcat23
    @coolcat23 Před měsícem +1

    Smalltalk (an improvement over its successors).

  • @attilao
    @attilao Před měsícem

    Why show a starling when talking about swift, this is so confusing 😅

  • @tomladdus9264
    @tomladdus9264 Před 4 dny

    I really think Swift has the right balance of features, safety, expressibility, I am glad to see it well represented here. BTW It does not use GC. One thing I would like to have seen is a discussion of generics handling. I think Swift shines here.

  • @abcwarbot
    @abcwarbot Před měsícem +1

    Nim deserves more love

  • @savagepro9060
    @savagepro9060 Před měsícem

    Could've have made it more interesting by including 'archaic' languages such as: COBOL, Perl, and Fortran, for comparison.