Elixir is great! But I like my types 😁

Another great new language!

Glad you found it useful!

True! I like simple languages

What do you mean it doesn't need tail call elimination? I've not used Clojure at all, so I'm curious what this would look like

You're right, thank you!

Go is great! I agree with your first three points for sure. On the last one, with the BEAM, your cache can be a separate process, or even on a separate node, but still be in your program, and still be perfectly fault tolerant!

JetBrains Mono

Uhhhhh good luck good luck

I have no strong opinions really. It's useful in some cases, but in others it's unnecessary indentation

Yeah, that'd be nice. Unfortunately it's difficult in Gleam as it doesn't have its own runtime, and instead relies on the runtimes it compiles to for most optimisations, especially runtime ones.

You're not sacrificing performance though. As I said, tail call optimised recursive functions get compiled down to tight loops, so they perform exactly the same.

Glad you found it useful!

Gleam is actually a lot simpler than an object oriented language! There's a lot less to learn and a lot less going on. It's merely a matter of what you're used to

😂

Definitely got a JSON video planned!

Someone didn't watch all the way to the end before commenting 👀

@@IsaacHarrisHolt I actually did, this was more of a shared experience ;) I actually liked the video a lot, keep more of these coming!

Yes

Gleam doesn't support currying or partial application (at least, not in a generalised way). Higher order functions are a big part of any functional language, but I'm not sure how much of a video I could do on them 😅

@@IsaacHarrisHoltI would find it super valuable if you did a video reviewing gleam code and showing how it could be simplified using the standard library. plenty of higher order functions there

@@IsaacHarrisHolt Whatever you call it, the quick "let add_one = add(1, _)" type of function is a lovely way of doing what I think of when I think of partials

It 100% is way too exposed 😅

Unlikely - html and CSS don't really translate well to mobile unless you're making a progressive web app. You could use Flask for an API backend though

Someone gets it

Angelic

This is definitely one of the comments of all time. You come across as though you've never worked on a large project with many developers. When writing software in teams, the best thing you can do is get the computer to do as much of the work for you as possible (auto formatting, lint checks, automated testing, etc.). Type checking is part of that - it reduces the mental load on each engineer, increasing the development velocity of the team as a whole. If you're relying on variable names to tell you their types, e.g. "number", you're basically introducing your own weak, inconsistent version of static typing anyway and creating more work for the people writing code and the people reviewing code. There are cases where dynamic typing is helpful, for sure, but for the work that 90% of people are doing, having static types is going to be a boon purely for the time it saves debugging issues. As much as anything else, static typing is a form of documentation. When you're onboarding new engineers onto a project, having types for them to read makes parsing the codebase infinitely easier - they don't have to keep all the context of all the types of every possible permutation of variables in their head to understand the flow of what's going on. And if you try to make the argument for documenting types in docstrings etc., again, you're using a poor-man's static typing. On the Python point, as someone who has written a fair bit of Python professionally, and used to make Python videos on this very KZbin channel, a lot of the industry is moving towards using type hints as much as possible. The same trend can be seen in other popular dynamically typed languages - Elixir is getting a type checker built into the compiler, and Ruby's Sorbet is growing in adoption. Basically, all this to say... what??

I see. You're a proponent of the bloat approach. You're in a team so pile on the boilerplate and layer on the comments. "We can't take the stabilisers off the bike dad, it'll fall over." Let's agree to differ on that front.

Type annotations aren't bloat. Having to do more typing to make your life and your colleagues' loves easier is always worth it. Typing isn't your main job as a software engineer anyway.

@@IsaacHarrisHolt They literally are boilerplate. Listen, we clearly have very different ideas of what constitutes good code. You're the the verbose / explicit camp, I'm in the minimalist. Some experienced coders would agree with you and competent coders would agree with me. :)

@@davidmurphy563 you're very difficult to have a constructive conversation with, by god.

Gleam isn't a new concurrency system, it builds on Erlang!

Interesting! I still have (and use!) the exact same mouse I showed in the video, and I've never had that issue. Perhaps you had a faulty unit? It does happen, sadly

How kind, thank you :)

Uhhh... drunken woodworking?

@IsaacHarrisHolt that is an activity xD

How come?

@IsaacHarrisHolt I think it just looks off and includes a lot of visual noise like a lot of brackets (often semantically useles ones like [], if an element has no atributes) the html. prefix (or you have to import the functions you use) etc. I really just like looking at actual HTML way more.

That's fair, but I don't think it's enough of a reason not to try Lustre. It's pretty great, and you get used to the syntax very quickly

@@IsaacHarrisHolt can you use lustre just on the Server. Because I want to try out htmx for the frontend

Absolutely!

I've slowed down a lot in newer videos :)

I don't think I ever said defer existed for that reason, and like I showed, you can implement it perfectly fine without `use` in a functional language. `use` just makes things a lot nicer. And I dunno, being nested 2000 levels deep would be pretty gnarly. Even the tabs v spaces folks would gang up against you there! And lastly, this video is definitely not `use`less. Seems to me that there's quite a lot of `use`ful stuff happening here...

Ah, pedantry. We are alike, you and I 😅

Thanks! Let me know how you get on

You could possibly use it in a similar way, but `use` is a lot more general than that

Well it's a good job Gleam doesn't have returns or loops to break out of then! And if you need things behind the function scope, you'd either a) not use `use` or b) pull your `use` usage out into a function. While you can use a block to change the scope, you're right in that it's pretty pointless

@@IsaacHarrisHolt I admit it is a great sugar for languages that rely heavily on callbacks. Use is great because it does not propagate to the function's caller (like with async/await syntax). Great video, as usual.

Thank you :)

Thanks!

If you use tail call recursion, and your language supports it, your stack size won't increase.

You're right!

Yep, it can help with a lot of styles of programming you'll see elsewhere, for sure. `use` with `result.try` gives you that nice railway programming experience

You'll start to love it as you write more Gleam. It's so great

It's just a joke dw :)

@IsaacHarrisHolt ah i see, you trying to bait engagement >:|

Not necessarily? I'm just a functional programmer making a joke about OOP langs :)

Except Lucy is always pink!

Check out the gladvent package!

It's absolutely fantastic, but I don't know if it'd work in every language. I'd be curious to see what it's like to use in JS, though

@@IsaacHarrisHolt One thing I noticed is that the type of `return` must necessary change from the return type of the outer function to that of the callback function. Also, early return for the outer function is no longer possible. Is that correct?

It doesn't necessarily have to change. It'll depend on what function you're using with `use`. You'll get the return type of that function, not the callback. Of course, that function MAY return the same type as the callback (e.g. result.try, the defer example) but it doesn't have to (e.g. with list.map)

I think this is something you get used to. Everything under `use` in the same scope becomes your callback. You're right though - this is one of the ways `use` can be misunderstood.

Seems very similar, lets you write a heavily nested lambda in a procedural way. Other than not using monads it seems almost identical.

It was probably somewhat inspired by that for sure

​@@nathansnailit uses monads though

@@vytah how so? it doesn't seem to add any additional monadic structure from what the video shows.

You're gonna love it!