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=22&m=1&d=6

Thursday, 6 January 2022

00:05:00 <kazinsal> https://twitter.com/mjos_crypto/status/1478690108274524162
00:05:00 <bslsk05> ​twitter: <mjos_crypto> Gosh, VAX assembly was amazing (I blame @thingskatedid for looking at this). Here's opcode 38, EDITPC. Yes, it's a single opcode. https://pbs.twimg.com/media/FIVcNjXXEAIWPln.png https://pbs.twimg.com/media/FIVcWKoX0AEijsU.png https://pbs.twimg.com/media/FIVcZ9PXEAM_Qke.png https://pbs.twimg.com/media/FIVccJTXwAIDOfu.png
00:06:00 <kazinsal> "You know what we need? An opcode to implement sed."
00:09:00 <bauen1> kazinsal: so is there even a VAX opcode that isn't turing complete
00:10:00 <kazinsal> honestly the VAX ISA is one of the most amazing things
00:10:00 <kazinsal> it really is the peak of CISC
00:11:00 <kazinsal> the PDP-11 ISA was already CISC as hell but VAX pushed that in some fascinating new directions
00:13:00 <kazinsal> people love to point at x86 and go THIS IS WHY WE NEEDED TO REINVENT NICE THINGS but there's some absolutely phenomenally complex things in the VAX ARM
00:16:00 <kazinsal> variable length bitfield instructions are neat though not gonna lie
00:18:00 <programmar> has anyone here ever faced the situation that live usb doesn't detect internal drive through fdisk ?
00:22:00 <kazinsal> nope. try parted?
00:29:00 <programmar> yep, also not detected
00:29:00 <programmar> so weird
01:39:00 <geist> huh https://gcc.godbolt.org/z/zz754Mnqc is kinda strange
01:40:00 <geist> the inner loop there where it's called val() on the object, looks like it's the same address
01:40:00 <geist> ie, since the object has no fields it's decided to not actually do a VLA on the stack, and store a bunch of overlapping objects at the same address
01:41:00 <geist> so it loads into x0 (this pointer for val()) the same address for each of the elements in the array
01:41:00 <geist> so i thought classes couldn't be 0 bytes long and there'd be a minimum 1 byte sizeof()
01:43:00 <geist> of course if you add anything to the class to make it nonzero bytes the codegen is different and it actually does a VLA by bumping the SP down a variable amount, etc
01:51:00 <geist> kazinsal: also interesting that editpc instruction must have been there early on since it has a one byte opcode 0x38
01:52:00 <geist> someone on the thread mentions it was written for COBOL. probably directly maps to something there
04:41:00 <Jari--> morning
04:42:00 <Jari--> Is there a command like Global Memory Copy in Linux?
04:42:00 <Jari--> You can through a system call copy a memory region from PID to PID ?
04:43:00 <Jari--> But now thinking, that's a bit risky.
04:43:00 <moon-child> well, there's shared memory
04:43:00 <moon-child> there is also mremap
04:43:00 <moon-child> and I think macos has a thing to 'copy' huge chunks of memory by abusing vm
04:44:00 <moon-child> but not sure exactly what you're looking for
04:57:00 <Jari--> moon-child: looking for ways you can do kernel - application communication
04:57:00 <Jari--> Messages good?
04:58:00 <Jari--> I managed to do pretty awesome things with IPC InterProcess Communication. Like postman service. Basically it provided disk access, video, audio, etc. Those services for applications.
04:58:00 <klange> What do you want to communicate? Most OSes, Linux included, offer many different options for different scenarios. If sharing large blocks of memory is your goal, then you want... shared memory.
04:58:00 <zid> sockets for life
04:58:00 <Jari--> klange: so shared memory is same for all applications, or it is multiplied and many areas depending on PID ?
05:00:00 <geist> yah direct access to another address space is a security nightmare
05:02:00 <klange> Shared memory usually works by having some handle to a particular "object". There's a few different approaches even within Linux. You can map to a file that may or may not exist, you can use the POSIX shm_open stuff which has its own namespace, you can have anonymous shared mappings that you pass around through a different IPC mechanism...
05:05:00 <heat> I was reading the log from windows and I booted into Linux just to say that Linux does have syscalls to read and write from/to another process, process_vm_readv(2) and process_vm_writev(2)
05:06:00 <zid> ReadProcessMemory not good enough for you? smh
05:07:00 <heat> ReadProcessMemory is for cheat devs
05:07:00 <zid> ...more or less :p
05:07:00 <geist> we actually have somethin exactly like that in zircon but we're actively trying to removei t
05:07:00 <heat> process_vm_readv is for le epic linux developer chad
05:07:00 <zid> The trick to inject code into a process in windows still amuses me
05:07:00 <geist> used almost exclusively by debuggers
05:08:00 <geist> key is with some sort of capability like system it's at least a little nicer, because you have to be able to get ahold of the handle to the process in the first place
05:08:00 <klange> ptrace offers that but the standardized version is poorly defined because it only specifies transfers in "words".
05:08:00 <geist> NT included
05:08:00 <moon-child> geist: didn't you tell me such a process can be used to recover from faults?
05:08:00 <moon-child> LIES
05:09:00 <moon-child> (thread x dies; thread y gets spawned and told about it, and sets new ip for thread x?)
05:09:00 <heat> ptrace is garbage and that's a fact
05:09:00 <heat> every unix-like system has a different flavor of ptrace
05:09:00 <klange> https://github.com/klange/toaruos/blob/master/apps/dbg.c#L101
05:09:00 <bslsk05> ​github.com: toaruos/dbg.c at master · klange/toaruos · GitHub
05:10:00 <klange> my debugger is... fun
05:12:00 <heat> i haven't decided if I'm going to stick with a ptrace approach, make up new syscalls, or imitate another unix's ptrace
05:13:00 <heat> but I do need debugging, a lot
05:13:00 <heat> its gotten so non-trivial to debug any kind of userspace program that I spend most of my time trying to point GDB to the right things
05:18:00 <klange> yeah, having a hosted userspace debugger helped with a lot of stuff, like debugging some issues while I was redesigin my desktop panel
05:20:00 <heat> i was thinking about actually porting gdb or lldb
05:20:00 <heat> or at least the gdbserver part
05:22:00 <heat> then I could also ditch my ptraceless half-assed strace for the upstream strace
05:22:00 <heat> or at least I could modify it so its less half-assed
05:23:00 <klange> strace is what I implemented a ptrace for: https://github.com/klange/toaruos/blob/master/apps/strace.c
05:23:00 <bslsk05> ​github.com: toaruos/strace.c at master · klange/toaruos · GitHub
05:24:00 <heat> yup
05:25:00 <heat> what I did instead was that I just implemented a process event system and I got my syscall enter and exit from there
05:25:00 <heat> no way to read the other process' address space though (so things like reading any sort of userspace pointers are a no-go)
05:26:00 <zid> I just leave a few exploits laying around, read whatever process' memory you like, just don't involve me for support
05:28:00 <heat> klange, what does your ptrace do in regard to threads?
05:28:00 <klange> nothing, but I was going to add FOLLOW flags eventually, I just didn't get around to it
05:36:00 <klange> actual ptracery is mostly here: https://github.com/klange/toaruos/blob/master/kernel/sys/ptrace.c
05:36:00 <bslsk05> ​github.com: toaruos/ptrace.c at master · klange/toaruos · GitHub
05:36:00 <klange> with some hooks in places like: https://github.com/klange/toaruos/blob/master/kernel/sys/syscall.c#L1156
05:36:00 <bslsk05> ​github.com: toaruos/syscall.c at master · klange/toaruos · GitHub
05:39:00 <heat> https://github.com/klange/toaruos/blob/master/kernel/sys/ptrace.c#L138 <-- doesn't that break COW?
05:39:00 <bslsk05> ​github.com: toaruos/ptrace.c at master · klange/toaruos · GitHub
05:40:00 <klange> no, the poke will fail because there's a writable check before that
05:43:00 <klange> so maybe more the inverse, COW may break it if the process itself didn't do the write; and I guess there's also a toctou bug waiting to happen, but... whatever, don't care any more
05:44:00 <heat> I kind of like how the freebsd ptrace works (PT_ATTACH attaches to everything, then you can see what thread caused the stop)
05:45:00 <heat> I also like the linux ptrace but it doesn't really fit into my thread model
05:45:00 <heat> PTRACE_ATTACH attaches to a pid, so a single thread if its multithreaded
05:46:00 <heat> apparently a thread can't attach to one of its process' threads, according to llvm
05:47:00 <heat> so the issue I was imagining with the freebsd approach isn't really there
05:47:00 <heat> compiler-rt & libsanitizer have a need for a StopTheWorld function (which I currently don't have implemented) so I kind of need to think about that
05:48:00 <heat> but I guess either the Linux or the FreeBSD approach would require a fork()
05:48:00 <heat> *both
05:48:00 <klange> I didn't really put all that much thought into it, I just wanted to get something banged out to demonstrate the concept.
05:49:00 <heat> (for linux they don't fork but do a clone(2) with a shared address space to avoid any sort of COW but I'm not really into that)
06:29:00 <zid> https://pbs.twimg.com/media/FIURvjXWQAAJ1II?format=png&name=large
07:43:00 <sham1> Not incorrect. I'm impressed
09:53:00 <junon> Hi everyone, hopefully everyone had a good near years :)
09:53:00 <junon> new*
09:54:00 <junon> This question probably oversimplifies things and I know the answer will probably be "benchmark it of course" but it's worth asking anyway: is a page fault going to be faster than a sysenter?
09:56:00 <Mutabah> Unlikely
09:56:00 <Mutabah> Very unlikely
09:56:00 <Mutabah> syscall/sysenter are designed to be fast
09:57:00 <zid> a page fault effectively *is* a sysenter
09:57:00 <Mutabah> The CPU pipeline can see the transition coming, and can mostly predict around it
09:57:00 <zid> it has to do all the same things, but now you have to deal with the page fault too
09:57:00 <Mutabah> While a page fault is unexpected
09:58:00 <clever> Mutabah: and why cant the cpu predict the fault, because its doing load several opcodes ahead, as part of normal prefetch logic?
09:59:00 <clever> it could even be pre-loading the TLB for a store, before it knows if its going to commit or not
09:59:00 <zid> I don't think it predicts either
09:59:00 <clever> before the data is even known, it could have pre-converted the virt->phys, and posibly set a
10:00:00 <clever> "will page fault" flag on the opcode
10:00:00 <Mutabah> Eh, it can probably know it'll PF...
10:00:00 <zid> but a page fault means invoking the OS' page fault code, which is going to be pretty heavy in most OSs
10:00:00 <Mutabah> not 100% sure, but I don't think syscall is serialising?
10:00:00 <zid> they both do a ring switch
10:00:00 <Mutabah> a PF quite likely is
10:00:00 <clever> zid: i think the question is ignoring whatever the os is doing, and asking purely about how quickly the cpu core can switch states
10:01:00 <junon> ^ correct
10:01:00 <junon> This is before OS logic.
10:01:00 <junon> I'm actually more curious if the PF will be slower than a sysenter.
10:01:00 <junon> Should have worded it that way.
10:01:00 <junon> I was optimistic in thinking it'd be faster.
10:01:00 <junon> But speculation would lead me to believe it's about the same.
10:02:00 <clever> things like spectre also show that page faulting doesnt always work right
10:02:00 <clever> basically, its ignoring the permission flags, when pre-fetching data, and acting on it
10:03:00 <clever> the real result will never be visible in a register, and it would have faulted if you got that far
10:03:00 <clever> but the side-effects (loading cache lines) still happen
10:03:00 <zid> I would *expect* a PF to be slower
10:04:00 <zid> unless you fault injected the PF in which case it's at *best* the same speed
10:04:00 <zid> The PF still has more cpu logic to do
10:04:00 * clever heads off to bed
10:04:00 <junon> Thanks for the info clever, sleep well :)
10:04:00 <junon> hmm okay.
10:05:00 <junon> what do you mean by fault injected here?
10:05:00 <junon> you mean artificially raise a PF?
10:06:00 <junon> anyway if that's the case, then wouldn't manual page management via syscalls on a mmap'ed region (e.g. from the fs) be faster than relying on page faults upon reads/writes?
10:07:00 <junon> of course way more work on the application's end, but a slight performance improvement if there's a critical path, right?
10:07:00 <junon> Or is page swapping doing something more clever than using PF?
10:11:00 <zid> The speedup is because almost all anonymous mapped regions never get touched
10:12:00 <zid> the pf is also a small part of the latency on that
10:12:00 <zid> the major part is the actual allocation, page table modifications, etc
10:13:00 <junon> gotcha so it's not so drastic compared to a sysenter that it's observably different in terms of performance
10:13:00 <junon> corollary, it's outweighed by the rest of the collective operation
10:14:00 <junon> If PFs aren't reliable though, that means mmaped pages also aren't reliable, right?
10:14:00 <zid> pardon
10:15:00 <junon> > things like spectre also show that page faulting doesnt always work right
10:15:00 <zid> it always works correctly
10:15:00 <junon> oh
10:15:00 <zid> spectre was a side channel attack by measuring the *timing* of things, to measure the state the OS internals were in
10:16:00 <zid> specifically, the branch predictor of the cpu was what was being timed
10:16:00 <zid> Ever seen one of those scenes in a movie where they crack the password one character at a time with tense music? that's what spectre was.
10:16:00 <junon> hahah
10:17:00 <zid> Rather than having to guess every byte at once, it let you measure if things were happening 'too quickly' which meant the OS knew a thing you weren't supposed to
10:17:00 <zid> and grab each byte
10:17:00 <junon> gotcha okay
10:17:00 <junon> this is good info, thanks.
10:18:00 <junon> I'm drafting up a unidirectional IPC port design without syscalls for a microkernel. I'm heeding your (collective) advice and targeting amd64 first.
10:18:00 <zid> yea just send IPIs with the lapics, done
10:18:00 <zid> then cry because it's shit and slow ;)
10:19:00 <junon> In this case there won't be IPIs. A port will be owned by a single processor.
10:19:00 <junon> Well, at a time.
10:19:00 <zid> 'port'
10:19:00 <zid> define port
10:19:00 <junon> I want to investigate using INVLPG.
10:19:00 <junon> Logical IPC channel.
10:20:00 <junon> has nothing to do with CPU ports or networking.
10:20:00 <zid> there's a logical ipc channel the hw supports natively, called IPI
10:20:00 <junon> I understand, I don't want to use that.
10:20:00 <moon-child> junon: hmm so how do you do it? ring buffers?
10:21:00 <moon-child> what if you wanna wait?
10:21:00 <junon> This is on top of any single particular CPU feature. It's a ring buffer design.
10:21:00 <zid> how do you intend to snoop the cache invalidation protocol from the software side of a cpu? afaik there's no exposure
10:21:00 <junon> moon-child: yep
10:21:00 <bradd> can I access the serial port from uefi boot services?
10:21:00 <zid> well nothing is stopping you
10:21:00 <bradd> (by using ports)
10:21:00 <moon-child> junon: so what if I wanna wait?
10:22:00 <junon> moon-child: working out the details at the moment but the idea is that if the reader reads from the head but the writer hasn't committed, the #PF will schedule the task for resumption (is that a word?) when the writer has done so
10:22:00 <junon> in a highly async application, they can check the head/tail cursors directly and reap those benefits
10:22:00 <zid> the pf will hit *your* cpu, btw
10:22:00 <junon> right yep
10:22:00 <junon> the pf is just a signal to the scheduler.
10:22:00 <zid> so the question is still how you do the IPC
10:22:00 <moon-child> how do you figure out when the writer writes?
10:22:00 <moon-child> pay a page fault there too?
10:23:00 <junon> if the channel is synchronous yes.
10:23:00 <moon-child> bah! Not terrible but I don't like it :)
10:23:00 <zid> still needs a way to actually do the IPC..
10:23:00 <junon> However both ends are of course allowed to be async and spin on the head/tail cursors
10:24:00 <junon> zid: there's a ring buffer of messages
10:24:00 <zid> when do I check it?
10:25:00 <junon> either in a poll loop (async) or you simply read the next slot and pay the #PF, which will schedule you to resume when the writer writes something (or a new slot opens up, if you're backpressured)
10:25:00 <junon> the latter behavior is synchronous
10:25:00 <zid> so completely manually?
10:25:00 <junon> what do you mean
10:25:00 <zid> while(1); I just crashed your entire OS?
10:25:00 <junon> no?
10:25:00 <junon> does while(1) crash any other pre-emptive OS?
10:26:00 <zid> process calculates pi, it's now completely locked up and cannot be talked to no matter what?
10:26:00 <junon> unless it's preempted.
10:26:00 <junon> I don't see that as having anything to do with the IPC mechanism though.
10:27:00 <junon> If an application doesn't consume messages from a port of course it'll backpressure
10:27:00 <zid> I'll stick with signals
10:27:00 <junon> okay
10:27:00 <zid> and I still don't know what your actual mechanism is
10:27:00 <zid> to do the real IPC
10:27:00 <junon> zid: ring buffers and clever scheduling
10:27:00 <zid> so, shared memory?
10:27:00 <junon> yes
10:28:00 <zid> you're going to eat a bunch of data structure walks in that code btw
10:28:00 <zid> as you figure out what the fault was and why
10:28:00 <junon> Perhaps but that would happen with a syscall too.
10:29:00 <zid> no because the syscall is always caused by syscall
10:29:00 <zid> the PF is caused by *someone* at *some* address for *some* reason
10:29:00 <junon> True
10:29:00 <zid> you have to figure those three things out for every PF
10:29:00 <junon> Yes but the address isn't arbitrary
10:29:00 <moon-child> the overhead of the syscall/pagefault is gonna be quite significant anyway
10:29:00 <moon-child> so I wouldn't worry about it
10:29:00 <moon-child> and anyway hash tables are fast
10:29:00 <junon> the vmem layout would have a bounds
10:29:00 <junon> especially since the ports are static.
10:29:00 <zid> is this a paged memory fault? a user->kernel fault so the app needs to crash, kernel->kernel so the kernel needs to crash? etc etc
10:30:00 <junon> they're defined prior to execution, in a metadata section
10:30:00 <junon> zid: what do you mean
10:30:00 <junon> paging is enabled in this case
10:30:00 <zid> the pf handler is super generic, there's a lot of logic to turn it into an actual decision about what to do, first
10:31:00 <junon> yes - the first of which is to fetch the current task structure and check if the address is within the IPC region bounds
10:31:00 <junon> since those are known upfront and will not change.
10:31:00 <junon> (for now)
10:31:00 <junon> so it's a simple bounds check.
10:32:00 <zid> on every PF
10:32:00 <junon> yes
10:32:00 <zid> so it also slows down swap and everything else, something to note
10:32:00 <junon> yes, fair.
10:32:00 <junon> Might be worth checking swap first.
10:32:00 <zid> but now your IPC is slow :p
10:32:00 <junon> The synchronous mode isn't meant to be fast per se, but to be a sane default.
10:32:00 <junon> zid: only if the IPC is operating in synchronous mode.
10:33:00 <junon> if you're polling head/tail cursors then there is no #PF in a well formed application.
10:33:00 <zid> oh so they're just slow in general :P
10:33:00 <junon> why would that be slow
10:33:00 <zid> none of my apps have to poll
10:33:00 <junon> okay
10:33:00 <junon> many do
10:34:00 <junon> it's the basis for io_uring
10:34:00 <junon> so high throughput applications use this mechanism
10:34:00 <junon> can use*
10:34:00 <zid> it's just santioned shared memory, afterall
10:34:00 <junon> there's absolutely no kernel involvement in such a case
10:34:00 <junon> so it's opt-in performance gain
10:34:00 <zid> shared memory is pretty normal
10:34:00 <junon> yes
10:35:00 * moon-child still wants language-oriented sasos
10:35:00 <junon> the fallback case is when you try to read/write to a slot that isn't current available, either via backpressure (upon a write) or a drain (upon a read) in which a #pf occurs
10:35:00 <moon-child> there's no reason ipc should only be free for async
10:35:00 <junon> and thus you're pre-empting yourself
10:35:00 <junon> moon-child: in sync you're still paying a syscall
10:35:00 <junon> otherwise how do you signal to another task that something is available
10:35:00 <moon-child> not if you run everything in a single address space you don't
10:36:00 <junon> moon-child: that's a non-starter in this case, it's a paged OS.
10:36:00 <junon> also I don't see how a SAS system would facilitate automatic synchronous IPC?
10:36:00 <moon-child> can still do paging. But you have one vm map for everyone
10:37:00 <moon-child> but switchign between processes has about as much overhead as switching between coroutines on a traditional os
10:38:00 <junon> but on a SAS you lose memory protection between tasks, right?
10:39:00 <moon-child> yes
10:39:00 <moon-child> hence 'language-oriented'
10:39:00 <moon-child> do your protectio in software
10:39:00 <junon> that's if you trust the other processes running on the machine
10:39:00 <junon> in my case, I do not
10:39:00 <GeDaMo> The whole system is written in a language which enforces protection
10:39:00 <moon-child> ^
10:40:00 <junon> ah I see
10:40:00 <junon> even against malicious actors?
10:40:00 <moon-child> depends on the quality of your compiler
10:40:00 <moon-child> I have a half-written response to the same question on reddit so I'ma finish that and then link it
10:40:00 <junon> but I can craft a binary that sidesteps the compiler?
10:40:00 <GeDaMo> How?
10:40:00 <moon-child> GeDaMo: buggy compiler
10:41:00 <moon-child> js jits are all buggy
10:41:00 <junon> oh the payloads are running in a VM?
10:41:00 <GeDaMo> There can also be hardware bugs which sidestep protection
10:41:00 <junon> that's different then. I thought you meant like a language that compiles to machine code
10:41:00 <moon-child> yes, language that compiles to machine code
10:41:00 <GeDaMo> It can still compile to machine code but with strict limits
10:41:00 <junon> and how do you enforce those limits if not at the CPU level?
10:42:00 <GeDaMo> At the compiler level
10:42:00 <junon> aside from trusting the code itself to play nicely
10:42:00 <moon-child> take js as an example. Js is not _capable_ of expressing memory-unsafe code
10:42:00 <moon-child> and js is compiled to machine code
10:42:00 <moon-child> hence, a faithful rendition of a js program in machine code _can not_ be memory-unsafe
10:42:00 <junon> but I can sidestep the compiler
10:42:00 <GeDaMo> How?
10:42:00 <moon-child> how?
10:42:00 <junon> unless you're literally compiling the code on each run
10:42:00 <junon> locally
10:42:00 <moon-child> well, you can cache it
10:43:00 <junon> moon-child: JS is at best JIT'd. That's not compilation to a machine code executable.
10:43:00 <moon-child> that's transparent from a user's perspective. But the system refuses to run code it didn't compile itself
10:43:00 <junon> so you're performing compilation ad-hoc on the local machine, then?
10:44:00 <moon-child> yes
10:44:00 <junon> okay, that's the missing piece of info lol
10:44:00 <junon> sure, if you control all aspects of codegen on your machine then you can do whatever you want
10:44:00 <moon-child> you may compile from an intermediate representation (cf jvm bytecode), which will go much faster
10:44:00 <junon> that's not my case for the IPC and thus I have to have memory protection and thus can't do SAS etc.
10:44:00 <junon> Neat idea though :)
10:44:00 <moon-child> so you are binary-compatible with an existing os?
10:45:00 <junon> moon-child: nope
10:46:00 <junon> maybe in the future I'll support something like syscall emulation modes since so far no syscalls are needed to interact with the system (on paper).
10:46:00 <junon> but that's just wishful thinking.
10:46:00 <moon-child> then why can you not force all programs targeting your os to be distributed in a memory-safe format?
10:47:00 <junon> Because that limits languages that can be used.
10:48:00 <junon> An explicit non-goal.
10:48:00 <moon-child> ok
10:48:00 <moon-child> (imo it is irresponsible to write in memory-unsafe languages. But I am still writing in c soooo I can't really say anything :P)
10:48:00 <junon> I think it also increases surface area
10:48:00 <junon> for exploits and whatnot.
10:49:00 <moon-child> I have a compelling argument against that
10:49:00 <moon-child> copy-pasting from the reddit comment:
10:49:00 <junon> If another CPU vulnerability comes out at least it'll have a much higher mitigation priority since it affects nearly everyone. The same cannot be said for a proprietary engine.
10:49:00 <moon-child> Given pervasive, expressive IPC (borne, of course, by the language-oriented SASOS), how much more likely will application developers be to architect their applications as clusters of communicating processes, each of which may have its own capabilities? Original post asked about microkernels. Currently, such designes are pursued only by the extreme (I mentioned djb) because they are slow, clunky,
10:49:00 <moon-child> and annoying. (Surprise, surprise: unix failed, pipes suck. And erlang was a great success.)
10:50:00 <sham1> "pipes suck" that's brave
10:50:00 <junon> Erlang is successful because of its abstractions.
10:50:00 <junon> I very much disagree with "pipes suck"
10:50:00 <moon-child> pipes are completely void of inherent structure
10:50:00 <junon> They alone improved performance in a number of dist-sys designs.
10:50:00 <moon-child> any that you project onto them must be completely ad-hoc
10:51:00 <kazinsal> erlang is successful because it was used to develop massively successful infrastructure when it was a proprietary language
10:51:00 <moon-child> and they necessitate copying
10:51:00 <sham1> moon-child: I'd also argue that it's their strength
10:51:00 <geist> well, no because they are void of structure doesn't make them intrinsically bad
10:51:00 <moon-child> so they do not scale. That's why shared memory exists
10:51:00 <sham1> That you *can* project your own structure on them
10:51:00 <geist> ipc and shared mem can work together
10:51:00 <junon> moon-child: then by proxy UNIX sucks, because pipes were one of the first things put into UNIX and strictly follow the "everything is a file" philosophy.
10:51:00 <moon-child> yes, unix socks
10:52:00 <geist> hard to have a solid pro-con discussion when people start throwing out thigs like * sucks
10:52:00 <kazinsal> all computers suck. sand was not meant to think
10:52:00 <GeDaMo> Yes, asterisks suck! :P
10:52:00 <moon-child> geist: fair enough
10:52:00 <geist> yeah it quickly devolves to repeat ad adfinium
10:52:00 <junon> I think that's a rather broad dismissal of unix...
10:52:00 <junon> also, hi geist
10:53:00 <geist> hola
10:53:00 <moon-child> 'That you *can* project your own structure on them' that is a valid argument. I think that there is definitely value in common data structures, but that pipes just don't give you enough to work with
10:53:00 <GeDaMo> Do kids still say things "suck" or is that just old people projecting? :P
10:53:00 <moon-child> and would contrast them with apl's multi-dimensional arrays, which _do_ have enough structure (imo) to be useful
10:53:00 <junon> they do
10:54:00 <geist> they probably compare them to a can of beans
10:54:00 <geist> and yell PETER
10:54:00 <geist> gen z humor is on some other plane
10:54:00 <junon> ayo unix pipes aint it no cap
10:54:00 * junon dabs ironically
10:55:00 <GeDaMo> I still don't know what "dabbing" is :|
10:55:00 <kazinsal> despite only being a couple years older than the oldest zoomers I do not understand like 90% of what people younger than me post on the internet
10:55:00 <geist> is that the hand motion with one hand pointing up?
10:55:00 <moon-child> another criticism I have of unix is that it is stratified. The compiler is a file, and the executables it generates are files; but the internal data structures that the compiler uses are not files, and it would be impractical to write a compiler that did use files. Contrast with lisp, where the compiler is a first-class object, the code it compiles is a first-class object, and the internal data
10:55:00 <moon-child> structures it uses are also first-class objects
10:55:00 <junon> https://thumbs.dreamstime.com/b/african-guy-performing-dabbing-dance-isolated-grey-studio-background-makes-dab-perform-move-point-one-arm-towards-aside-168447456.jpg
10:55:00 <junon> doing this pose, usually in very quick succession
10:55:00 <sham1> I mean, pipes allow me to do something like this: tar -czf - file1 file2 fileN | ssh target-machine 'cat > backup.tar.gz' and other such assorted tricks. Of course you'd actually use rsync for this, but think about it. Pipes and SSH and such are these dumb things that you can only carry bytes through
10:55:00 <junon> borne out of a rap video. was cool for about 10 minutes then it's done ironically now
10:56:00 <GeDaMo> That looks like he's sneezing into his shoulder :|
10:56:00 <sham1> moon-child: I'd say that Smalltalk does thateven more
10:56:00 <junon> GeDaMo: aha, that's applying logic to a pop trend. don't do that.
10:56:00 <kazinsal> gen z twitter is like, Weird Twitter filtered through a combined haze of anxiety, neo-cold-war-existentialism, and research chemicals
10:56:00 <moon-child> sham1: smalltalk is cool, though I have not used it so I can not say anything about it
10:56:00 <geist> dlang. dicuss.
10:56:00 <junon> geist: great idea, poor execution
10:57:00 <junon> not terrible, just poor
10:57:00 <sham1> I like the GC idea
10:57:00 <sham1> But other than that, D is a bit too C++ for me
10:57:00 <moon-child> geist: good implementation of c++, but why would you want any implementation of c++ at all?
10:57:00 <geist> yah i honestly have no opinion, but someone was asking me about it today
10:57:00 <kazinsal> great idea but by the time it was potentially a thing that could have caught on mozilla showed up with rust
10:57:00 <geist> yah i assume rust has sucked whatever air out of that room
10:58:00 <junon> D was way before Rust FWIW
10:58:00 <moon-child> I don't like rust. Affine types are counterproductive imo
10:58:00 <junon> but the D maintainers held some philosophies and made some breaking changes that pissed a lot of its community off.
10:58:00 <junon> That's a crude history in a nutshell.
10:58:00 <moon-child> junon: yeah but it wasn't completely opensource until more recently
10:58:00 <kazinsal> yeah but people didn't really seem to *want* that kind of safe multi-paradigm systems programming language until whenever it was rust showed up
10:58:00 <geist> i'm not sure they want it now but they're being mindwashed into thinking so
10:58:00 * geist dabs
10:58:00 <kazinsal> boom
10:59:00 <junon> haha
10:59:00 <moon-child> rust had really good marketing, and an ocaml type system
10:59:00 <sham1> kazinsal: that's because Rust has a marketing budget, yeah
10:59:00 <junon> the rust shills alone turn me off from it
10:59:00 <moon-child> most people who are using rust would probably do better to use ocaml
10:59:00 <junon> I've seen people legitimately argue that Rust code is completely bug-free
10:59:00 <sham1> Meh, that's people just being overly enthusiastic
10:59:00 <moon-child> ada has been around since way WAY before rust too, fwiw
10:59:00 <kazinsal> if rustc just emits a blank file when you feed it a blank file that might be considered bug-free code
11:00:00 <sham1> Also, as was already mentioned, lisps
11:00:00 <geist> i generally just see that sort of thing as pretty standard newish/junior/inexperienced programmer stuff
11:00:00 <geist> the assumtion that new tool/paradigm/style/language/feature is going to fix all the prior problems is inexperience
11:00:00 <junon> cc -o/dev/null
11:00:00 <junon> bug free C
11:00:00 <geist> doesn't mean new things *arent* good. but they never fix all the problems
11:00:00 <junon> guaranteed
11:00:00 <kazinsal> yeah
11:00:00 <geist> and it's dangerous to rely too much on it
11:00:00 <GeDaMo> I think your command has a bug :P
11:00:00 <kazinsal> some things stick around. some things don't
11:00:00 <junon> Plus Rust slows down development tenfold
11:01:00 <junon> "but that's a feature!" not really
11:01:00 <kazinsal> it'll be interesting to see if rust/swift/go/other new hotness here continues to be mainstream in 2030
11:01:00 <sham1> rustc relies too much on llvm for optimisation
11:01:00 <junon> I refuse to touch swift until it has a solid cross-platform story.
11:01:00 <junon> I don't want another gnustep.
11:01:00 <moon-child> sham1: my understanding is rust relies a lot _less_ on llvm for optimizations, compared with other languages that target it
11:01:00 <kazinsal> I've given up on the hope of the python/pip ecosystem dying
11:01:00 <moon-child> junon: haha
11:01:00 <kazinsal> I have personal syntactical grievances with python but I'm okay with it existing
11:01:00 <kazinsal> I'm not okay with pip.
11:02:00 <sham1> moon-child: well it's more that Rust emits somewhat "poor" LLVM IR, and that's part of the reason why the compilation takes an eon, since LLVM is then trying to optimize it
11:02:00 <junon> I'm tired of people using python for web applications
11:02:00 <moon-child> kazinsal: haven't used python seriously, what's wrong with it?
11:02:00 <moon-child> sham1: I see
11:02:00 <junon> I was on a django project and wanted to die. It made me feel stupid.
11:02:00 <kazinsal> syntactically I really dislike significant whitespace
11:02:00 <moon-child> same
11:02:00 <sham1> Yah. Not a fan
11:03:00 <junon> I like it, personally. If it's done right.
11:03:00 <moon-child> (what I really want is structural editing. But considering the reception my views on pipes got, I will not say any more :)
11:03:00 <kazinsal> the language is designed under a philosophy of "if the code looks good it's good code"
11:03:00 <j`ey> moon-child: im not sure why affine types are bad, that's what Clone is for in rust, to not have affine types
11:03:00 <sham1> Indentation is good. But mandatory indentation for semantics? Nah
11:03:00 <junon> moon-child: I actually agree with you.
11:03:00 <junon> But good luck getting editor support.
11:03:00 <junon> with structural editing, syntax wars go away
11:04:00 <junon> linting goes away
11:04:00 <sham1> moon-child: well I agree with you on structural editing. Paredit and such are nice, although I've never gotten used to them even when doing Lisp stuff
11:04:00 <moon-child> j`ey: you should not be required to copy things
11:04:00 <kazinsal> the typing system is also... questionable, enough so that there are about half a dozen different implementations of static type analysis systems
11:04:00 <junon> weird syntax-related bugs go away
11:04:00 <moon-child> junon: yeah, have to ditch editors. But, look at how much effort was expended on visual studio and intellij. Bet a really good structural editor would be just as good and orders of magnitude less work
11:04:00 <j`ey> moon-child: not be required to copy things.. when?
11:04:00 <moon-child> j`ey: when you want to share them
11:04:00 <junon> the problem is editor support and version control. Text-based diffing goes out the window unless you use a text-based storage format.
11:05:00 <j`ey> moon-child: you dont have to copy them in that case
11:05:00 <j`ey> you can give a reference
11:05:00 <sham1> Well you could diff on the AST
11:05:00 <moon-child> junon: ah, yeah, diffing is a problem. Solvable, though. I saw a paper about it recently
11:05:00 <kazinsal> and then we have the issue of pip, which largely has the same issue that you see in npm
11:05:00 <junon> to be clear, structural diffing isn't the issue. It's how you store it in your VCS.
11:05:00 <junon> e.g. Git would be ill-suited for it.
11:06:00 <moon-child> j`ey: rust has some syntactic sugar thattaways, but you can not share an object mutably, and you have to _think_ about lifetimes even if you write non-mutating code; have to know when to write clone
11:06:00 <junon> Unless you modified git's behavior to understand the diffs somehow.
11:06:00 <moon-child> junon: I think git has a pluggable storage layer, though I may be wronga bout that
11:06:00 <sham1> Of course, I don't know if I'd be comfortable for example doing lisp programming with a visual editor. Like for example Scratch might be the most popular language that is mainly used with actual structural editing, and that's terrifying
11:06:00 <junon> Otherwise it might do some weird shit to your encoded source files and corrupt them.
11:06:00 <junon> (We went down this path at Vercel once upon a time)
11:06:00 <moon-child> vercel?
11:06:00 <kazinsal> there are a number of things git is ill suited for but people shove all kinds of magical things into it
11:06:00 <sham1> git-lfs
11:06:00 <junon> moon-child: unfortunately not.
11:07:00 <junon> well, depends on what you mean
11:07:00 <junon> custom object types = no.
11:07:00 <junon> Just tried that the other day.
11:07:00 <moon-child> sham1: scratch is a strawman. Look at e.g. hazel, fructure
11:07:00 <junon> You can do it locally but good luck getting e.g. Github, Gitlab, etc. to accept a push.
11:07:00 <moon-child> junon: I see
11:08:00 <moon-child> sham1: even hazel and fructure I think do not show the full power of structured editing. Imagine structured search-and-replace (or just search) with wildcard ast patterns
11:08:00 <junon> I wanted to implement git-based task management using custom objects within the trees. Git didn't like it.
11:08:00 <junon> like attaching TODOs to things. Just as a prototype. was DOA.
11:08:00 <moon-child> see, this is because unix is insufficiently composable, because files lack structure
11:08:00 <moon-child> :)
11:08:00 <sham1> I'd rather just have a tool that scrapes the source files for TODO comments
11:09:00 <junon> sham1: tried that, it gets too messy trying to have things like threads, or linking to them with UIDs
11:09:00 <junon> also inter-task dependencies was a feature I wanted (needed) and that's not possible with TODOs either
11:09:00 <junon> what do you use? tuple of filename/line number? what if you change the line number? everything has to update
11:10:00 <junon> manually put in an ID? that's messy and prone to human error
11:10:00 <junon> etc.
11:10:00 <moon-child> I also want some sort of weak pointer system. Basically what hypertext promised. Imagine linking to some part of the documentation or specification, and seeing what else links there too
11:10:00 <junon> yeah
11:10:00 <sham1> / TODO (#id): Foo bar baz
11:10:00 <sham1> You can have a tool generate the ID
11:10:00 <moon-child> Should be able to just put in a reference to the spec, and the editor shows you that section when you ask
11:10:00 <junon> sham1: and the human has to remember to run the tool
11:11:00 <junon> has to have the tool available on the PATH, which means the tool needs to be available for their platform.
11:11:00 <sham1> Well sure, but they can then automate it further by making it part of a standard TODO snippet thing
11:11:00 <junon> what standard snippet thing?
11:11:00 <sham1> This is mostly a social issue, not a technical issue
11:11:00 <sham1> Well the snippet tool isn't universal, but like a project-specific template
11:11:00 <junon> right, which means huge barrier to entry for cross-team interop
11:11:00 <moon-child> it's a social issue in that you have to get everyone to use whatever environment you set up
11:12:00 <junon> participating in the system means you have all the pre-reqs and understand the workflow
11:12:00 <moon-child> but it's a technical issue in that you have to actually set up such an environment
11:12:00 <moon-child> and such an environment does not already exist
11:12:00 <sham1> Emacs
11:12:00 <junon> hahahah
11:12:00 <junon> no thanks
11:12:00 <junon> :D
11:12:00 <moon-child> emacs is good but it has no pointers
11:12:00 <junon> no hate to emacs users, but I am not one of them
11:12:00 <sham1> Sure it does. It has hyperlinks
11:13:00 <junon> I still want to be able to use my pinky finger when I'm older
11:13:00 <moon-child> including backlinks?
11:13:00 <moon-child> and a mechanism for canonicalization and sharing?
11:13:00 <sham1> Yeah
11:13:00 <moon-child> junon: get a kinesis. All the modifiers on the thumbs :)
11:13:00 <junon> I already have a....
11:13:00 * junon forgot the name
11:13:00 <junon> some other split kb with a bunch of meta-modes
11:13:00 <junon> I'll stick with vim
11:14:00 <junon> :D
11:14:00 <moon-child> I use vim too
11:14:00 <moon-child> BUT emacs is cool
11:14:00 <sham1> I sometimes use Vim
11:14:00 * moon-child has ctrl alt super shift compose space enter delete backspace on thumbs
11:14:00 <moon-child> oh and esc
11:14:00 <junon> which reminds me, I still need to get a tenting kit.
11:14:00 <moon-child> should probably replace delete actually I don't use it that often
11:15:00 <junon> in other news, lolbitcoin
11:15:00 <moon-child> oh?
11:15:00 <moon-child> did it crash?
11:15:00 <junon> yes
11:15:00 <junon> well, it's trending on twitter at least
11:16:00 <junon> I stay well enough away from all that these days but it always amuses me when people are surprised when they're reminded that cryptocurrencies are a volatile thing
11:16:00 <moon-child> meh looking at 6-month price graph it looks pretty stable
11:16:00 <moon-child> but yeah fuck cryptocurrency
11:17:00 <geist> This year I’ll finally put something over the arrow keys on the keyboard and fully embrace using jkl; for navigation
11:17:00 <moon-child> they stole the 'crypto' moniker. AND they're mainly used by fascists. AND they're a dumb use of power
11:17:00 <junon> yeah
11:17:00 <moon-child> I mean there are some interesting technological ideas, but they ... Do Not Work Out
11:17:00 <GeDaMo> I think Kazakhstan banned bitcoin mining
11:17:00 <junon> geist: hjkl
11:17:00 <junon> not jkl;
11:17:00 <junon> at least, I hope...
11:17:00 <moon-child> geist can jkl; a little, as a treat
11:18:00 <junon> we're talking vim bindings right?
11:18:00 <geist> Yeah i was thinking that myself, on an ipad right now can’t visualize where it is
11:18:00 <geist> But yeah those
11:18:00 <geist> Plus the damn thing keeps wanting to autocorrect it
11:18:00 <junon> I feel the pain, took me a while too when I first started.
11:18:00 <moon-child> weird thing is I would feel crippled with any editor other than vim. But I don't use vi-mode in my shell
11:18:00 <sham1> Working on Zirchon clearly makes you do unorthodox choices, like removing .. and using jkl;
11:18:00 <junon> takes about a week to get used to, but you miss it when it's not there.
11:18:00 <geist> I can use them okay, but i just don’t reach for it when trying to navigate
11:18:00 <moon-child> so I also know all the readline^Wzle bindings
11:19:00 <geist> My instinct is to still reach over for the arrow keys
11:19:00 <zid> readline implements about as much vi as I actually know
11:19:00 <junon> if you configure it to, yeah
11:19:00 <sham1> readline^Wzle^Wemacs
11:19:00 <geist> But last year, for example, i made a concerted effort to start using both shifts and both caps locks, as appropriate
11:19:00 <zid> you can configure readline?
11:19:00 <sham1> Yeah
11:19:00 <geist> Prior to that i always favored one or the other
11:19:00 <junon> though IME it's really hit or miss whether or not the readline implementation for a particular application really hoors it
11:19:00 <zid> where at?
11:19:00 <junon> zid: yeah
11:19:00 <junon> sec
11:19:00 <junon> .inputrc
11:19:00 <moon-child> sham1: zle has some different behaviour (by default at least). Notably ^U deletes the whole line, not the part that precedes the cursor
11:20:00 <geist> And i feel like a boss when I out of the blue use the best possible combination
11:20:00 <junon> https://relentlesscoding.com/posts/readline-transformation/
11:20:00 <bslsk05> ​relentlesscoding.com: Relentless Coding
11:20:00 <moon-child> (and emacs and readline have some different things too)
11:20:00 <zid> so you can
11:20:00 <geist> S/caps lock/Carl
11:20:00 <moon-child> who is Carl?
11:20:00 <geist> Haha damnit
11:20:00 <moon-child> :)
11:20:00 <geist> Stupid ipad autocorrecting
11:20:00 * moon-child smashes geist's ipad
11:20:00 <junon> > both caps locks
11:20:00 <junon> oh ctrls
11:21:00 <geist> Both Carls even!
11:21:00 <moon-child> I don't even have a capslock key
11:21:00 <junon> the Carl key
11:21:00 <zid> I do but I've never pressed it
11:21:00 <moon-child> on main keyboard I bound it to end, on laptop I made it super
11:21:00 <junon> right next to the Any key
11:21:00 <geist> I always remap the caps lock as another carl
11:21:00 <zid> I know swapping esc and caps is popular for vim
11:21:00 <moon-child> 'keyboard not found. Press any key to continue'
11:21:00 <sham1> I just use the caps lock key for Compose
11:21:00 <zid> press any carl
11:21:00 <junon> on the mac I made it escape since mine had the shit-bar
11:21:00 <geist> So really its three carls
11:21:00 <moon-child> junon: m1 go brrr
11:21:00 <sham1> And the actual caps lock functionality comes from pushing both shift keys
11:21:00 <moon-child> and also has no shitbar :)
11:22:00 <sham1> How many Carls is too many Carls
11:22:00 <moon-child> you can never have too many carls
11:22:00 <junon> I have an M1 right now that I think the defunct company I used to work for forgot I had
11:22:00 <geist> Get a sun type 6 and remap the blank key as an additional carl
11:23:00 <junon> my keycaps have english as well as hiragana on them
11:23:00 <junon> maybe I'll replace one with "Carl"
11:23:00 <junon> as my obligatory vanity cap
11:23:00 <geist> And so a meme was born
11:24:00 <zid> if I knew how to get my IME to type katakana I'd have suggested kaaru
11:24:00 <junon> oh sorry, katakana, not hiragana
11:24:00 <junon> sorry klange, I know better :v
11:24:00 <junon> geist: look what you did
11:24:00 <junon> you dabbed and created a meme in a span of 20 minutes, true gen z shit
11:24:00 <moon-child> lol
11:24:00 <geist> Hmm i wonder how i can type extra stuff on the ipad
11:24:00 <sham1> You should have an organ keyboard for kanji^Whanzi
11:25:00 <geist> Åoø…
11:25:00 <junon> e-x-t-r-a- -s-t-u-f-f
11:25:00 <GeDaMo> http://xahlee.info/kbd/chinese_drum_keyboard.html
11:25:00 <bslsk05> ​xahlee.info: Chinese Characters Drum Keyboard
11:25:00 <geist> Ah same as on a regular Mac, alt key
11:25:00 <junon> wat
11:25:00 <moon-child> éxţŕá śţúff
11:25:00 <junon> I think it'd make more sense to have a keyboard that does chinese radicals
11:26:00 <junon> that must exist... IME keyboards exist for chinese, how they type shit out?
11:26:00 <junon> pinyin or something?
11:26:00 <moon-child> yeah I think so
11:26:00 <geist> I just like … key
11:26:00 <geist> So you can jrpg answer all questions
11:26:00 <sham1> Well if the keyboard has the radicals, how do you type the main part of the character
11:26:00 <zid> There's like 20 competing methods, junon
11:26:00 <junon> oh wow they do
11:26:00 <moon-child> —
11:26:00 <zid> I saw like, a vox thng about it or something
11:27:00 <geist> ≠
11:27:00 <junon> sham1: aren't the glyphs entirely made up of radicals?
11:27:00 <junon> just in different spots?
11:27:00 <junon> zid: doesn't surprise me
11:27:00 <moon-child> ‽
11:27:00 <geist> Våx?
11:27:00 <sham1> No. Only the side part is the radicals
11:27:00 <junon> oh
11:27:00 <GeDaMo> ಠ_ಠ
11:27:00 <zid> junon: it was kinda interesting, chinese basically stunted chinese tech growth for a long time
11:27:00 <junon> I didn't know that
11:27:00 <junon> also doesn't surprise me
11:27:00 <zid> until someone came up with a decent-ish method, but that one got replaced, but isn't the one speed typists use anyway
11:28:00 <geist> Omg i wish i had the kyubey eyes available right now
11:28:00 <junon> at least japanese has some sanity there
11:28:00 <zid> https://www.youtube.com/watch?v=hBDwXipHykQ it may have been this video
11:28:00 <bslsk05> ​'How China Conquered The Keyboard' by Johnny Harris (00:21:06)
11:28:00 <junon> I think you can just type hiragana/katakana (probably katakana) and it'll allow you to replace things with kanji where necessary
11:28:00 <junon> klange would know
11:28:00 <sham1> The parts are not all called radicals in Japanese either
11:28:00 <zid> I type english
11:28:00 <zid> and it suggests kanji/hiragana/etc
11:28:00 <moon-child> sometimes I feel like I'm the only person here who doesn't know japanese
11:28:00 <zid> space to open a 'I want something else' box
11:28:00 <junon> zid: do you know japanese?
11:29:00 <zid> a bit
11:29:00 <junon> oh neat
11:29:00 <sham1> I don't know Japanese. I just happen to vaguely know how Chinese characters work
11:29:00 <zid> If you watch a japanese person type, they often use the english conversion, rather than actual japanese
11:29:00 <junon> I feel bad for trying to learn since I actually need to learn German
11:29:00 <zid> which does exist
11:29:00 <junon> since I... you know, moved here
11:29:00 <moon-child> I wanna learn german too
11:29:00 <zid> meh, germans all speak english
11:29:00 <moon-child> oh I didn't move to germany lol
11:29:00 <junon> moon-child: no you don't
11:29:00 <junon> don't do it
11:29:00 <sham1> zid: no they don't
11:29:00 <zid> be one of those annoying immigrants who refuses to speak the local language
11:29:00 <junon> zid: in berlin, yes. Not elsewhere
11:29:00 <moon-child> junon: but one of my favourite authors writes in german
11:30:00 <zid> sham1: anyone worth talking to does
11:30:00 <moon-child> and I wanna read his stuff in the original
11:30:00 <moon-child> two of them actually
11:30:00 <geist> Not bold. Bold
11:30:00 <junon> zid: every american ever >.>
11:30:00 <sham1> zid: TIL airport staff isn't worth talking to
11:30:00 <zid> they all know english
11:30:00 <zid> They just refuse to talk to you in it
11:30:00 <geist> Italic
11:30:00 <geist> Underlined
11:30:00 <junon> german is a language of 1000 rules and infinite exceptions
11:31:00 <junon> to the point there's almost no point in the rules
11:31:00 <zid> which makes it vastly simpler than english ;)
11:31:00 <moon-child> wondering whether it's weechat, tmux, or xterm that's not rendering the bolds
11:31:00 <geist> Germans like rules
11:31:00 <moon-child> I think tmux
11:31:00 <junon> yes but equally nonsensical
11:31:00 <sham1> Something about Ordingun
11:31:00 <moon-child> hm no, guess it's weechat
11:31:00 <moon-child> (|ncurses)
11:31:00 <moon-child> s/bold/italic/
11:31:00 <geist> Oh interesting,the formatting actually came through?
11:31:00 <GeDaMo> Some channels filter it out
11:31:00 <geist> Now I’m curious how that got flattened to utf8
11:32:00 <moon-child> underline and bold did
11:32:00 <ThinkT510> bold rendered here in weechat
11:32:00 <geist> I’m using IRCCloud app on ipad
11:32:00 <sham1> Welp, time for my hot take since we talk about stuff like underlines and the inability to render them: I hate terminals. Shells? Good. Terminals? Nah
11:32:00 <junon> "Mir ist heiss" = I am feeling hot. "Ich bin heiss" = I am attractive. Not a single German can explain to me why it's this way. It's just one of those things you accept.
11:32:00 <zid> bold italic underline are just escape sequences in the irc proto
11:32:00 <moon-child> utf8 doesn't have anything to do with it. It's low-range unprintable chars
11:32:00 <moon-child> same things with actions
11:32:00 * moon-child does x
11:32:00 <moon-child> is sent as \x01ACTIONdoes x\x01
11:32:00 <zid> yea CTCP is all \1
11:32:00 <junon> sham1: I use wezterm on windows right now and it's probably the best I've used on any platform.
11:32:00 <geist> Ah like colors. Good to know
11:32:00 <moon-child> zid: that is not ctcp
11:33:00 <moon-child> ctcp is client-to-client protocol
11:33:00 <geist> Didn’t know irc had those
11:33:00 <geist> 4Red
11:33:00 <moon-child> yep red
11:33:00 <sham1> geist: yeah
11:33:00 <junon> geist: I think they're more like ansi escapes where they're not formally specified but are agreed upon by most clients
11:33:00 <junon> and weirdly enough, it works on element (matrix client)
11:33:00 <junon> neat
11:33:00 <sham1> They are not ANSI escapes, but they were originally an mIRC thing that was just picked up by everyone else
11:33:00 <zid> https://tools.ietf.org/id/draft-oakley-irc-ctcp-01.html#rfc.appendix.A.1
11:33:00 <ThinkT510> some channels might set modes that disable colours
11:34:00 <zid> it's literally part of the CTCP spec
11:34:00 <junon> sham1: that's correct as per my memory
11:34:00 <geist> 0I knew about red, but i didn’t realize there was escapes outside of that. Neat.
11:34:00 <zid> ctrl-k in mirc, then number comma number
11:34:00 <zid> I forget what the actual escape character is though
11:34:00 <junon> can't do colors in element :(
11:34:00 <junon> wait I've always been curious
11:34:00 <junon> 🤥
11:34:00 <junon> does that work
11:35:00 <sham1> https://modern.ircdocs.horse/formatting.html
11:35:00 <bslsk05> ​modern.ircdocs.horse: IRC Formatting
11:35:00 <geist> I see an emoji
11:35:00 <sham1> I also see an emoji
11:35:00 <junon> yeah okay
11:35:00 <junon> that's just utf-8 though so shouldn't be surprising
11:35:00 <geist> I think those are just straight utf7
11:35:00 <sham1> But yeah. The colour code of IRC is 0x03
11:35:00 <geist> 8yeah
11:35:00 <junon> feels dirty to see emojis in irc...
11:35:00 <sham1> Or ^C for colour
11:36:00 <junon> that's like saying "alt-f4 for color" for irssi users
11:36:00 <zid> /quit and /part were riding in a boat, /part got out, who was left in the boat?
11:37:00 <sham1> /quit
11:37:00 <junon> /quit
11:37:00 * junon laughs in matrix
11:37:00 <junon> DCC SEND 0 0 0 0
11:37:00 <junon> that used to be a thing I saw
11:37:00 <junon> would crash a lot of peoples' clients or something
11:38:00 <sham1> Wait, people still do DCC?
11:38:00 <junon> no
11:38:00 <junon> at least I hope not
11:38:00 <junon> trashfire from a security perspective
11:38:00 <geist> Haha that’s awesome
11:38:00 <sham1> Mmhm
11:38:00 <geist> The quit/part thing
11:38:00 <junon> most networks block it now
11:38:00 <zid> I prefer
11:38:00 <geist> Also don’t forget
11:38:00 <geist> +++ATH
11:38:00 <zid> omg the network blocks it
11:39:00 <zid> I physically cannot send the string I want to send
11:39:00 <geist> And the one modem somewhere some time that used to hang people up on the remote end
11:39:00 <zid> X 5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*
11:39:00 <sham1> One thing I could see would be that with modern IRCv3 features like batches, one could define a modern file sharing sub protocol for IRC
11:39:00 <zid> remove the space after the first X.. used to make norton boot people off irc
11:39:00 <moon-child> junon: ^C is colour in irssi though
11:39:00 <sham1> Just encode the files as base-64 and send them as a bunch of PRIVMSGs within a certain batch
11:40:00 <moon-child> try ^C4hi^C0
11:40:00 <geist> See if irc was as good as zmodem, you could upload *and* download *and* talk to the sysop at the same time!
11:40:00 <geist> True multitasking!
11:40:00 <moon-child> ;o
11:40:00 <sham1> :O
11:41:00 <sham1> Modern ZModem revival when
11:41:00 <junon> moon-child: oh
11:41:00 <zid> discord has you beat, you can barely send messages at all
11:41:00 <sham1> The end-game of Discord: To send messages you need to buy nitro
11:41:00 <junon> Sorry you've reached the 2000 character limit. Please pay us ungodly amounts of money monthly to sent more bytes to your friend.
11:41:00 <geist> But it can inline embed 50MB 3 second GIF videos
11:41:00 <geist> So it’s all good
11:42:00 <junon> geist: only if you pay ungodly amounts
11:42:00 <junon> otherwise it only allowed 8mb
11:42:00 <sham1> Discord is the zoomer IRC and it's annoying
11:42:00 <zid> You guys are allowed to send messages?
11:42:00 <geist> Haha
11:42:00 <geist> I just type on it, hoping some day someone answers me
11:42:00 <moon-child> I feel like there are some cool people that are only on discord, but the stn ratio is much worse, and I don't have the bandwidth for more than one chat service
11:43:00 <moon-child> already have to use slack for work...
11:43:00 <zid> mine goes "nope, greyed out text. 10 seconds later, red text"
11:43:00 <junon> I got random CP DMed to me from a bot account I had no mutual servers with. I messaged discord about it multiple times with absolutely zero response.
11:43:00 <junon> Dumpster fire of a service.
11:43:00 <zid> because discord is ENTERPRISE
11:43:00 <sham1> Remember when we had PMs, as in "Private Messages" Nowadays we have DMs, as in "Direct Messages". Really makes you think 🤔
11:43:00 <moon-child> not so private any more :P
11:43:00 <zid> anyone who uses discord with allow private messages from randos enabled is wrong
11:43:00 <sham1> Mmhm
11:43:00 <geist> But random are the spice of life
11:44:00 <geist> You grind them up with a pestle
11:44:00 <junon> zid: you can't get messages from randos
11:44:00 <sham1> I use random unsolicited messages as a way to seed my RNG
11:44:00 <junon> discord doesn't allow it
11:44:00 <geist> Randos, damnit you autocorrect!
11:44:00 <zid> you can if you allow it
11:44:00 <junon> the only setting is if you share a server with them
11:44:00 <junon> no you can't
11:44:00 <junon> I'm looking at my settings right now
11:44:00 <geist> NITRO
11:44:00 <zid> server privacy defaults
11:44:00 <geist> Pay monies for more randos
11:45:00 <junon> zid: and the only two options there are "Allow direct messages from *server members*" and "Allow access to NSFW servers on iOS"
11:45:00 <zid> yea, don't allow the former
11:45:00 <junon> the bot that messaged me had no mutual servers
11:45:00 <sham1> Also one thing that annoys me about Discord is how the rooms are called "servers" and the subrooms "channels"
11:45:00 <junon> that was my point
11:45:00 <geist> Oh i do that, i just don’t join servers where people are going to DM me garbage
11:45:00 <junon> per discord's rules, they shouldn't have been allowed to message me
11:45:00 <junon> at all
11:46:00 <geist> Usually i join servers where i’d actually not mind talking to someone if they wanted to
11:46:00 <sham1> Maybe they paid Discord a fat sack of cash
11:46:00 <zid> most of the servers I am in require you to pay to join ngl
11:46:00 <sham1> To be able to harass junon with unsolicited DMs
11:46:00 <junon> to send highly illegal CSAM to random people?
11:46:00 <junon> CP here = child pr0n
11:46:00 <geist> sham1: yah it really tweaks me a bit too that it’s called a server
11:46:00 <moon-child> what's a prawn
11:46:00 <geist> It’s… not a server
11:47:00 <junon> moon-child: adolescant shrimp
11:47:00 <junon> (jk please don't actually make me spell it out)
11:47:00 <junon> (inference, people)
11:47:00 <geist> And on that bombshell
11:48:00 <junon> geist: it's the cloud, so ofc it's a server
11:48:00 <junon> just not yours
11:48:00 <moon-child> well, it's part of a server
11:48:00 <moon-child> or possibly multiple servers, depending on how many people are on it
11:48:00 <sham1> Pornography depicting minors
11:48:00 * junon sighs
11:49:00 <sham1> I said it, not you
11:49:00 <junon> anyway yeah discord refused to acknowledge it
11:49:00 <junon> still upsets me
11:49:00 <junon> also they never responded to my application years ago so still miffed about that
11:49:00 <junon> not that I want to work there anymore anyway, but still
11:49:00 <sham1> I see /u/spez of Reddit has upgraded in the world and apparently also does stuff with Discord considering the apparent inaction for CP
11:50:00 <junon> spez shouldn't be doing anything on the internet
11:50:00 <junon> aaron schwartz would cry if he saw what spez did to reddit
11:50:00 <sham1> I think he does
11:51:00 <junon> spez is also married to that one super famous tennis player
11:51:00 <junon> in a weird marriage of worlds.
11:51:00 <junon> almost as weird as the grimes/musk crossover
11:51:00 <sham1> Wild
11:51:00 <junon> yes
11:52:00 <junon> anyway I'm all socialized out, these energy drinks aren't doing anything for my screwed up sleep schedule. I should nap.
11:52:00 * junon waves goodbye and fades into the distance
11:55:00 <moon-child> somebody asks: 'How do you create a graphics/widgets library like Qt?' And it's weird cuz I know how, but I haven't the faintest idea where I got this knowledge or what I could tell somebody that would be useful
11:55:00 <GeDaMo> It involves boxes :|
11:56:00 <moon-child> hey constraints are viable! Definitely!
11:57:00 <sham1> Nested boxes
11:57:00 <moon-child> agh!!
11:57:00 <moon-child> you mean a box
11:57:00 <moon-child> inside of another box
11:57:00 <GeDaMo> It's a tree of boxes!
11:57:00 <moon-child> it's just not right!
11:57:00 <moon-child> I respect people's right to put boxes wherever they like, but Not in front of my children!
11:58:00 * moon-child tired, loopy
11:58:00 <sham1> One thing I've semi seriously been thinking about is something like JSX but for C, wherein you can do things like widgets with a descriptive XML stuff and then embed C code, and have the XML embedded in the C code as well
11:59:00 <junon> sham1: went down this path
11:59:00 <junon> it's a lot of effort.
11:59:00 <junon> also getting the syntax to not conflict is tricky, esp. for C++
11:59:00 <sham1> I can imagine
11:59:00 <junon> since there is an alternative lambda syntax that will make it hard to tokenize the jsx
11:59:00 <junon> sec
11:59:00 <moon-child> hmm, haven't actually touched jsx but
11:59:00 <moon-child> I did a templating language with _really_ seamless lisp integration recently
12:00:00 <junon> https://stackoverflow.com/questions/56860831/is-there-any-case-barring-strings-or-macro-invocations-where-is-a-valid-s
12:00:00 <bslsk05> ​stackoverflow.com: c++ - Is there any case, barring strings or macro invocations, where `(<` is a valid stream of characters? - Stack Overflow
12:00:00 <junon> I asked that in the same JSX-in-C context.
12:00:00 <zid> \*(<
12:00:00 <moon-child> c++ :<
12:00:00 <zid> //(<
12:00:00 <junon> moon-child: if you want my opinion, use custom attributes.
12:01:00 <junon> zid: that would get dropped by most parsers
12:01:00 <zid> there were contraints? title just says C++ is there any case except x
12:01:00 <junon> comments are not tokens
12:02:00 <moon-child> junon: custom attributes?
12:02:00 <zid> title doesn't say tokens
12:02:00 <sham1> Although this is C++, and not C
12:02:00 <junon> zid: > Assuming the translation unit has been pre-processed and no macros exist.
12:02:00 <junon> pre-processed here implies no comments
12:02:00 <zid> yes
12:02:00 <zid> It just doesn't sayu that, I'm not incapable of reading I just didn't :P
12:03:00 <junon> sham1: both languages have custom attributions
12:03:00 <junon> attributes*
12:03:00 <junon> C starting in C11
12:03:00 <moon-child> oh the [[things]]
12:03:00 <junon> c++ starting in... 14? I think? maybe 17.
12:03:00 <junon> yeah.
12:03:00 <moon-child> no c didn't get those until c2x
12:03:00 <moon-child> which hasn't been standardised yet
12:03:00 <junon> oh
12:03:00 <junon> oh right yeah
12:03:00 <moon-child> also I don't like them. Ugly :<
12:04:00 <junon> Meh then don't use C
12:04:00 <moon-child> I mean
12:04:00 <moon-child> __attribute__
12:04:00 <junon> no
12:04:00 <junon> [[attribute]]
12:04:00 <junon> the attribute is non-standard syntax
12:05:00 <sham1> How does [[attribute]] make parsing XML not possible I wonder
12:05:00 <moon-child> gcc should be enough for everybody
12:05:00 <junon> GCC-specific
12:05:00 <junon> sham1: it is possible
12:05:00 <zid> /* fallthrough */ is my favourite non-standard but accepted syntax with semantic meaning
12:05:00 <junon> custom attributes allow any stream of characters as long as parens match up
12:05:00 <sham1> Oh good
12:05:00 <moon-child> zid: yeah that's pretty good
12:05:00 <junon> zid: new one is [[fallthrough]]
12:06:00 <moon-child> zid: though I usually #define fallthrough __attribute__((fallthrough)) and undef it for non-gcc if I care ot
12:06:00 <sham1> The only thing would be to somehow hook into the compiler to find the custom attributes, because they might be behind the preprocessor
12:06:00 <zid> why do you keep trying to teach me C :(
12:06:00 <junon> sham1: [[jsx(you can put anything here)]] jsx_t SomeElement;
12:06:00 <junon> err, SomeElement();
12:06:00 <sham1> Why would you do ()
12:06:00 <moon-child> zid: because I'm a sadist
12:07:00 <zid> not you, junon
12:07:00 <junon> then if you don't pre-process them, worst case you get undefined linker errors
12:07:00 <junon> sham1: elements are typically functions
12:07:00 <moon-child> well, junon apparently is a sadist too
12:07:00 <zid> ah
12:07:00 <sham1> Hm, true
12:07:00 <junon> functional components at least, not that react class-based shit.
12:07:00 <sham1> I forgot about that
12:07:00 <junon> plus you don't get undefined errors if you don't properly pre-process
12:07:00 <junon> if you make them variable declarations
12:07:00 <junon> (I've thought way too much about this fwiw)
12:07:00 <sham1> One other way of doing this would be to do something like what yacc and lex do
12:08:00 <sham1> So you make it a custom language instead
12:08:00 <junon> don't do what yacc or lex do, they're awful
12:08:00 <junon> :D
12:08:00 <moon-child> ^
12:08:00 <sham1> I smell heresy
12:09:00 <moon-child> raku has the _only_ good implementation of parser generators I have yet encountered
12:10:00 <junon> raku appears to be a scripting language for perl
12:10:00 <junon> does it output C parsers?
12:10:00 <sham1> Raku is a separate language from Perl
12:10:00 <moon-child> raku is perl 6
12:11:00 <moon-child> but semantically it's much closer to ruby and common lis
12:11:00 <moon-child> p
12:11:00 <junon> It just looks like a generic BNF parser
12:11:00 <moon-child> but it keeps its text-processing roots and improves on them, unlike everybody else who just clones pcre or posix re
12:11:00 <junon> sham1: if you want a good one that integrates with C, use re2c
12:11:00 <moon-child> junon: it's _very_ well-integrated with the language
12:11:00 <sham1> Perl regexes were already absolutely disgusting with all the backtracks and such, and Raku just made it more
12:11:00 <moon-child> and unlike say re2c or lex/yacc, doesn't require a separate build stage
12:12:00 <junon> but it still requires perl
12:12:00 <moon-child> not perl. raku
12:12:00 <sham1> And when I said lex/yacc, I didn't mean using those but more just how those languages embed snippets of C code
12:12:00 <junon> so... still requires a build stage.
12:12:00 <junon> kinda.
12:12:00 <moon-child> no
12:12:00 <sham1> Well it's all integrated in the language
12:12:00 <sham1> You dynamically change the language
12:12:00 <sham1> Well you can do that anyway
12:14:00 <junon> how did I get roped back here, I'm supposed to be napping
12:14:00 * junon waves goodbye again
12:15:00 <moon-child> night
12:15:00 * moon-child is chronically incapable of napping. Really wish I could
12:15:00 <sham1> You don't
12:16:00 <moon-child> why?
12:17:00 <sham1> Makes it harder to sleep at night
12:17:00 <zid> moon-child has never slept
12:17:00 <zid> he's better than us
12:18:00 <moon-child> sham1: I have enough trouble getting to sleep at night as is, I don't think it can possibly get any worse
20:31:00 <Oli> gog! *I give you a hug* I am feeling content to see you around! *I inhale deeply once* Hello, and good day, fellows connected at this Internet relay chat channel!
20:34:00 <Oli> Talking about fellows connected at this Internet relay chat channel, I find myself pondering about how doug16k is.
20:38:00 <Oli> A wonderfully skilled, kind and assisting being who used to share by.
20:40:00 <GeDaMo> Looks like Doug's last github activity was September
20:44:00 <gog> hi Oli
21:03:00 <moon-child> he was active for a bit after he disappeared from irc though. So that doesn't _necessarily_ signify anything
21:06:00 <GeDaMo> Yeah, looks like he was on stackoverflow more recently
21:07:00 <GeDaMo> I'm not a stalker, honest :P
21:07:00 <kazinsal> he was eaten by a yeti in the frigid canadian wastes
21:07:00 <moon-child> can confirm, am yeti
21:09:00 * gog pets moon-child
21:18:00 * moon-child grunts and screeches
21:40:00 * kazinsal pets gog