1 Problem, 16 Programming Languages (C++ vs Rust vs Haskell vs Python vs APL...) 

Bcz u need a very good reason to use gcd in any code thats not math research related

Application specific features like that SHOULD NOT IMO clutter up the core language. It should provide the features to use well optimised maths libraries. In a game a function sin() might be about players behaving badly rather than mathematical. Reserving names is evil.

Well let me explain why. There is only 1 possible way to implement gcd, no one will ever make a better version, and there is only 1 type that gcd can ever be defined for, and the acronym gcd can't possibly ever refer to anything else. That's why we need our betters to put it into the global namespace.

@SixTB "Blah blahblah" was speaking sarcastically. And he is right. There can be only one type to do `gcd` on.

@SixTB Ok, you're both trolling, I'm also.

It's a bit verbose, (and the namespacing should've used `use num::integer::gcd;` on an earlier line) but I absolutely love that Rust forces you to consider the edge cases like that. If any other function gets given an empty list, either they'll just crash unconditionally, or give some kind of weird default value (I think). Rust actually just says "I don't know if the minimum or maximum exist at all so you have to deal with it before you can work with a value that may or may not exist." My solution would probably be: pub fn find_gcd(nums: &[i32]) -> Option { use num::Integer; nums.iter().min()?.gcd(nums.iter().max()?) // Or maybe // Integer::gcd(nums.iter().min()?, nums.iter().max()?) }

Easily one of the most attractive things about Rust. It’s got speed, but instead of letting you shoot yourself in the foot, it grabs your hand and says “stop it, get some help.” Edit: If you absolutely need even more speed, that’s what FFIs are for. But then your thinking will shift into “this is danger zone land, better be careful.” Other programming languages expect you to just stop being a dumb human. Well, humans are remarkable flawed. Thirty years of constant security nightmares, so often caused by simply mismanaging strings and their pointers, has shown us that.

@@liesdamnlies3372 If you absolutely need more speed you can use unsafe, you don't need FFI.

@@nilstrieb You have no idea how hard I just facepalmed at myself just now…dammit…

@@angeldude101 I'd go with the variant you commented out, since chaining binary mathematical operators becomes really hard to read. Also, cramming everything into one line is unnecesary. It's much more readable when you split it into logical units pub fn find_gcd(nums: &[i32]) -> Option { Some(num::integer::gcd( nums.iter().min()?, nums.iter().max()?, )) }

Lmao, fair point.

Do they have ? for Option now? Nice!

It looks a little bit inefficient cause it takes two iteration over arr to get min and max, unlike c++ version with min_max() function. Is there some good alternative of this in Rust?

@@arjentix you would probably have to either write your own .fold() accumulator lambda, or use a library

Vec is moved, not copied. Not sure 8*3 = 24 bytes of pointer + data + capacity is much of a performance issue. But I do agree that you should take a slice whenever possible, as it makes it possible to interop with a lot more contiguous data structures as possible.

@@arjentix You would probably need to write your own function for that. Not a big inconvenience, but it would still be nice to have an inbuilt one, y'know? I'm pretty sure that a single PR or RFC on GitHub and it'll be there in the next stable.

Thanks! I didn't know this!

@@code_report Ruby also influenced Rust's Lambda expression and return syntax.

I don't know Ruby, but the word "implicitly" in your comment reminds me of "The Elements of Programming Style" A Fortran programmer, years ago, wrote 4 lines of comment to document that omitting "END" after the final subroutine was fine because the compiler would see the EOF... Laughable... The demonstration that all of these languages each have their subtle idiosyncrasies to trip-up newbies is terrifying... "Back in my day," said the old man, "when we needed gcd() we spent 10 minutes coding it, not 2 hours lamenting that the language, unlike some others, didn't have a built-in." This is the modern implementation of "Jack of all trades (languages); master of none."

@@rustycherkas8229 Not really. It's an immediate compiler error because if you forget to return, or put the semi-colon after the last statement (atleast in Rust where the expression must be naked), or put a wrong statement as return, it'll be a type-mismatch. Never encountered such a bug thanks to static typing :)

@@VivekYadav-ds8oz Dunno... Maybe I'm old... I remember the time before "lint"... The good ol' days o' the 'C' Wild West, where "men were real men!" (and the man page for Unix 'cat' was only a few lines!) To these old eyes, "One problem; 16 languages (sorry if your favourite was excluded)" rings of "The Tower of Babel"... (Moore's Law applied to language population; doubling every 18 months...) Once upon a time, the title "Craftsman" was earned by learning and applying ALL the nuances of one's craft... I stand by the expression, "Jack of all languages; master of none."

You would think so wouldn't you. The thing is that with the languages like APL most code trends towards being a one-liner. Raku also trends towards simple expressions. Partly because you can modify the language as you go to make things simpler. The languages which are longer have fewer features that allow for this compression of ideas into simple expressions. So they get longer faster.

@@b2gills This is just an excuse, let's be honest. The so-called "challenge" was a not terribly useful or realistic, banal task that you could give a newbie after 10 lessons of programming, even without any built-in function. And having built-in functions for not particularly useful functionalities (talking about general purpose languages) is 1. not a statement about the expressivity of the language in my opinion 2. surely not any relevant when one is to judge which language to use for what task or how effective a language is in a real-life scenario. Like what next? Are we going to compare "Hello World" code snippets?

@@rndszrvaltas I program regularly in Raku, and I can say with confidence that if I were to translate my code to another language it would be orders of magnitude longer. Not to mention the code I write which is not directly translatable. When I write meta code in Raku, that is a feature that is not generally available in other languages. That meta code also allows me to condense and clarify the code further. The languages which are longer in this example tend to also be longer in general. I have seen a lot of code on the codegolf stackexchange. The general size comparisons among the languages tend to be consistent. Actually that's probably a best case scenario for the longer ones. The shorter ones would tend to be shorter anyway. When I actively participated, the Raku code was almost always among the shortest of the non golfing languages. There were quite a few times where my golfed code was what I would have written anyway.

@@b2gills I'm not arguing for or against Raku, mind you. Actually, I'm trying to pick up Raku because I like the principles of it and it definitely makes life easier if you need to script Linux. That doesn't change anything related to the actual video, though. It's not informative in any way and no, trivial tasks, let alone solved with library functions, do NOT tell anything about the overall verbosity of a language. It tells exactly nothing about the language - or, if anything, whether it's shaped accordingly to this particular task or not.

@@rndszrvaltas Raku let's you manage complexity by pushing your complexity into the language. I sometimes write functions which don't have any code in them because the entirety of the complexity needed for the function is handled by just the signature and using multis. Both of which lead to simpler and shorter functions. So this example is actually more exemplary than you might think.

To be honest, this is the kind of situation where I think that using applicative or monadic abstractions does not make the result more clear (because the applicative/monad instance for functions is one of the harder ones to grasp). I prefer a less feature-heavy solution like ``` findGCD2 nums = gcd (minimum nums) (maximum nums) ``` Of course this is subjective :-).

@@w-mwijnja8919 I generally agree, but I think using the applicative operators and is plenty readable. Especially since this sort of pattern comes up a decent amount of time. At least in my code.

Monad is not necessarily sequential. Computations that don't depend on each other can be evaluated in arbitrary order.

Your first sentence is akin to faulting a screwdriver because it is a lousy hammer.

@@tonyennis1787 No, it is akin to faulting a screwdriver because it doesn't work in cold weather because the screwdriver designer lives in temperate weather.

The real test of a language is: can you come back a year after you wrote the function and quickly understand what it does.

Wow.. this puts a lot of my problems with certain languages in one sentence. A truly flexible and ergonomical language will excel even in cases not protected and overseen by the designer. I'm inclined to also think C++, but Rust for sure shines a lot here. Unless you want to go against the borrow checker, in which case, good luck XD

@@tonyennis1787 Screwdrivers are not Turing complete.

Good question. I'd love to see some examples of gcd use in real life problem solving.

That too, then he docks BQL for this despite it decently explaining why it doesn't have a GCD built-in.

Maybe once every ten years

@@ZReChannel I guess this is the reason that I started learning programming in 2015 and don't know what GCD is today.

When you have to display fractions to a user, you can easily reduce a fraction using GCD. 14/21 reduces to 2/3 because (gcd 14 21) = 7, so (14/7)/(21/7) → 2/3. Not finding a use for something does not make it inherently useless.

also in julia you don't need to use variable length argument functions min, max, you can use minimum and maximum to find extrema in array this will improve performance

@@PanMaciek So: findgcd(nums) = gcd(minimum(nums), maximum(nums))

@@BoyoWhoGoesPoyo or even better findgcd(nums) = gcd(extrema(nums)...))

Julia is such a beautiful language, this is incredibly easy to read and terse as hell. I’m reading through the docs right now, can’t wait to find a project I can actually use it on.

that's cool

I'm not sure if the method is needed. If nums is already defined then it isn't. This video is misleading, if it doesn't show how a function is called, or how the array is defined.

If you think that these solutions have to be heavily commented then I don't think the solutions are the problem here

you should look at 1:24 where he says he is ranking these "from favorite to least favorite"

@@xGOKOPx If someone sent me any of the array language solutions, I would automatically reject them and answer that a cat run over their keyboards, apparently.

@@JackDespero I was talking about the solutions from more conventional languages here. They're all pretty readable if you have basic familiarity with the concepts (although C++ namespaces do create some visual noise). And if you were in a position where someone sends you a solution written in an array language and you can accept or reject it, then you'd probably know that language, so it would be readable to you as well

​@@xGOKOPx dude like youll be able to read last few ones 💀 personaly it doesnt matter the language if your writing code in rust, C or phyton becouse theyll just get compiled to binary anyways... simply readable easy language > cryptic language especially if your working with a team of people

I'd tried to learn Cobol once learning from an IBM course, but essentially i learnt almost nothing. First, you can't run Cobol locally, only runs on IBM mainframes, so to compile your code you must do it remotely. Is tab sensitive, and that is a not for me. If i remember, there not such thing as a for, only goto, something that i only have seen on assembler. Also the compiling routine is awful, you must check before compiling some generated files to look for errors, and then you can compile. is it readable? yes, but by modern standards over-complicated, from COBOL and FORTRAN, i prefer FORTRAN, seems easier.

COBOL is an absolutely atrocious language. Some problems are borderline impossible to implement in COBOL so the problems will have to be simple.

My grandma used to work with COBOL. A procedural oriented language for business. Very cool to hear about it

@@ceber54 Readable? I guess we have different definitions of readable. Compared to Assembly sure, but honestly I find C considerably more readable.

@@r.pizzamonkey7379 The argument of why the sintaxis of cobol is how it is, is because the code should be audited by someone not expert in the code, or at least that was the initial idea. That what it means when "cobolist" refer Cobol as readeable. But yes C, or even Fortran, is easiest to understand at first glance than Cobol. Personally I don't think that cobol is readeable.

Honestly, the responses from the Fortran community here and on Twitter have been amazing! I am definitely going to be doing a follow up video.

I'm quite surprised, I expected it's dead for 30 years and replaced by Pascal, C, .... Last 15 years Python is extremely popular, but it's painfully slow. C++ misses any useful standard libraries for image processing, worker thread pools, parsing even most basic files (ini, csv, xml, ...) and standard template library is like 100x slower in debug mode (at least one that comes with Microsoft Visual Studio and contains extra error checking). It's quite painful to setup build environment for extra libraries. I've just discovered Julia week ago and I think I may use it for some projects (already wrote 600 lines of data crunching code and it seems ok)

@@pavelperina7629 30yrs ago, the fortran90 standard has been released which has made a huge step from F77 (which I have never used, I have only to understand it sometimes when debugging in the ancient parts of our software :-D computed GOTO... arg). And if you check modern standards like 2003 or 2008 which introduced object oriented features like inheritance etc, or native parallel stuff like DO CONCURRENT, you have a modern language (the OOP stuff feels a bit cumbersome to be used, but it works fine). I think it is a fine language for the number crunching work, but I'm no IT guy, but a mechanical engineer who codes 🙂

@@pavelperina7629 Fortran is still well alive, Soon an official LLVM Fortran compiler called Flang will be released, and an interactive LFortran compiler is currently in the works, And also there are high quality Fortran compiler from Intel and Nvidia called Ifort and NVFortran respectively, So it is well alive, But I guess they need to do some updates to the standard, Maybe add generics, templates, meta-programming, tuples, lambdas to the language, After that it could be a fun language to work with which could be substituted for the likes of C++ or Rust for certain systems level programming tasks

@@ingenium5831 I've used f77, and even f60. They're fun, but pretty unusable. f90+ is definitely the best experience

std::minmax receives just 2 elements. Here you need to receive a sequence of elements.

@@VamoAComeLaPapa I was talking about C++20 std::ranges::minmax, which does take a whole range. I even mentioned your very same issues with the old std::minmax in the final sentence? :)

@@Possseidon yes, you are right, it seems that one of the overloads of std::ranges::minmax is an alias for std::ranges::minmax_element Thanks!

I would add that Clojure benefits from the JDK ecosystem - the largest library ecosystem of all 16 of these languages

@@jonseltzer321 this is why it's been hard for me as a Java developer to transition to D and other small languages that have a better design, but a much smaller ecosystem

@@andrewlalis Agree, that's why I don't understand why you don't have a 'Haskell for the JVM', or 'APL for the JVM'.

Damn Clojure was pretty smart to keep backwards compatibility in such a simple way. No extern "Java" crap, just simple 'yeah just name the library. meh.'

writing code in the future is going to look very different. "type" won't be how you write it.

There are this things called a) "keybindings" and b) "brain" that are required to use languages like that. APL was lauched in 1966 and has been used ever since by companies like IBM, and influenced many other languages such as C++, Python and Wolfram. Also "human-readable" is a buzz word at this point, if people where capable of using punch cards to program, so is anyone capable of learning a few difficult symbols (if they need-to/want-to of course 😉 ). Should just replace "human-redable" with "lazy-readable". Well explained comments is where it's at.

@@klittlet Just because we are capable of something, doesn't mean it's a good way to do it. That's why we no longer use punch cards. We are also capable of programming in binary, and no sane person would go through the effort. You also know as well as I do that most people are too lazy to put in decent comments. If you are tasked with updating something and you need a language reference to look up every 3rd character, then there is something wrong with the language. You should be able to intuitively understand the language by reading it. Imagine telling someone you can read english, so they provide you with something in english but it is written with egyptian hieroglyphs. It's frankly a useless extra step that just makes things harder for you with no gain.

@@Acaykath lol then you agree with me with the "lazy-redable" bit. Not commenting your code is a bad practice and just exposes a bad programer, also all the majority of applications for back-end jobs that I've seen it was in the requirements to make well documented and commented code. If 'professionals' are not doing this then there's something seriously wrong with this industry. And my last point is: you learned the alphabet didn't you? What commas and exclamation marks mean and when they should be used, right? You've probably learned what && and || mean by association with words, right? Or better yet, the basic logic symbols: "v ^ ¬ -> ≡" that the first semester of college teaches (idk about the US). APL has these same associations. So no, me, the thousands of other people and professionals don't have to look up every 3rd character because we have the basic human function to remember what those characters mean. But I guess we are all wrong then! After all what defines the quality of a language (according to you) is not characteristics like it's runtime performance, rapid prototyping or efficiency, but JUST it's "readability". I guess what you mean by readability is if the ops team can read it or not, which is fair.

@@klittlet I actually never learned this in school. Edit: I learned this but with different symbols. v : no idea. Never used or seen a v as anything other than a speed unit. Hmm google tells me this is really an || operator. ^ : I assume this is meant for exponents as that is how it's represented in text equations without fancy math display software. Hmm google tells me this is really an && operator. ¬ : I've seen this symbol before, but outside of ascii art I have no idea what it means. Ahh, google tells me it's a ! (not operator). ->: I've seen this used in some languages as referencing or accessing properties. But I doubt that's what this is meant in this context. The only time I've used arrows in math is to describe limits. Perhaps it is used to apply something to an entire array? I only assume that because apl has array in it's name. Or maybe appends to an array.... this seems to be if !(a && !b) ... Not really sure where this would ever be used... : A double ended arrow. No idea. Perhaps combining a pair of arrays? Hmmm... Google says ((a)==(b)) ≡: Some form of equality operator? See if all contents match? Hmm googling tells me it means having the same value, like a == instead of a === in some languages. in fact, ≡ seems to be the same as . These are completely different from the logic symbols I learned. If I was focused on making graphic card firmware, I might have more of an idea of what the symbols mean. But I prefer working on front end stuff. I know this makes me a little biased. Runtime performance? That's a compiler issue, unless you're doing bare metal operations. Rapid prototyping? If you can't easily read or write it, then everything will be slow, not just prototyping. Efficiency? That's a measure of how effective a programmer is, not the language. Readability? Everything flows from this. A language with good readability makes everything easier, faster, and less error-prone.

This comment should be pinned.

well, they could have just asked for x86 assembler

@@cobaltno51 Or code it purely in nand based boolean logic for real bare-metal level programming.

@@cobaltno51 Ever heard of ARM SVE2? Or Itanium for that matter? :-D

Same for rust, Vec[u32] should be &[u32]

I was about to make the same comment.

does rust not have an unwrap? why can't one pass the '.into_option()?' tuple as 2 parameters of gcd?

yeah those languages are completely unreadable and seer really hard to write. I know nothing about them, perhaps they're great. On first glance though I thought I was looking at brainfuck lol

@@oxey_ if you have a solid understanding of mathematics and lambda calculus, it's not bad at all.

Imo the solution shown was nicer

Clone instead of Copy would give a solution that works for large number types.

@@CarrotCakeMake finding .max() or .min() don't require any sort of copy, as the internal .cmp() function takes its comparison numbers by reference anyways. &[T] where T: Integer is good enoughl.

@@VivekYadav-ds8oz Ord::max/min returns the same type it outputs, so it either has to clone or return a reference. num::integer::gcd requires ownership of an integer type. So you have to clone sometime, but you could get away with it by doing a gcd(found_min + 0, found_max + 0) maybe. Having gcd require ownership seems like a mistake unless there is a really good optimization that comes from it.

Better yet, `extrema`, which enables this: `find_gcd(nums) = gcd(extrema(nums)...)`

imo, if you're going to use `with` anyway, you might as well skip the reduction and use &gcd as an infix operator: .min gcd .max with @nums # but TIMTOWTDI, of course

raku -e 'say {[gcd] .minmax}(2..10)' 2 Yeah, we got the good stuff.

@@zengargoyle oh, interesting - I didn't realize that Range.minmax returns a List (unlike Any.minmax, which returns a Range). So to accept Arrays as input, you need .minmax.bounds (or, I guess, .minmax.minmax - which is a pretty odd construction!) but if we only need to accept a range then your one-liner works. I wonder why Larry et al. decided to have the two .minmax methods return different types?

imagine forcing programmers to write error-free code instead of just segfaulting in production like a real programming language

There is nothing to do with Category Theory. Only higher order functions with lazy/partial evaluation. You can easily read things like "f = g h" as an aliasing. Everything passed to the "f" (if expected by type) will be passed to the right-hand side :)

@@qandak But isn't "point-free" another name for Category Theory?

@@vonBottorff Nop

@@vonBottorff No. APL is far more point free than something like haskell, for example. Other way to think about point free is how julia does it (multidispatch), which is also emutable with anything w/ dynamic dispatch with type Any.

Point free means you're working on entire spaces and transformations, rather than individual points within them. That usually takes the form of removing arguments that are simply repeated; e.g. addone x = 1+x translates to addone = (1+). x here is a placeholder for one particular point, while its type is the domain the function can operate on. In practice it's just decluttering the data paths, hopefully letting us consider our operations at a higher level. revwords line = let ws = words line rws = map reverse ws result = unwords rws in result revwords line = unwords (map reverse (words line)) revwords = unwords . map reverse . words -- . is the ∘ combinator for unary (aka monadic) function composition, pronounced "of" revwords "olleH !dlrow" This simple example relied on the input argument only occurring once, at the end. If that's not the case we might want to use combinators like liftA2, flip or const (map is a second order combinator, operating across a whole list). Building such combinators is where lambda calculus kicks in, the overly mystified art of variable substitution. The mere fact we can leave arguments out is because we have partial application and first class functions. Point free style in Haskell is like tacit style in APL, but APL has more combinators built into its syntax. Category theory is usable to describe function compositions, but does not on its own relate to source text, which is where style like point free is expressed.

There's a comment above showing Ruby and Raku using an explicit `minmax`.

That's what I initially thought, but 1:48 you can see the problem statement does ask for the gcd of the smallest and largest elements, not of the entire array.

Prolog will definitely get highlighted in the future!

To be honest, most other languages have a minmax function, too ;)

The gcd part can be done recursively quite easily using pseudocode like gcd(x,y) = (if y == 0: x, else: gcd(y, x mod y)) I would also have preferred finding the gcd of *all* numbers in the array, instead of the min&max. To be honest, the way it is now, the video more or less boils down to "which language has the most succinct gcd and minmax syntax". And I hate it when programmers' kneejerk reaction is to require builtins for even simple tasks.

It would, if that was something truly revolutionary or hard to implement yourself.

@Delyan Kirov c++

In the first example, I think you can also make the "gcd" function tail recursive. Doesn't change anything conceptually, but it would make it somewhat faster

Lol, I guess you can't. There's too many things in C++ so you can't know all of them. On the other hand very basic things are missing. I'd like to know how to upper-case unicode string, how to sort strings according to locale etc, thread pools,... What I would recommend is either fmt library (3rd party) or std::format (most used functions of fmt made it into c++20) because and are pain.

"A Tour of C++ (second edition)" seems to be your best bet. Lots of the stuff you are seeing has been available for a long time via libraries (Boost, various proposed extensions, etc.), but they are adding them to the language and removing a lot of the ceremony around using them which is nice. The language updates every 3 years, and you can use the "beta" versions of stuff earlier than that. So, keeping current is a lot.

bruh believe me.. it would be better if you don't go down the rabbit hole of C++ it have no ending this language have so much that even pros don't know everything of it

read the documentation, code side-projects and do not use last cpp version as compilers are inconsistant in their implementation (cpp20 is currently not fully implemented in clang and gcc).

ding ding ding a winner. Compile-time errors are *much* cheaper than run-time errors.

Yep, I cover that in a follow up video.

Almost every programming language has an ffi, the JVM languages just usually have a nicer interopt. I therefore agree to not counting the Java standard library as part of Clojure

@@petermuller608 that's a silly line to draw. By that standard Kotlin doesn't have HashMaps

logN times slower for... what?

Then you would be comparing programming language implementations and not programming languages

There's not really a way to prove that to the compiler. A better solution would be to just accept that you'll return an Option and use the `?` try operator. The solution is cleaner and more general. It's theoretically possible with const generics, but proving at compile time to never have an empty list would be several times longer than leaving it as is.

I think you can do that with const generics, but it'll be uglier than this. As much as I like the Haskell philosophy of making all unwanted states unrepresentable by making all such errors compile-time, you have to balance that with the maintainability of the code, the increased compilation time, the poorer generic error messages, and if it's really worth to push the runtime error to compile time. In this case, not really, as it can be handled in runtime just as smoothly.

So too does Raku, only its spelled more guessably as minmax.

Now, there are another option to use something equivalent to minmax, using the function extrema, so the solution looks like fing_gcd(nums) = gcd(extrema(nums)...) but now we can't avoid an ellipsis, but only if we override the function gcd to accept arrays, something that is easy to do in Julia.