01:46 <c15ade4> its cool how you can watch the livestreams a bit later

01:46 <c15ade4> semi live stream

01:54 <c15ade4> andrewrk: just a warning, i think you made a slight mistake at the beginning

01:54 <c15ade4> Im not sure you intended the camera to be active while the countdown was on

03:05 <daurnimator> Where are std lib docs?

03:17 <daurnimator> andrewrk: watching your stream now

03:17 <daurnimator> andrewrk: clone2 is just fork with extra flags.

03:17 <daurnimator> andrewrk: newer platforms don't have a fork syscall. you're meant to use the clone2 syscall instead.

03:18 <andrewrk> daurnimator, that's really good to know, thanks

03:18 <andrewrk> std lib docs don't exist yet https://github.com/ziglang/zig/issues/21

03:19 <daurnimator> andrewrk: there are many syscalls that have gained an extra flags argument as time goes on. newer arches don't get the old syscall without the flags argument.

03:23 <daurnimator> andrewrk: note the actual kernel implementation of fork: https://elixir.bootlin.com/linux/latest/source/kernel/fork.c#L2230

03:32 <daurnimator> andrewrk: also I wanted to get a bit more about zig's coroutine feature and perhaps share some of what I hope for

03:32 <daurnimator> andrewrk: IMO a good coroutine implementation needs to avoid the "red function/blue function" issue (http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/)

03:33 <daurnimator> which is essentially that a non-async function needs to be able to call an async function

03:34 <daurnimator> --> what is zig's current status/thinking on that?

03:38 <andrewrk> daurnimator, how would that work with needing to suspend? would functions secretly be generated as coroutines?

03:38 <andrewrk> most coroutines need access to an event loop object

03:38 <daurnimator> andrewrk: so there's a few approaches:

03:38 <andrewrk> I have a lot of bones to pick with this red/blue function article

03:38 <daurnimator> 1. if you try and yield() and you're called from an non-async function. it throws an error instead.

03:39 <andrewrk> also - this conversation is interesting to me but I have some household duties at the moment. I hope you stop by during the day soon when I can give you more attention

03:39 <daurnimator> this can be helpful if you can write a function like so: async fn foo(x) { if (x > 42) { suspend wait(); } else { return compute() } }

03:40 <daurnimator> i.e. a function that only *sometimes* needs to do async work

03:40 <daurnimator> that can be helped along by a function `is_suspendable`

03:42 <daurnimator> 2. construct an event loop *inside* of the current function call so that the async function is resumed multiple times from the sync() call site.

03:43 <andrewrk> I have a lot of thoughts on this

03:44 <daurnimator> 2. can be combined with 1.: fn foo() { looptype loop; if (@isSuspendable()) { loop = mainloop } else { loop = newLoop(); } loop.addJob(fooJob); if (!@isSuspendable()) { loop.runUntilEmpty(); } }

03:44 <daurnimator> (sorry for pseudo-syntax. I don't know zig much yet so I'm sort of combining all sorts of things together)

03:48 <andrewrk> check the logs tomorrow and I'll have a thoughtful response for you

03:48 <daurnimator> andrewrk: k :)

03:48 <daurnimator> andrewrk: our time zones don't match up very well

03:51 <diltsman> Given this code: const vector_table align(4) section(".vector") = VectorTable.{.initial_sp_value = 0x20100000,.reset = _start};

03:51 <diltsman> I get this in the binary: 82b00846 01910090

03:51 <diltsman> Any ideas?

03:52 <diltsman> This is the struct definition: const VectorTable = packed struct.{initial_sp_value: U32,reset: fn () void};

04:03 <diltsman> Why wouldn't I see some bytes that look vaguely like 0x20100000?

06:00 <andrewrk> diltsman, that output looks surprising to me

06:16 <hryx> andrewrk, just watched (and enjoyed) the stream video. I didn't know you're doing weekly streams!

06:25 <andrewrk> hryx, yep, I have the older ones saved here: https://www.youtube.com/playlist?list=PLviMr_WImMhHA_yCD2-VfUSB_j4qSQ8pf

06:26 <andrewrk> some are better than others

06:26 <andrewrk> I recommend: * Allocators & Memory Management * Compile Time Code Execution * "Hello World" x86 Kernel

06:27 <hryx> rad. I'm looking forward to those

12:39 <DutchGh0st> does the compiler run on arm?

12:39 <DutchGh0st> I downloaded the LInux 0.3 compiler, on my raspberry, but it cant run it..

12:43 <nbjoerg> pre-built is x86_64 only

12:44 <DutchGh0st> mhh okey, how do I build for arm then?

12:44 <nbjoerg> build from source?

12:44 <DutchGh0st> I guess

12:54 <DutchGh0st> mh, bad luck at first try: " llvm-c/Core.h: No such file or directory",

12:54 <DutchGh0st> I have gcc 8.2.0 and clang 7.0.0 installed, but I dont know how this all works ^^

13:54 <diltsman> andrewrk, it looks odd to me, too. The only other thing that the linker puts in that section is a while(true) loop for _start. It appears mostly correct (bn. 8000e in there twice...)

13:55 <diltsman> Dumping .text seems to think that the symbol at 00080000 is <panic>, though I don't know where that is coming from.

14:02 <euantor> DutchGh0st: Probably best to read the CI script for Linux: https://github.com/ziglang/zig/blob/master/ci/azure/linux_script#L8

14:03 <DutchGh0st> is there a String implementation in stdlib?

14:03 <euantor> It installs all the dependencies required to build on x86_64 and then builds, you will need the same dependencies for ARM

14:03 <DutchGh0st> Im making one currently...

14:10 <daurnimator> DutchGh0st: "String implementation"?

14:10 <DutchGh0st> dynamic String's

14:10 <daurnimator> DutchGh0st: how is a string more than a slice of u8?

14:11 <DutchGh0st> well, you cant push onto a []const u8

14:11 <DutchGh0st> or []u8

14:11 <DutchGh0st> https://pastebin.com/tnmCGAef

14:15 <diltsman> andrewrk, I had to export the vector_table symbol. I wouldn't think that would be necessary, since the .vector section is like this in the linker script: KEEP(*(.vector))

14:18 <MajorLag> DutchGh0st, ArrayList(u8) is basically what you're describing.

14:19 <Hejsil> There is also Buffer: https://github.com/ziglang/zig/blob/master/std/buffer.zig

14:22 <DutchGh0st> I suppose hahahaha

14:22 <diltsman> andrewrk, it seems to be working now. The issue was that the vector_table symbol was not being exported (not certain why I needed to declare it export). I declared it export, had to change the types of the vector table entries to be C ABI compatible, then recompiled. It had been placing the panic handler at the location of vector_table. Still not certain why I had to export it even though the section has KEEP in the linker script.

14:27 <daurnimator> DutchGh0st: I'm used to languages with immutable strings, so I wouldn't even expect that as part of a string library!

14:27 <DutchGh0st> Immutable Strings...mhh

14:28 <DutchGh0st> I think extend() and push() are essential to a String

14:29 <DutchGh0st> why? well, if the capacity is large enough, why would't you be able to just push and extend? creating a new string, allocating enough space AND then copying everything over seems really expensive

14:29 <daurnimator> DutchGh0st: because with immutable strings you can reference count them. as well as storing other data along side such as hashes, utf8 validity, etc.

14:30 <DutchGh0st> now, sure, I also need to do that, but a *good* implementation only needs to do that a 'couple of times to be able to hold huge number of characters

14:30 <DutchGh0st> Just put reference counted struct around a mutable String

14:31 <DutchGh0st> and provide acces to it using like "getRef()" or "getMut()", which would bump the refcount

14:31 <Hejsil> DutchGh0st, Immutable string uses a different data structure from mutable ones, so they don't require a copy on append

14:31 <Hejsil> Normally they do at least

14:31 <Hejsil> "append"

14:32 <daurnimator> DutchGh0st: immutable strings can also more easily use data in the data section of your executable etc.

14:32 <daurnimator> anyway. different strokes for different folks

14:32 <Hejsil> It really depends on the problem

14:32 <DutchGh0st> oh it more keeps track of the little strings, but all those little strings may on different places in memory, Hejsil?

14:33 <Hejsil> I'm not 100% sure on the datastructure. It tends to be some kind of tree of cache sized blocks i think

14:33 <daurnimator> DutchGh0st: now you're talking about a rope...

14:33 <Hejsil> But yea, you'll get memory in different places

14:33 <DutchGh0st> heh ^^

14:34 <Hejsil> But an allocator could fix a lot of cache issues with such a data structure

14:34 <DutchGh0st> How did you read my mind haha

14:35 <DutchGh0st> I just wanted to ask "but what if you Iterate, don't you get lots of cache misses"?

14:35 <Hejsil> :)

14:36 <Hejsil> Different tools for different problems. Sometimes you don't want shared strings, and the copy would cost more than the cache miss

14:36 <Hejsil> shared mutable strings*

14:36 <daurnimator> and now you're asking about gap buffers. possibly without realising it

14:36 <daurnimator> are you familiar with https://ecc-comp.blogspot.com/2015/05/a-brief-glance-at-how-5-text-editors.html ?

14:37 <Hejsil> If you're asking me, then I'm not

14:38 <Hejsil> I

14:38 <Hejsil> I've*

14:39 <DutchGh0st> No, but the triangle thingy makes sense actually

14:44 <DutchGh0st> so daurnimator, what language(s) do you come from ?

14:45 <daurnimator> DutchGh0st: Lua, C, JS, Haxe, (going back a while:) Actionscript

15:01 <DutchGh0st> mh, the correct way to get an iterator of *T and *const T out of an ArrayList(T), is trough list.toSlice() ?

15:02 <DutchGh0st> and then using `for(..) |item| {}` on the slice?

15:24 <presiden> speaking of gap buffer, https://nullprogram.com/img/gap-buffer/intro.gif

16:20 <andrewrk> DutchGh0st, you might have better luck cross compiling for arm rather than trying to build zig on arm

16:21 <DutchGh0st> I figured

16:21 <DutchGh0st> but that is sad, because I like the vim colorscheme I have on my raspberry, its nice than the one I currently have in vscode...

16:21 <DutchGh0st> so I wanted to use vim to write in haha

16:23 <andrewrk> diltsman, ah right. if you don't export something, it doesn't go into the object file

16:23 <andrewrk> unless you (directly or indirectly) depend on it by something that is exported

17:00 <andrewrk> diltsman, I do think that it should be possible to export a packed struct. I'll open an issue for that

17:00 <andrewrk> or rather, export a variable whose type is a packed struct

17:02 <andrewrk> wait, that already works

17:06 <andrewrk> diltsman, I just tried your example, the only change being to add `export` in front of `var` and it compiles for me

23:38 <presiden> how do you declare an array which size is calculated from a function that can be computed at compile time?

23:40 <presiden> let say, I have fn foo(n: u32) u32 { n+42 /* or some complex calculation */ }

23:40 <presiden> and I want var arr: [foo(10)]bool = undefined; for example