It's such a great pattern when implemented well, for sure

They're still sorted as arrays of UTF-8 codepoints, the same as any other string. The std.unicode package in the standard library has functions for wrangling unicode strings, and I believe you can have it output a u21 for a unicode codepoint, as that's enough to cover the entire unicode space. There are some really good articles online you can look at if you want more info :)

It's pretty cool, right! Though it's not particularly likely I'll be doing more Zig at the moment - I'm pretty focused on Gleam

💯

Fair criticism! As for that, the short answer Gleam has some really great ways of having in memory kv stores thanks to Erlang and the BEAM. The long answer is a little more complicated, and one for research :)

Thankfully syntax is just surface level, and quite easy to get over once you start using the language in earnest!

Thankfully syntax is something you can get over pretty quickly when learning a language

Glad you found it useful!

That's a fair point, but as someone who writes both languages a lot and spends time in the community, I can say that that's not generally true for people. And if recursion is something you struggle with, I have a great video on the topic 😉

As someone who writes Rust for work, I don't _totally_ disagree with you, but it's not just about actually getting the code on the page. The long compile times lengthen the feedback loop (even with caching etc.) and deploying Rust is a real pain in the ass most of the time. Dockerising it is never as simple as it should be.

@@IsaacHarrisHolt You're right, but those aren't really fundamental language design problems, such that you didn't even mention them in your video. These are things that are being worked on and that are likely to improve with time, unlike something like lifetimes which does make the language more complex and also is not going away. That also assumes everyone would be using the same type of environment as you, I don't use docker for instance, a self contained binary is easy enough to deploy. Still I don't believe that Rust will ever reach a state that your point isn't at least technically true.

Zig is good!

I'm happy for you. It was just a meme.

@ and its use told me all I need to know.

1. Yeah, sorry, I'm pretty ugly, right? 😁 2. I've got to be able to support making this content somehow. I don't have unlimited free time, so I have to prioritise. Would you rather have a video with a 30-60s ad or no video at all?

@@IsaacHarrisHolt 1. it's noise. i prefer minimalism 2. yeah, but it makes saving and recommending a video hard

Fair enough. I'd rather produce videos with minimalistic animations to explain the points I'm making, like CodeAesthetic or aarthificial. Unfortunately, I have neither the time, skills, nor time to learn the skills to make that happen, and finding someone who can animate well enough to achieve what I want, but also understands the concepts of the videos well enough to not need hand holding all the time, is next to impossible. And there are sponsor segments in a huge amount of videos these days. They're what allow creators to put time, effort and money into their videos. That said, you can skip them, or just not watch the video in the first place.

@ Btw, can you recommend a job? I use Rust, Gleam, Haskell, Elm, Nix. The direction I want to take is data science, game theory and genetics. Currently I am learning how to frequently find value bets, since now main priority is earning several million so I can own a business so I can do my research on how to give advantage to children. My goal is to be an ancestor to last life, since I realized that life depends on low entropy and it seems to grow globally :D

@@IsaacHarrisHolt Btw, can you recommend a job? I use Rust, Gleam, Haskell, Elm, Nix. The direction I want to take is data science, game theory, genetics. Currently I am learning how to frequently find value bets, since I want to earn several million so I can own business so I can do my research on how to give advantage to children. My goal is to be an ancestor to last life, since I realized that life depends on low entropy and it seems to grow globally :D

It's probably my least favourite part of Zig. That said, you would always just write all your function names in snake case and deal with the fact that library functions will be camel case

Thank you!

I can't really answer your question I'm afraid. Performance-wise, fine! People wrote games in all sorts, including JavaScript and Lua, so it depends on the complexity of your game. It'll mostly come down to tooling, and I don't know enough about that.

Gleam is definitely like a functional Go!

The BEAM VM (and therefore Gleam) uses 'processes' which are essentially green threads and can be thought of as analogous to Go's goroutines. The only difference really is the 'shared nothing' architecture whereby each process has its own memory and call stack.

Haha thank you!

I totally get why futures and future-likes have the function colouring problem, my point is mostly that it's not the only concurrency model that exists. People do tend to think of it by default, though. Promises work great for single-threaded systems that can only achieve background work by polling, but they're overkill when you have green threads/processes. They also can't work in a totally immutable system

Oops, that’s Typescript, sorry!

No worries!

I don't understand what you mean here, sorry

Join the Gleam Discord! Loads of people there who can give you help

@IsaacHarrisHolt okay thanks for the info. Will do.

Of course!

You can make generic functions with them across many different phantom types. For example, with the `Distance(a)` type, I could write: `fn add(dst1: Distance(a), dst2: Distance(a)) -> Distance(a)` Then I could add ANY two distances, as long as they have the same phantom type. If I was using new type wrappers, I'd have to have an add_miles, add_kilometres function, etc. Also, phantom types have no runtime overhead, as they're compile-time only.

Very easy! Phantom types are just generic type parameters at the end of the day. `fn calculate_speed(dst: Distance(a), time: Time(b)) -> Speed(a, b)` You'd have to write it as a function though, and have a `Speed(a)` type. You wouldn't be able to just use primitive operators (which makes sense as `Distance` and `Time` aren't primitives)

Hopefully it was helpful!

Thanks!

Interesting! I don't know how many languages are likely to support it, but that's pretty cool

Phantom typing is just the generic name for the concept. Languages may have their own names for sure

Thanks for the feedback!

Sure, but another tool in your belt is always helpful!

Awesome! Glad this was useful

Phantom types in Rust are necessary only because sometimes types need extra information to pass to trait impls. I'm pretty sure they weren't made with typestate/newtype pattern in mind.

They can absolutely be used as phantom types. There's a good talk somewhere on type driven API design in Rust that uses a similar concept.

They can absolutely be used as phantom types. There's a good talk somewhere on type driven API design in Rust that uses a similar concept.

I'm not totally sure what they are! Are they a language-specific thing?

@@IsaacHarrisHolt ValueObject is a name often used in Domain Driven Design, and it describes a concept of creating classes/concepts/types (depending on the paradigm) that wrap primitive types, so instead of using a float, one would create a (for example) Measure class that would wrap a raw float. It's basically a design pattern to fight "primitive obsession", so the goal is the same, but it's in runtime, and allows to have for example methods that would allow adding Miles to Kilometers but with proper conversion ;)

I might not understand what you mean. It doesn't feel like you could achieve Compile-time checks with this strategy

@@antoniong4380 You do. Instead of using some phantom types, just just use normal types. The disadvantage is that it can be a lot of boilerplate, as you now have a full type, so in places where you need a float (for example in some library you're using) you cannot directly use your own type, but must do a conversion, or break encapsulation, something like that.

With ValueObjects you could achieve compile-time checks as well since you can make methods that only take said classes, thus forbidding certain unwanted behaviours. For example, I could make a value object for Email, and validate that the string provided is not empty, has a certain length and matches my email regex. With that, I know that anytime I'm using an Email elsewhere, I don't have to check for such things. Thus any code that relies on them can work based off those assumptions at runtime, and leverage their properties/methods at compile time

Yeah, it's definitely one of those "be the change you want to see" things. If you can start implementing them in the bits of the codebase you own, you may be able to start convincing people through the organisation to use them

Phantom types are probably closer to branded types. Dependent types usually require the compiler to know something about the actual runtime value (e.g. my dependent type is only EVEN numbers) whereas phantom types are effectively user-assigned tags.

@@IsaacHarrisHolt In the dependent-type world you could have Open and Closed be the constructors of a single enum-ish type, restricting the "type of the type" of File to be just one of those two (and not an unrestricted type). If I understand it correctly, Gleam has only 2 "levels" of "stuff" - values and types, with no way to differentiate different types (noone can stop me from working with a `File(File(Int))` or something. One might say that the "type of types" (the type of stuff you can put in `File(here)` is "Type" and not something more specific, i.e. the type of types is an "open type", in contrast with a closed one (like a hypothetical enum).

Interesting. Seems I need to do more research into type theory 😅

That was my immediate thought aswell. I wrote my Bachelorthesis about verifying a prgramming language using Coq and learned a lot about dependent types in the process. Although Phantom Types are more restricted than dependent types.

That's correct

In fairness, this one probably is a little fast 😅 I've tried to slow down more recently. Thank you, though!

Comparing what? At what scale? Between which languages? What are we measuring and why is that important? What are we measuring? It's never as simple as just "do a performance benchmark".

I'm only a soy dev because lactose makes me gassy 🤷‍♂️

"Better" can sometimes mean "wastes less of my time to configure". Sure, call it a skill issue, but if something keeps me from working on the truly important things, and there's another tool that'll let me achieve the same thing faster, I consider that better.

@@IsaacHarrisHolt I wouldn't call that case a skill issue. It's just not the primary reason for that mindset of reinventing the wheel. Your case is the exception to the rule.

Yep!

I think syntax is a hurdle you can get over pretty quickly. Give it a shot!

There are definitely plenty of different ways to write all of this! And a lot of this will depend on the language you're writing, too. Not every one is set up to be able to replicate this nicely, though it does seem we're heading more towards functional and "post-OOP" based on which new languages are becoming popular

It's great

Honestly having everything as expressions is one of my favourite languages features, be it in Zig, Rust or Gleam!

You're right, thank you!

This is a great take. These days we're also seeing more and more specialist programming languages and fewer "general purpose" ones, and I think that's fine! Alternatively, we see languages like Gleam which can compile to different backends depending on the use case you're targeting.