| 00:00:43 | * | sdothum quit (Remote host closed the connection) |
| 00:02:54 | * | sdothum joined #nim |
| 00:10:13 | FromDiscord | <pipeliner.osdev> hey which compiler is faster?↵clang? mvsc(vcc)? gcc? icc? |
| 00:37:51 | FromDiscord | <im_rob> sent a code paste, see https://play.nim-lang.org/#pasty=ZkOlSQOr |
| 00:38:11 | FromDiscord | <im_rob> (edit) "https://play.nim-lang.org/#pasty=VizjmjeI" => "https://play.nim-lang.org/#pasty=OVLNWEmW" |
| 01:02:15 | * | mal`` quit (*.net *.split) |
| 01:02:15 | * | vival quit (*.net *.split) |
| 01:02:15 | * | tty303 quit (*.net *.split) |
| 01:02:16 | * | karolyi quit (*.net *.split) |
| 01:02:16 | * | nariyel quit (*.net *.split) |
| 01:02:16 | * | tanami quit (*.net *.split) |
| 01:02:16 | * | jj quit (*.net *.split) |
| 01:07:56 | * | mal`` joined #nim |
| 01:07:56 | * | vival joined #nim |
| 01:07:56 | * | tty303 joined #nim |
| 01:07:56 | * | karolyi joined #nim |
| 01:07:56 | * | nariyel joined #nim |
| 01:07:56 | * | tanami joined #nim |
| 01:07:56 | * | jj joined #nim |
| 01:08:42 | * | jj quit (Max SendQ exceeded) |
| 01:08:56 | * | jj joined #nim |
| 01:27:17 | * | rockcavera quit (Remote host closed the connection) |
| 01:38:42 | FromDiscord | <_timurski> In reply to @im_rob "Can someone help me": change `body` to `untyped` |
| 01:40:12 | FromDiscord | <_timurski> can't have a `typed` body when there's no body yet. but this is indeed a confusing error message |
| 01:42:02 | FromDiscord | <_timurski> Nim's comptime complexity unfortunately does make it a lot more prone to bugs |
| 01:46:11 | FromDiscord | <Robyn [She/Her]> In reply to @pipeliner.osdev "hey which compiler is": in which way? compilation speed or when running a binary? Compilation speed will nearly never be an issue, since it's the Nim compiler that adds most of the compilation time↵↵Runtime speed, iirc Clang produced faster binaries than gcc |
| 02:02:54 | FromDiscord | <im_rob> In reply to @_timurski "can't have a `typed`": I needed the untyped for reflection on the proc's return type and thought I was lucky when I got this error message |
| 02:03:01 | FromDiscord | <im_rob> Appreciate it |
| 02:03:27 | FromDiscord | <im_rob> I understand very little of this |
| 02:03:31 | FromDiscord | <im_rob> macros very new to me |
| 02:04:01 | FromDiscord | <_timurski> it's very understandable, it might help to do something as simple as to read the first half of "Crafting Interpreters" |
| 02:04:11 | FromDiscord | <_timurski> knowing just a bit more about compiler design can help a lot |
| 02:04:25 | FromDiscord | <Robyn [She/Her]> In reply to @im_rob "Can someone help me": I have a question, what are you trying to do? |
| 02:05:24 | FromDiscord | <_timurski> LLMs are also actually quite good at writing macros in my experience, because you can easily debug them with `expandMacros` and there's a lot of code which is just a pain to write by hand |
| 02:05:56 | FromDiscord | <_timurski> but you should definitely understand them yourself if you're using them in your project |
| 02:06:06 | FromDiscord | <Robyn [She/Her]> ngl i wouldn't trust a LLM to write macros |
| 02:06:34 | FromDiscord | <Robyn [She/Her]> i wouldn't trust a LLM for most code meant for serious use besides for small things |
| 02:06:37 | FromDiscord | <_timurski> my best success with it was getting to optimize spline evaluations, which is extremely easy to verify correctness for |
| 02:06:50 | FromDiscord | <Robyn [She/Her]> ah? spline evaluations? |
| 02:06:52 | FromDiscord | <_timurski> yes |
| 02:06:54 | FromDiscord | <im_rob> In reply to @_timurski "it's very understandable, it": I'll take a look |
| 02:06:55 | FromDiscord | <_timurski> evaluating b-splines |
| 02:07:29 | FromDiscord | <_timurski> In reply to @battery.acid.bubblegum "i wouldn't trust a": my experience is just that if you give specific instructions where there's no ambiguity, it usually works great |
| 02:07:43 | FromDiscord | <_timurski> "implement algorithm X in this proc" is usually fine |
| 02:07:51 | FromDiscord | <_timurski> however as soon as you get into any architectural decisions it all goes to shit |
| 02:08:29 | FromDiscord | <Robyn [She/Her]> that makes sense, gotcha |
| 02:09:55 | FromDiscord | <_timurski> In reply to @battery.acid.bubblegum "ah? spline evaluations?": it managed to implement a compile-time version of Horner's method (spline degrees were known at comptime) where it's very obvious that the generated code can't get any faster, leading to 640 million spline evaluations / sec on my mac m1 |
| 02:10:36 | FromDiscord | <_timurski> which is pretty damn good |
| 02:10:51 | FromDiscord | <_timurski> definitely something a human could do as well, not anything genius-level, but it saves time |
| 02:41:56 | * | SchweinDeBurg joined #nim |
| 02:46:09 | FromDiscord | <pipeliner.osdev> In reply to @battery.acid.bubblegum "in which way? compilation": speed of running binary |
| 04:18:35 | FromDiscord | <lainlaylie> #nim-ai |
| 05:07:29 | FromDiscord | <asviest> In reply to @battery.acid.bubblegum "in which way? compilation": I wouldn't say so, last time when I tested, compiling nim code with clang (especially zig cc) was much faster. I don't sure why, maybe nim compiler overhead reduced because parallel compilation of different modules (I'm not sure if Nim before 2.4 can do that) or because I have some C deps that compiles faster but seems that compilation with clang (zig cc) is definetly fast |
| 06:27:04 | * | termer quit (Remote host closed the connection) |
| 06:27:25 | * | termer joined #nim |
| 06:29:41 | * | Skippy8 joined #nim |
| 06:56:41 | * | Skippy8 quit (Ping timeout: 247 seconds) |
| 07:40:39 | FromDiscord | <mratsim> In reply to @battery.acid.bubblegum "ngl i wouldn't trust": I have a Nim -> Cuda/OpenCL/Vulkan/WebGPU compiler implemented in macros and DeepSeek V4 Flash is able to navigate it fine, even the getType/getTypeImpl/getTypeInst madness |
| 07:40:59 | FromDiscord | <mratsim> also macro fails at compile-time so instant compiler feedback |
| 07:41:09 | FromDiscord | <mratsim> (edit) "macro fails" => "macros fail" |
| 07:42:56 | FromDiscord | <mratsim> but like @_timurski said, for greenfield you need to either DYI or very strong steering. For incremental addition it's fine. For refactoring, make very clear goals. |
| 07:43:24 | FromDiscord | <_timurski> what's DYI? |
| 07:58:43 | * | Skippy8 joined #nim |
| 08:02:48 | * | SchweinDeBurg quit (Remote host closed the connection) |
| 08:04:07 | * | SchweinDeBurg joined #nim |
| 08:14:47 | * | Skippy8 quit (Ping timeout: 270 seconds) |
| 08:15:21 | * | Skippy8 joined #nim |
| 08:19:47 | * | Skippy8 quit (Ping timeout: 260 seconds) |
| 08:22:52 | FromDiscord | <mratsim> In reply to @_timurski "what's DYI?": typo, DIY -> Do It Yourself |
| 09:46:55 | FromDiscord | <_ot> was there @ everyone ping or something |
| 10:41:44 | * | Skippy8 joined #nim |
| 10:43:29 | * | Mister_Magister quit (Excess Flood) |
| 10:43:53 | * | Mister_Magister joined #nim |
| 10:57:05 | * | Skippy8 quit (Ping timeout: 241 seconds) |
| 10:59:49 | * | Skippy8 joined #nim |
| 11:24:56 | FromDiscord | <mratsim> In reply to @_ot "was there @ everyone": I don't think so but it might have been deleted |
| 11:26:28 | * | Skippy8 quit (Ping timeout: 243 seconds) |
| 11:35:38 | * | FromDiscord quit (Remote host closed the connection) |
| 11:35:51 | * | FromDiscord joined #nim |
| 11:39:46 | * | FromDiscord quit (Remote host closed the connection) |
| 11:39:59 | * | FromDiscord joined #nim |
| 12:10:30 | FromDiscord | <Robyn [She/Her]> In reply to @mratsim "I have a Nim": hm. fair ig |
| 12:20:48 | FromDiscord | <Phil> In reply to @_timurski "what's DYI?": Don't Yodle Instantly |
| 12:20:57 | FromDiscord | <Phil> Always prepare |
| 12:21:09 | FromDiscord | <Phil> (edit) "Always prepare ... " added "first" |
| 12:54:32 | * | zero` quit (Ping timeout: 260 seconds) |
| 13:12:09 | * | zero` joined #nim |
| 13:25:33 | * | SchweinDeBurg quit (Remote host closed the connection) |
| 13:25:41 | * | SchweinD1 joined #nim |
| 13:27:30 | * | Skippy8 joined #nim |
| 13:47:44 | * | Skippy8 quit (Ping timeout: 256 seconds) |