Functional vs Array Programming 

Dude I'm high as f watching random cs videos and I see we returned to hieroglyphs wtffffffff

APL is how coding looks like for non-coders

what programming looks like to non programmers

Me: oh c++ thats pretty verbose but I can somewhat understand it *changes to python* Ah! I really get the idea now, yeah this is fairly intuitive *switches to scalla and haskel* uhhh huh... *digression* im trippin balls dude *switches to APL* WHAT THE F-

Honestly, from the video you made me prefer Haskell over APL. It really doesn't matter if the code is shorter if you need someone specialized on the language to make sense of it, while on Haskell after you explained the S operator and that was all I needed to get a rough ideia of what the code was doing.

APL feels like Chinese in that there is a single symbol per concept. The learning curve is steep but it's beautifully rewarding when you get there.

I have an APL book called "APL An Interactive Approach" and you can tell it's old because it asks you to plug your computer into a phone line. Such a weird and obscure language but it was pretty fun to mess around with.

Great talk. For reference, this is how you could solve the problem in the Wolfram Language: (nums - FoldList[Min, nums]) // DeleteCases[0] // Prepend[-1] // Max

Im pretty sure APL is the code Neo sees as the matrix when he gets revived… the moral of the film is we should all take a page from neo’s book and learn APL 😤

When introducing the Python solution @ 17:12 , replaces clear easy to read semantically meaningful variable names with short abbreviations while stating "...change the variable names to make them more concise which, in my opinion makes them a lot more readble" - realizing, oh yeah his fav language is APL! ;-) haha Also nice job on the combinators intro!

APL (A Programming Language) has been the source of jokes in the programming community for nearly 50 years! I couldn’t readily find good references beyond en.wikipedia.org/wiki/Write-only_language?wprov=sfti1 , but there used to be fun competitions on who could write the shortest and most indecipherable code in APL. More practically, APL started out at a time when programming was still regarded by some as an extension of pure mathematics, so a highly symbolic syntax was not totally out of left field. Memory at the time was also at a premium, likely costing over a dollar a bit, so being able to represent core functionality in a glyph represented by just a few bits had practical benefits.

Great video! Really interesting. A couple of comments: 1. It seems really redundant to use -1 to signify no solution, since, if you read the problem carefully, nums[i] < nums[j]. This means that nums[j] - nums[i] > 0, if a candidate solution. So, if max of all candidates is 0, there is no solution. This would simplify the Scala especially. 2. I understand that Python was just used as an example language for imperative programming, but it could come off that you were comparing Python and Haskell/Scala's abilities, when Python is capable of solving this in a very functional manner as well. In fact, the implementation can be quite elegant: max(map(sub, nums, accumulate(nums, min))) Though Python does not explicitly have scanLeft or zipWith, Python's map auto zips multiple iterables, and the standard itertools library has accumulate, which is essentially the same as scanLeft. Conveniently, if you don't provide an initial value to accumulate, the first value is just the first item of the iterable (which seems similar to Haskells scanl1). Python's operator library provides the sub function. One other nice thing about this, is that it works entirely with iterators, so there are no intermediate results. If you want to use -1's instead of 0's, I think the most elegant way would just be to use an 'or' operator, since 0 is falsey: max(map(sub, nums, accumulate(nums, min))) or -1

Thank you so much. This is by far the most accessible intro to combinators and combinatorial logic I've ever seen. I do admit to never making a true effort to seek out understanding of combinators beyond a very quick skim of Wikipedia, but that doesn't change the fact that what little effort I have put in was never rewarded with conceptual clarity. For example, all previous videos I've seen making the claim that they are an easy intro to the topic... well, they failed me. I guess what I'm saying is thank you! So concise and clear and completely useful!

This is probably one of the, if not the best, computer science video I have ever watched. This helped me expand my perspective on problem solving as a new programmer. Thank you!

APL is also functional programming, the main difference is that arrays are the main data structure while in Lisp the Single Linked List is the main data structure.

IMO dev teams are diverse and code ideally should be readable for everyone. I personally liked Scala and Haskell solutions (although I need to learn combinators to fully understand it, so I'll watch your videos about it). What's nice about this F# solution is that it's clear, concise, and can be run step by step interactively in REPL to see the transformations: let maximumDifference nums = nums |> Seq.scan min System.Int32.MaxValue |> Seq.tail |> Seq.zip nums |> Seq.map (( Seq.filter (() 0) |> Seq.fold max -1

I think APL deserves a prize for being more esoteric than assembly.

Personally, I'd take the C++ (or a Rust) implementation. It's more obvious what's going on and all of the intermediate values are easily available for evaluation or logging or whatever during debugging. And it's likely better performing, particularly once you get beyond trivial examples. And of course, you can just put the whole thing in a helper if you need the algorithm more than once, and you never even see the guts unless you need to (at which point it's a lot easier to see the guts.) I'd also argue that extremely minimal syntax isn't really an important goal of software. Creating products for people to use is the real purpose of software. One problem in software (as in many pursuits) is that too many people become more about the pursuit itself than about the purpose of the pursuit. Nothing wrong with that in and of itself, but it can become an issue. I think C++ is suffering from this currently. It's too driven by people who are into languages and not enough people who just want to create products for people to use.

One one hand I'm awed at the deep mathematics on display, on the other hand I want to never use it myself. All of these highly formal functional languages are so ridiculously complex and unmaintainable, I can't imagine anyone using them in a serious setting.

I was shocked when I first saw the APL version of the gave of life, a game that took me ~100 lines to code in python written in a single line

In my opinion, in imperative languages, branching into loops and conditional blocks really benefit from braces. I agree they add noise, but I feel like it helps sort out what the blocks of code are doing. Which is a main reason I find python infuriating, it's still imperative, but relies on a lot of tabbing to generate structure, which can get annoying to read in large parsing sections of code. For context Haskell is my favorite language, with C# being my professional language

Is it just me, or is the Scala form the most readable? The briefer the function gets, the harder it is for me to read. Even when I know haskell and not Scala.

Wow, just amazing! You are just the programming channel I was looking for. Thanks for your content, keep it up! Cheers!

Great talk as always. The slides were much smoother this time around, loved it.

This is going to be a good one, I can feel it

My moment has finally come! _I used APL before you were a glint in your father's eye_ . 👍. Great video. Enjoy the journey it's everything.

Combinatory logic gameplay: Combinatory logic lore: "Somebody I Used To Know remix played over this accelerated video" Thanks for this video, quite interesting introduction to combinatory logic and array programming.

APL was the very first programming language that I learned at the age of 8, taught to me by deaf friends. The next was BASIC. Imagine that!

Imperative programming is like a recipe. You follow the steps and out comes the result at the end. Functional programming is like an assembly line for your data, where each step computes, recombinates or combines the data, to get to the endproduct. I feel that the recipes of imperative programming are easiest to read and follow, because you can easily digest it step by step and see the intermediate results. If you do simple things like map, filter and reduce and an occasional zip, functional programming can still be very readable for most programmers, but it becomes way more complex once you start using the combinators. And I don't mean that those can't be understood. I mean if you can see at a glance what it does without too much effort, which helps maintainability.

it's worth noting that the problem being solved has a real-world interpretation: If the numbers are a time series of prices (like daily prices for a stock), this gives the maximum profit you could make if you bought and sold at the optimal times (assuming you can't short-sell). So if you are evaluating some trading algorithm this gives the upper bound on performance. This is also solved in one of the "Q for mortals" videos.

Anyone ever open a door out of curiosity and instantly regret it? Time for another mug of coffee...

Oooooh a very interesting comparison! Love your channel

Man I really really loved this video. You convinced me to look into combinatory logic. I'm gonna check out To Mock a Mockingbird. Thanks for the great video!

Just the first video I watched on this channel, and looking at other videos... this is probably the best channel I found over the last ~10 years

I love your podcast! I didn’t realise this was your channel.

I can't wait to see this showdown. 😁 Thanks in advance for making this!

clojure solution: (defn maximum-difference [nums] (->> nums (reductions min) (map - nums) (filter pos-int?) (cons -1) (apply max))) i like it better than the skala solution and clojures map fn forgoes the need to zip, which is always nice. But point free solutions like these tend to fall apart when you don't have a consistent placement for argument (notice my use of cons instead of conj). But that can happen in haskell and apl too, if it werent for combinators to save the day. clojure just solves this with more macros which has it's own tradeoffs.

Such a great presentation!

Thank you. I finally get what combinators are _for_ not having seen it explained in a way I have understood as an engineer until now.

This is the first time I came to know of combinators. Interesting.

I'm pretty sure APL was developed by our alien overlords.

I love APL . It helped me so much with Linear Algebra and Calculus.

Excellent production!

APL is the Doctors handwright of programing

Thank you, this is the first time I have a good idea of what the S Combinator is all about... Sharing the same argument again, without being forced to mention it twice... Neat...

I wanted to ask this in the last video. Did you create a logo for APL? If so, this looks cool! 😁😁

What's your thoughts on the C++ standard trying to becoming more expressive like the inclusion of the ranges-v3 and I've seen a proposal for C++23 for a new composition operator for I think regular (imperative) functions as well as the range, view and lambda functions. I believe the proposed operator was operator |> (x, f(y)) where f is a function and y is its input and x is a value or function that is passed to f through y. I was curious on your thoughts. Awesome video though.

What people like this guy often forget, is that code is read a lot more than it's written

How does changing variable names from clear words to random meaningless syllables make the code more readable

What's your opinion on J programming Language vs APL? honestly I've been giving both a bit of review, and seem to like J language more. What would you say - which one is "more powerful", if you could/can compare them?

I am convinced this guy is insane. His main argument for APL and related languages is that... they use less symbols? Like... what? There is no world in which that is a worthwhile argument for or against any language. Being able to express a function in terms of a single obscure unicode character as opposed to four standard ASCII characters is not an inherent benefit. Not to mention the fact that both Haskell and APL have the same issue when it comes to readability and attitude towards newcomers to each respective language - they both have an unbelievably academic and elitist community which favors mathematical names and concepts over more readily understood equivalents. You can express the S-combinator both in terms of an abstract mathematical concept, or in terms of a simple C-like function signature, and I hazard a guess that the C-like function will be a lot more readable and understandable to a lot more individuals. However, I will agree that there are tasks that languages like Haskell and APL excel at, particularly related to data processing.

I like your run through. Very good example and good work. Personally I like languages which are multi paradime. I our team we use D and try get my colleagues to use other part of the D language. Specially the OOP or OOOP (Over Object Oriented Programing)

The parentheses aren't even needed in the APL solution, making a cool looking function with the max reduce at one side and the min scan at the other

I wonder if Clojure's macros can be used to introduce combinators 🤔

Your strategy is overly complex, no? maxDiff :: [Int] -> Int maxDiff = snd $ foldl' go (maxBound, -1) where go (lo, diff) x = (min lo n, max diff (x - lo))

What are the pros and cons of writing the algorithm in one paradigm vs the other? For example the pros and cons of the Haskel implementation vs the Python one? For context, Python is my main language but I'm kind of interesting in learning Haskel.

Waiting⏳also your sicp course is insane

Very nice presentation!

Smullyan's bird book will arrive most likely on 2021-12-18. I'd ordered it well before I saw this video. I'm happy to see that you recommend it too :D!

Elegance !== Legibility

Would you do a Julia over view? It looks like a jack of all trades and master of few.

I hardly understand 5% of what's going on here but I feel amazed and quite smart after watching these vids. LMFAO. Seriously the world of computing is mind blowing. The so called "developers" like me don't even know 1% on what goes behind the scenes when we call an in-built function or use any tooling like Git or SDKs etc. Thanks mate for keep making these vids. Hope you're keeping backups we don't know when WW3 ends everything.

I think the very idea that only collections (aka arrays) of things should exist is brilliant, kudos to APL to introduce that.

Please could you comment how do you do those smooth text code transtions? Thanks in advance.

You broke my brain ! Great vidéo ! Subed'

imagine you have to check a pull request and see this: 20:12

What do you think about GNU APL for a beginner?

How do you even produce those characters on your keyboard? Is typing a function call really so taxing that reducing it to a single character is the difference maker? I don't understand how this kind of language can be easier to read/write or reason about.

This talk demonstrates why functional programming is less widely adopted: the imperative approach is, more or less, “do what the problem description says to do”, the functional approaches require reinterpreting the problem in terms of the concepts that are well supported by the language.

7:40 100% disagree. Even though I knew what the variables were originally, I got immediately confused by these short variable names. It’s maybe to do with parsing mathematical formulas, which I am super bad at, but I feel like 1-3 word variables are much more readable than 1-3 letter variables. Except for i in a loop, but even there, index, position or location may be more appropriate depending on what you’re actually iterating over.

Honestly I am far from understanding it but congratulations for the great presentation and thank you for taking the time to explain it. There's a lot I still have to learn tô fully appreciate it.

Did you use Manim to create the slides? It looks great.

Your videos are cool! Can I ask what you use to create these amazing slides and animations?

Before the functional language section I tried to solve the problem with Haskell myself. What surprised me is that my solution was completely different from yours. I only used recursion and ifs, no fancy functions like scan, map, filter, reduce and combinators, but my code is still O(n). It made me wonder which is faster for larger input arrays, I might check it out later.

I would love to know how you manage your time. Would love to start doing more outside of work, but I you’re like 10X and I’m struggling

5:00 doesn't it make more sense to assume the max_dif to be n[1]-n[0] if positive, otherwise -1, such that .we increase the difference as we find a larger one, instead of assuming it to be MAX_INT?

It would be amazing if you did BQN or APL tutorials.

"The expressivity of the single glyphs"? oh yea, totally sold me...I'm switching to APL, where do I buy a keyboard with all these expressive symbols?

This video has convinced me to drop out of my CS degree and just drive an Uber.

About the example problem: I believe it might be faster to store two variables of the highest number and highest difference, and instead of comparing the difference between the min and the current number to the current biggest difference on every single step, we just compare the current number to the highest number. Each time we find a new min, we compare the highest difference to the different between the current max and min, and store the largest of those as the largest difference, then set the min and max to the new min we found. So instead of doing a subtraction for every element in the array, we only do a subtraction each time we find a new minimum. I have no idea how fast variables can be accessed and stored, so I don't know wether the increased number of variables used increases compute times more than the reduction from fewer subtractions.

So APL is what people refer to as a write-only language

Well. This video made me happy to stay with C++ I guess. :D Or I guess I just won't go for APL.

You've earned a sub

20:35 Twin Algorithms secret reference (and 21:58) could have sniped his conference talk while he waited to give it in person

Are functional and array orthogonal paradigms? Could you theoretically have a programming language that is both functional and array based?

MATLAB: res = max(nums (2:end)-nums(1:end-1)) If all(res

I would like to learn more about this combinatory logic stuff.

If BQN also had all the type theory stuff Haskell does, I'd be sold. Without it, although the glyph notation is cool, it's just a limited version of Haskell not worth learning (imo) - just learn Haskell at that point. Or I guess I can ask: Other than the fact that it's more succinct on account of the glyphs, what does BQN offer that Haskell doesn't?

Nice 👍 really informative

Hi, personally many of these languages are not my cup of tea. APL cannot even be typed on a normal keyboard. But I liked to see what I could do in C# here. I am both able to go the imperative way as well al the functional way which is called LINQ. I had to write the ScanLeft part myself, of which my yield return version turned out to be the nicest, because in that way you still benefit from Linq it's lazy execution efficiency. But the rest was quite easy. For Map you use Select and for Filter you use Where. The nicest thing is that Zip is available as well and it accepts and extra input array as direct input, so that I basically get something simular to that S combinator solution from Haskell, even though the code looks more like the Scala code in the video.

This is definitely really cool. But for me there is always a question: how to get things done on such languages? What's the purpose? How difficult it would be to write for example autodiff library on APL? Or train ML model (or GPT-3 for example)? process tabular data from csv? scientific algo, which should be as efficient as possible?

You can do it one-liner in Python like this: def solve(*args: int) -> int: return max(args[min(args):]) - min(args) if min(args) != args[-1] else -1 But I think it would be better if you store "min(args)" first in a variable.

So what you're saying is that some languages have more useful (for this problem) standard library functions than others. So the comparison is between standard libraries, not languages. Still a valid discussion but you're mixing syntax Vs library

what font do you use?, It looks nice.

It's too esoteric to me to be honest haha, but it seems really cool to know how to program in a language like this. And I have 2 questions about Array Programming (or APL): 1 - To code in APL you need a specif IDE? because I don't even know if it's possible to type some of the characters that I saw. 2 - And what kind of problems this type of language is target for? like, in which scenario I would choose Array programming instead a normal approach (like C++)?

The S combinator explained at 17:32 reminds me of functions as monads: you can chain a binary function x onto a unary function y, so in Haskell it would be something like y >>= x. I believe the same is achieved by treating functions as applicatives with x y (solution of this video).

Wow, APL and BQN are gorgeous.

Why auto maximum_difference(std::vector nums) -> int, instead of int maximum_difference(std::vector nums)? Why by value instead of by const-ref?

I understand why you like these languages. Your thing about making the variables shorter in python to make it more "readable" is a subjective thing that I don't really share...

7:55 - for the python example, isn't it better to use math.inf instead of sys.maxsize?