Video

I missed that that's standardized in wasm already. I'll have to see the support for that. And I'd want to have explicit tail call indicator of some sort in Rio for that, I think. And I'd eventually want to verify it in the Rio compiler if so. But yeah, I think tail calls are great when verifiable.

And thanks for drawing my attention to it! And I'm not yet sure exactly how I'd want to indicate it in Rio syntax yet.

Thanks for the encouragement! I'm actually leaning toward nominal typing, and it's actually nominal right now. I should have mentioned that in the video. The = is a fixed definition, then I track it as a distinct thing. I love structural, but nominal is easier to code in the compiler and easier to report in messages (although I don't have messages yet). Maybe easy spread syntax will get some of the advantages of structural also. But I also need to see how it goes. Some people want design set in stone in advance, but I'm still winging it some.

I do also plan separate "packed" (somewhat like Rust "Copy" trait) and "class" types from "struct", where packed and struct act like C# record types also in ways, but classes are opaque abstractions. And might still say "record" instead of "struct". Thinking about that.

Glad the videos are helpful to you! And yeah, life balance is tricky. Gotta make the decisions that are right for your situation, whatever those are.

And I still need to study wit (wasm interface types) sometime.

@@contextfree I'd love a video on those and how to use them! Really, any walk through of how you've done what you've done would be helpful.

I've played with Koka some, but I still don't feel super familiar with them. For Rio, I plan to indicate in effects in some fashion, maybe even just by required args, but I probably won't go full algebraic effect handling or anything.

Just looked it up and read a blog post on it. Is it not just dependency injection? I get that it goes up the stack to find the closest 'handler' for a certain effect, but similarly you can pass dependencies down.

By "required args", I effectively meant dependency injection. Some languages make effect handling a primary language feature though, and maybe combined with coroutines and such, they get more low-level flow control out of it. But I can't speak authoritatively on the subject at all.

I have some videos on effects and also dynamic scope where I explore the subjects in a limited way, but that's as far as I've gone.

I've been calling my hobby language plans Rio for decades, even though the specific language plans have changed over time. It's had more meaning for some of those language variations than others (in the "river" sense of the word). But it's primarily named for my fond (and sometimes not so fond) memories of Río Blanco, San Marcos, Guatemala.

Rio conveniently also might remind people of Lua, which is nice because I aim to be small in implementation and feels like Lua is. If the R reminds people of Ruby, that's also not so bad. Even though Rio is statically typed unlike default Lua or Ruby.

And might remind people of Lua since that comes from a more famous place with Rio in its name.

And sorry for the spam, but maybe only 10-15 years of using that name for projects and ideas.

@@contextfree and Rio languages it will only be a hobby or plans that are something real?

And I hope to have destructuring definitions and pattern in matching in Rio also. If I allow those in arg position for ad hoc arg struct types, it would look just like defining named args also, but I'm not yet sure if I want ad hoc structs like that. And I'm moving slow here, clearly, so we'll see what gets done. Thanks for the comment!

I've often used wasmer for cli execution in past videos, but I like to check on at least some variety of wasm engines, and wasmi is a lightweight and performant interpreter that's well maintained. I haven't done it yet, but I'm inclined to automate running of all my test/example programs using wasmi. I regularly manually check on wasmer as well. And wasmer is surprisingly fast startup for being a compile-to-native engine. And yeah, I probably should be checking wasmtime also.

Yes, that works, although I didn't do any browser nor js stuff here.

Mind explaining more?

@@contextfree We don't put structs into database tables. We put records into database tables. They are records

So you would prefer if these languages had used the term "record" instead of "struct", if I understand correctly. Interestingly, C# has a language feature called "record" these days, and it means something different than "struct" there. More to what seems to be your main point, long ago I learned C before learning Pascal, so I learned the term "struct" first. Although I think you're right that "record" has a longer history in such usage.

@@contextfree Yes. Ada, Modula, Oberon, Oxygene, Icon, they all have records. But whatever Haskell you take from outside the family, it also has records

Thanks for the comment! Yeah, I purposely passed by reference to the main printing function in both C++ and Rust to have examples of pass by reference here in addition to the examples of passing by copy/clone.

I just didn't mention it in verbal discussion, and maybe I should have.

When I remember, I always measure cli time in my videos. My videos are edited, but I try not to edit command execution, and keeping the time there is part of that. I'm also interested in compiler speed. I'm not benchmarking here. But a viewer did do some benchmarking, even if this still is just a micro benchmark. I've linked to that in the video description.

I abandoned learning Rust because there are so few jobs in it, and getting a job as a programmer at a quality company when you're in your mid-late 50s is hard enough as it is. I didn't get to the point in my Rust journey where it ever felt like I wasn't fighting the language, but I truly believe that I would have, eventually. The main thing that I love about Rust is the way enums are first-class data objects, and the way the compiler makes sure you're covering every possible value that can be returned (if the return type is an enum). It feels so natural, and I wound up writing functions that looked a lot like finite state machines, which I find particularly easy to understand and reason about correctly. It is my understanding that this feature is common in functional languages; even if that's the case (pun not intended but duly noted), Rust is the first time I remember encountering it in a C-derived language. (Actually, now that I think about it, I also really miss that attribute system, which took a while to wrap my head around, but has profoundly changed how I think about many problems, to the point that I've become really interested in tagging systems in contexts other than programming. I know Rust isn't the first language, or even C-derived language, to use something like attributes, but it's the first time I encountered it as a core language feature.)

@@andrewgr144 You are right, Rust is not a good choice for work reasons, but I only learned it because of its modern features. I worked for a company that made set-top boxes, and the original code of the company's product had a lot of unused annotations. And a large number of global static variables, and the inexplicable insistence on using the ANSIC standard makes the original code messy and difficult to maintain. I don’t understand why the company insists on using the C language. Obviously the tool chain provided by the set-top box supplier provides g++ related files. There is nothing missing. Using C++'s data encapsulation function and construction and destruction function can enhance the readability of the code and simplify a lot of complexity. Of course, this is a story later. The company's programmers do not have the ability to C++. they can't even understand the construction and deconstruction functions provided by the C++ language. This is a company where engineers insist on only doing their own part to clean up the trouble. After many years, I learned that the internal state of this kind of company is very important to a China mainland company. The company is the norm. Fortunately, I left my job early. At that time, I still had the enthusiasm for new technologies and the insistence that the code should be beautifully designed. I was not suitable to stay in such an aging and decadent company.

The timing includes compile time, because I care about that also. One viewer did some actual timing analysis with fuller optimizations, though, using Rust, C++, and D (in multiple configurations). See the link above in the description.

Worth noting that even the benchmarking linked in the description is still limited to this simple program, which is a micro benchmark. Hopefully the measurements manage to exclude IO time as well, but I didn't ask that.

What adjustments would you like to make for a multithreaded look at the topic?

@@contextfree What happens when you mutate your struct from different threads? In Cpp it works (except it rarely causes data races?), in Rust it doesn't (Rc is not Send, have to use Arc<Mutex<FearlessConcurrency>> instead), in C# I don't know… Also, C# tracing GC stops all (most) threads when it runs but the other two guys don't?

One place I've seen `clone` before Rust is Java, where they say that "by convention" the cloned object "should be independent" of the original object, meaning deep copy of anything mutable, and I suspect the Java method name may have influenced Rust's naming, but I don't know what predates Java in that, nor have I dug up conversations from Rust development. And of course, Java still has no value/copy types outside of primitives quite yet, although possibly coming soonish.

Trade-offs exist for most things.

Semi-serious question: would it be possible to provide hardware acceleration for GC? ("Semi-serious" because I don't know exactly how GC works, and if it would make sense at all to do this. But I'm guessing that if it hasn't been done yet, especially given how common GC languages are, then it's probably a silly idea. Or maybe it's not a silly idea, and we can get by fine by just throwing more powerful generic hardware at the problem... 🤔)

@@vlc-cosplayer No immediate answer from me. I'd have to study that for a while.

@@vlc-cosplayer good question, I think the overhead wouldn't be worth it, because the best solution is to keep as much memory as possible for as long as you don't need it for something else. Really memory management is only necessary for Operating Systems with concurrent applications that need your memory. If you manage memory for your own application you can just keep the memory address to a large piece of memory and return the last the end of the piece of memory and assign on top of that. That is how arenas do it. So all this memory management issue is largely a multiprocess issue.

Speed isn't necessarily the issue with GC languages, and in fact I think it might not even be the issue the majority of the time. The other issues are predictability and constancy of execution time. For example, say you're writing the back end for a massively multiplayer game of some sort. It could be the case that the mean, median, and modal performance averages are all plenty fast enough, yet your decision to use GC dooms your game to poor reviews and player retention, because some small percentage of the time, the GC runs and sees that something can be deleted, but by deleting that thing, it now sees that some other stuff can be deleted, etc., in a cascading effect that leads to a noticeable lag in the game. The conditions for creating this lag may be incredibly rare as a percentage of the number of times the GC runs, but the GC may run often enough that the lag is still occurring every five or ten minutes of real time. (I think maybe a high-volume day-trading stock system might have made a more compelling illustration, but my mind immediately goes to games, and I'm sure anyone who reads this comment can see how performance lags due to GC would be disastrous in that scenario-- if the GC is fast enough for 999/1000 trades to get executed flawlessly, but 1/1000 times there's a half-second delay, allowing the many competing auto-trading bots to make their trades first, those delayed trades might completely wipe out the profit margin made by the other 999.)

It's what's currently handy on Compiler Explorer. They also have an unclear "main" option. I suspect 8.0 is coming there sometime.

@@contextfree aaa nice to know

dotnet 7 also supports AOT

@@Liphi yes but codegen for 8 is much better as libraries get more annotated for AOT

@@metaltyphoon I mean, that's just a basic struct manipulation. Doubt that .net 8 can change something here

Yeah, I rarely express opinions directly in my videos (although I actually like Rust clone vs C++ implicit copy constructors, but don't tell anyone). I usually just explore stuff. And RC optimizations are definitely an interesting topic that I avoided discussing here.

One of many interesting video topics could be exploring heavily compiler-optimized C++ and/or Rust and/or Swift RC in simple cases vs say Perceus RC such as in Roc or Koka. Haven't explored that yet, though.

@@contextfree After a few years of C++ i love to remove implicitly as this leads to the worst errors. At some point I created a hardware interface implicitly from string which caused havoc :)

@@contextfree It could be as simple as reading numbers from file, adding them up and printing the sum to terminal. With godbolt its great that you can compare different optimization levels and see when the compiler starts using SSE instructions.

C# app was also in x86 assembly (aot or after jit). IL looks different

Yes, in some cases if we have predefined lifetime, `ptr*` will be best solution (probably in some wrapper).

Data is ownership is a thing in GC languages, including C#, they're just not exposed to the programmer, but the GC algorithm needs to know who owns the data and for how long so that it can `safely` drop objects. This process can be quite fast and efficient, the problem is that reference counting and data dropping is not done eagerly for a lot of reasons, so you end up with these performance dips that can be unpredictable.

@@user-uf4rx5ih3v Oh sure, you're right. I should have specified *user-facing* existence of it. Of course that will matter in implementation details, for performance, etc.

​@@japedrEven as a user you still have to think about ownership sometimes. For example when you have to ask yourself, should this be a regular HashMap or a WeakHashMap? And if you guess wrong your objects either spontaneously disappear or start hogging up your memory.

I disagree. Shared ownership and mutability should be used very sparingly. Shared ownership itself is absolutely fine and often a nice tool to keep track of context.

The comparison shouldn't come close though... Shared pointer is literally just an atomic size_t variable that gets incremented and decremented, and deletes the pointer to the held object if the reference hits 0; that's incredible cheap to the point of being almost zero-cost. Garbage collection has MUCH more work to do with walking through the list of items and checking to see if an object is still "reachable" from the programs root. I've personally built my own custom "shared_ptr" type that offers additional functionality from the standard library, and it's much much easier to implement than even a custom container type would be, let alone writing anything resembling competent garbage collection.

Are you sure? I also don't really know CIL, but .NET has AOT compilation sometimes, and those registers and instructions look like x86-64 and don't look like this example of cil here: en.wikipedia.org/wiki/Common_Intermediate_Language#Example

Or rather .NET supports AOT compilation these days, and I suspect that's what they've configured on Compiler Explorer. See also: github.com/compiler-explorer/compiler-explorer/pull/3168

@@contextfree oh nice didnt know that!

it's*

​@@contextfreeThose are assembly instructions, but you don't need aot for assembly instructions

The entire point of gc is to make things simpler

@@stercorarius right, I meant simpler for the compiler/CPU, as in it has to do less work (at given time, because obviously it will have to do the work later)

would help a lot if you tell us what your blog name or url

Hey, can you share your blog?

I chatted a bit with Jonas and confirmed that this is his blog. It's still brand new, but he has some additional posts planned, such as he mentioned above. jonas1ara.github.io/

Odin is definitely a great option for people that like C but want something more convenient and more modern.