channel logs for 2004 - 2010 are archived at http://tunes.org/~nef/logs/old/ ·· can't be searched

#osdev2 = #osdev @ Libera from 23may2021 to present

#osdev @ OPN/FreeNode from 3apr2001 to 23may2021

all other channels are on OPN/FreeNode from 2004 to present

http://bespin.org/~qz/search/?view=1&c=osdev2&y=24&m=7&d=21

Sunday, 21 July 2024

00:11:00 <gog> ih
00:16:00 <heat> gog ih
00:16:00 <gog> ack heat
00:27:00 <heat> grog bazel
07:16:00 <kof673> quote gnu.org: Can the US Government release a program under the GNU GPL? (#GPLUSGov) If the program is written by US federal government employees in the course of their employment, it is in the public domain
07:16:00 <kof673> well that clears that up j/k :D > The Most Important Office In A Democracy Is The Citizen www.democracy.community
07:16:00 <bslsk05> ​www.democracy.community: International Democracy Community | Home
09:26:00 <Ermine> I've tried grepping 'gps' over linux tree and got a lot of hits in rcu code
09:28:00 <heat> gp usually means grace period here
09:28:00 <heat> dunno what gps means
09:28:00 <heat> except "grace period*s*", might be that
09:29:00 <heat> s/here/there/
09:29:00 <Ermine> maybe gp sequence
09:29:00 <Ermine> ./kernel/rcu/rcutorture.c: gps = rfp->n_launders_hist[j].launder_gp_seq;
09:30:00 <heat> oh rcutorture
11:20:00 <sortie> You ever have one of those days where you have to sha256sum 3.2 TB
11:24:00 <nikolar> Why
11:24:00 <sortie> Doing a massive backup :)
11:26:00 <zid> I read that as breakup
11:27:00 <zid> your ex has poisoned 1 of your files, the door will unlock when you find it
11:28:00 <sortie> You joke but I did have to resume the transfer halfway so there may actually be one poisoned file
11:28:00 <sortie> Might that be a picture of a ex? Who knows, but like Caroline said, that will be one door that leads to another door to another door
11:43:00 <kazinsal> I would simply only write systems for an 8088 so it makes it highly improbably for a vindictive ex to poison my system
11:45:00 <kazinsal> original plan: router/firewall/switching operating system
11:45:00 <kazinsal> reality: I wonder what kind of dumb crap I can do on a PC/XT
11:47:00 <sortie> kazinsal: Would you like to join the 8086_32 Working Group?
11:47:00 <kazinsal> hell yeah I have a PS/2 I need to recap
11:48:00 <sortie> kazinsal: We're working on SO/RTIX, a 32-bit operating system for the 8086: https://gitlab.com/sortix/sortix/-/wikis/SO/RTIX
11:48:00 <bslsk05> ​gitlab.com: RTIX · Wiki · sortix / Sortix · GitLab
11:48:00 <kazinsal> actually this one's a 286 system but I need to do some major recappage on the floppy riser board
11:48:00 <sortie> 286? You must be wealthy
11:49:00 <kazinsal> two of the voltage fliter caps went bang and I need to replace them
11:49:00 <kazinsal> once they're replaced the 3.5" disk drive should work again
12:42:00 <mcrod> tell me something
12:43:00 <mcrod> for those who are on arch with wayland+nvidia, is firefox wildly unstable
12:43:00 <mcrod> it was not like this until I updated
14:15:00 <gog> mcrod: workss fine for me
14:15:00 <gog> when did you update? maybe i'm behind
14:15:00 <gog> seemss i am
14:18:00 <heat> hi behind, i'm heat
14:27:00 <adder> hi heat
14:28:00 <gog> heat
14:28:00 <gog> hi
14:28:00 <sham1> hi
14:29:00 <heat> gog
14:29:00 <heat> sham1
14:29:00 <heat> adder
14:30:00 <adder> heaten
14:30:00 <adder> bom dia
14:30:00 <heat> olá
14:31:00 <heat> gog, egl-wayland 1.1.14 seems to be correct but fucks up firefox and OBS at least, do not update
14:31:00 <guideX> what do you guys do with errors, my errors in my os are not what I desire, any error causes kernel panic, also I can wrap things in try/catch but I don't have an exception class to properly catch what error it was
14:32:00 <guideX> it'd be nice to like gracefully handle the errors, and return a description of what happened to the user somehow, instead of haulting the system, eh I'm still trying to figure that out
14:33:00 <sortie> guideX: Doing a custom design or a POSIX?
14:33:00 <guideX> this is a custom os
14:33:00 <sortie> In POSIX systems, the system calls return a well known error code such as ENOENT (no such file or directory) on failure
14:33:00 <guideX> based off of.NET 7 Native AOT
14:33:00 <guideX> ah ok
14:34:00 <sortie> Generally I encourage you to always handle errors, including allocation failures, and gracefully clean up and abort the operation, then return an error code showing what happened
14:34:00 <sortie> It's just good software practice in general
14:34:00 <guideX> this is more like, an unhandled null reference exception usually
14:34:00 <sham1> But malloc never fails™
14:34:00 <guideX> it haults the system, and I display kernel panic
14:34:00 <guideX> eh i'll work on that
14:34:00 <sham1> So it's totally okay to halt and catch fire with the program on alloc failure
14:34:00 <sortie> sham1: That is a choice you have to made. Usually that means you explode randomly later on a benign memory opertation.
14:35:00 <sham1> Oh of course
14:35:00 <sortie> E.g. overcommit (random boom), or blocking indefinitely on memory to become available (deadlock)
14:35:00 <heat> overcommit is based
14:35:00 <sortie> Plus on a real production kernel, you want to never crash on errors
14:35:00 <sortie> Sortix doesn't overcommit and malloc returns NULL btw
14:36:00 <guideX> sortie, the problem with that is, then I don't return what happened, that's no ok either I need to fix that huh
14:36:00 <heat> onyx overcommit does not return NULL
14:36:00 <heat> s/overcommit/malloc/
14:36:00 <sham1> overcommit is cringe
14:36:00 <guideX> you see, the .net7 exception isn't part of my code, so there is no exception, and the one from .net7 doesn't work in .net7 native aot, so I need to figure something else out i guess
14:37:00 <heat> puck, could you enable the bslsk05 sed message thingy here please? it's really useful
14:37:00 <sortie> guideX: There's two different kinds of errors that can happen. 1) Well known predicted errors (such as missing files, allocation failures, etc.) that you want to handle 2) Unexpected errors that means the code is buggy and cannot reasonably recover. A null pointer access is usually that. Even with exceptions in a managed language like .NET, you will want the equivalent of a kernel panic if you detect the kernel itself is faulty
14:37:00 <guideX> sortie, ah oik
14:38:00 <heat> counter-point: linux rarely panics but OOPSes instead, which is not quite the same thing
14:38:00 <guideX> so only show the user errors which are expected, and things like I screwed up should hault
14:38:00 <guideX> like unreferenced variable I'm trying to touch
14:38:00 <guideX> ok cool
14:38:00 <sortie> E.g. in the Dart programming language I worked on, we have Errors and Exceptions being two different things, where one means it's a bug in the problem and the other one means a predicted runtime issue that can be recovered from
14:38:00 <puck> heat: i will in a bit, because my gpg agent has died
14:39:00 <heat> thanks <3
14:39:00 <guideX> In a program I am writing, I would usually handle all exceptions I can, even ones I don't know about, and have a logging mechanism, I guess not so much here as it's an os there's different reasons to do things
14:39:00 <sortie> So e.g. in your system call implementations in a managed language, you don't want to catch everything, you want to panic on an unhandled exception, and to fail gracefully on expected exceptions
14:44:00 <guideX> https://pastebin.com/raw/wLMyR0Tt I guess I need to figure out how to gracefully bubble this back to the user without haulting sometimes
14:45:00 <sortie> Yeah I suggest kinda not doing that at least initially
14:46:00 <sortie> That right there is not a system call
14:46:00 <sortie> That is a CPU exception handler, e.g. the program crasher
14:46:00 <sortie> The right choice initially is probably to kill your program and let it crash, from a simple implementation point of view
14:47:00 <sortie> And if it is the kernel, to probably panic too
14:47:00 <sortie> But later on, when you're ready, the question is how to dispatch a null pointer exception to the failing thread
14:47:00 <nikolar> SIGSEGV
14:47:00 <sortie> Since you're using .NET, there has to be some sort of ABI for how to dispatch those exceptions. You need to do that.
14:48:00 <sortie> nikolar: Indeed but guideX is working on a .NET managed language with a custom system interface, so they need to think up their own design for this when ready
14:49:00 <nikolar> Ah right
14:49:00 <sortie> guideX: I'm guessing that in cases like this, you want to try to deliver the exception to userspace, and if that mechanism fails, then you want to forcefully kill the process.
14:49:00 <sortie> It's up to you also whether you want to deliver null pointer exceptions to the kernel itself
14:50:00 <guideX> ah ok interesting
14:50:00 <guideX> yes this is in the kernel
14:50:00 <guideX> if I'm like playing with it, and screw up I give myself kernel panic xD
14:51:00 <guideX> I guess that's ok, it kind of should be like that in the kernel, and not like that in the os code
14:51:00 <sortie> I would suggest you start out with maybe delivering an exception across a system call boundary or something
14:51:00 <sortie> Learn a bit from that
14:52:00 <sortie> Although the .NET mechanism for null pointer accesses are very different I suppose. I think that it actually just lets it crash natively and catches the access violation exception from Windows and uses it to then throw an exception in the calling code.
14:52:00 <sortie> You'll have to study that ABI :)
14:53:00 <guideX> yeah I'll look into that
14:53:00 <sortie> Since you're saying it's .NET AOT that means it's anyone's guess how it handles these, if at all
15:00:00 <heat> <sortie> And if it is the kernel, to probably panic too
15:00:00 <heat> nooooooooooooooo
15:00:00 <heat> i've slowly over time been fully converted into "panic is bad"
15:01:00 <heat> linox handles most crap conditions as "meh, SIGKILL and we'll deal with it later" or similar
15:01:00 <heat> which basically allows you to debug easier or even just keep running indefinitely
15:01:00 <heat> could crash right after, could never crash for the next 10 months, you don't know
15:02:00 <mjg> lol
15:02:00 <heat> oh look here's mr kernel debugger
15:02:00 <mjg> how tf how getting a dump as soon as the problem is found makes "debug easeir"
15:02:00 <sortie> heat: It is a bit of a mixed bag. Yes, generally, they are bad. Recoverable situations must be recovered from gracefully. BUT there is also a class of situations, like asserts or bug checks and so forth, where you realize a key kernel invariant has been broken. You can panic now and say what's wrong and it can be fixed, since it's a kernel bug. Or you can keep going and you're going to explode mysteriously, and attackers are going to exploit the
15:02:00 <sortie> broken invariants to root the kernel.
15:02:00 <mjg> not*
15:02:00 <guideX> I feel like if I hide the errors I will get complacent and system will be unstable xD
15:03:00 <guideX> I mean I could just add try/catch everywhere, but idk
15:03:00 <sortie> Personally I follow the pattern where I handle all errors gracefully. If it panics, then I make it a P0 to debug and fix that crash,.
15:03:00 <mjg> i think you missed the part where even companies like red hat enable panic on oops
15:03:00 <mjg> and get crashdumps
15:03:00 <mjg> not everything can be debugged from an oops report
15:03:00 <heat> i mean, yeah if you can get crashdumps then panic on oops is a solid choice
15:03:00 <GeDaMo> https://www.usenix.org/conference/hotos-ix/crash-only-software
15:03:00 <bslsk05> ​www.usenix.org: Crash-Only Software | USENIX
15:03:00 <mjg> lemme tell you what does not crash on oops: fucking arch desktops
15:03:00 <sortie> guideX: It is indeed important that errors are caught and brought to your attention and that you make it a priority to fix them
15:03:00 <heat> or if you have a debugger ready to attach
15:03:00 <mjg> and similar
15:04:00 <sortie> *that kernel bugs
15:04:00 <heat> i know
15:04:00 <guideX> sortie, yueah cause, I'm sure I'll just get lazy, and it'll get ridiculous
15:04:00 <guideX> like some excel spreadsheet importer I don't really care that much about xD
15:04:00 <mjg> there are very few problems one can merely reported
15:04:00 <mjg> report
15:04:00 <heat> idunno i rarely see crashdumps being shared around
15:04:00 <sortie> In osdev, it's important imo to do things right, always, and think ahead and design very good primitives for everything
15:05:00 <mjg> heat: that's because there is no culture to do it on linux
15:05:00 <sortie> But hey when you're getting started, have fun making things work, then clean up and improve incrementally
15:05:00 <mjg> most notably you would need to carve out a chunk of ram for kexec
15:05:00 <mjg> merely to support crashdumps
15:05:00 <sortie> how dare you I downloaded all of my ram
15:06:00 <mjg> meanwhile this is a mosty solved problem elsewhere: you have dedicated code which performs direct writes to swap
15:06:00 <heat> what's elsewhere?
15:06:00 <mjg> so there is no prep needed modulo a swap partition
15:07:00 <mjg> fucking SOLARIS even
15:07:00 <sortie> ~linux
15:07:00 <mjg> or any bsd
15:07:00 <mjg> you may not know this but before 2010 linux was not the only game in town
15:07:00 * sortie does not have a kernel debugger anymore in Sortix
15:07:00 <mjg> and the need to collect crash info was already there
15:07:00 <sortie> (it was too bad and I removed it)
15:07:00 <mjg> sortie: see i can give mild props to linux here, the crash debugger is quite ok
15:08:00 <heat> what happens if you need to write directly in the bad kernel, but the bad kernel is bad and re-crashes?
15:08:00 <mjg> in fact it contains features the solaris people tried to brag about in their own debugger
15:08:00 <sortie> Local Man Commends Linux Crash Debugger Experience
15:08:00 <heat> like, the crash kernel makes sense
15:08:00 <mjg> heat: thje writing code is isolated
15:08:00 <mjg> i have never seen a case where *that* also panicked
15:08:00 <mjg> but in that spirit what if kexec'ed kernel panics
15:08:00 <heat> doesn't matter, goes through a helluva common paths
15:08:00 <mjg> 's likem on
15:08:00 <mjg> no it does not, it's part of the point
15:08:00 <guideX> some kind of dumb scenarios A) when my kernel detects there's no keyboard or mouse, is that a hault? (I would suspect it would load the os without them) B) when the os code can't find the png file for the gui, halt? (I suspect I can use a generic image, and not hault, or just not load that icon and recover gracefully, currently it halts) C) when the kernel detects a null value in a variable (I presume halt)
15:09:00 <mjg> guideX: if your kernel does not need mouse nor keyboard, why would it halt
15:09:00 <GeDaMo> "Keyboard not found, press F1 to continue"
15:09:00 <guideX> mjg, it needs both
15:09:00 <mjg> i was gonna say that
15:09:00 <guideX> without that, it will just be useless
15:09:00 <zid> GeDaMo: F13 is my favourite
15:09:00 <mjg> the proper response to not fiding a keyboard is asking them to press F1 to continue anyway
15:09:00 <zid> it has a scancode I think?
15:10:00 <guideX> yes exactly, I scancode
15:10:00 <heat> mjg, swap - block - pci - irqs - nvme/ata/ahci/ide/usb/whatever. you dupe all of these pathen?
15:10:00 <GeDaMo> Probably something like Ctrl+Alt+F1
15:10:00 <mjg> heat: you wriet miniminal fucken' code to do a block write to it
15:10:00 <mjg> heat: probably not usb tho, but regular storage
15:11:00 <heat> idk, sounds a little sussen boss
15:11:00 <guideX> this is where I do usb scanning etc https://pastebin.com/raw/CKTx6UMj
15:11:00 <heat> but i'll believe you
15:11:00 <mjg> you mama is suss
15:11:00 <mjg> look mofo
15:11:00 <mjg> in serious deployments
15:11:00 <mjg> like actually serious
15:11:00 <heat> to me the crash kernel makes a lot of sense, even if you need to lose a little memory upfront
15:11:00 <mjg> where people debug
15:11:00 <mjg> they get crashdumps of some sort
15:12:00 <mjg> so happens in linux this requires reserving ram upfront for kexec
15:12:00 <mjg> and that cost is being paid
15:12:00 <mjg> the upshot is then you can do remote dumps and shit very easily
15:12:00 <guideX> that's another thing, I removed cosmos from my project and lost visual studio debugging xD
15:12:00 <mjg> bottom line tho
15:12:00 <guideX> I need to figure that out
15:12:00 <mjg> you don't continue after an oops
15:12:00 <guideX> yeah I think so too, it just dies imo
15:13:00 <mjg> apart from full crashdumpen freebsd for example has "textdumps", which i considered to be a nice middle man feature
15:13:00 <mjg> middle of the way, excuse me
15:13:00 <heat> middle management feature
15:13:00 <mjg> you get a bunch of commands from the debugger typed down, the dump is liek 1-2MB tops
15:13:00 <zid> GeDaMo: You live in midge-land, how are they this year?
15:13:00 <guideX> I take away the os, display the error on the screen and the user must reboot to continue
15:13:00 <mjg> and contains most of what you would normally want to check
15:14:00 <mjg> should you have sthousands of devices remotely this is a sensible thing to use for crash colleciton
15:14:00 <mjg> if you can't just roll with a full dump
15:14:00 <mjg> linux would probably like this as well
15:14:00 <GeDaMo> I haven't seen many but supposedly they are numerous and belligerent
15:15:00 <GeDaMo> https://www.smidgeup.com/midge-forecast/
15:15:00 <bslsk05> ​www.smidgeup.com: The Scottish Midge Forecast - Smidge
15:15:00 <zid> oh, like the rest of the inhabitants then
15:18:00 <zid> bloody picts
15:18:00 <heat> mjg, but if you don't have a crash kernel and you don't have a way to coredump externally, oops is your best bet
15:18:00 <mjg> heat: in linux as implemented at the moment, yes
15:18:00 <mjg> heat: but this is not an inherent property
15:18:00 <heat> the mere power of dmesg | nc termbin.com 9999 and getting the logs out of there is great
15:19:00 <heat> and *probably* works if things didn't go mega terribly wrong
15:19:00 <mjg> you do understand oops outoput does not necessarily contain what's needed to find out wtf
15:19:00 <heat> yes i do understand that
15:19:00 <mjg> trivial example, say you oopsed on being stuck somewhere, but you dont' know why you are stuck
15:20:00 <mjg> this can be improved, but afaics nobody is doing it
15:20:00 <mjg> cause people who really care already have kexec and full dumps
15:21:00 <heat> like, i know this isn't anywhere near a replacement for coredumps, but it's your best bet if you don't have them, and could very well help
15:21:00 <mjg> it is *something* for sure
15:21:00 <mjg> probably sufficinet when actively developing something
15:21:00 <mjg> as for end users it's so-so
15:22:00 <heat> on onyx i've been sufficiently screwed by panic messages scrolling out of sight :)
15:22:00 <mjg> that's another bug in a bug, freebsd has that too
15:22:00 <mjg> a de facto panic can be a series of printfs
15:22:00 <mjg> have several cpus hit that and the screen is spaghetti
15:23:00 <mjg> you probably want to increase the size of the magic console buffer
15:23:00 <heat> not just that but e.g i can't see a KASAN panic screen fully cuz of the sheer amount of info dumping i do
15:23:00 <mjg> and more importantly: recover it after reboot
15:24:00 <mjg> probalby not a thing the way you handle onyx at the moment tho
15:24:00 <mjg> well in that case you should be printing shit to a serial port
15:24:00 <mjg> and log that on the host
15:24:00 <heat> yeah i do recover logs after boot
15:24:00 <heat> reboot i mean
15:24:00 <guideX> do all these weird questions bother you guys? just checking, there's like thousands more xD
15:24:00 <guideX> trying to ask them only a few a little at a time xD
15:25:00 <guideX> the really important ones
15:25:00 <sham1> I think that if they were bothersome, people wouldn't answer
15:25:00 <heat> recovering it *used* to be really easy cuz i had a simple text buffer that didn't wrap like a proper ring buffer, now i should probably have a userspace program deal with it
15:26:00 <mjg> if you have a proper ring buffer you are set
15:26:00 <mjg> you find the original end
15:26:00 <mjg> add a 'booting mofo' message
15:26:00 <mjg> and start from there
15:26:00 <mjg> you can literally pick up as if nothing happened
15:26:00 <heat> oh *that* is not possible
15:26:00 <mjg> how so
15:27:00 <mjg> fbsd is doing that
15:27:00 <mjg> does your msgbuf wander around?
15:27:00 <heat> 1) printk buffer is in .bss 2) onyx does physical KASLR
15:27:00 <mjg> 8s
15:27:00 <mjg> well then serial port it
15:27:00 <heat> i use qemu and memsave it
16:01:00 <heat> mjg, do you know where people usually free the old thread struct/thread stack?
16:01:00 <nikolar> KERNAL
16:01:00 <heat> i'm thinking RCU here, i had a DPC thread but it sucks some ass
16:01:00 <heat> and RCU *sounds* like the perfect solution here
16:03:00 <heat> could also take the L and do it mid context switch but sounds terrible
16:03:00 <nikolar> Is there ever a situation where rcu isn't a good solution
16:08:00 <Matt|home> o\
16:13:00 <gog> it volates one of my core tenets
16:13:00 <gog> reading? totally cool. copying? always copy things you like
16:13:00 <gog> updating? no
16:14:00 <gog> never update
16:16:00 <mjg> heat: it's the context switch
16:16:00 <mjg> and it's bad too
16:16:00 <mjg> fucken spinlock in there
16:16:00 <mjg> (lol)
16:18:00 <heat> OH if debian is so stable why does it have read copy *update*???
16:18:00 <heat> mjg, so RCU batching sgty suggested-by: Mateusz Guzik?
16:19:00 <mjg> no suggestions
16:20:00 <mjg> 's all crapper
16:20:00 <heat> ok never free sgtm ok heat@
16:20:00 <mjg> there you go
16:20:00 <mjg> if you did not need the process why tf did you create it
16:20:00 <mjg> 111
16:22:00 <nikolar> Resource reclamation is overrated
16:23:00 <heat> amen
16:23:00 <heat> if free wasn't a thing you'd think twice before calling malloc
16:23:00 <heat> thus memory usage would go down
16:26:00 <nikolar> Indeed
16:26:00 <nikolar> Also can't use after free if you don't free
16:26:00 <Matt|home> https://i.ibb.co/pRdMLW1/IMG-1135.jpg <-- i feel like an l337 hax0r from hackers or swordfish or smth :D ima call myself... ...... infinityText >:D
16:27:00 <nikolar> Ew visual studio
16:28:00 <Matt|home> shush u, VS is great
16:28:00 <nikolar> No it ain't
16:28:00 <nikolar> msvc is the worst
16:28:00 * Matt|home pets nikolar
16:28:00 * nikolar gets confused
16:29:00 <Matt|home> so whats your major gripes with it?
16:29:00 <nikolar> For a start, it's a c++ compiler cosplaying as a c compiler
16:29:00 <Matt|home> also keep in mind, a fantastic reason for me to make this and qt my primary IDEs are cuz i get free 24/7 tech support with tme
16:29:00 <Matt|home> them*
16:30:00 <nikolar> How so
16:30:00 <heat> c++ has nothing to do with visual c being bad
16:30:00 <heat> well, mostly
16:30:00 <Matt|home> my sister is some kinda dev and it's her favorite editor of all time so if i ever have trouble with it i just ask her and she tells me what to do :D
16:30:00 <nikolar> Has she tried anything else :P
16:30:00 <heat> visual c is bad cuz they dgaf, because they're on the C++ copium
16:30:00 * Matt|home eyerolls
16:30:00 <heat> so it's somewhat culpable, but not really
16:31:00 <Matt|home> in all seriousness i've never run into a problem with VS before. VScode, yes (fuck linux)
16:31:00 <Matt|home> VS on MS, no
16:31:00 <heat> msvc is terrible for many other reasons though, even the C++ bits
16:31:00 <Matt|home> still waiting to hear those reasons :p
16:31:00 <Matt|home> oh vc, sry
16:31:00 <heat> codegen is garbage, features are miles off of gcc and clang
16:31:00 <nikolar> Agreed
16:31:00 <heat> warnings are shit, default warnings are shit and annoying
16:32:00 <nikolar> > VScode, yes (fuck linux)
16:32:00 <Matt|home> im using visual -studio- . that's different from vs code right?
16:32:00 <nikolar> What's Linux got to do with that
16:32:00 <Matt|home> e.g. vc
16:32:00 <Matt|home> i don't wanna get into it, too long of a story and i've already spent hours ranting
16:32:00 <heat> vc is visual c
16:32:00 <heat> it's visual studio's compiler
16:32:00 <Matt|home> never used it
16:32:00 <heat> yes you did
16:32:00 <nikolar> Lol i meant what does vs code sucking have to do with Linux
16:32:00 <Matt|home> ah
16:32:00 <Matt|home> wait a minute. im 99% sure im using gcc, lemme check
16:33:00 <nikolar> In vs?
16:33:00 <heat> modern vs does support clang-cl at least, so there's that
16:33:00 <nikolar> Lel
16:33:00 <Matt|home> yeah i dunno where to find what compiler it's using rn
16:33:00 <heat> also technically linux gcc(?) development. no idea how
16:33:00 <Matt|home> i know you can change settings, e.g. it was extremely easy to switch from whatever version i was using to C++17 , so im assuming it's trivial to switch compilers as well
16:33:00 <heat> lol no
16:34:00 <nikolar> In uni, when we were using c in a class, their recommendation was to download a 10gb visual studio install just to use a c compiler
16:34:00 <nikolar> Which is very silly
16:34:00 <heat> meh
16:34:00 <heat> visual studio is the friendliest approach to C
16:34:00 <nikolar> Matt|home: it's very much not easy
16:34:00 <Matt|home> anyhoo i gotta get back to work, i wanna at least get a working commandline interface going before i get stoned today
16:35:00 <heat> keep this in mind: most uni tutorials say "just do gcc main.c -o program" which misses the whole of everything good about these compilers
16:35:00 * Matt|home packs a bowl lights it and passes it around
16:35:00 <nikolar> heat: well we didn't get anywhere close to that
16:35:00 <heat> C without warnings is absolutely unusable by hoomans
16:36:00 <nikolar> My uni is for some reason allergic to the command line, I swear, most of the other students wouldn't know how to write and execute a line of code if there wasn't a big play button in front of them
16:37:00 <heat> well if not for the command line, your alternative would be... codeblocks? fuck that lol.
16:37:00 <heat> clion but that's too modern
16:37:00 <heat> (and equally humungous)
16:38:00 <nikolar> Command line for the win
16:41:00 <nikolar> My friend once asked how to do something in the command line, instead of through eclipse, and the instructor's response was like, why'd you want to use the command line, that's outdated and no one's using it anymore
16:41:00 <nikolar> Lel
16:44:00 <gog> hi
16:44:00 <nikolar> ou
16:45:00 * Matt|home tackles & snuggles gog
16:45:00 <Matt|home> <3
16:45:00 <gog> o:
16:45:00 <nikolar> Thought you left to do something productive :P
16:45:00 <gog> i'm doing nothing productive today
16:45:00 <Matt|home> yeh but im still sitting in front of the monitor
16:45:00 <gog> that's not true though i cleaned a little
16:46:00 <gog> i don't wnat to clean though i'm tired of being the one who cleans
16:47:00 <Matt|home> hm. not sure how im supposed to do this. i need this function to return either an integer _or_ a memory address. that's annoying. (don't help me im just talking out loud)
16:47:00 <zid> hire a filipino maid in a short skirt
16:48:00 <zid> I can't afford it so I just get nikolar to wear it
16:48:00 <nikolar> Good luck with that
16:48:00 <Matt|home> i guess i could just have it return NULL in case of error, but i like the idea of returning 0 on success
17:27:00 <Matt|home> hm. why isn't this working
17:31:00 <nikolar> what isn't
17:37:00 <Matt|home> https://i.ibb.co/RHdrNnQ/Screenshot-6.png <-- don't help me
17:42:00 <nikolar> i thonk i have an idea
17:42:00 <nikolar> it's c++
17:42:00 <nikolar> :P
17:51:00 <Matt|home> no i know what the problem is, im just bad at coding. i'll fix it
17:54:00 <Matt|home> yeah im putting this on pause, i'll wait til the evening to take another crack at it
17:54:00 * Matt|home grabs his vape and packs another bowl
18:03:00 <dinkelhacker> nikolar: at least c++ doesn't require you to dislocate your arm to get a raw pointer to a mutable... like Rust does :D
18:03:00 <nikolar> lel good point
18:05:00 <Matt|home> i really, really, _really_ don't understand the syntax for this and i've read like six different books.. grrr....
18:05:00 <dinkelhacker> syntax for what?
18:05:00 <nikolar> what for exactly
18:06:00 <Matt|home> constructors and initializers. im very very shaky with the terminology too. working on it
18:06:00 <GeDaMo> Matt|home: did you see EdFletcher's suggestion in ##programming ?
18:06:00 <Matt|home> im reading. im reading, im just whining
18:07:00 <dinkelhacker> ah you're talking about c++... nobody understands it because there are 200 ways of doing the same thing.
18:07:00 <nikolar> just write c :P
18:07:00 <Matt|home> this is a front end pretty GUI program im writing, im not doing it in C <3
18:07:00 <dinkelhacker> the solution to all C++ problems... just don't :D
18:07:00 <Matt|home> i'd rather chop my balls off
18:08:00 <nikolar> dinkelhacker: lel
18:08:00 <Matt|home> so.... do i wait for my sister to wake up or do i proceed on my own..
18:08:00 <nikolar> Matt|home: that's hardly productive
18:08:00 <Matt|home> pfffft. GeDaMo any chance i could pm ? if not it's fine
18:09:00 <GeDaMo> Matt|home: OK
19:14:00 <puffer> sup
19:16:00 <nikolar> Lol
21:24:00 <Cesarww> hi, im trying to use limine_terminal_request function to make a print function but it gives this error: ``` error: expected unqualified-id before ‘.’ token
21:24:00 <Cesarww>    65 | limine_terminal_request.response->write(terminal, str, strlen(str));
21:24:00 <Cesarww>  ```
22:31:00 * Ermine witnessed normie choosing krita for drawing
22:51:00 <heat> Ermine, wasn't krita actually ok? idk
22:58:00 <heat> Ermine, btw, check this shit out: https://lore.kernel.org/all/ZpkKwfESyr91ekco@freedom.csh.rit.edu/
22:58:00 <bslsk05> ​lore.kernel.org: Re: [PATCH 1/3] mm: vmalloc: export __vmalloc_node_range - Mary Strodl