00:10 <FromGitter> <watzon> What happens in C if you try to access an array index larger than the size of the array?

00:10 <FromGitter> <Blacksmoke16> *doom*

00:10 <FromGitter> <watzon> Does it overflow? Or just return 0 or something?

00:12 <FromGitter> <watzon> Because this, in Crystal, throws an index out of bounds exception

00:12 <FromGitter> <watzon> https://github.com/pyrogram/tgcrypto/blob/master/tgcrypto/aes256.c#L361

00:12 <FromGitter> <Blacksmoke16> https://www.geeksforgeeks.org/accessing-array-bounds-ccpp/

00:12 <FromGitter> <Blacksmoke16> looks like just a garbage value?

00:13 <FromGitter> <tenebrousedge> you read further into memory

00:13 <FromGitter> <watzon> Ruh roh

00:13 <FromGitter> <tenebrousedge> lots of security errors begin this way

00:13 <FromGitter> <tenebrousedge> certainly it's the median computer security flaw in history, and may actually be the majority of all computer security flaws

00:14 <FromGitter> <watzon> Yeah that makes sense

00:14 <FromGitter> <watzon> Damn C

00:14 <FromGitter> <watzon> Maybe I'm doing this wrong

00:15 <FromGitter> <watzon> Yes I am

00:15 <FromGitter> <watzon> I'm using `0.upto(nk)` when I should be going up to nk - 1

00:17 <FromGitter> <tenebrousedge> so `(0...nk)`

00:18 <FromGitter> <watzon> Yep haha

00:35 <FromGitter> <watzon> Hmm, is there a better way to handle a for loop like this than with a while loop? ⏎ ⏎ ```for (i = 0, j = 56; i < j; i += 4, j -= 4) { ⏎ ... ⏎ }``` [https://gitter.im/crystal-lang/crystal?at=5dec45639319bb5190fae450]

00:36 <FromGitter> <watzon> Right now I have this, but it doesn't feel very Crystally ⏎ ⏎ ```i = 0; j = 56 ⏎ while i < j ⏎ ... ⏎ end ``` [https://gitter.im/crystal-lang/crystal?at=5dec459b9319bb5190fae57d]

00:37 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/0.31.1/Number.html#step(*,to=nil,by=1,&block)-instance-method ?

00:37 <FromGitter> <Blacksmoke16> oh nvm, are more than 1 vars

00:38 <FromGitter> <watzon> Yeah that's the issue haha

00:38 <FromGitter> <watzon> I used step in another part

01:19 <FromGitter> <tenebrousedge> `a = (0...56).step(4); a.zip(a.reverse)`

01:20 <FromGitter> <tenebrousedge> hmm, does range have reverse?

01:21 <FromGitter> <Blacksmoke16> prob would have to make it an array first?

02:26 <FromGitter> <christopherzimmerman> @watzon you can just divide (j-i) by the factor you scale them by and loop that many times. Assuming they scale at the same inverse rate

02:26 <FromGitter> <christopherzimmerman> I guess it would be dividing by the factor times 2

02:26 <FromGitter> <christopherzimmerman> It also should be a minor performance tweak since you only would calculate once.

02:28 <FromGitter> <christopherzimmerman> It also assumes you don’t need i or j in the loop

03:53 <FromGitter> <watzon> What should you do if a C library you're trying to link to has a struct with uppercase field names?

03:53 <FromGitter> <anamba> hi all, long time. i'm using HTTP::Client to test for IPv4 and IPv6 connectivity. for a host that supports both, is there a way to force it to use one or the other?

03:59 <FromGitter> <anamba> i suppose i could do the DNS resolution myself, then point HTTP::Client at either the IPv6 address or the IPv4 address, making sure to set the Host header appropriately. if that's the easiest way then so be it, but in that case, my question becomes, what's the best way to do the DNS resolution step?

04:03 <FromGitter> <Blacksmoke16> @watzon https://crystal-lang.org/reference/syntax_and_semantics/c_bindings/fun.html#function-names

04:03 <FromGitter> <Blacksmoke16> er sorry, field names

04:03 <FromGitter> <watzon> Found what I was looking for actually

04:03 <FromGitter> <watzon> https://github.com/crystal-lang/crystal/issues/1082

04:03 <FromGitter> <watzon> Apparently field names don't matter, but I'm getting a segfault somewhere

04:04 <FromGitter> <Blacksmoke16> 👍 fair enough

04:06 <FromGitter> <watzon> Got it working. Didn't like my `uninitialized` and `pointerof` for some reason

04:06 <FromGitter> <watzon> But `Pointer(U).malloc` worked

04:21 <FromGitter> <anamba> answered my own question by reading the stdlib source (still easily my favorite aspect of Crystal). HTTP::Client uses TCPSocket, which uses Socket::Addrinfo.resolve. ```

04:21 <FromGitter> <anamba> ```code paste, see link```

06:50 <FromGitter> <watzon> Why does working with slices have to be such a pain in the ass?

07:18 <Yxhuvud> Is it?

19:28 <raz> hmm. what exactly is unsafe about String#to_slice? and is there a safe way to get the raw bytes from a string?

19:29 <FromGitter> <tenebrousedge> like `"abc".bytes` ?

19:29 <raz> no, more like "abc".to_slice

19:30 <raz> it seems to work as intended. but i wonder if the returned slice could be randomly garbage collected or such. (the docs say it's "unsafe" but not what it means)

19:33 <FromGitter> <tenebrousedge> unsafe meaning you're grabbing a pointer and the data associated with it https://github.com/crystal-lang/crystal/blob/0e2e1d067af09e7b1e4573a7258c433e3cf8fa17/src/string.cr#L4297

19:34 <FromGitter> <tenebrousedge> it's highly likely to not be garbage data

19:34 <Yxhuvud> `to_slice` looks pretty safe though: https://github.com/crystal-lang/crystal/blob/0e2e1d067af09e7b1e4573a7258c433e3cf8fa17/src/string.cr#L4292

19:35 <raz> yup, i'm basically just wondering why it's marked as unsafe. like, in what scenario would it be unsafe?

19:35 <raz> (may assumption is that it wouldn't be garbage collected as long as a pointer is around?)

19:37 <FromGitter> <tenebrousedge> https://crystal-lang.org/reference/syntax_and_semantics/unsafe.html

19:37 <raz> ahhh i see

19:38 <raz> so it's only unsafe if actively do pointer arithmetic with it

19:38 <FromGitter> <tenebrousedge> perhaps, or if you manage to grab something that's not a string

19:40 <Yxhuvud> also you may have to handle stuff like multi-byte characters etc by yorself, but you probably don't care if you want it as a slice.

19:40 <FromGitter> <tenebrousedge> that, for sure

19:40 <raz> gotcha, thx

20:47 <livcd> I cant wait till Crystal works on Windows :X

20:47 <FromGitter> <tenebrousedge> why?

20:59 <livcd> Because I want to deply on Windows

21:05 <FromGitter> <tenebrousedge> you know about this? https://github.com/crystal-lang/crystal/wiki/Porting-to-Windows

21:09 <FromGitter> <tenebrousedge> this seems encouraging https://github.com/crystal-lang/crystal/pull/7995

22:55 <FromGitter> <tenebrousedge> I'm debating a design decision. I have something like `Book has_many Chapter has_many Page`, where `book` has an `owner_id`. I want owners to only be able to access their own books, chapters, pages. I'm debating whether `Page` needs an `owner_id`, or whether it's acceptable to walk up the tree to find the owner. I'm concerned about the performance implications of the latter strategy

22:57 <FromGitter> <christopherzimmerman> How often do you access pages without accessing the book first?

22:59 <FromGitter> <tenebrousedge> I'm working on scoping the backend authorization, so it will only be considering the `Page` model

23:00 <FromGitter> <tenebrousedge> another wrinkle is that `Page` is polymorphic: `Chapter` doesn't necessarily exist

23:03 <FromGitter> <christopherzimmerman> If different users can own pages in a single book, you’d need the ID, otherwise I’d keep it at the lowest level that can differ.

23:03 <FromGitter> <tenebrousedge> at this point, only one user can own any given element

23:04 <FromGitter> <christopherzimmerman> Ever plan on changing that?

23:05 <FromGitter> <tenebrousedge> it has crossed my mind that users might want to collaborate, but I don't currently have the dev resources to enable that

23:07 <FromGitter> <christopherzimmerman> What type of DB is this stuff stored in? If it’s something like elasticsearch you’re going to have to go flat anyways.

23:07 <FromGitter> <tenebrousedge> postgres, and they're likely to only be accessed in-order

23:09 <FromGitter> <tenebrousedge> well, on the consumer side anyway. People don't usually read books out of order