1 Problem, 6 Programming Languages (C++ vs Rust vs Haskell vs APL vs Clojure vs Scala) 

I love the way you talk about the "beauty" of a solution. It's that sort of thing that reminds me why I love programming. Thank you :)

i use C++ for high performance code , Python for interfacing and Haskell to keep my ego in check

As a guy who inherited application support for 500,000+ line code base of C and a couple 2-3000 line APL applications i can tell you, I'd much rather see the word MAX written out rather than have to look up every single glyph i stumble upon at 3:30am on a Saturday morning.

In the Scala solution, it is recommended to skip the curly braces. What you are doing here is creating a block. Blocks return their last expression. This block only has one line and is thus unnecessary.

The APL solution seems to be the most straightforward if i figure out where is the max symbol in my keyboard 😁.

In the Haskell solution you could just do `foldl1' (+)` and `foldl1' max` to make the reductions explicit

Would be interesting to see benchmark between them. Especially the c++ versions and rust (I work as a c++ developer as well).

If you don't mind spicing the type signature up you can do this in Rust: fn maximum_wealth(v: T) -> Option { v.map(Iterator::sum).max() } The code in this one looks a bit nicer but the data type are just crazy and you have to parse the vectors first as an iterator. Also notice that by returning an Option you can get rid of .unwrap(). This has also the benefit of returning None when your outer Vec is empty and does not throw an exception like other languages would

The composition operator is just a function, so that makes 4 functions in the Haskell solution.

I watch these so I can get confused, then I can get my brain adjusted to how much I don't know. Lovw the content.

I've been around a long time, learned COBOL on a Burroughs mainframe in the 80s and do cloud architecture and security now. I knew about APL, Haskell, Scala and Clojure but had never seen a solved problem before. All you hear about these days is JS and Python and maybe Go. Thanks for the video, you presented and explained the material very well. It clicked with me vs. a lot of the other coding channels. New subscriber.

Python: return max(map(sum, accounts))

I find the python solution for this pretty nice: def maximumWealth(mtx): return max(sum(x) for x in mtx)

Cleaner Clojure solutions are available using transducers. (transduce (map (partial apply +)) max input)

The APL solution as someone who doesn't know that language or someone who is new to the language is horrendous. Not to say the C++ solutions are ideal but the for-loop one would be very obvious as to what it's doing for anyone even reasonably familiar with programming. (The rust solution also) I think the Haskell solution is probably the cleanest as someone who has never even programmed before might be able to figure out what it does somewhat. But even if you were Dennis Ritchie himself you wouldn't have the slightest clue what the hell the APL solution is doing without already being very familiar with the language. Less lines of code doesn't always mean better code.

For me readbility is the king, Haskell, Rust are what I like the most. For some languages I suppose the programg just crash if the array is empty

Question: Is the later versions of the c++ solutions that are parallelized actually faster? The original solution is easily optimized by a compiler. Is the parallelization basically threads? Because I really think some AVX/SIMD and some forloop unrolling will do a better job speeding things up vs the overhead of dealing with threads for such a simple problem. If I've learned anything from pushing performance in C it's don't obfuscate what's actually happening, select which optimization strategy you actually want for the problem starting with very vanilla code, don't get in the way of an optimizing compiler, know your compiler flags because what people think is optimized (-O3) is nothing compared to what you actually get for free by throwing in a few more flags (as long as let those optimizations work by not giving it already optimized code that's been optimized in the wrong direction.) Because of that I've learned to see any time someone says "this code pattern is always faster.. because this feature", I can't help but say yeah right. I'm sure it's really fast. For example, most time when people use a high level utility to speed something up you get at best 4x speed minus overhead.. hopefully. I've seen that letting fully flagged optimizing compilers work their best it can speed things up ten fold on the regular. If you have really modern hardware that's only going to increase as there are more features to leverage. That's why not getting it its way is rule one for fastish code at ease.

I love your work!

For me readability is king, only when performance is an issue I would go with more technical solutions. When working with a team, this kind of fancy code tricks make everyone's life a nightmare debugging. Although it is nice to see the possibilities.

Would we not need to add *std::execution::par* to run it parallel in the reduce/transform_reduce functions?

more elegant clj: (->> data (map (partial apply +)) (apply max))

in c++ with funlib this is just const auto wealth = stream(accounts) | map( fold( add, 0)) | max();

In 3:09, how did you achieve this transition in the video? is it manual editing or did you use a special program for that?

The rust's one is very easy to read! awesome videos

I don't know if it is actually any better, but in Scala you could also write it as accounts map(_ sum) max

Amazing content thanks a lot !

I'm learning ocaml and here's the solution I would use (with the Batteries library): let maximumWealth = Array.(map sum %> max) Without the Batteries library you don't get sum or max, but they're easy enough to define in terms of folds: let maximumWealth m = let max arr = Array.fold_left max arr.(0) arr in let sum = Array.fold_left ( + ) 0 in m |> Array.map sum |> max

@10:40 that's because you hardly EVER just take the max of two elements in mathematics. Usually you want a max over some array or set, so you always need to feed ⌈ into some combinator. In other words, because we don't teach combinators in schools, a single-glyph for the "max" binary operation simply isn't very useful. In much the same way, mathematics notation doesn't actually use the symbol "+" for the equivalent of APL's `+\`, instead they use something like an upper case Sigma with explicit range bounds etc. I would agree that it would be very nice to teach combinators in middle school, and even teach kids with stuff like Haskell or APL.

using C# linq (assuming input is the given matrix: input.Select(acc => acc.Sum()).Max(); or alternatively input.Max(acc => acc.Sum());

would you prefer something like foldl1 max . map (foldl1 (+)) to be explicit about the reduction?

the APL solution looked like a trick, similar to those you can do in C, and everyone tells you not to do them, but you still like them and do them. I agree with you that there should be single char operators for mix/max as they are used too often. The single char reduce operator was the division operator and this is confusing if you don't know APL, which I don't, but I get it. Nice.

I suppose you technically could make the Rust solution point-free if you use the function form of the .iter method if you're ok with an extra map: accounts.iter().map(Vec::iter).map(Sum::sum).max().unwrap() My Rust is a bit rusty though, so I'm not sure if this'll work

Such a great video 👍 Thanks!!!

Using the same data, how different would it be to find the wealthiest bank instead of the wealthiest client?

Very interesting.

It is worth noting that maximum has to be a partial function (throw exception or return something like `null` for empty list). Some people (including me) consider using it a bad code. In Haskell, you could use total alternatives, e.g. safe package: maximumMay . map sum

Damn, thanks a lot! I was just recently thinking maybe I could make a vector calculator with what I had learned and combining this problem to what I had I actually managed to make a pretty neat program that prints out a matrix. Next would be deciding if I should try and use these methods for the arithmetics. Noteworthy: #include for the C++20 solution, it's not you need to import despite the name std::ranges:: and std::views::

Excellent! My father worked at IBM at same facility as Ken Iverson, inventor of APL. My father noted how Ken had his own printer, which in the 1970s was bigger than a fridge and cost a fortune. Why? “Because he invents things.” Now, can you please explain monads?

In clojure + is a variable arg function and calls reduce internally for more than 2 arguments. So below is enough (->> data (map (partial apply +)) or equivalent (map #(apply + %)) (reduce max))

Very cool stuff! But I have to disagree with your ranking here. IMO, Rust is CLEARLY the winner, just because it's the only one that forces you to explicitly state what you want to happen if the sequence is empty. In practice, that's a huge achievement. And although it's doing that, the implementation is still very clean and readable (and also easily parallelizable).

What about safety, if the input is empty would all of them crash? In rust, because you used unwrap it is clear. You could have returned a result so the caller can decides how to handle the error

Maybe anyone know where everybody can order APL-glyphs KeyCups?

You can write the Haskell solution in Clojure! (def maximum-wealth (comp (partial apply max) (partial map (partial apply +)))) "apply +" is needed in Clojure to use + in vector form "apply max" is needed to use max in vector form "partial" is needed as Clojure does not curry functions "comp" is the Clojure way to do function composition Having said that I believe your Clojure solution is more idiomatic and the Haskell solution is cleaner than either Clojure solution!

Could you do a performance comparison with larger arrays, such as 1,000,000 x 1,000,000? How much memory is used? How large are the executables, etc. Thanks! Really interesting video.

Wow, haskell and apl are so beautiful. Also, now I understand why some coders loved haskell during advent of code

The question is ill-formed because what happens if the array is empty? Rust makes this problem apparent because you called unwrap. It also showed why I think algorithms in C++ is not entirely useful because it requires so much ritual to get anything done that you question why you did it in the first place. Without pipes, the control flow is not entirely obvious. Admittedly, some of these are done for performance reason, namely, entering the begin and end pointer makes sense in low level terms, but not entirely natural in the way piping are done since something like this is usually achieved by performing a filter instead.

For-for loop and left-folding are single-pass algorithms. Mapping and then searching maximum needs two passes. 2d array to number folding in clojure: (reduce #(max %1 (apply + %2)) Long/MIN_VALUE accounts)

We can get a functional definition with JavaScript too! With: const maxWealth = compose(max, map(sum)); We just need this simple helper functions: const map = fn => list => list.map(fn); const sum = list => list.reduce((acc, val) => acc + val, 0); const max = list => Math.max(...list); const compose = (...fns) => arg => fns.reduceRight((value, fn) => fn(value), arg);

Suggestions on material to use to learn apl? RU-vid didn't seem to have a sound support for it, udemy neither. I found microapl.com but I like multiple resources to learn from.

In this example the problem fits perfectly the language (APL). In every day programming rarely you will find a mathematical problem like this. What about a web server connected to a MySql db ?

My Solution in Rust would be accounts.into_iter().map(IntoIterator::into_iter).map(Iterator::sum).fold(0, i32::max) yes we could use the advantage of .max(), but it return an option and I don't really like unwraps, you could do a unwrap_or(0) but thats one more line, fold is as readable in my opinion and let you directly place a default

Haskell version in which "maximum" is last because it happens last: map sum >>> maxiumum in which each sum is computed in parallel: maximum . parMap rseq sum in which the two reductions are explicit: ala Max foldMap . fmap (ala Sum foldMap)

Awesome, BTW, reminds me Context Free channel. Your brother's name Tom? :)

Very useful content. I didn't knew reduce and transform like things exist, before this. I better learn them. 😇

What did other languages than Rust do when you call max on an empty sequence?

Clojure have transducers, they may do it more expressive and shorter

Just like you, in my day-to-day work, I avoid for loops, while loops, and do while loops like the plague if possible. I'm a JS developer by day, but I'm learning Haskell on the side. The more I work with Haskell, the more I love it.

I don't like that APL one at all. Seems fine in isolation, but I reckon it would have the Perl problem of a script being a cluster fuck when you come back to it years later

What is the fixation with threading macros in Clojure ? I also find the anonymous function shorthand ugly - I much prefer: (reduce max (map (partial reduce +) accounts))

Why you need to do all in 'raw loops' or all in 'algorithms' ? Why not int maximumWealth(std::vector& accs) { int max = std::numeric_limits::min(); for (auto& row : accs) max = std::max(max, std::reduce(begin(row), end(row))); return max; } ??? It is much more readable then two accumulates or smth

Something I was playing with recently was writing sha256sum in C, C++, Rust, Python and other languages. I had no idea where to begin writing it in Haskell, so googled around and took a peek at what someone wrote earlier. For that, the Haskell ends up verbose and ugly compared to C and Rust.

I know I'm late on this video, but the Scala solution could have been way shorter, actually you can declare it as a simple lambda expression :) val maximumWealth: Seq[Seq[Int]] => Int = _.map(_.sum).max

// The JavaScript solution isn't far off from Scala: const maximumWealth = accounts => ( Math.max(accounts.map(sum)) ) // Although you do have to BYO sum function: const sum = _ => _.reduce((a, b) => a + b)

Fortran: maxval(sum(x,dim=1)) full program: integer :: x(3,3) = reshape([3, 7, 2, 8, 10, 2, 3, 3, 4],[3,3]) print*, maxval(sum(x,dim=1)) end

(N.B. This comment is about ADSP podcast; didn't see anywhere to leave a comment on an episode on the podcast page) Conor, My ears perked up when you said any scan is parallel-isable The the formal definition of plus scan a series of numbers like iota 4 equal to 1 2 3 4 is a series of reductions +\ iota 4 is: (+/1),(+/ 1 2),(+/1 2 3),(+/ 1 2 3 4) Because plus is both commutative and associative you can parallelize the +/ first, and then run the +\ as four +/ on four separate cores each of which is running the plus reduce parallel algorithm But that only works for things that are both associative and commutative like plus or multiply, it wouldn't work for things like divide and minus scan ( you could, of course, run each of the four ÷/ required for a "÷\ iota 4" on a separate core, but I don't see how you could parallelize the ÷/ itself) But of course, being an APL guy, I let The interpreter do all the smart optimization, so I very much look forward to gaining some insight from your upcoming podcast episode discussing parallelizing scans. T.C.

It's interesting that the OO languages have effectively given up on their claims that OO is the solution to issues of reliability and complexity. Almost all the new features in C++/Java/C# are watered down functional ideas. So why not just use a proper functional language like Haskell or F#?

Cool. Now do an http request, and find all instances of /get_file/ between single quotes and rank the results by an integer found within the string. Then try to convince people that the haskell that results from that is beautiful. Javascript, scala, go, and rust will do the best in that order. Then clojure, c++, haskell. I don't know how to do that in APL. It would be very cool if it stays elegant. Then I will have to agree APL is cool if it can do that. Not having 50 bajillion text types might help.

A program is beautiful because it is beautiful, not because it is short. I'm fine with people playing code golf but not the entire world is a golf course.

С++ somehow seems the most readable one

The most beautiful & readable solution in my opinion is the Rust one.

In JavaScript you could do a=b=>Math.max(...b.reduce((c,d)=>c+d,0)) which I think is a great balance between simplicity and readability. You unwrap b with ... after calling reduce on b which takes two arguments: a function and an initial value. c is our sum/initial value and d is each element of b which is then added to c which becomes our new c next iteration.

why the dislikes? i'm so confused it's a great video

Best example of the elegance of APL. Those 4 symbols literally express the essential mathematical solution; all the rest is noise.

I love videos like this! I think Java would be a worthwhile addition to these...especially if you're going to do 3 different versions of C++ lol. Java streams results in a solution that is _very_ similar to Rust, but possibly more readable (assuming RU-vid doesn't destroy the formatting lol): int max = Stream.of(accounts) .mapToInt(a -> IntStream.of(a).sum()) .max() .getAsInt();

all i learned in the first 5 minutes is that i don't fucking know C++, i'm gonna go cry now

I think the best solution for C++ is the first C++11, but using algorithms to do the sum.

no need to call unwrap in rust, if you are going to assume the result wont failt just call .max()? with the ? operator

my own language named “MaxWealth” has an absolutely beautiful solution: ¥ See its just 1 character isnt that beautiful? Much better than the C++ solution

Python solve = lambda m: max([sum(x) for x in m]) matrix here as a list of lists of numbers

Agda has a single symbol min as well: ⊓

another solution for Clojure (apply max (apply map + accounts))

C++, using FunctionalPlus: auto maximumWealth = fplus::fwd::compose(fplus::fwd::transform(fplus::fwd::sum()), fplus::fwd::maximum()); will work on any container, and any numeric type.

It's all fun and games until you have to debug 1000 lines of APL and it's just made out of characters. :) Though very informative and good video. Thanks

Fully functional in Clojure: (comp (partial apply max) (partial map (partial apply +)))

solution of same in my language to that i had created: array vec = [ Array[4,5,6], Array[6,7,8], Array[88,88,0], ] loop len[{vec}]: uelem vec:$$I = sum[vec..$$I] arr richesIndex = indicesof[{vec},max[{vec}]] print [richesIndex]

(For me) Haskell is the most elegant language. APL just has massive readability issues (for me?). The outlined good point about APL (i.e. explicit 2 reduces) might be a bad advise when considering from the perspective of other langs. reduce is just too general and its existence in code is problematic (from readability standpoint) IMO, I always prefer to use something more restrictive. Let me illustrate that with an example here is the solution just using reduces. maximumWealth = foldr1 max . foldr (\x xs -> (foldr (+) 0 x) : xs) [] Everything here is a reduce (foldr is Haskell's version of reduce). i.e. maximum is a reduce (maximum = foldr1 max) (foldr1 is just like foldr but uses the last element of the list as base value) summation is a reduce (sum = foldr (+) 0) mapping is a reduce (map f = foldr (\x xs -> f x : xs) []) put another way, when you encounter reduce first you have to figure out what it is doing then you understand the solution (which is the same problem with for-loop). That is why I don't like to use reduce ever as a general rule. I say the solution, where there is no reduce, is far simpler to read - maximumWealth = maximum . map sum

Kotlin val accounts: List val res = accounts.maxOf { it.sum() }

Scala solution is most readable and elegant at the same time. It seems like a pseudo code. accounts.map(_.sum).max Even you don't know scala you can read this code and understand what it does.

People are bothered by the smallest things lol. Some will prefer to not have to memorize a new symbol and instead use a very short word like min/max, but definitely to each his own. It IS interesting to have a symbol for those.

literally programmer these day

Scala is java right?

From all C++ versions I'd choose that with two for loops. It's very readable. C++17 is the worst IMO. Too many technicalities exposed.

APL seems like a language Aliens would use to talk to each other.

Ok, it's two lines of code, whoopdidoo. But now what's the time and space complexity in comparison to C++ huh? Everything looks cool and all at first sight until you realize it's inefficiently using resources

Could be interesting to add a 1 million for loop on top of each, a matrix definition (same for each of course) and evaluate the performance :)

In my opinion, clojure and rust it's the beautiful solution

Elixir looks pretty good: wealths |> Enum.map(&Enum.sum/1) |> Enum.max

I will submit a Groovy one-liner that strikes a nice balance of readability and elegance: ​def maximumWealth(def accounts) { accounts.collect {it.sum()}.max() }

Scala shorter solution: val maximumWealth: Array[Array[Int]] => Int = _.map(_.sum).max

Here's my Scala solution: val maximumWealth: Array[Array[Int]] => Int = _.map(_.sum).max