02:23 <FromGitter> <watzon> Finally finished with my Matrix (https://watzon.github.io/apatite/Apatite/LinearAlgebra/Matrix.html) class. It's API pretty much perfectly matches that of Ruby's .

02:24 <FromGitter> <watzon> Now I can get back to doing ML stuff, and hopefully this time without the memory leaks I was having before

04:21 <FromGitter> <girng> interesting

04:21 <FromGitter> <girng> damn you wrote a lot of code

04:25 <FromGitter> <watzon> Yass

06:09 <FromGitter> <watzon> What's the experimental overflow flag?

06:13 <FromGitter> <watzon> Never mind, found it

07:47 <FromGitter> <watzon> @lodestone don't know if you're around, but my friend on Telegram just found your overshare project lol

07:47 <FromGitter> <watzon> Seems pretty cool

08:25 <FromGitter> <girng> slow day today for crystal eh

08:26 <FromGitter> <girng> we need to make crystal more popular

08:26 <FromGitter> <girng> what to do

08:40 <livcd> find a company that can pay 5-10 compiler devs ? :O

08:42 <FromGitter> <mwlang> @watzon I'm definitely happy to see you building out Matrix and these other ML libraries. At some point, I'm planning to start employing a lot of ML into automated trading and was originally planning to lean on python for a lot of this since it's well supported in that community.

08:45 <FromGitter> <mwlang> I'm not familiar with the Matrix class you're working on presently, but have played around some with Numo and Python's Numpy. In particular going through these exercises: https://github.com/ruby-numo/numo-narray/wiki/100-narray-exercises

09:33 <FromGitter> <girng> @livcd can't crystal get support from big companies, godot got a grant from firefox of $20,000

09:34 <FromGitter> <girng> not firefox, mozilla*

09:34 <FromGitter> <girng> rofl i said the browser xD

12:56 <FromGitter> <mavu> @girng Why the rush? Just lean back and enjoy the ride.

15:23 <FromGitter> <bajro17> What is the easiest way to use pointers

15:23 <FromGitter> <Blacksmoke16> dont use pointers? :P

15:23 <FromGitter> <Blacksmoke16> or use a slice

15:24 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/master/Slice.html

15:24 <FromGitter> <bajro17> but pointers is good for performance

15:24 <FromGitter> <Blacksmoke16> but they're unsafe if you dont know what you're doing

15:24 <FromGitter> <Blacksmoke16> slice is a good middle ground

15:25 <FromGitter> <bajro17> is there anything like *ptr

15:25 <FromGitter> <bajro17> to use * or some other character to describe its pointer or I must use pointerof()?

15:26 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/0.29.0/Pointer.html

15:28 <FromGitter> <bajro17> thank you I will check this now I want make something to show crystal is faster then golang :D

15:28 <FromGitter> <bajro17> until sunday we will see if its possible to I proof

15:34 <FromGitter> <j8r> @bajro17 it's not a good point to show that unsafe crystal is faster than safe golang

15:35 <FromGitter> <j8r> probably you can optimize without using pointers

15:35 <FromGitter> <j8r> the main point of using Crystal vs other compiled languages isn't really speed or memory IMO, they are all comparable

15:36 <FromGitter> <j8r> users cares more about the language features, and good enough speed/memory

15:36 <rkeene> That's why users use Tcl ;-)

15:36 <FromGitter> <j8r> *and static typing

15:36 <rkeene> You can statically type Tcl, if you want

15:37 <FromGitter> <j8r> Tcl isn't as efficient as other compiled languages

15:37 <FromGitter> <j8r> it wasn't designed to

15:37 <rkeene> If you AOT compile it it is

15:37 <rkeene> (AOT compiling isn't complete, and is a TREMENDOUS undertaking, 5 PhDs worth so far)

15:37 <FromGitter> <j8r> I know, the official PDF explicitly stated it was partially

15:38 <FromGitter> <j8r> because big challenges remains due to the dynamic nature of the language

15:38 <FromGitter> <j8r> (IIRC)

15:38 <rkeene> Tcl is more dynamic than JavaScript, and there aren't many JS AOT compilers either for the same reason

15:38 <rkeene> Yeah

15:39 <rkeene> But it works in the same way as Crystal, with type inference and code splitting for different types

15:40 <rkeene> There's probably some applicable techniques in there that could be used in Crystal as well

15:40 <FromGitter> <bajro17> You know until now for me is so hard to understand trie data

15:40 <FromGitter> <bajro17> this is why I want try implement it

16:13 <FromGitter> <meltheadorable> i read somewhere that recursive aliases may be going away but i wasn’t quite able to figure out whether there was a good alternative to them at the moment — I’m trying to write a deserializer for a custom data format, and I noticed that JSON::Any and YAML::Any both still use recursive aliases under the hood — is there a clear alternative I should be moving towards or is that still being discussed?

16:15 <FromGitter> <j8r> there aren't using recursive aliases anymore @meltheadorable

16:16 <FromGitter> <meltheadorable> they seemed to be when i looked at the code yesterday, but maybe i was looking at the wrong place

16:16 <FromGitter> <j8r> it was this before https://github.com/crystal-lang/crystal/blob/0.20.4/src/json.cr#L75

16:16 <FromGitter> <j8r> now it's https://github.com/crystal-lang/crystal/blob/f7c0e753663b4e851a2cd25adc8c3ba810d93532/src/json/any.cr#L20

16:17 <FromGitter> <j8r> You can use a similar pattern too

16:17 <FromGitter> <meltheadorable> oh gosh, i see why i made the mistake i did — whoops

16:18 <FromGitter> <meltheadorable> I forgot that a recursive alias would have had to use `Type` not `Any` in its definition, I confused myself

16:20 <FromGitter> <j8r> Is the data highly dynamic, or does the mapping known in advance?

16:25 <FromGitter> <meltheadorable> The actual data can be arbitrary byte strings, the format allows encoding display/type hints, but using them to infer anything would be complicated, because those hints aren’t, say, restricted to mime types or anything similar, but for the purposes of parsing it’s really just arbitrarily nested layers of arrays of byte strings or arrays with optional hints

16:26 <FromGitter> <meltheadorable> but because the nesting is arbitrary i need some way of specifying that its an array of more arrays or byte strings

16:27 <FromGitter> <meltheadorable> so a lot less complex than JSON or YAML in terms of the possible types, but still need the recursion because the structure is arbitrary

16:28 <FromGitter> <meltheadorable> i will also probably include some things to attempt to coerce the data to strings in various encodings because the primary use case is not actually arbitrary binary data but it can be so I can’t assume it’s strings either

16:45 <jokke> hi

16:46 <jokke> is there a crystal lib for writing to/reading from x clipboard?

16:46 <jokke> (without using xclip)

17:27 <FromGitter> <watzon> @mwlang I actually did take a lot of inspiration from numpy originally, but I messed up somewhere and had massive memory leaks. This new API is based completely on Ruby's Matrix class, but I fully plan on redoing all of the numpy methods that I had there originally.

17:27 <FromGitter> <watzon> I want it to be easy to adopt for people who are familiar with Ruby and Python

18:02 <rkeene> j8r, There's a Tcl conference in October that you should come to, the Quad Code guys are there

20:54 <wmoxam> Are there any plans to support newer versions of LLVM going forward?

20:55 <wmoxam> Context: OpenBSD is moving to LLVM 8 in the next release and there are no back ports of older versions

21:15 <FromGitter> <j8r> @meltheadorable I see. Note that a class can have an ivar that has its type, but not a struct. Nevertheless, a struct T can have an ivar of SomeType(T). That's one reason why `Exception` is a class (because of @cause), but Any can be a struct (Hash(String, Any))

21:16 <FromGitter> <j8r> and Array(Any)

23:04 <FromGitter> <girng> @mavu oh i am :P

23:14 <FromGitter> <girng> just thinking of ways to get the developers more $

23:15 <FromGitter> <girng> if i didn't live in this shithole of a state i'd already donate money but igave it to my mom for mortgage payments

23:31 <FromGitter> <Blacksmoke16> rip

23:52 <FromGitter> <girng> although, if i can get this IT Technician job at a local library, i'd def be able to donate

23:52 <jokke> hey

23:53 <FromGitter> <girng> hey

23:53 <jokke> how would i write a shard which binds to a c library i've written as an extension?

23:54 <FromGitter> <meltheadorable> @j8r struggling to process the implications of that at the moment — i haven’t fully learned the language yet, so i’ve been playing it largely by ear trying to write this little parser

23:54 <jokke> it's actually a bit more complex than that. i have a rust library which exposes unmangled functions. i want to bind those from crystal

23:55 <jokke> basically what i'm wondering is how i deal with the linker flags

23:55 <jokke> and the built .so file