00:01 <FromGitter> <anamba> oh hey, i got part 1. i don't know why i am still working on this though

01:10 <FromGitter> <DanilaFe> I stayed up till 3 am my time to finish it so I wouldn't have to do it today

01:42 <FromGitter> <anamba> @DanilaFe ah geez. i kept inputting the min ap needed for part 2. reading skills...

01:42 <FromGitter> <DanilaFe> reading skills is exactly what this problem strained today

01:42 <FromGitter> <DanilaFe> it's very poorly written imo

03:43 <FromGitter> <proyb6> Day15 may be faster with BFS than A*?

03:52 <FromGitter> <lokeshh> Isn't it possible to use Rubex in the following manner? ⏎ ⏎ I write some Ruby code as I would normally do, I debug is using interpreter and so on. But when I move it to production I use crystal to make it run fast?

03:54 <FromGitter> <lokeshh> Because the only drawback of Crystal is that it turns Ruby to a Compiler language then a interpreted one.

04:15 <FromGitter> <anamba> i don't consider that a drawback. interpreted languages in production are a lot more vulnerable (for example, deserialization vulnerabilities are a constant threat)

04:24 <FromGitter> <lokeshh> @anamba Ok. What's the recommended way of debugging? In Ruby I'm use `pry`.

04:26 <FromGitter> <anamba> i might be unusual here, but i don't use debuggers for... anything, really. except Xcode, since it kinda pushes you into that workflow.

04:29 <FromGitter> <anamba> if the code is complicated enough that i can't easily follow it in my head, i fix that :)

04:35 <FromGitter> <anamba> ah, i see `pry` is not a debugger (sorry, never used it before). different definition of debugging. when i need this kind of thing `crystal play` is usually sufficient

04:38 <FromGitter> <lokeshh> I mean like this https://learn.co/lessons/debugging-with-pry

04:38 <FromGitter> <anamba> nope changed my mind again :) misunderstood what they meant by "IRB alternative." it definitely does let you look around "running" code. (which again, I think should generally be unnecessary if you've built it right)

04:41 <FromGitter> <anamba> build up functionality incrementally, write specs to make sure each layer is doing what you think it's doing. that usually does the trick

04:43 <FromGitter> <anamba> @lokeshh rubex looks interesting, i wonder how well/how often it actually works in the real world?

04:58 <FromGitter> <proyb6> @lokeshh Not sure if cry is exact similar to pry ⏎ https://github.com/elorest/cry ⏎ ⏎ https://github.com/veelenga/awesome-crystal [https://gitter.im/crystal-lang/crystal?at=5c15db7a539aca60b218db57]

05:43 <FromGitter> <DanilaFe> dang

05:43 <FromGitter> <DanilaFe> almost rank 100

05:43 <FromGitter> <DanilaFe> boom!

05:43 <FromGitter> <DanilaFe> not to mention, 29 millis

06:17 <yxhuvud> today was not a slow task though.

06:29 <FromGitter> <DanilaFe> that is true, but I mean speed relative to other solutions.

06:29 <FromGitter> <DanilaFe> How did today go for you, Linus?

07:10 <FromGitter> <DanilaFe> wow, TDD

07:11 <FromGitter> <DanilaFe> that's quite intense for a daily programming puzzle, but good habits :D

08:51 <yxhuvud> @danila: place 442 globally, so okish. I lost a lot of time due to doing stupid stuff in part2 :&

08:52 <yxhuvud> I wish I took more time to continue with my parser generator ;)

08:53 <yxhuvud> but I'm stuck in a hellish long refactoring so it is a lot of work for few features.

09:01 <FromGitter> <DanilaFe> well, mine doesn't have a lot of features besides...generating parsers :D

09:01 <FromGitter> <DanilaFe> I made it so that it outputs JSON data, and that means it can generate parsers for different languages via "backends", but then it doesn't have proper support for semantic actions, which is how I believe Yacc does it

09:02 <FromGitter> <DanilaFe> once I'm done with my current project I'll look into it once again

09:05 <yxhuvud> semantic actions as what happens when a rule is completed? I have that (somewhat limited to the first derivation), but otoh I don't support character ranges yet :)

09:08 <FromGitter> <DanilaFe> Yeah, that's what semantic actions are. I've actually spent a considerable amount of time making regex engines (runtime) before, probably starting junior year high school. They're always the same, based on Thompson NFA. This time I just made it generate lookup tables. My main concern is that I want it to be mostly language-agnostic, but semantic actions are very tied to the language of the parser

11:28 <foxxx0> hey, might one of the AoC guys provide me with his day12 input and day12p2 result? i'm probably in the off-by-one sort of bugs in my code and would like to have something to validate against :)

11:28 <foxxx0> would be much appreciated!

11:49 <FromGitter> <asterite> today's AoC was nice, having to guess opcodes (different from the other years where you had to just execute ops). And I'm so glad we have macros :-)

11:56 <foxxx0> ah, finally found my bug

12:19 <FromGitter> <asterite> if anyone wants to learn Crystal, here's a 122 pages PDF written in Japanese (jawdrop): https://crystal-jp.github.io/introducing-crystal/assets/pdfs/introducing-crystal.pdf

12:30 <FromGitter> <proyb6> We have to learn Crystal and Japanese languages

12:36 <mps> "Yoku mireba, nazuna hana saku. Kakine kana!" when I way young I learnt this haiku :)

12:42 <FromGitter> <greenbigfrog> @jwoertink I thought it was stable, got some errors PoolTimeout again though

12:48 <yxhuvud> asterite: ah yes, macros were nice. Though I have to admit I added them after solving things. In retrospect I think I lost time by not doing it directly.

12:49 <yxhuvud> @asterite: I recognize makejustnow out of the authors, but havn't seen the other 3.

12:55 <yxhuvud> I also noticed the formatter don't like oneline macros.

14:10 <FromGitter> <r00ster91> In the Lexer class of Crystal: https://github.com/crystal-lang/crystal/blob/665b18c73066b88acd84777f22a68bfa1b63a646/src/compiler/crystal/syntax/lexer.cr#L6 ⏎ How do I find out if color output is enabled or disabled for the program that is being currently compiled? There's no `program` getter or anything.

14:22 <oprypin> r00ster91, i dont understand how are the 2 things you mentioned related in any way

15:17 <FromGitter> <r00ster91> oprypin: the `Program` has the color getter: https://github.com/crystal-lang/crystal/blob/master/src/compiler/crystal/program.cr#L71

17:29 <oprypin> r00ster91, it is there only to be able to change it with a flag https://github.com/crystal-lang/crystal/blob/ba559542a5c504ca83b0fe76c0df58f6ae87fe49/src/compiler/crystal/command.cr#L512

17:30 <oprypin> i dont think you can obtain this value and i dont see why you would want that

17:31 <FromGitter> <r00ster91> oprypin: I'm trying to fix this: https://github.com/crystal-lang/crystal/blob/665b18c73066b88acd84777f22a68bfa1b63a646/src/compiler/crystal/syntax/lexer.cr#L684 ⏎ I'm trying to make the did you mean message yellow

17:32 <oprypin> ok that's valid then

17:39 <FromGitter> <j8r> @proyb6 I've an idea for the library to filter characters

17:39 <FromGitter> <j8r> I'll use an enum :)

17:43 <FromGitter> <j8r> the function will return the type of the characters, then that's up to the user what to do

18:44 <FromGitter> <j8r> Does it exists a way to iterate over enum value, with a macro?

18:44 <FromGitter> <vladfaust> Hey guys, I've updated my HTTP params parsing shard with annotatons -- https://github.com/vladfaust/http-params-serializable. Use master branch for now

18:45 <FromGitter> <vladfaust> @j8r, https://github.com/crystal-lang/crystal/blob/c9d1eef8fde5c7a03a029d64c8483ed7b4f2fe86/src/enum.cr#L101

18:52 <FromGitter> <j8r> @vladfaust thanks a lot, macro lord 😄

18:53 <FromGitter> <vladfaust> Nah, take a look at https://github.com/vladfaust/http-params-serializable/blob/master/src/http-params-serializable.cr -- I've documented it a lot, may be useful to gain additional knowledge

19:18 <FromGitter> <j8r> @vladfaust what is the `ext` directory?

19:19 <FromGitter> <j8r> i.e why having this subdirectory architecture vs all in `/src`?

19:30 <FromGitter> <vladfaust> Because it's extending known classes

19:45 <FromGitter> <j8r> I suppose having `http-params-serializable` inside src is a gem convention

19:46 <FromGitter> <j8r> @proyb6 @Prutheus I've created this shard for you 😄 https://github.com/j8r/unicode_blocr

19:49 <FromGitter> <j8r> @vladfaust I really need to take the time to have a CI like you, that build docs to a `gh-pages` branch

19:53 <FromGitter> <vladfaust> @j8r, to `require "http-params-serializable"` you have to put `http-params-serializable.cr` into `src`, isn't that?

19:54 <FromGitter> <j8r> nope, why it would be needed?

19:54 <FromGitter> <j8r> hum yes

19:54 <FromGitter> <j8r> but i mean, all the other stuff

19:54 <FromGitter> <j8r> like the ext directory @vladfaust

19:56 <FromGitter> <vladfaust> > Because it's extending known classes

19:56 <FromGitter> <vladfaust> Because it's crystal code, so it's under `src`. Because it's extending, so it's under `ext`

19:56 <FromGitter> <j8r> got it

19:56 <FromGitter> <j8r> but why not `/src/ext`

19:57 <FromGitter> <j8r> like https://github.com/crystal-lang/shards/tree/master/src

19:57 <FromGitter> <j8r> :)

20:01 <FromGitter> <vladfaust> Because `/src/*` directiories rewrites each other when required as dependency. For example, if shardA had a `src/ext` diredctory, it would be shadowed by my `src/ext` directory

20:02 <FromGitter> <j8r> I doubt

20:02 <oprypin> vladfaust, no

20:07 <FromGitter> <talbergs> ```code paste, see link``` ⏎ ⏎ Compiler says "Can't infer the type of instance variable '@pane' of Display". How so? I explicitly tell the return type of a method "draw_pane" [https://gitter.im/crystal-lang/crystal?at=5c16b07be86b0460b3aa8436]

20:08 <FromGitter> <j8r> @talbergs all ivars need to be defined in initialize, or in the main class

20:08 <FromGitter> <j8r> not in methods

20:09 <FromGitter> <j8r> hum

20:09 <FromGitter> <talbergs> @pane is in constructor isn't it

20:09 <FromGitter> <j8r> oh yes

20:09 <FromGitter> <j8r> you have to defined it

20:09 <FromGitter> <j8r> in the class

20:10 <FromGitter> <j8r> `class Display; @pane : NCurses::Window`

20:10 <FromGitter> <talbergs> Yes it seems to work now. Thanks!

20:51 <FromGitter> <proyb6> @j8r Nice unicode blocker! Appreciate.

22:08 <FromGitter> <j8r> @proyb6 Thanks! not really a blocker, more a character idientifier. It tells its type: emoticon, latin, greek etc

22:10 <FromGitter> <j8r> I may rename it to `unicode_identifier`

22:55 <FromGitter> <girng> nice shard @j8r !!

23:06 <FromGitter> <asterite> @talbergs the compiler won't infer the type from instance methods, only from class methods (it's a bit simpler to do)

23:11 <FromGitter> <j8r> @girng thanks, it's a really dumb one (one big enum). In fact, enums are really cool

23:12 <FromGitter> <j8r> More or less like a collection of immutable tags