<< 11-03-2026 >>
00:14:38*amadaluzia quit (Read error: Connection reset by peer)
00:49:17FromDiscord<.tokyovigilante> Is there a good pattern form merging asyncdispatch and Windows events? I want to be able to call `runForever()` in my main thread then process UI events asynchronously. I can just watch the Wayland file descriptor for this on Linux but `MsgWaitForMultipleObjects` blocks too it seems.
00:49:35FromDiscord<.tokyovigilante> (edit) "form" => "for"
01:31:36*mrinsane quit (Ping timeout: 264 seconds)
02:14:45*tokyovigilante quit (Ping timeout: 245 seconds)
03:14:32*rockcavera quit (Remote host closed the connection)
04:04:39*mrinsane joined #nim
05:21:38FromDiscord<indelusionalizationary> In reply to @nnsee "what metric do you": bro, I mean... writing an OS kernel (like linux), OS level utilities (like GNU provides) and even desktop applications for mac, windows or (at least and most importantly for me) linux. I explored android studio and saw, there's an option with cpp too other than java and kotlin ones.
05:22:31FromDiscord<indelusionalizationary> In reply to @nnsee "and nim is, by": am I provided with proper tools to manage memory and do all the things required if I turn off GC?
05:31:14*mrinsane quit (Ping timeout: 252 seconds)
06:50:10FromDiscord<nnsee> In reply to @indelusionalizationary "bro, I mean... writing": you can do all of that very successfully with nim
06:50:57FromDiscord<nnsee> In reply to @indelusionalizationary "am I provided with": generally, you don't want to "turn off GC" but rather use a deterministic memory management mode such as ARC
06:51:35FromDiscord<nnsee> https://nim-lang.org/blog/2020/10/15/introduction-to-arc-orc-in-nim.html
08:07:11FromDiscord<asviest> sent a long message, see https://pasty.ee/OXfZBuEx
08:10:32FromDiscord<asviest> In reply to @.tokyovigilante "Is there a good": Pooling works on all OSs
08:19:02FromDiscord<asviest> sent a long message, see https://pasty.ee/aJKUZVZQ
08:22:20*hygo quit (Quit: WeeChat 4.6.3)
08:34:39FromDiscord<indelusionalizationary> in simple words, I just want a language that I can make my own- replacing c/cpp & rust. ↵I have listed all I could: Nim, D, V, Crystal, Zig, Hare, Odin. ↵My optional but important goal is that if it's not too hard to learn (list rust) and my primary and main goals are that a dev (when gets good at writing it) can writing anything that a dev can with c/cpp, rust. ↵I don't have a problem with rust, in fact I'm currently
08:45:17FromDiscord<asviest> In reply to @indelusionalizationary "in simple words, I": So, what’s the issue? Try building a project in Nim or Zig to see if you like the syntax, features, and design choices. If you're wondering whether you can do anything with them— just give it a try. If you find something impossible, just patch the Nim or Zig compiler and open a pull request. I’m not sure about Zig, but the Nim compiler code is quite readable.
08:47:43FromDiscord<shalokshalom> In reply to @asviest "I’m not an expert": I feel like OS kernel development needs an even better control over memory, or at least discipline. Theoretically possible.
08:54:46FromDiscord<indelusionalizationary> sent a long message, see https://pasty.ee/mNcddrZN
08:55:15FromDiscord<nnsee> In reply to @asviest "I don't think anyone": some would argue that the lack of distinction between an array and a pointer is not a flaw but rather a feature
08:56:03FromDiscord<indelusionalizationary> In reply to @nnsee "some would argue that": i was about to point it out, thank god i stayed quiet.
08:56:25FromDiscord<indelusionalizationary> (edit) "stayed" => "stood"
08:57:03FromDiscord<kapendev> It's a high level feature
08:59:07FromDiscord<kapendev> Something similar happens with languages that have slices, but there you have arrays that decay to slices. You don't want that sometimes lol
09:00:17FromDiscord<kapendev> Like accidentally passing the whole buffer instead of a part of it.
09:27:54*mrinsane joined #nim
09:32:34*mrinsane quit (Ping timeout: 276 seconds)
09:33:10FromDiscord<pmunch> Hmm, is it not possible to GC_ref a string?
09:45:21*beholders_eye joined #nim
09:46:14FromDiscord<asviest> In reply to @kapendev "It's a high level": Yeah, it’s a high-level feature, just like goto... I mean, goto lets you easily break out of a nested loop or do something like if (error) goto handleErrors;. If we look at block/break, it’s basically just a polished and constraint version of goto. Does that make goto high-level? That’s not how it works.
10:37:06FromDiscord<kapendev> It's not different than automatic casting
10:38:24FromDiscord<kapendev> You have a problem with that?
13:28:04*mrinsane joined #nim
13:32:29*mrinsane quit (Ping timeout: 252 seconds)
14:00:25FromDiscord<mr_rowboto> sent a long message, see https://pasty.ee/hepbpBnj
14:00:44FromDiscord<mr_rowboto> (edit) "https://pasty.ee/QISQhREv" => "https://pasty.ee/mCRbbDvO"
14:01:00FromDiscord<mr_rowboto> (edit) "https://pasty.ee/ETOkiwiL" => "https://pasty.ee/jOPfszGb"
14:01:18FromDiscord<mr_rowboto> Be sure to check the OSDev wiki: https://wiki.osdev.org/Main_Page
14:03:29FromDiscord<mr_rowboto> And please, PLEASE... PLEASE work on hacking together a cross-compiler or at least a reproducible environment (using docker, nix, or whatever) that can output non os-dependant binaries first. There are plenty of tutorials out there.
14:04:04FromDiscord<mr_rowboto> (edit) "whatever)" => "whatever tool)"
14:04:19FromDiscord<mr_rowboto> (edit) "os-dependant" => "os-dependent"
14:06:47FromDiscord<olfactoryhallucinations> Here's an example of someone writing their own OS using Nim and getting quite far: https://github.com/khaledh/fusion
14:42:48nisstyreI just looked at the code and see C files...
14:43:41nisstyresurely it needs to compile it down without the C runtime at least, since you won't have stdlib
14:46:27FromDiscord<nnsee> i don't see C files apart from what's in `include`
14:47:00nisstyrethat's what I was referring to
14:47:05nisstyrebut it makes sense you'd need that
14:47:35nisstyreTIL nim has inline assembly
15:03:41FromDiscord<tewesday> Nim seems extremely flexible much like C\C++ but with some modern conveniences and shorter syntax
15:05:00FromDiscord<tewesday> Is there an example of using nim with memory arenas?
15:09:56nisstyreyou would just statically allocate an array of bytes and use that, or use malloc or mmap
15:10:20nisstyreworks well if you have a lot of uniformly sized data
15:11:42FromDiscord<tewesday> ARC can be used with that as long as the scope is global, so it doesn't get cleaned up right?
15:12:37FromDiscord<tewesday> the pool would not get cleaned up by ARC
15:13:05nisstyrejust use a global array of data if you don't need to expand it
15:13:25nisstyrekind of kills one of the benefits of arenas though
15:13:36nisstyrewhich is that you free the data all at once
15:13:57FromDiscord<tewesday> Right
15:13:58nisstyreI don't see why that wouldn't still work with ARC though
15:14:05nisstyrejust make sure the scope is correct
15:14:35nisstyreand also how do you pass in the allocator function to other places?
15:14:42nisstyredepends highly on your use case
15:15:09FromDiscord<tewesday> Just trying to make sure I understand that ARC won't ever surprise me by deallocating the arena or from the arena as long as the arena is in scope
15:15:49nisstyreshouldn't but if you have pointers to other stuff in it you might have problems
15:16:33FromDiscord<tewesday> Yeah that makes sense
15:38:25Amun-Rajust compiled my nim project with filcc, works like a charm
15:57:13FromDiscord<Robyn [She/Her]> In reply to @Amun-Ra "just compiled my nim": `filcc`? what's that?
15:57:31FromDiscord<Robyn [She/Her]> huh fun
15:58:33*xet7 quit (Ping timeout: 248 seconds)
15:59:32FromDiscord<Robyn [She/Her]> It looks pretty neat, honestly
15:59:53*beholders_eye quit (Ping timeout: 252 seconds)
16:03:44FromDiscord<nervecenter> In reply to @Amun-Ra "just compiled my nim": Kinda redundant since the whole point of Nim's compiler is to generate correct bounds checking and lifetimes out of the gate, but cool?
16:04:03FromDiscord<nervecenter> Double-safe programs
16:10:41*xet7 joined #nim
16:12:55*hygo joined #nim
16:16:51FromDiscord<indelusionalizationary> In reply to @mr_rowboto "Hi, I've taught OSDev": why zig and not nim?
16:19:25*beholders_eye joined #nim
16:23:44FromDiscord<nnsee> memory allocation is a bit more deliberate in zig which is attractive for osdev stuff
16:24:28FromDiscord<mr_rowboto> sent a long message, see https://pasty.ee/KAsTEgPD
16:32:19*Artea quit (Read error: Connection reset by peer)
16:36:08FromDiscord<mr_rowboto> sent a long message, see https://pasty.ee/tkRmHVba
17:10:56*mrinsane joined #nim
17:31:21*shrikant joined #nim
17:35:42*shrikant quit (Ping timeout: 255 seconds)
17:37:35*shrikant joined #nim
17:42:00*shrikant quit (Ping timeout: 255 seconds)
18:11:47FromDiscord<shalokshalom> In reply to @nnsee "memory allocation is a": How would you sew Odin compared to that?
18:19:20FromDiscord<kapendev> It's all the same thing.
18:20:15FromDiscord<shalokshalom> Zig's memory management allows for security issues.
18:22:42FromDiscord<kapendev> They have 2 things that might make things safer: a tracking allocator and some specific pointer types that give you more info on the type level about how they work.
18:23:40FromDiscord<kapendev> Making a tracking allocator is easy in most languages and you easily make a better one than the zig default.
18:23:53FromDiscord<kapendev> (edit) "Making a tracking allocator is easy in most languages and you ... easily" added "can"
18:25:23FromDiscord<shalokshalom> Interesting
18:25:34FromDiscord<shalokshalom> I thought Odin is all about arena based memory management
18:26:51FromDiscord<kapendev> Both zig and Odin provide tools for that.
18:27:09FromDiscord<kapendev> But it's a standard library feature I would say.
18:27:47FromDiscord<kapendev> Nim could have an arena in the standard library probably.
18:41:53FromDiscord<eebahn> sent a long message, see https://pasty.ee/ItpLPgiI
20:04:50FromDiscord<shalokshalom> In reply to @eebahn "nim's entry point is": why is the entry point important?
20:06:36FromDiscord<eebahn> In reply to @shalokshalom "why is the entry": because the entry point is how you control the boot/entry process of an OS
20:09:08FromDiscord<eebahn> Calling an external asm-defined function is possible, but calling the bootloader directly on the entry file is also possible (imo cleaner also)↵So abstracting away the very thing that controls your OS is not very good for learning to control your os 🤷‍♂️
20:10:51FromDiscord<eebahn> _(this is in the context of learning, of course. something being "possible" does not equate to something being "clear/easy to learn")_
20:12:15FromDiscord<shalokshalom> ok, I have no idea what the / an entry point is. I was always under the suspicion, that this is limited to the programming language itself. I had no idea, that has connections to so deep in the system itself. ↵↵Awesome, thanks!
20:19:32FromDiscord<mr_rowboto> In reply to @eebahn "because the entry point": This is actually a good point.
20:21:08FromDiscord<mr_rowboto> In reply to @shalokshalom "Zig's memory management allows": No. Bad programmers allow security issues of any kind.↵A supposed strength of some language does not imply a flaw on every other language that does not implement lifetime checking and burrowing obsessively to the point of being unreadable and unwrittable.
20:21:27FromDiscord<mr_rowboto> Just test your software if you're worried about security.
20:21:46FromDiscord<shalokshalom> In reply to @mr_rowboto "This is actually a": It looks like there is a flag for it.
20:21:50FromDiscord<shalokshalom> https://media.discordapp.net/attachments/371759389889003532/1481386687278878854/Screenshot_2026-03-11-21-21-19-597_com.brave.browser-edit.jpg?ex=69b3205d&is=69b1cedd&hm=5f14dfc7701256f6023472917b8636e88a8a91d7a8a0fc3dc2e65481c12a7a14&
20:21:57FromDiscord<shalokshalom> You can disable it.
20:22:03FromDiscord<mr_rowboto> In reply to @shalokshalom "": That's cool
20:22:14FromDiscord<shalokshalom> In reply to @mr_rowboto "No. Bad programmers allow": That's a bad argument
20:22:21FromDiscord<mr_rowboto> No, it's not.
20:22:27FromDiscord<mr_rowboto> Want Rust? Go program in rust.
20:22:33FromDiscord<shalokshalom> It doesn't matter that there are bad programmers.
20:22:43FromDiscord<shalokshalom> It matter that we want save programs.
20:22:47FromDiscord<mr_rowboto> Yes, yes it does. If you want memory safety you can program in javascript.
20:22:55FromDiscord<mr_rowboto> Save programs from what?
20:23:21FromDiscord<shalokshalom> In human history, there were always people being bad at something. Should we risk the whole civilization, just for these couples of idiots?
20:23:44FromDiscord<mr_rowboto> In all human history never civilization has collapsed due to dereferencing a pointer to null.
20:23:52FromDiscord<mr_rowboto> and spoiler alert
20:23:54FromDiscord<mr_rowboto> never will
20:24:01FromDiscord<shalokshalom> Or rather create guidelines, safety practices, and ultimately standards, who happen to be enforced by law?
20:24:18FromDiscord<mr_rowboto> Lol
20:24:30FromDiscord<shalokshalom> Its called regulations.
20:24:33FromDiscord<mr_rowboto> I'll repeat myself: if you want guardrails you can just program in javascript.
20:24:39FromDiscord<shalokshalom> Yuk.
20:24:43FromDiscord<mr_rowboto> Or C£
20:24:51FromDiscord<mr_rowboto> (edit) "C£" => "Csharp"
20:24:55FromDiscord<shalokshalom> Stupid non-sense
20:24:56FromDiscord<mr_rowboto> Or Java
20:25:07FromDiscord<mr_rowboto> Sure 😂
20:25:38FromDiscord<nnsee> In reply to @mr_rowboto "No. Bad programmers allow": propagating the use of memory safe languages is orders of magnitudes easier than removing all bad programmers. by this logic, cars aren't unsafe either, we just have bad drivers, which might be true on a very surface level but isn't exactly a helpful insight
20:25:53FromDiscord<mr_rowboto> In reply to @nnsee "propagating the use of": Testing is easier than both.
20:26:08FromDiscord<mr_rowboto> And effectively removes "bad programming" if not "bad programmers"
20:26:28FromDiscord<mr_rowboto> That's exactly what you do in order to keep the most critical software safe
20:26:34FromDiscord<mr_rowboto> unit, functional, fuzz, you name it
20:26:52FromDiscord<mr_rowboto> "securing" the language memory model is just not enough
20:27:04FromDiscord<mr_rowboto> if it was, rust would never have been invented, and we'd be using javascript
20:27:13FromDiscord<mr_rowboto> (edit) "language" => "language's"
20:27:57FromDiscord<nnsee> In reply to @mr_rowboto "And effectively removes "bad": you and i both know that's not true. programmers smarter than you and i combined write memory-unsafe code if they write in memory-unsafe languages, even with tests and fuzzing and the whole works
20:28:27FromDiscord<mr_rowboto> And I insist, the problem is with this statement:↵"Zig's memory management allows for security issues."↵↵A languages feature does not imply another language's issue for not implementing it.
20:28:48FromDiscord<mr_rowboto> In reply to @nnsee "you and i both": I know for a fact that it's true, let me show you:
20:29:02FromDiscord<mr_rowboto> here: https://github.com/bitcoin/bitcoin/tree/master/test
20:29:14FromDiscord<mr_rowboto> There's no sfotware more mission critical today than that repo.
20:29:38FromDiscord<mr_rowboto> The reason why there's all the testing, is because security has nothing to do with the memory model.
20:30:12FromDiscord<mr_rowboto> Is it desirable? Yeah, to an extent. It's not enough, and swapping c++ for rust wouldn't make unit, functional, and fuzz testing less important.
20:30:16FromDiscord<mr_rowboto> (edit) "Is it desirable? Yeah, to an extent. It's not enough, and ... swapping" added "magically"
20:30:24FromDiscord<mr_rowboto> (edit) "important." => "important nor required."
20:30:54FromDiscord<mr_rowboto> The memory model is just a tiny small part of the whole deal with "security".
20:31:57FromDiscord<nnsee> just to be clear, are you implying that bitcoind has never had memory corruption vulns?
20:32:04FromDiscord<mr_rowboto> Never.
20:32:09FromDiscord<nnsee> oh boy
20:32:11FromDiscord<mr_rowboto> Where am I implying that?
20:32:31FromDiscord<mr_rowboto> I just crashed a bunch of bitcoind nodes the other day with a couple python scripts
20:32:43FromDiscord<nnsee> ... by saying that the solution to memory corruption issues is testing and pointing me to that repo?
20:33:03FromDiscord<nnsee> maybe i'm misunderstanding you, then
20:33:08FromDiscord<mr_rowboto> I thikn so.
20:33:11FromDiscord<mr_rowboto> (edit) "thikn" => "think"
20:33:21FromDiscord<nnsee> In reply to @mr_rowboto "And I insist, the": also not sure how one implies the other. what part of that sentence is untrue?
20:33:34FromDiscord<mr_rowboto> I'm pointing to that repo, because I'm arguing that the memory model is not only not enough by a mile, using that repo as an example of how you achieve actual security.
20:33:44FromDiscord<[Next-System] systemblue> yeah memory management model is not all of safety
20:33:53FromDiscord<mr_rowboto> "Zig allows for security issues" is just stupid Ras.
20:33:55FromDiscord<[Next-System] systemblue> it's part of security
20:34:11FromDiscord<mr_rowboto> "Is the same as saying "X-lang except for Rust" allows for security issues"
20:34:21FromDiscord<mr_rowboto> and using that metric as if it was really important
20:34:21FromDiscord<[Next-System] systemblue> zig allows for security issue... it's half true and half false
20:34:22FromDiscord<mr_rowboto> it is not
20:34:35FromDiscord<mr_rowboto> security does not come from the memory model
20:34:41FromDiscord<mr_rowboto> security comes from here: https://github.com/bitcoin/bitcoin/tree/master/test
20:34:47FromDiscord<mr_rowboto> also from reproducible builds
20:34:52FromDiscord<mr_rowboto> also from a good community of devs
20:34:55FromDiscord<mr_rowboto> also from conferences
20:34:55FromDiscord<[Next-System] systemblue> zig's comptime and type check is better than C but manual memory management is also dangerous in noobs
20:35:00FromDiscord<mr_rowboto> also from wargames and testing
20:35:12FromDiscord<mr_rowboto> it's not that the statement is "false"
20:35:20FromDiscord<mr_rowboto> it's that it is absoltuely irrelevant for SECURITY
20:36:35FromDiscord<[Next-System] systemblue> yes, it's true↵security problem is come from dev's mistake↵if dev code unsafely and use null in C# or Java it might be dangerous too
20:36:47FromDiscord<[Next-System] systemblue> but I think language can help security
20:37:10FromDiscord<[Next-System] systemblue> by type safety, memory safety, nil(null) safety, parallel safety, value safety
20:37:12FromDiscord<nnsee> sent a long message, see https://pasty.ee/vaFXgnWF
20:37:19FromDiscord<mr_rowboto> sent a long message, see https://pasty.ee/oRqkCPiz
20:37:56FromDiscord<mr_rowboto> In reply to @nnsee "nobody said it is.": Exactly, so why do rustaceans explicitly spend all their time saying "oh this memory model allows for security issues hum humm"
20:38:00FromDiscord<mr_rowboto> (edit) "humm"" => "humm"?"
20:38:24FromDiscord<nnsee> In reply to @mr_rowboto ""Zig allows for security": it's not "zig allows for security issues" it's quite specifically that zig's memory management model allows for memory corruption issues, which is literally factual
20:38:25FromDiscord<[Next-System] systemblue> In reply to @nnsee "nobody said it is.": oh you are pentester ↵and my friend is learning hacking too and he always said that memory and type issue are one of primary bugs
20:38:41FromDiscord<mr_rowboto> In reply to @nnsee "it's not "zig allows": Every single language allows that.
20:38:43FromDiscord<[Next-System] systemblue> In reply to @nnsee "it's not "zig allows": I agree
20:38:49FromDiscord<mr_rowboto> Except for the vm'ed ones
20:39:00FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "Every single language allows": no Nim and Rust'
20:39:05FromDiscord<mr_rowboto> If we really wanted to scrap the "security issues", we'd be running on vm's.
20:39:11FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "no Nim and Rust'": Nim?
20:39:14FromDiscord<[Next-System] systemblue> s memory management strategy do not allowed it
20:39:21FromDiscord<mr_rowboto> I can segfault on nim much easier than on rust.
20:39:40FromDiscord<mr_rowboto> It was the first thing I did with the lang I think haha
20:39:48FromDiscord<[Next-System] systemblue> but it's true that any language can be segfaulted
20:40:15FromDiscord<[Next-System] systemblue> even Rust, even Ada can do that
20:40:20FromDiscord<mr_rowboto> What I'm saying is not that the statement is false.↵I'm saying the statement is meaningless compared to actuall issues from the real world.
20:40:37FromDiscord<[Next-System] systemblue> but language has tendency
20:40:41FromDiscord<[Next-System] systemblue> safe or unsafe
20:40:46FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "even Rust, even Ada": Well, javascript won't segfault.
20:40:57FromDiscord<mr_rowboto> (unless a vuln is found ofc)
20:41:15FromDiscord<[Next-System] systemblue> I know that Javascript has other problem, type issue
20:41:25FromDiscord<mr_rowboto> sure, let's ignore that
20:41:28FromDiscord<[Next-System] systemblue> and also javascript can be weak at some point
20:41:30FromDiscord<mr_rowboto> we can take another similar lang
20:41:53FromDiscord<[Next-System] systemblue> many javascript backend are attacked by memory voluble
20:42:05FromDiscord<nnsee> In reply to @mr_rowboto "Every single language allows": no, actually, most of the most widely used languages in the world _don't_ allow that (at least unless you start manually poking at the internals), notably Java, Python, JS, perl, or if you're looking specifically at compiled languages, Go
20:42:12FromDiscord<[Next-System] systemblue> I think language has tendency,↵safe language, unsafe language
20:42:37FromDiscord<mr_rowboto> In reply to @nnsee "no, actually, most of": Which is exactly what I'm saying, but there is a reason why we use nim, rust, go etc.
20:42:42FromDiscord<mr_rowboto> (edit) "saying," => "saying above,"
20:43:02FromDiscord<mr_rowboto> Btw, are you 100% sure Go can't be broken?
20:43:11FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "Btw, are you 100%": I can't sure it
20:43:12FromDiscord<mr_rowboto> (without a bug that is)
20:43:14FromDiscord<nnsee> In reply to @mr_rowboto "If we really wanted": most of the world does!
20:43:31FromDiscord<mr_rowboto> exactly
20:43:37FromDiscord<mr_rowboto> then why use Rust huh?
20:43:42FromDiscord<mr_rowboto> (or nim)
20:43:46FromDiscord<[Next-System] systemblue> I think language has tendency, safe language and unsafe language
20:43:57FromDiscord<nnsee> In reply to @mr_rowboto "Btw, are you 100%": not at all, but i've rarely ever if ever heard of a memory corruption issue in standard go code (barring actual go runtime bugs)
20:44:00FromDiscord<[Next-System] systemblue> Rust, Ada, Nim is safe language↵and C, C++, Zig are unsafe language
20:44:15FromDiscord<[Next-System] systemblue> (edit) "Nim" => "Nim, Swift"
20:44:25FromDiscord<[Next-System] systemblue> (edit) "is" => "are"
20:44:32FromDiscord<mr_rowboto> In reply to @nnsee "not at all, but": I haven't programmed much in go lately but I am under the impression that it can be destroyed.
20:44:37FromDiscord<mr_rowboto> I can almost assure you I have done it.
20:44:53FromDiscord<mr_rowboto> But I'd be lying if I say I'm sure.
20:45:18FromDiscord<[Next-System] systemblue> In reply to @nnsee "not at all, but": yes it rarely appears but it appears
20:46:07FromDiscord<mr_rowboto> The point I'm making here is that the phrasing is disingenuous becuse it is designed to impact every single 'compiled to native' language out there except for Rust, and at the same time, it covers only a very small surface of what actual 'security' is.
20:46:21FromDiscord<mr_rowboto> And I'm pretty sure everyone would agree on that.
20:46:37FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "The point I'm making": and why do you think Rust is exception
20:46:53FromDiscord<mr_rowboto> Becuse it's designed to bem, that's great.
20:46:54FromDiscord<nnsee> just to be clear i didn't see anyone mention rust until you mentioned it out of the blue
20:47:00FromDiscord<mr_rowboto> In reply to @nnsee "just to be clear": I did.
20:47:01FromDiscord<[Next-System] systemblue> Rust has safety issue ↵I know that Rust can't even collect reference cycle
20:47:10FromDiscord<mr_rowboto> The reference to rust was obvious.
20:47:15FromDiscord<mr_rowboto> But yea, I brought that here.
20:47:24FromDiscord<ashish> does anyone wonder why nim did not get same traction as Rust ?
20:47:45FromDiscord<nnsee> no specific niche and no aggressive backing and PR
20:48:02FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "The reference to rust": and Rust's memory model and Nim's memory model is similar (two lang is RC lang and it check ownership too)
20:48:23FromDiscord<mr_rowboto> But you know the statement is a "Bed of Procrustes" Ras.↵You know _perfectly_ that the phrasing was designed to highlight Rust... and also know _perfectly_ that memory safety is a veeeery small portion.
20:48:32FromDiscord<mr_rowboto> (https://en.wikipedia.org/wiki/The_Bed_of_Procrustes)
20:48:51FromDiscord<mr_rowboto> (edit) "(https://en.wikipedia.org/wiki/The_Bed_of_Procrustes)" => "(https://en.wikipedia.org/wiki/Procrustes)"
20:49:13FromDiscord<nnsee> well, you must think me smarter than i am, because i for sure didn't read out that they were specifically implying rust with that comment about zig's memory model
20:49:15FromDiscord<mr_rowboto> (edit) "portion." => "portion of what safety is."
20:49:21FromDiscord<[Next-System] systemblue> nim does not make segfault while you are using ref or var↵if you use pointer, it's unsafe ↵but nim does not make memory voluble in common programming sytle
20:50:08FromDiscord<mr_rowboto> In reply to @nnsee "well, you must think": Which other language that can be compared to zig or nim does not have those """"issues"""" with their memory model? 😛
20:50:16FromDiscord<mr_rowboto> Go? 😛
20:50:30FromDiscord<mr_rowboto> There are veeery few players in the playfield.
20:50:46FromDiscord<shalokshalom> In reply to @nnsee "not at all, but": I would assume Google cares for software that runs their business.
20:50:59FromDiscord<shalokshalom> In reply to @mr_rowboto "There are veeery few": There are lots.
20:51:18FromDiscord<[Next-System] systemblue> sent a long message, see https://pasty.ee/cSOdJwpp
20:51:18FromDiscord<mr_rowboto> No, there are not lots of systems programming languages that are actually used.
20:51:31FromDiscord<shalokshalom> In reply to @bluewhale_unkown_x "zig and nim are": Nim has a bunch of options
20:51:41FromDiscord<mr_rowboto> In reply to @shalokshalom "Nim has a bunch": yep
20:51:42FromDiscord<shalokshalom> Probably the most of any programming language
20:51:48FromDiscord<mr_rowboto> that's true
20:51:51FromDiscord<[Next-System] systemblue> In reply to @shalokshalom "Nim has a bunch": yeah it's true
20:51:56FromDiscord<mr_rowboto> ARC/ORC/fuck it
20:51:57FromDiscord<[Next-System] systemblue> but I'm only thinking with ORC
20:52:01FromDiscord<shalokshalom> At least of the production ready ones.
20:52:11FromDiscord<[Next-System] systemblue> nim is weak in none memory model
20:52:13FromDiscord<shalokshalom> There is also a borrow checker comming.
20:52:18FromDiscord<mr_rowboto> 'fuck it' memory managment is a fun concept
20:52:23FromDiscord<shalokshalom> Although I like that one of Cpp2.
20:52:38FromDiscord<[Next-System] systemblue> I'm saying that Rust has weak point, Rust can't collect reference cycle automatically
20:52:50FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "I'm saying that Rust": nor can nim
20:52:57FromDiscord<shalokshalom> In reply to @mr_rowboto "No, there are not": Which is, btw, one of the options of languages that are usable.
20:52:59FromDiscord<mr_rowboto> which is why ARC/ORC right?
20:53:08FromDiscord<[Next-System] systemblue> Nim can collect reference cycle in ORFC
20:53:09FromDiscord<shalokshalom> ORC can
20:53:18FromDiscord<nnsee> In reply to @mr_rowboto "Which other language that": swift immediately comes to mind
20:53:19FromDiscord<shalokshalom> That's what the O is for.
20:53:23FromDiscord<[Next-System] systemblue> ORC is innovation
20:53:28FromDiscord<mr_rowboto> Oh sure
20:53:32FromDiscord<[Next-System] systemblue> O is ownership
20:53:34FromDiscord<mr_rowboto> In reply to @nnsee "swift immediately comes to": hmmmmm mMMMMMM
20:53:35FromDiscord<shalokshalom> Ada
20:53:39FromDiscord<[Next-System] systemblue> it's similar with Rust but upgraded
20:53:42FromDiscord<shalokshalom> So many.
20:53:50FromDiscord<[Next-System] systemblue> it can do parallel without atomic
20:53:55FromDiscord<[Next-System] systemblue> and thread-local heap
20:54:09FromDiscord<[Next-System] systemblue> and nim's type system is come from Ada
20:54:19FromDiscord<[Next-System] systemblue> Nim's quite safe language
20:54:22FromDiscord<shalokshalom> OCaml with extensions↵https://blog.janestreet.com/oxidizing-ocaml-ownership/
20:54:24FromDiscord<mr_rowboto> If you tell me "Yeah we're _seriously_ programming this embedded application in Swift, no, it's not for anything apple", I will know that you went full loonie Ras.
20:54:24FromDiscord<[Next-System] systemblue> even then Rust in some point
20:54:47FromDiscord<mr_rowboto> And don't get me wrong, I love Swift.
20:54:51FromDiscord<mr_rowboto> It's a great lang.
20:54:55FromDiscord<nnsee> well now you're adding arbitrary constraints. why does it suddenly have to be embedded
20:54:57FromDiscord<mr_rowboto> But "who does that?"
20:55:06FromDiscord<mr_rowboto> In reply to @nnsee "well now you're adding": it doesn't have to
20:55:11FromDiscord<ash12355> never write rust .
20:55:14FromDiscord<mr_rowboto> I put that as an example of systems prog
20:55:29FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "And don't get me": Swift can't even collect reference cycle and it's type system is weaker than NIm
20:55:34FromDiscord<shalokshalom> Lots of standard ML implementations like MLKit
20:55:36FromDiscord<[Next-System] systemblue> never write rust lol
20:55:57FromDiscord<shalokshalom> Swift is overrated as programming language and underrated as subject of research
20:56:12FromDiscord<shalokshalom> Its a very good language with a couple of very bad decisions
20:56:17FromDiscord<mr_rowboto> In reply to @shalokshalom "Swift is overrated as": because it's not that used.
20:56:18FromDiscord<ash12355> I feel language wars are over now with AI.
20:56:19FromDiscord<nnsee> /shrug there are and always will be different tools for different jobs, just pick the tool that makes the most sense for the job at hand
20:56:26FromDiscord<[Next-System] systemblue> and swift has no ownership right?
20:56:34FromDiscord<mr_rowboto> In reply to @nnsee "/shrug there are and": Of course I agree.
20:56:34FromDiscord<ash12355> I think nim is best for AI.
20:56:40FromDiscord<shalokshalom> Protocols are good, their implementation of a type inference is an insult to every researcher
20:56:43FromDiscord<[Next-System] systemblue> there's only two language that has ownership today, nim and rust
20:57:00FromDiscord<shalokshalom> In reply to @bluewhale_unkown_x "there's only two language": That's not really true
20:57:05FromDiscord<shalokshalom> I just named Cpp2.
20:57:09FromDiscord<shalokshalom> And there are more.
20:57:20FromDiscord<[Next-System] systemblue> you mean Nim and Rust are C++ 2?
20:57:23FromDiscord<[Next-System] systemblue> what the...
20:57:26FromDiscord<shalokshalom> No
20:57:29FromDiscord<shalokshalom> Cpp2 is Cpp2
20:57:33FromDiscord<ash12355> In reply to @bluewhale_unkown_x "there's only two language": rust somehow gimmick-ed everyone.
20:57:36FromDiscord<[Next-System] systemblue> oh
20:57:38FromDiscord<shalokshalom> The compiler is called cppfront
20:57:41FromDiscord<[Next-System] systemblue> Cpp2 is ownership?
20:57:44FromDiscord<mr_rowboto> In reply to @nnsee "swift immediately comes to": Hmm but then again, wait... swift should be super easy to segfault.
20:57:51FromDiscord<mr_rowboto> Like SUPER easy.
20:57:55FromDiscord<nnsee> "if cpp is so great why isn't there a cpp 2"
20:57:57FromDiscord<shalokshalom> Done by one of the most prominent figures in the Cpp community
20:58:04FromDiscord<shalokshalom> Who is a real Gem of a presenter
20:58:19FromDiscord<[Next-System] systemblue> In reply to @nnsee ""if cpp is so": yeah C++ has so many problem and that's why there's cpp2
20:58:50FromDiscord<shalokshalom> In reply to @bluewhale_unkown_x "Cpp2 is ownership?": In an arguably better way than Rust, but I think the Nim approach may even be(come) better than both of them.
20:58:55FromDiscord<nnsee> In reply to @mr_rowboto "Hmm but then again,": i don't write a lot of swift code but that's not the impression i've gotten so far, considering they have a separate `Unsafe` interface for unsafe ops
20:59:00FromDiscord<shalokshalom> Cpp2 as a whole is an interesting language.
20:59:12FromDiscord<ash12355> Rust only got traction because of mozilla and msft backing.
20:59:14FromDiscord<mr_rowboto> In reply to @nnsee "i don't write a": Ok, I don't either, and I read the manual eons ago.
20:59:31FromDiscord<ash12355> it's a shitshow.
20:59:32FromDiscord<mr_rowboto> I'm almost sure it's not rust levels of safety.
20:59:36FromDiscord<shalokshalom> No, Swift is an Apple language, and if Apple knows ONE THING then its security.
20:59:38FromDiscord<[Next-System] systemblue> and there's no language that can absolutely protect memory issue
20:59:42FromDiscord<[Next-System] systemblue> but it's tendency
20:59:48FromDiscord<mr_rowboto> In reply to @shalokshalom "No, Swift is an": ehh...
20:59:49FromDiscord<mr_rowboto> no
20:59:49FromDiscord<mr_rowboto> hahaha
20:59:58FromDiscord<nnsee> In reply to @shalokshalom "No, Swift is an": not sure if this is tongue in cheek or not but... lol
21:00:12FromDiscord<shalokshalom> https://github.com/qwaz/rust-cve
21:00:16FromDiscord<mr_rowboto> laughs in _the fappening_
21:00:17FromDiscord<mr_rowboto> (edit) "" => "¬"
21:00:20FromDiscord<shalokshalom> In reply to @mr_rowboto "I'm almost sure it's": No, its much better
21:00:25FromDiscord<mr_rowboto> (edit) "¬" => ""
21:00:37FromDiscord<shalokshalom> Rust is ok, Swift is better, and Ada potentially the most secure one.
21:00:46FromDiscord<mr_rowboto> memory secure
21:00:59FromDiscord<mr_rowboto> Security does not come from the memory model.
21:01:08FromDiscord<shalokshalom> In reply to @nnsee "not sure if this": I know how they code the stuff that's under NDA.
21:01:28FromDiscord<shalokshalom> And they have a very fine track record. You can blame them for a lot, but not that.
21:01:33*ash_ joined #nim
21:01:41FromDiscord<shalokshalom> In reply to @mr_rowboto "Security does not come": I am aware about that.
21:01:49FromDiscord<shalokshalom> Its one part of security.
21:01:51FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "I'm almost sure it's": I think nim's safety is similar with Rust and even good at some time
21:01:58FromDiscord<mr_rowboto> a _small_ part of security
21:02:00FromDiscord<mr_rowboto> very small
21:02:13FromDiscord<shalokshalom> Probably better after Nimony
21:02:21FromDiscord<shalokshalom> and potentially less so than today
21:02:29FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "I think nim's safety": Well, memory safety for Rust is "better" always, because Nim does not handle lifetimes.
21:02:32FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "a _small_ part of": and what point that do you think Rust is safe↵without memory management,
21:02:34FromDiscord<shalokshalom> In reply to @mr_rowboto "a _small_ part of": Its a large part of actual exploits.
21:02:52FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "Well, memory safety for": Nim has life time too ↵at var, ref
21:02:52FromDiscord<shalokshalom> Most critical security issues are memory related for a long time.
21:03:00FromDiscord<mr_rowboto> In reply to @shalokshalom "Its a large part": check the msgs by Ras above, it's very small
21:03:03FromDiscord<[Next-System] systemblue> but it's not showed
21:03:05FromDiscord<shalokshalom> And that changes only in the last years.
21:03:23FromDiscord<shalokshalom> In reply to @mr_rowboto "check the msgs by": Its not. And especially not among C and C++ code.
21:04:02FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "Nim has life time": rust lifetime is far more strict, the lifetime management forces what can and can't be passed as arguments
21:04:04FromDiscord<mr_rowboto> (edit) "rust" => "Rust"
21:04:16FromDiscord<mr_rowboto> which is essentially why you can very easily segfault on nim
21:04:23FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "check the msgs by": and what point do you think Rust's safety is better than Nim↵don't say just "Rust is safer than Nim"↵say which point is safer
21:04:24FromDiscord<mr_rowboto> and it's not that easy to segfault on rust
21:04:38FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "and what point do": lifetimes.
21:04:46FromDiscord<eebahn> In reply to @shalokshalom "": You still need to call `NimMain` at some point, afaik, or nothing in the language will work
21:04:50FromDiscord<ash12355> In reply to @mr_rowboto "which is essentially why": it's an unnecessary rule
21:04:56FromDiscord<mr_rowboto> Even so I don't like lifetimes.
21:04:59FromDiscord<mr_rowboto> (edit) "so" => "so,"
21:05:03FromDiscord<mr_rowboto> In reply to @ash12355 "it's an unnecessary rule": I agree.
21:05:07FromDiscord<shalokshalom> https://www.chromium.org/Home/chromium-security/memory-safety/
21:05:24FromDiscord<shalokshalom> https://media.discordapp.net/attachments/371759389889003532/1481397655023386634/piechart.png?ex=69b32a93&is=69b1d913&hm=981a4643312bab163353e23463fa704a07a366cbf19f0325426b43e188d8409c&
21:05:32FromDiscord<shalokshalom> https://www.ibm.com/think/news/memory-safe-programming-languages-security-bugs?utm_source=perplexity
21:05:51FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "lifetimes.": Nim's life time is automatic and it's not unsafe↵most time, nim's life time is oversafe
21:06:06FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "Nim's life time is": It's very very easy to segf on nim.
21:06:14FromDiscord<shalokshalom> In reply to @eebahn "You still need to": ok, I saw very little to no documentation about this flag, that snippet that I posted was the only one, besides some issues.
21:06:49FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "It's very very easy": and I don't know Rust but I think Rust may be similar if I learn Rust and find way
21:06:53FromDiscord<nnsee> In reply to @shalokshalom "I know how they": this is tangentially related, but this made me thing and i realized that my memory exploitation journey started way back when with webkit, which is just absolutely notorious for having safety issues and was a common entry point for userland exploits for game consoles etc, most of which used (and still do) webkit for their browsers
21:07:02FromDiscord<nnsee> (edit) "thing" => "think"
21:07:05FromDiscord<[Next-System] systemblue> NIm's common programming style does not make segfault
21:07:06FromDiscord<mr_rowboto> In reply to @bluewhale_unkown_x "and I don't know": I have coded in both Rust and nim, they're not similar.
21:07:27FromDiscord<mr_rowboto> Hey, blue, we can continue in offtopic if you want, because we're mixing convos.
21:07:34FromDiscord<mr_rowboto> and it's a PITA
21:07:55FromDiscord<shalokshalom> In reply to @nnsee "this is tangentially related,": Do you know the blog, that posts such an article for every single one of critical CVEs caused by C/C++?
21:08:23FromDiscord<nnsee> it's hard to overstate how unsafe webkit is. it's kind of become a running joke in the binary exploitation community
21:08:35FromDiscord<nnsee> In reply to @shalokshalom "Do you know the": not sure which one you mean specifically
21:08:42FromDiscord<nnsee> or if this is rhetorical or what
21:08:54FromDiscord<eebahn> sent a long message, see https://pasty.ee/OCuEYATI
21:09:18FromDiscord<[Next-System] systemblue> In reply to @mr_rowboto "I have coded in": and you can't make segfault error without using ptr in release mode↵if danger mode and using ptr it can have segfault error but
21:09:56FromDiscord<[Next-System] systemblue> @mr_rowboto and I know that Rust can have deep recursion attack too
21:10:12FromDiscord<eebahn> In reply to @shalokshalom "ok, I saw very": Yea, much like `--mm:none`, the "no abstractions" workflow of nim is severly underdeveloped and undocumented (and also buggy as hell, been bitten by that already)
21:10:45FromDiscord<mr_rowboto> In reply to @eebahn "<@176460389662457856> <@208199869301522432> Missed ": Agreed.
21:11:07FromDiscord<shalokshalom> That's a nice one.↵↵https://h.within.lgbt/
21:11:16FromDiscord<shalokshalom> h is completely memory safe with no garbage collector or heap allocations. It does not allow memory leaks to happen, nor do any programs in h have the possibility to allocate memory.
21:11:36FromDiscord<shalokshalom> In reply to @eebahn "Yea, much like `--mm:none`,": Yeah, generally an issue with Nim, docs and internal stability.
21:14:37FromDiscord<asviest> In reply to @mr_rowboto "Just test your software": Ugh, I like static analysis instead
21:16:09FromDiscord<mr_rowboto> In reply to @asviest "Ugh, I like static": the more the better
21:16:30*ash_ quit (Quit: Konversation terminated!)
21:17:31FromDiscord<nnsee> In reply to @shalokshalom "That's a nice one.": finally, the perfect language https://h.within.lgbt/grammar/h.peg
21:18:40*ash_ joined #nim
21:19:25FromDiscord<asviest> In reply to @mr_rowboto "Is it desirable? Yeah,": Btw, swapping c++ to c magicaly make code safer (especially with good tests)
21:19:47FromDiscord<shalokshalom> In reply to @nnsee "finally, the perfect language": No, sure not.
21:19:52FromDiscord<shalokshalom> Ours is better 😋
21:21:26FromDiscord<shalokshalom> In reply to @nnsee "finally, the perfect language": I think that code which is less readable than common language, to have failed at designing the language.↵↵Which happens to be every single language, but Nim is actually one of the most readable imho.
21:23:16FromDiscord<nnsee> (to be clear that is the entire language grammar definition, not h code itself)
21:23:17FromDiscord<shalokshalom> You can't really that it does what it says, since the docs are outdated, or non-existent, and the compiler may fail here and there, but the code is at least very clear to read.↵↵And a compiler can be fixed. But try to fix an entire ecosystem full of code that takes you much more time to jump back in, and continue where you left.
21:23:33FromDiscord<shalokshalom> In reply to @nnsee "(to be clear that": LoL
21:24:18FromDiscord<shalokshalom> In reply to @nnsee "(to be clear that": The imported repo is 404
21:24:28FromDiscord<shalokshalom> Where did you read that?
21:30:01*rockcavera joined #nim
21:57:48FromDiscord<asviest> In reply to @shalokshalom "That's a nice one.": A => B => C => D => E => F# => h programming language
21:58:49FromDiscord<asviest> (edit) "In reply to @shalokshalom "That's a nice one.": A => B => C => D => E => F# => ... h" added "G =>"
22:17:11*amadaluzia joined #nim
22:30:27FromDiscord<[Next-System] systemblue> hey Nim's embedded and security channel is nearly dead
22:30:29FromDiscord<[Next-System] systemblue> QQ
22:36:57*ash_ quit (Quit: Konversation terminated!)
22:38:36FromDiscord<kapendev> Well, write a project and post it there!
22:45:13FromDiscord<transclusivity> In reply to @mr_rowboto "I'll repeat myself: if": I think the point is to have the guardrails without the lack of control, crappy design, and other downsides
23:20:00FromDiscord<shalokshalom> Effortless security