00:00:21 <zzo38> The other way would be to emulate the instruction set, but that will be slow.
00:00:22 <ais523> of course, the easy way for an OS to effectively force programs to be position-independent is just to load them at a random address – then if they aren't position-independent they will usually break
00:02:12 -!- Evylah10 has joined.
00:02:33 <HackEso> olist <https://www.giantitp.com/comics/oots1309.html>: shachaf oerjan Sgeo boily nortti b_jonas Noisytoot
00:04:05 -!- mtm has quit (Ping timeout: 248 seconds).
00:04:54 <Sgeo> I completely forgot about olisting new comics
00:05:56 -!- mtm has joined.
00:07:15 <ais523> I almost always get beaten to the olist
00:07:38 <ais523> this one happened at a weird time of week, though – I'm not even sure why I thought to check
00:08:57 <esolangs> [[Talk:Markov algorithm]] https://esolangs.org/w/index.php?diff=136649&oldid=136644 * Tommyaweosme * (+319)
00:09:04 -!- Evylah10 has quit (Quit: Client closed).
00:13:41 <Sgeo> I hooked up IFTTT to Facebook and used to have it hooked up to Twitter, so there are accounts on both that broadcast when there's a new one. So I get notifications quickly. Used to use Yahoo Pipes, RIP
00:36:45 <b_jonas> Sgeo: the operating systems can just load the programs to varying addresses, and even though the program can use absolute addresses, it will just break if it doesn't expect to be position independent. The OS doesn't enforce that the program can't find out the address.
00:38:07 <b_jonas> You could make an eso-processor that's position-independent if all the addresses and pointers are relative to their location, or at least to the start of the page of their location.
01:06:50 <ais523> but it's very hard to program in a language where all pointers are IP-relative
01:07:23 <ais523> I guess to make it work, instructions that read memory would need to support literal offsets, so that you can offset all the pointers by a known distance based on the location in the code
01:07:47 <ais523> and then just store pointers relative to some fixed location in the code
01:08:02 <ais523> the memory allocation API for this would be confusing but you could make it work
01:13:43 <b_jonas> ais523: no, you'd just support adding two registers as indexes like x86_64, since you read a pointer from a known location you just use its address as one of the offsets. sometimes you need three offsets so it does need extra instructions, but it's not impossible. IP-relative doesn't come into it often except for global variables, and for those you already use IP-relative addresses.
01:14:07 <b_jonas> you'd just store pointers as relative to where they are
01:15:44 <b_jonas> the problem is only when you pass pointers as function arguments in registers, in which case I think you'd use addresses relative to some point on the stack specified in the function call ABI
01:16:52 <b_jonas> you'd have to offset pointers whenever you copy them in memory, but that's not much more of a burden than adjusting reference counts for smart pointers in a high-level reference counted language
01:17:53 <b_jonas> as a bonus, you can esaily use such relative pointers easily in shared memory segments or disk files that can be mapped to different addresses in different processes
01:18:15 <b_jonas> sure, normally you'd just use pointers relative to the start of that segment or file
01:22:56 -!- troojg has joined.
01:30:48 <ais523> ooh, self-relative pointers, I didn't think of that option
01:33:11 <b_jonas> it's rather silly and I wouldn't recommend them for serious purposes, if you want something like that you'd better use indexes relative to the memory pools into which you're allocating in, but on an esoteric scale it's reasonably workable
01:37:39 -!- troojg has quit (Remote host closed the connection).
01:42:58 <ais523> it might actually make sense for the "just save the memory image to disk" method of saving
01:43:18 <ais523> although that would be incredibly insecure and not recommendable in any non-esoteric context
01:43:24 -!- b_jonas has quit (Read error: Connection reset by peer).
01:44:05 <ais523> (I am reminded of the way that Jelly's intended way to do a string → int conversion is a string eval)
01:45:53 -!- b_jonas has joined.
01:48:02 <ais523> ooh – Rust has huge problems with moving structures that contain self-references – what about making self-referential structures use self-relative references?
01:48:12 <ais523> this is actually less silly than many of the solutions that have been proposed
01:55:05 <b_jonas> ais523: it's kind of two problems that may or may not be related
01:56:06 <ais523> I'm interested in hearing this
01:57:36 <esolangs> [[User:MihaiEso]] https://esolangs.org/w/index.php?diff=136650&oldid=136096 * MihaiEso * (+60)
01:57:45 <b_jonas> the structures with pointers to inside them that I've seen are C++ std::string in later C++ standard libraries, and the array structure in opencv. both cases use a pointer instead of just an index into the internal array because the pointer may be either into the small buffer inside the structure or into an externally heap-allocated array.
01:58:43 <b_jonas> so for just reading you don't care where the pointer points, you just follow it. but when you move or copy or destroy or modify the structure then you may have to distinguish between the two cases, to know if you have to free the external array..
01:59:00 <esolangs> [[Special:Log/upload]] upload * MihaiEso * uploaded "[[File:OCR-test.jpg]]": Taken from this: [https://www.imgonline.com.ua/examples/text-photographed-eng-preview.jpg]
02:00:17 <esolangs> [[Special:Log/upload]] upload * MihaiEso * uploaded "[[File:Text-photographed-eng-preview.gif]]": Taken from this: [https://www.imgonline.com.ua/examples/text-photographed-eng-preview.jpg], then saved as GIF. Notice the diffusion noise that tricks some OCR software?
02:00:28 <esolangs> [[Special:Log/delete]] delete * Ais523 * deleted "[[File:OCR-test.jpg]]": Copyright violation: copyrighted image; content was: "== Summary == Taken from this: [https://www.imgonline.com.ua/examples/text-photographed-eng-preview.jpg]", and the only contributor was "[[Special:Contributions/MihaiEso|MihaiEso]]" ([[User talk:MihaiEso|talk]])
02:00:42 <esolangs> [[Special:Log/move]] move * MihaiEso * moved [[File:Text-photographed-eng-preview.gif]] to [[File:OCR-test.gif]]
02:01:25 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136655&oldid=134847 * Ais523 * (+287) /* Copyright violations */ new section
02:02:12 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136656&oldid=136655 * MihaiEso * (+136) /* Copyright violations */
02:02:15 <esolangs> [[Special:Log/delete]] delete * Ais523 * deleted "[[File:OCR-test.gif]]": Copyright violation: copyrighted image; content was: "== Summary == Taken from this: [https://www.imgonline.com.ua/examples/text-photographed-eng-preview.jpg], then saved as GIF. Notice the diffusion noise that tricks some OCR software?", and the only contributor was "[[Special:Contribu
02:02:16 <b_jonas> ais523: anyway, as for rust, rust normally really wants objects to be trivially movable in the C++ sense. this isn't absolute, you can still handle objects that aren't movable by reference, but you can't pass such structures by value or return them by value or have them by value in a local variable. the samea applies to a variable length array or to an array of unknown type satisfying a trait (in the
02:02:22 <b_jonas> Haskell sense), you can only access them through reference because they can't be trivially movable.
02:02:29 <esolangs> [[Special:Log/delete]] delete * Ais523 * deleted "[[File:Text-photographed-eng-preview.gif]]": Broken redirect: redirect to deleted file
02:03:37 <ais523> a VLA can be trivially moveable if you know what size it is
02:04:11 <b_jonas> the other problem is how you create such a structure, for which there isn't really an easy way because of the borrow checker rules. at least it's not easy if you want that inner pointer to be a proper rust reference. it's still possible, but not easy.
02:04:43 <esolangs> [[Special:Log/upload]] upload * MihaiEso * uploaded "[[File:Untitled2342.png]]": Taken from this: [https://www.nintendo.com]
02:05:02 -!- op_4 has quit (Remote host closed the connection).
02:05:32 -!- op_4 has joined.
02:05:44 <esolangs> [[Special:Log/upload]] overwrite * MihaiEso * uploaded a new version of "[[File:Untitled2342.png]]": Taken from this: [https://www.imgonline.com.ua/examples/text-photographed-eng-preview.jpg]
02:06:12 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136659&oldid=136656 * Ais523 * (+293) /* Copyright violations */ reply
02:06:39 <b_jonas> ais523: yes, but you can't just have a VLA variable on your stack (local variable or function parameter or return value) and move another VLA into it (regardless if the one on the stack is empty or initialized). you'd need alloca magic, ABI rules for how to pass and return such values, and it's not clear how much of those we want in the language and compiler.
02:07:13 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136660&oldid=136659 * MihaiEso * (+111) /* Copyright violations */
02:07:31 <esolangs> [[Special:Log/block]] block * Ais523 * blocked [[User:MihaiEso]] with an expiration time of 1 day and 7 hours (account creation disabled): copyright violations
02:07:48 <b_jonas> nor can you just have a VLA as a member of a structure without problems. rust has the beginnings of some support for this, as in it technically allows structures whose last member is a VLA, but there's no sane way to actually create such a structure.
02:07:59 <esolangs> [[Special:Log/delete]] delete * Ais523 * deleted "[[File:Untitled2342.png]]": reupload of image that was deleted due to copyright violations, possibly with an attempt to disguise what was happening
02:10:58 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136661&oldid=136660 * Ais523 * (+466) /* Copyright violations */ blocked
02:12:36 <b_jonas> that part with structures ending in a VLA is mostly the same as in C++: the standard library has a way to allote a VLA on the heap (in std::unique_pointer), or a growable VLA on the heap (in std::vector), but no nice way to create a generic user-defined structure with a VLA on the end. you have to fill a memory area with what should become that structure, then do a type conversion of pointer in a way
02:12:42 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136662&oldid=136661 * MihaiEso * (+232) /* Copyright violations */
02:12:43 <b_jonas> that the compiler doesn't know is typesafe to instantiate such a structre (at least if the VLA at the end isn't empty).
02:14:23 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136663&oldid=136662 * MihaiEso * (+24) /* Copyright violations */
02:15:27 <b_jonas> so in both rust and C++, a combination of the core language and standard library support either a lone variable length array on the heap, or a growable variable length array on the stack; or an unknown type satisfying a trait in rust (with some restrictions on the trait) or an unknown subclass of a class in C++; but for most other cases with variable layout you have to do your own thing and assert to
02:15:33 <b_jonas> the compiler that it's correct, hopefully with a small safe wrapper
02:16:55 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136664&oldid=136663 * Ais523 * (+515) /* Copyright violations */ it's a temporary block
02:17:36 <ais523> the wiki never used to need this much moderation of humans, it used to just be fighting spambots
02:18:00 <b_jonas> but you can write such wrappers if the actual objects that your users handle aren't variable layout, but just some kind of smart pointers pointing to those variable layout, and you pass those smart pointers to library functions
02:18:24 <ais523> b_jonas: hmm, can dyn Trait be stored directly on the stack? I thought it could only be stored by reference
02:19:00 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136665&oldid=136664 * MihaiEso * (+166) /* Copyright violations */
02:19:11 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136666&oldid=136665 * MihaiEso * (+85) /* Copyright violations */
02:19:12 <b_jonas> ais523: it can only be stored by reference
02:19:46 <b_jonas> the reference could point to the stack I guess if it's on the stack frame of a function that has a concrete type as a local variable
02:20:52 <ais523> so continuation-passing-style would work – you have a dyn Fn that takes a callback and passes an &dyn Trait to it, the dyn Fn is not on the stack but the dyn Trait is
02:21:45 <b_jonas> so C++'s std::string and OpenCV's cv::Mat are concrete fixed layout type, they just might point to variable-length arrays on the stack or to inside themselves and the functions implementing them handle that in a mostly transparent way (in the case of cv::Mat enough of the internals is public API that user code can handle part of it too)
02:23:14 <ais523> I was actually just reading about that today: apparently some std::string implementations store the string in their own length field and point to that
02:23:23 <ais523> (presumably NUL-terminated?)
02:23:29 <ais523> if it's short enough to fit
02:23:52 <b_jonas> ais523: no, I think it's four pointers wide, the pointer to start and length is always present, and then it's a union of a two pointer wide buffer or the capacity
02:24:10 <b_jonas> I don't know if it's nul-terminated, but the size is always there
02:24:20 <b_jonas> at least in the libstdc++ implementation
02:24:21 <ais523> wait, why would buffer need two pointers
02:24:40 <ais523> one of them would normally always be the string start, wouldn't it?
02:25:01 <ais523> also, one of my pet hates is capacity fields in C/C++/Rust-like languages
02:25:10 <ais523> it is such a waste of memory, just ask the allocator, it should know
02:25:25 <ais523> it has to, in order to be able to deallocate the memory again
02:25:37 <b_jonas> the buffer doesn't need to be exactly two pointers size, that's just how much the library uses. it's a tradeoff between making the structure large vs having to allocate often.
02:25:59 <ais523> (a note to other wiki admins: you are allowed to shorten the MihaiEso block without my permission if you wish, although I suspect from their userpage comments it'd be a bad idea)
02:26:14 <b_jonas> ais523: no, because those arrays are very often small, and this way you can use a sized allocator that does NOT store the capacities next to the arrays for small arrays
02:26:33 <ais523> in that case you know the size based on which allocator was used
02:26:54 <ais523> like, the allocator always has to know how to deallocate, therefore it always has to know the size
02:27:03 <ais523> it doesn't necessarily have to *store* the size, but it has to *know* it
02:27:09 <b_jonas> it can just allocate lots of small arrays in an array of 16-bit buffers on the heap and an array of 32-byte buffers on the heap, and know which one you use because the string or vector tells the deallocator what capacity is expected
02:27:11 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136667&oldid=136666 * MihaiEso * (+9) /* Copyright violations */
02:27:41 <b_jonas> no, you can have an allocator api that requires you to tell the allocated size whenever you free or realloc a chunk, a lot of libraries use such allocators
02:28:07 <b_jonas> that doesn't work for malloc because its API doesn't allow that, but C++ new is explicitly designed to allow that
02:28:21 <ais523> b_jonas: I guess doing that plus a capacity field is equivalent to getting the allocator to store the size next to the allocation
02:28:30 <b_jonas> and you often know the size if you store a known type, like a subclass of a class with a vtable
02:28:48 <b_jonas> ais523: no, because you often store non-vlas, in which case you store a vtable pointer instead of a size
02:29:10 <b_jonas> or you just store an explicitly known type, like a node in a btree
02:29:26 <ais523> fwiw, with plentiful virtual memory, I think it probably makes sense to store allocations of different sizes in different virtual addresses, so that the size is encoded in the pointer
02:30:03 <ais523> I can see the point of "having the capacity in the structure when necessary to tell the allocator the size makes more sense then having the allocator track it always", although it rather depends on how the allocator works
02:33:22 <b_jonas> virtual memory is not plentyful. you remember when intel had to add an extra level of paging tables to extend the available pointer bits with 9 bits because people had close to enough physical memory to exceed the previous limit. that means there were too few spare bits in a pointer you could rely on in a future-proof way back when that happened, unless you want to mask out the extra bits every time you
02:33:28 <b_jonas> want to dereference the pointer.
02:33:59 <b_jonas> now if you do want to mask out extra bits every time then you can probably get away with a few tag bits, but only with 64-bit pointers of course
02:34:41 <b_jonas> I remember when Sicstus prolog got bitten by growing memory sizes in 32-bit land because it stored tag bits in the top rather than bottom of its 32-bit pointers
02:34:48 <ais523> I do remember that Intel added the extra 9 bits (although not the exact timing), but remember being confused by it
02:35:21 <ais523> fwiw, I think the safe tag bits are a) anything implied by pointer alignment and b) the very top bit, as that's reserved for kernel-mode pointers
02:35:38 <ais523> I would not rely on the others to be stable into the future
02:36:04 <ais523> also, the meaningful bits of the pointer can be used as unmasked tag bits if you're careful to allocate at the right addresses
02:36:38 <ais523> (there is little reason why programs shouldn't have full control over their own memory maps nowadays other than ASLR)
02:39:10 <ais523> oh, you can also refuse to allocate low, and then use the bottom few pointers as special invalid values
02:39:40 <ais523> $ cat /proc/sys/vm/mmap_min_addr
02:40:09 <ais523> even if someone changes mmap_min_addr for some reason, there is very little reason to allocate below there anyway
02:40:25 <b_jonas> ais523: specifically the most recent x86_64 pointers have a sign bit plus 56 magnitude bits, which gives 67 bits which is looked up in 5 levels of page table each 9 bits wide (4096 bytes long for 512 entries of 8 byte each), then the last 12 bits are direct address within a 4096 byte long page (can be 4 levels plus 21 direct bits for 2K large pages, or 3 levels plus 30 direct bits for 1G sized huge
02:41:13 <ais523> I was actually using the 1G huge pages recently, or trying to
02:41:36 <ais523> I didn't actually manage to optimise the rest of the program to the point where minimizing TLB misses became relevant
02:41:51 <b_jonas> so the user half of virtual address space is 56 bits wide, and tom7 used at least 37 of those bits for actual physical memory in BoVeX
02:42:26 <b_jonas> that gives at *most* 19 extra bits on top for currenly available hardware, and that will shrink quickly
02:42:43 <ais523> I think at some point, it makes sense to start using indexes instead, then you can have as many tag bits as you want
02:42:43 <b_jonas> I admit you do have some wiggle room, but I'd prefer to use tag bits on the bottom in most cases
02:43:13 <b_jonas> the advantage of tag bits at the bottom is that if you know the tag bits then you don't need to mask them out, you can just subtract them in an offset operand
02:43:18 <ais523> fwiw I'm pretty sure I've never tagged a pointer high, and can't remember whether or not I've ever tagged a pointer low (but I have tagged the middle bits using the "choose where you allocate" strategy)
02:43:47 <b_jonas> if you ever used ruby 1.8 then you have tagged a pointer low
02:44:05 <ais523> I have been wondering whether, if using low tag bits for an integer/pointer union, it makes more sense to tag the pointer as odd or even
02:44:26 <ais523> the offset argument makes me think that maybe the pointer should be tagged by subtracting 1…
02:44:48 <ais523> and by "I've tagged a pointer" I meant in my own code, with my own pointer arithmetic
02:44:58 <b_jonas> although IIRC that tag is almost always zero, it's nonzero only for non-large integers, symbols, and a few special values like true, false, and two or three null values whatever they call them
02:45:03 <ais523> I've used OCaml at work, that tags pointer/integer unions, although I forget how
02:46:17 <ais523> but the 31-bit integers are a bit of a giveaway (I wonder whether those are 63-bit integers on 64-bit systems?)
02:46:36 <b_jonas> I wanted to ask about some memory allocation strategies here that might involve tagging indexes, but I don't think that will be today
02:47:03 <ais523> doesn't luajit store most things as double-precision floats, including pointers which are NaN payloads?
02:47:23 <b_jonas> ais523: I think r5rs requires that you support integers at least 28 bits wide exactly because they expect you to tag at most four bits in a pointer that may be 32-bit wide
02:47:39 <b_jonas> but for tagged integers you can just transparently heap-allocate anything that doesn't fit and still have most of the gains
02:48:00 <ais523> it's just so rare that I need to tag pointers
02:49:59 <b_jonas> technically rust and C++ both have some built-in language support for treating null pointers specially, but I don't think that counts as tagging
02:51:30 <ais523> rust has dangling, which is a special pointer value in a way
02:51:39 <ais523> although I'm not sure it would ever make much sense to compare against it
02:52:02 <b_jonas> no, that's explicitly not a special pointer value, as in you can't compare against it
02:52:03 <ais523> and I think it's theoretically possible for it to be the same address as a legitimate allocation and thus compare equal to it
02:52:24 <b_jonas> it's an arbitrary non-null value that you can compare against null but not against other valid pointers, it may be equal to a valid pointer
02:52:33 <ais523> well, I don't think the language can stop you comparing against it, it just doesn't guarantee that it doesn't equal a valid pointer
02:52:59 <b_jonas> if you want a special value that you can compare to then you just allocate a structure with the same alignment and get a pointer to it
02:54:13 <ais523> I guess not wasting values by refusing to allocate there might be important in some very memory-constrained systems
02:54:29 <b_jonas> you can basically always reuse some other allocation
02:54:54 <ais523> I've used processors with less than a kilobyte of memory – tagging pointers *there* would have been really obnoxious because they were 8 bits wide and used bank switching
02:55:49 <b_jonas> I don't want to work with such systems. Though I'm fine with narrow indexes into small arrays on a big processor with more memory in general.
02:55:55 <ais523> there were a couple of values that were necessarily invalid because they were memory-mapped and used for pointer dereferencing (it was something like "if you write x to address 8 you can read/write *x from address 0"
02:56:15 <ais523> but in general making special sorts of pointer would be really hard
02:57:04 <zzo38> Presumably you could jump to a absolute address by writing the address into the return address register, so can you then enforce position-independent code? Probably the best way would be instead you can use virtual addressing or bank switching or use tagged pointers like Flex uses that I think is unable to determine the address of a block (it is an opaque value that arithmetic cannot be made).
02:57:06 <ais523> also about half of RAM was memory-mapped to something or other, often in ways that meant you could use it as general purpose registers if you switched off the specific feature it controlled
02:57:40 <ais523> zzo38: it'd technically be possible for the return address register to be relative to the stack pointer
02:58:17 <ais523> because, on function entry, the position of the stack pointer on function exit is known (at least if the stack usage is balanced, and it generally is)
02:58:47 <ais523> although that just raises the question of what the stack pointer is relative to
02:59:12 <b_jonas> https://esolangs.org/wiki/Apollo_Guidance_Computer is funny because they had a bank-switching system and then they found out that the bank-switching system has too few bits so they extended it in a weird way to remain compatible with existing code that assumes there's only so many bits in the bank numbers, so it's really weird
02:59:41 <ais523> I kind-of miss bank switching
02:59:47 <ais523> I can see why people wanted to get rid of it
03:00:13 <ais523> but smaller pointers have their own benefits
03:01:33 <b_jonas> I haven't written an article on https://www.bigmessowires.com/cpu-in-a-cpld/ yet, but that one has relatively sane bank switching in a separate chip from the main CPU, the main CPU doesn't know about banks, but that's kind of normal for a chip inspired by 90s era microcomputer systems, this just has a much smaller address space
03:02:53 <zzo38> Sometimes you could require the data to be in a specific array or other memory area that is small enough to use smaller pointers, and then add it to the base address, so sometimes the benefits of small pointers can still be possible.
03:04:33 <b_jonas> specifically 2**10 bytes of virtual memory, of which the bottom 2**9 bytes is one bank-switchable block among 2**7 pages of 2**9 bytes each of physical memory, half of which is RAM and half is ROM, and the other half is fixed memory plus a few IO registers including the one that tells which bank to use
03:04:34 <zzo38> With the ideas I had about the operating system design, it is intended to be a security feature that programs cannot know how they are loaded, so probably would not work with physical addressing unless bank switching is used and other security features to prevent programs from accessing another program's memory.
03:05:32 <ais523> <Apollo Guidance Computer> There is a special indexing instruction that loads an operand from memory and adds its value to the next instruction as that instruction is executed. ← this is an incredibly clever way to do indirect memory access
03:05:56 <ais523> although it only really works if you trust the pointer value
03:05:58 <b_jonas> you can do bank switching today with mmap/mremap if you want
03:06:15 <ais523> you can but it's very slow compared to hardware bank switching
03:06:22 <b_jonas> you can verify a pointer value.
03:06:39 <ais523> fs and gs are probably a more sensible way to bank-switch
03:07:00 <b_jonas> I don't think you can use those on x86_64
03:07:11 <ais523> you can! even from user mode
03:07:34 <b_jonas> you can't make them point to whereever you want, can you?
03:07:43 <ais523> yes, on modern processors
03:08:04 <b_jonas> you can use them as in you can access memory through them, but one I'm not sure what it does and one is claimed for the thread-specific structure
03:08:05 <ais523> if you try to mov into FS or GS you get all the nonsense of segment selectors and the like
03:08:16 <ais523> but, there are separate instructions that just outright set them to anything
03:08:35 <b_jonas> I thought that needs operating system support which we don't have\
03:08:59 <b_jonas> like how we don't have support for 16-bit protected mode programs even though in theory the CPU supports them
03:09:07 <zzo38> So with this security feature, it is not quite the same as enforcing position independent code although there is a similarity.
03:09:21 <ais523> the OS can disable the instructions if it wants to
03:09:39 <ais523> but I think it usually doesn't
03:10:51 <ais523> incidentally, FS and GS have somewhat different performance characteristics because GS is heavily involved in the system call fastpath
03:11:33 <zzo38> If the OS does disable the instructions, can it receive an interrupt to emulate them? (In this case you probably do not need to, although it can be relevant for some other instructions that you might want to disable, e.g. CPUID (I don't know if you can disable that one), and measuring timing)
03:11:37 <ais523> I think that's the reason why the main Linux implementation of pthreads changed from using GS for thread-local storage on x86 to FS on x86-64
03:11:39 <b_jonas> ais523: huh, you're right, I hadn't known of this fsgsbase instruction set extension to x86_64. indeed we have that. you can probably only use one of them unless you really make sure that nothing is trying to use threads because any library function can assume one of them is the thread-specific area, but in theory you can use one to some extent.
03:11:59 <ais523> although, I'm not sure if they actually had to in order to make things work
03:12:22 <b_jonas> I'm not sure if it's worth over just using other ordinary indexing methods, but they seem to be available
03:13:12 <ais523> the other main instruction is SWAPGS which swaps GS with a kernel-only register that's only used by SWAPGS (although you can read/write it directly with the MSR instructions)
03:13:27 <b_jonas> zzo38: I think the problem is that if nobody uses these features then the OS might not want to save FS and GS with switching between tasks, at least might not want to save the one that's not used as the thread-specific area
03:13:29 <ais523> that gives the kernel a way to get pointers to its own structures when all the registers have user-mode values
03:14:17 <zzo38> b_jonas: OK, that is legitimate. But, maybe the operating system wants to use only one of them, so that the other one can be used by user programs.
03:14:22 <ais523> ah right, and I think the reason GS is slow is not that it's slow on the kernelmode/usermode transition, but that the kernel has to swap out the value of GS when switching from one usermode thread to another but it's in a weird register that's a bit hard to access
03:14:46 <ais523> so GS is primarily used by the kernel and FS is primarily used by the threading library, in practice on x86-64 systems
03:16:02 <ais523> incidentally, I have been wondering whether it would make sense to do thread-local storage by starting thread stacks at a known large alignment, then storing the thread-local storage below the thread stack and using SP to determine where it is
03:16:08 <b_jonas> I thought the reason why you don't want to use these is that they could disrupt modern CPU optimizations that try to guess what address you're accessing when you access memory outside of the L1 cache and load it in time before you need it
03:16:08 <ais523> but, using FS is probably faster
03:16:57 <ais523> (by "below" I mean at the end which doesn't do the calls and returns, which is actually above in terms of address because x86 stacks are upside-down)
03:16:57 <b_jonas> ais523: no, the linux kernel started that for task structures, storing them under small kernel stacks, but then they gave that up because it caused more problems than it solved
03:17:12 <ais523> I am not totally surprised
03:17:17 <ais523> (at either half of that)
03:19:06 <b_jonas> we have stuff stored under the *user-mode* stack, but only for a tiny moment when the kernel execs a process or spawns a thread and calls the start function in libc which I assume immediately store a pointer to that somewhere. argc, argc, and I think getauxval or some such nonsense lives there.
03:19:31 <b_jonas> that doesn't rely on alignment, the values are simply above the frame of the user-mode starting function
03:20:14 <b_jonas> perhaps only on exec, I don't know how thread start works
03:20:28 <ais523> it's auxv, getauxval is the function that accesses it
03:20:52 -!- Lord_of_Life has quit (Ping timeout: 252 seconds).
03:21:07 <b_jonas> so basically only libc or a replacement to libc has to know about that, and then you access the values through libc apis
03:21:51 <ais523> this is a generalised "you", right? I feel like most programmers are more inclined to use libc than I am
03:22:15 <ais523> I have been known to just write the raw syscalls to avoid bringing in libc as a dependency
03:22:24 <b_jonas> a generalized you, yes, not you ais523
03:22:40 <b_jonas> if you do that then your code is a libc replacement
03:22:49 -!- Lord_of_Life has joined.
03:22:57 <ais523> in general I dislike dependencies unless I get a lot of benefit from them, and if I'm only making a few syscalls, libc seems so heavyweight a dependency to bring in
03:23:40 <ais523> but the code isn't really a libc replacement because it only implements a small subset of the functionality – just enough to make it work
03:24:18 <b_jonas> well sure, basically nothing implements all of libc, even the actual useful replacements
03:24:36 <b_jonas> but yes, if it's just a few syscalls then that makes sense
03:25:00 <ais523> I think there are a few useful replacements that implement all of POSIX libc
03:25:13 <ais523> I would be surprised if any of the replacements did the entirety of glibc, though
03:25:30 <zzo38> Which instructions can be disabled by the operating system? Can the CPUID instruction be disabled? What on other kind of instruction sets?
03:26:24 <ais523> zzo38: there are quite a few, but I think the disabling methods are case-by-case/ad-hoc rather than there being any consistent rules
03:27:19 <ais523> RDTSC can be disabled, that's one of the main ones I know off the top of my head
03:27:38 <zzo38> Yes, and I also saw RDTSC disabled mentioned on Wikipedia.
03:27:45 <ais523> although the bit that disables it is, oddly, in CR4 for some reason
03:27:50 <b_jonas> zzo38: I think those disable things are concerned with two things: (1) CPU features that require operating system support such as saving registers between processes, and (2) virtualization with hot-migration between CPUs that implement different instructions, so the CPU lets you disable extensions that might not be present on other modern x86 cpus
03:27:51 <ais523> which seems like an overly important place to put it?
03:28:29 <b_jonas> well, also (3) instructions that would be unsecure because they let you access memory that you aren't supposed to or execute code in kernel mode or similar
03:28:57 <zzo38> For the security model of my operating system design will require that several instructions to be disabled (and for implementations using other instruction sets, they also might or might not need some instructions to be disabled). Virtualization with hot-migration is one of the reasons for this, actually, but there are other reasons too.
03:29:16 <b_jonas> ais523: I think that's because RDTSC is a very old instruction, goes all the way to the original pentium
03:30:16 <b_jonas> but I think there are uglier methods that the OS can use, like there was one workaround to disable an instruction that had a CPU bug back long ago
03:30:23 <ais523> also disabling RDTSC gives you a #GP fault (SIGSEGV) rather than a #UD fault (SIGILL) like you'd expect from a disabled instruction
03:30:25 <zzo38> However, some instructions might not need to be disabled and maybe they could be emulated instead, such as some of the bitwise manipulation extensions.
03:30:41 <b_jonas> using what's supposed to be debugging stuff or microcode update or something crazy like that
03:31:03 <ais523> microcode update is the intended way to disable a buggy instruction, isn't it?
03:31:23 <b_jonas> probably, I don't know the details
03:31:49 <b_jonas> I figure these are operating system details that I'm not concerned about, plus that one is very old
03:31:50 <ais523> I know that with the F00F bug, the best discovered fix involved doing something weird with the paging for the interrupt table
03:33:51 <ais523> ah – it seems that the "official" fix was to page out the undefined opcode interrupt handler, while ensuring that the page fault interrupt handler was on a separate page that was paged in (because you can't page that one out for obvious reasons)
03:34:09 <ais523> but just marking the undefined opcode interrupt handler as noncacheable turned out to be enough
03:36:59 <esolangs> [[Larry]] https://esolangs.org/w/index.php?diff=136668&oldid=136289 * ArsenicCatnip * (+1391) Added a section on how the Copy command works. This will also be a template for the Paste section.
03:39:20 <b_jonas> zzo38: have you looked at https://esolangs.org/wiki/BMOW_1 ? I think you might find that CPU interesting.
03:39:43 <zzo38> I have looked briefly, but I can look more now
03:44:48 <b_jonas> it's somewhat similar to a 6502-based CPU, but it has a few instructions that directly use full three-byte addresses stored contiguously as three bytes in RAM. I wonder if the WDC 65C816 has any of that
03:45:45 <b_jonas> hmm, apparently it does have such instructions
03:47:01 <b_jonas> but it looks like they handle zero page addresses differently
03:48:21 <b_jonas> also as far as I understand the subtract with borrow uses the carry flag differently, and the flags differ in other ways from 6502-derivatives
03:48:49 <b_jonas> so BMOW 1 is inspired by the 6502 but doesn't really try to be compatible with it in any sense, you're not expected to port 6502 code onto it
03:50:20 <b_jonas> but it still has lots of ways in which it imitates 6502, like how all its add and subtract instructions use the carry as implicit input
03:50:32 <b_jonas> and in its addressing modes
03:51:53 <b_jonas> the other difference is taht WDC 65C816 just straight up has 16-bit wide A,X,Y registers with 16-bit arithmetic and load/store operations on them, while BMOW 1 is pure 8-bit like the 8-bit 6502s
03:52:44 <b_jonas> but I think the BMOW 1 has a bit more instructions than the 6502 that use 16-bit address stored in memory
03:55:19 <b_jonas> also BMOW 1 has slow shift right instructions that are implemented by shifting right seven times in microcode
03:56:17 <b_jonas> i find that funny, but that's what you get if you build your CPU from 20th century discrete chips one of which is a large ROM chip used for microcode
03:56:49 <b_jonas> extra microcode are cheap so it's worth to implement such a feature in microcode
03:57:51 <b_jonas> the cheap microcode is also why the instruction table is so irregular: they could place any instruction to any opcode without penalty
03:58:23 <ais523> I am reminded of how complicated the VERW instruction is getting
03:58:55 <ais523> (and it still finishes off by working out the correct return value for the original definition of the instruction, even though doing so is pretty much entirely useless nowadays)
03:59:19 <ais523> it's one of the few microcoded instructions that can be run from userspace
03:59:21 <b_jonas> how is it getting complicated?
03:59:31 <ais523> it's full of mitigations for spectre, meltdown and friends
03:59:52 <b_jonas> more full than other memory accesses?
04:00:06 <ais523> like, it clears pretty much all the relevant microarchitectural state that they might try to read
04:00:44 <ais523> it's not even a memory access, it's basically just a "this is a security boundary" assertion and the processor tries to make sure that data doesn't leak across the boundary through sidechannels
04:01:24 <ais523> or, well, it might involve a memory access, I can't remember all the details of its intended functionality, except that it's related to old-fashioned real-mode segmentation
04:02:02 <b_jonas> but why does it have to involve more of that than other normal memory access?
04:02:23 <ais523> because if you wiped all the microarchitectural state on every memory access the processor would run incredibly slowly
04:02:42 <ais523> I think it does things like empty the branch predictors
04:03:10 <ais523> to ensure that one program can't train the branch predictors to mispredict the branches made by another
04:03:11 <b_jonas> oh! VERW has to ignore paging, it only checks if the address is valid in the segment level, not whether it's pageed in
04:03:26 <b_jonas> that's why it's complicated, it can't use the normal memory access logic
04:03:35 <ais523> oh, I see, you're asking why it's microcoded
04:03:49 <b_jonas> more why it's complicated microcode
04:04:10 <ais523> also I think VERW takes a segment selector as argument rather than a memory address
04:04:33 <b_jonas> I thought for some reason that it used the normal memory access logic and so if the page was paged out by the operating system then it told the user process that the address is not writable. nope. it only does the segment level checks, ignoring paging.
04:04:57 <b_jonas> yeah, apparently it takes a segment selector
04:05:00 <ais523> <Intel 64 manual volume 2> "The source operand is a 16-bit register or a memory location that contains the segment selector for the segment to be verified."
04:05:20 <b_jonas> yeah, that's probably microcoded because it's such an obscure and rarely used instruction that it isn't worth an optimized implementation
04:05:47 <ais523> right, not to mention useless on modern systems because they don't use segment selectors for anything
04:05:53 <b_jonas> but it's probably mostly the same as loading a segment register
04:06:25 <ais523> that might well be microcoded too? even 16-bit code doesn't do it very often
04:06:35 <ais523> segment override prefixes are common, but actually changing the segment registers isn't
04:07:01 <b_jonas> probably, because modern CPUs aren't optimized to run 16-bit protected mode code efficiently
04:07:46 <ais523> hmm, what's written in 16-bit protected? early boot is 16-bit real, and I think DPMI is 32-bit protected?
04:07:49 <b_jonas> they don't need to be because operating systems don't support it anymore
04:08:12 <b_jonas> ais523: 16-bit windows code mostly
04:08:28 <ais523> oh right, "386 enhanced mode"
04:09:36 <ais523> I doubt Intel cares much if their modern processors are slower at running Windows 3.1
04:09:46 <b_jonas> no, even windows in traditional 286 mode is running on 16-bit protected mode, that just means it can't access more than a megabyte of physical memory, so nobody used that even back when I was young, we had a full megabyte of RAM in the oldest laptop that I've seen
04:10:18 <b_jonas> in 386 mode the operating system is 32-bit but the user code is still 16-bit, which 386 is made to support:
04:10:24 <ais523> although, they strike me as the sort of company who might try to optimise for that for unknown reasons
04:10:39 <b_jonas> the segment selector of the code simply tells whether code in it is 16-bit protected code or 32-bit protected code
04:10:53 <ais523> they keep adding new instructions to the 32-bit and 16-bit instruction sets
04:11:04 <ais523> which means that the instructions have to have an encoding that doesn't calsh
04:11:58 <b_jonas> and windows 95 to XP supports mixing win16 and win32 code, with I think an entirely separate operating system interface for the two, then later two and a half separate interfaces (with old win32 versus winNT)
04:12:46 <ais523> it's not quite entirely separate, they have a lot in common
04:12:46 <b_jonas> and XP even lets you run 16-bit processes either in their own 16-bit namespace or a shared namespace where multiple win16 processes can directly address each other's memory
04:13:04 <ais523> I did a lot of 16-bit programming back on Windows 95
04:13:16 <ais523> I am not sure why I didn't switch to 32-bit; I think I might have been scared of change
04:13:30 <b_jonas> but then eventually in later windowses they dropped the built-in support for win16, so you have to run emulator software, either OS-level or full machine level emulators
04:13:52 <b_jonas> ais523: perhaps the compilers or libraries accessible to you were mostly 16-bit
04:14:20 <ais523> I do remember being very annoyed when they removed the API for beeping with a specific pitch using the internal speaker
04:14:35 <b_jonas> hah! I think linux still has that
04:14:46 <ais523> they had multimedia APIs instead for playing WAV files, but it wasn't the same (and also was extremely buggy)
04:14:59 <ais523> I'm not convinced this computer even has an internal speaker
04:15:15 <b_jonas> that's irrelevant, I'm talking about the API, not what hardware implements it
04:15:30 <ais523> but it'd be nostalgic to be able to test it out
04:15:51 <ais523> it would probably be possible to put Linux on an old computer to find out…
04:17:41 <b_jonas> https://man7.org/linux/man-pages/man2/ioctl_kd.2.html search for KDMKTONE
04:18:08 <b_jonas> I don't think it has to be an old computer, I think that works on modern, though I haven't tested
04:18:27 <b_jonas> (unless you mean the windows API natively)
04:19:19 <ais523> huh, my computer doesn't have that manpage
04:20:04 <ais523> your link says "broken in Linux 2.1.49-50" – I wonder if that includes all future versions too
04:20:28 <ais523> but it doesn't say the same about KIOCSOUND which is the next entry, and also controls the speaker
04:21:03 <b_jonas> 2.1.49 is very old so I don't think it includes all future version
04:21:10 <ais523> some of the programs at the time could play chords using the internal speaker; I assume that was done using some sort of audio equivalent of racing the beam, but never did figure it out
04:24:03 <b_jonas> ais523: try man 4 console_ioctl, I think that just got recently separated or moved to a different manpage
04:24:36 <ais523> ah yes, it's on that page
04:25:17 <ais523> and it still says "broken in Linux 2.1.49-50" with no further updates on if or when it was fixed
04:25:45 <b_jonas> I expect that it just works on modern linux computers if you run it on a virtual console that isn't running X11
04:26:22 <b_jonas> I don't remember if I used this on old computers or not; I used the ioctl calls that changes the font and the like
04:28:00 <b_jonas> ok, now I'm curious, I'll test it
04:34:25 <b_jonas> in an X terminal it returns an error errno=ENOTTY as expected, but on virtual console it returns success and makes no sound
04:34:27 <ais523> did you check KIOCSOUND too?
04:34:48 <b_jonas> maybe it does want to use only the built-in speaker and doesn't emulate on virtual consoles?
04:35:06 <b_jonas> I have not checked KIOCSOUND
04:35:34 <ais523> I woudln't expect it to emulate, I'd expect built-in speaker only
04:35:47 <ais523> although, maybe it has to emulate for beeps to work
04:36:41 <b_jonas> virtual console emulates what was originally supposed to be a VGA text mode console in graphics mode these days, which is why I expect to emulate the speaker too
04:38:34 <b_jonas> either it does not emulate, or something on X11 is using the sound system exclusively which is why it doesn't make a sound
04:40:57 <b_jonas> or I guess there could be some per-console or global setting in the kernel that disables the beeps and that's the default in this distro because beeps are annoying
04:41:39 <b_jonas> I don't feel like searching docs and/or kernel code for this now
04:53:30 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136669&oldid=136626 * Yayimhere * (-3512) /* with some complexity */ remaking it
04:54:58 -!- craigo has quit (Quit: Leaving).
05:02:36 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136670&oldid=136669 * Yayimhere * (-422) /* a step by step version */
05:04:13 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136671&oldid=136670 * Yayimhere * (+43)
05:06:16 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136672&oldid=136671 * Yayimhere * (+46) /* semantics */
05:29:30 <esolangs> [[Better Burn]] M https://esolangs.org/w/index.php?diff=136673&oldid=136631 * Unname4798 * (-1) typo fix
05:30:27 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136674&oldid=136672 * Yayimhere * (+206) /* one with no complexity */
05:35:38 <esolangs> [[User talk:Unname4798]] https://esolangs.org/w/index.php?diff=136675&oldid=136432 * Unname4798 * (+2) grade the discussions
05:36:12 <esolangs> [[User talk:Unname4798]] M https://esolangs.org/w/index.php?diff=136676&oldid=136675 * Unname4798 * (+4) correct headers
05:44:30 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136677&oldid=136674 * Yayimhere * (+595) /* some complexity */
05:47:44 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136678&oldid=136677 * Yayimhere * (+245)
05:48:01 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136679&oldid=136678 * Yayimhere * (+4) /* some complexity */
05:48:36 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136680&oldid=136679 * Yayimhere * (+42) /* a step by step version */
05:49:27 -!- tromp has joined.
05:54:53 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
05:56:02 -!- ais523 has quit (Quit: quit).
05:57:42 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136681&oldid=136680 * Yayimhere * (+11)
06:02:07 <esolangs> [[User talk:Unname4798]] https://esolangs.org/w/index.php?diff=136682&oldid=136676 * Yayimhere * (-4)
06:25:50 <esolangs> [[256]] https://esolangs.org/w/index.php?diff=136683&oldid=108844 * Yayimhere * (-18) /* Interpreters */
06:35:20 <esolangs> [[User talk:Unname4798]] https://esolangs.org/w/index.php?diff=136684&oldid=136682 * Unname4798 * (+4) Undo revision [[Special:Diff/136682|136682]] by [[Special:Contributions/Yayimhere|Yayimhere]] ([[User talk:Yayimhere|talk]]) (please do not revert unmame4798's edits)
06:38:28 <esolangs> [[Talk:256]] https://esolangs.org/w/index.php?diff=136685&oldid=136648 * Yayimhere * (+190)
06:39:32 <esolangs> [[3ME]] https://esolangs.org/w/index.php?diff=136686&oldid=136543 * Unname4798 * (+6)
06:41:18 <esolangs> [[User talk:Unname4798/Rollback test]] N https://esolangs.org/w/index.php?oldid=136687 * Unname4798 * (+4) Created page with "Test"
06:41:27 <esolangs> [[User talk:Unname4798/Rollback test]] https://esolangs.org/w/index.php?diff=136688&oldid=136687 * Unname4798 * (+6)
06:41:33 <esolangs> [[User talk:Unname4798/Rollback test]] https://esolangs.org/w/index.php?diff=136689&oldid=136688 * Unname4798 * (+6)
06:41:53 <esolangs> [[User talk:Unname4798/Rollback test]] https://esolangs.org/w/index.php?diff=136690&oldid=136689 * Unname4798 * (-12)
06:44:47 -!- tromp has joined.
06:46:55 <zzo38> Can you make a Babson task in Magic: the Gathering?
06:50:17 <esolangs> [[Nope]] https://esolangs.org/w/index.php?diff=136691&oldid=136260 * Yayimhere * (+652)
06:50:28 <esolangs> [[Nope]] https://esolangs.org/w/index.php?diff=136692&oldid=136691 * Yayimhere * (+1) /* = turing completeness proof */
06:51:54 <esolangs> [[Short Minsky Machine Notation]] https://esolangs.org/w/index.php?diff=136693&oldid=136489 * Yayimhere * (+41)
07:21:59 <esolangs> [[Bijection]] N https://esolangs.org/w/index.php?oldid=136694 * Yayimhere * (+433) Created page with "'''Bijection''' is a esolang created by [[User:Yayimhere]] where all you do is copy lines to other lines == commands == there is the main command: {}''n'' the contents of the brackets will be replaced with the contents of line ''n''(starting at 0). if the brackets a
07:24:16 <esolangs> [[OFFICIAL]] https://esolangs.org/w/index.php?diff=136695&oldid=136530 * Yayimhere * (-7) /* examples */
07:31:17 <esolangs> [[1L a]] https://esolangs.org/w/index.php?diff=136696&oldid=91646 * Graue * (+7) update links
07:33:54 <esolangs> [[User:Yayimhere]] https://esolangs.org/w/index.php?diff=136697&oldid=136630 * Yayimhere * (+16)
07:42:09 <esolangs> [[Func()]] https://esolangs.org/w/index.php?diff=136698&oldid=136467 * Yayimhere * (+40)
07:44:45 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
07:45:16 <esolangs> [[Truth-machine]] https://esolangs.org/w/index.php?diff=136699&oldid=136461 * Yayimhere * (+51) /* FurryScript */
07:50:12 <esolangs> [[]] https://esolangs.org/w/index.php?diff=136700&oldid=133228 * Yayimhere * (+174)
07:54:46 -!- tromp has joined.
07:56:32 <esolangs> [[]] https://esolangs.org/w/index.php?diff=136701&oldid=136700 * Yayimhere * (+62) /* computational class */
07:59:29 <esolangs> [[2dL]] https://esolangs.org/w/index.php?diff=136702&oldid=133356 * Yayimhere * (-159) /* examples */
08:00:35 <Sgeo> Esoteric shell idea: Scan all of memory for certain byte patterns, and if you see them, assume that they're valid commands. Wait, that's real, https://floooh.github.io/virtualkc/p010_kc85.html#:~:text=On%20the%20software,7F%207F%E2%80%99%20headers.
08:00:55 <Sgeo> Unless there's something I'm misunderstanding there
08:01:18 <esolangs> [[,(*+)]] https://esolangs.org/w/index.php?diff=136703&oldid=132539 * Yayimhere * (+1)
08:02:20 <esolangs> [[DQ]] https://esolangs.org/w/index.php?diff=136704&oldid=136561 * Yayimhere * (-6)
08:03:35 <esolangs> [[DQ]] https://esolangs.org/w/index.php?diff=136705&oldid=136704 * Yayimhere * (-9)
08:10:27 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
08:15:04 <esolangs> [[Marthue]] M https://esolangs.org/w/index.php?diff=136706&oldid=78077 * PkmnQ * (-142) See [[Talk:Markov algorithm]]
08:15:09 <esolangs> [[Transet]] M https://esolangs.org/w/index.php?diff=136707&oldid=118749 * PkmnQ * (+40) See [[Talk:Markov algorithm]]
08:15:11 <esolangs> [[1.1]] M https://esolangs.org/w/index.php?diff=136708&oldid=79309 * PkmnQ * (+10) See [[Talk:Markov algorithm]]
08:18:44 -!- tromp has joined.
08:30:23 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136709&oldid=136681 * Yayimhere * (+80) /* semantics */
08:33:04 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136710&oldid=136709 * Yayimhere * (+62)
09:00:32 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136711&oldid=136710 * Yayimhere * (+268) /* some complexity */
09:08:55 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136712&oldid=136711 * Yayimhere * (+4) /* some complexity */
09:09:45 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136713&oldid=136712 * Yayimhere * (+2) /* some complexity */
09:10:00 <b_jonas> Sgeo: “Scan all of memory for certain byte patterns, and if you see them, assume that they're valid commands.” => telnet with a plain text password is somewhat close to that, only for network instead of memory, and it usually requires a roundtrip or two for TCP to work
09:10:24 <b_jonas> assuming you configure the telnet server to just run a shell that is
09:10:26 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136714&oldid=136713 * Yayimhere * (+38) /* some complexity */
09:10:38 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
09:11:10 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136715&oldid=136714 * Yayimhere * (+87) /* some complexity */
09:11:14 <esolangs> [[Truth-machine]] https://esolangs.org/w/index.php?diff=136716&oldid=136699 * Ractangle * (+2) /* [[Func()|Func[]]] */
09:11:39 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136717&oldid=136715 * Yayimhere * (+36) /* some complexity */
09:12:03 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136718&oldid=136717 * Yayimhere * (+37) /* some complexity */
09:12:31 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136719&oldid=136718 * Yayimhere * (+34) /* some complexity */
09:12:52 <esolangs> [[Truth-machine]] https://esolangs.org/w/index.php?diff=136720&oldid=136716 * Ractangle * (+120) /* Python */
09:14:12 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136721&oldid=136719 * Yayimhere * (+280) /* some complexity */
09:14:26 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136722&oldid=136721 * Yayimhere * (+44) /* some complexity */
09:14:51 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136723&oldid=136722 * Yayimhere * (+31) /* some complexity */
09:14:57 <esolangs> [[Truth-machine]] https://esolangs.org/w/index.php?diff=136724&oldid=136720 * Ractangle * (-3) /* Python */
09:16:40 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136725&oldid=136723 * Yayimhere * (-3) /* some complexity */
09:18:05 -!- drwiz has joined.
09:27:43 -!- tromp has joined.
09:28:49 -!- __monty__ has joined.
09:32:57 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136726&oldid=136725 * Yayimhere * (+526) /* one with no complexity */
09:41:27 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136727&oldid=136726 * Yayimhere * (+42) /* another example with no colors n' stuff cuz im to tired -_- */
09:41:45 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136728&oldid=136727 * Yayimhere * (+19) /* example programs */
09:46:45 -!- slavfox has quit (Quit: ZNC 1.8.2 - https://znc.in).
09:48:42 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
09:49:31 -!- tromp has joined.
09:50:02 -!- slavfox has joined.
10:05:43 <esolangs> [[401]] https://esolangs.org/w/index.php?diff=136729&oldid=134538 * Yayimhere * (+499)
10:07:23 <esolangs> [[Truth Machine (language)]] https://esolangs.org/w/index.php?diff=136730&oldid=105853 * Ractangle * (+3) python technicaly uses == instead of =
10:07:47 <esolangs> [[Truth Machine (language)]] https://esolangs.org/w/index.php?diff=136731&oldid=136730 * Ractangle * (-3)
10:09:40 <esolangs> [[SLet]] https://esolangs.org/w/index.php?diff=136732&oldid=136255 * ZCX islptng * (+12)
10:11:13 <esolangs> [[SLet]] https://esolangs.org/w/index.php?diff=136733&oldid=136732 * ZCX islptng * (-3)
10:14:18 <esolangs> [[!()]] https://esolangs.org/w/index.php?diff=136734&oldid=134573 * Yayimhere * (-1)
10:15:08 <esolangs> [[!()]] https://esolangs.org/w/index.php?diff=136735&oldid=136734 * Yayimhere * (-1)
10:19:34 <esolangs> [[Truth Machine (language)]] https://esolangs.org/w/index.php?diff=136736&oldid=136731 * Ractangle * (-22) /* Commands */
10:19:59 <esolangs> [[SLet]] https://esolangs.org/w/index.php?diff=136737&oldid=136733 * ZCX islptng * (+70)
10:28:39 -!- dawids has joined.
10:28:45 -!- dawids has quit (Remote host closed the connection).
10:35:00 <esolangs> [[25 bytes o:]] https://esolangs.org/w/index.php?diff=136738&oldid=136275 * Ractangle * (+38) /* python intepreter */
10:42:53 <esolangs> [[Special:Log/upload]] upload * Yayimhere * uploaded "[[File:Wang tiles for w4ng =.jpg]]"
10:44:48 <esolangs> [[W4ng =]] N https://esolangs.org/w/index.php?oldid=136740 * Yayimhere * (+766) Created page with "'''W4ng <nowiki>=</nowiki>''' is a [[esolang]] created by [[User:Yayimhere]] inspired by [[Wikipedia: Wang tile|Wang tiles]]. a W4ng = program takes the given tiles and use a algorithm to tile the plane, halting when it can no longer tile == semantics == to define the l
10:52:55 <esolangs> [[W4ng =]] https://esolangs.org/w/index.php?diff=136741&oldid=136740 * Yayimhere * (+612)
10:53:13 <esolangs> [[W4ng =]] https://esolangs.org/w/index.php?diff=136742&oldid=136741 * Yayimhere * (+1)
10:54:44 <esolangs> [[W4ng =]] https://esolangs.org/w/index.php?diff=136743&oldid=136742 * Yayimhere * (+14)
11:06:14 -!- Sgeo has quit (Read error: Connection reset by peer).
11:06:18 <esolangs> [[User:Yayimhere]] https://esolangs.org/w/index.php?diff=136744&oldid=136697 * Yayimhere * (+13)
11:09:09 <esolangs> [[Transet]] https://esolangs.org/w/index.php?diff=136745&oldid=136707 * Yayimhere * (+2)
11:12:01 <esolangs> [[!()]] https://esolangs.org/w/index.php?diff=136746&oldid=136735 * Yayimhere * (+25)
11:13:08 <esolangs> [[!()]] https://esolangs.org/w/index.php?diff=136747&oldid=136746 * Yayimhere * (-25) /* examples */
11:14:35 -!- drwiz has quit (Ping timeout: 256 seconds).
11:14:37 <esolangs> [[OFFICIAL]] https://esolangs.org/w/index.php?diff=136748&oldid=136695 * Yayimhere * (+11) /* examples */
11:36:28 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
12:32:35 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136749&oldid=136728 * Yayimhere * (+39) /* another example with no colors n' stuff cuz im to tired -_- */
12:36:09 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136750&oldid=136749 * Yayimhere * (+18) /* example programs */
12:40:36 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136751&oldid=136750 * Yayimhere * (+66) /* some complexity */
12:41:24 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136752&oldid=136751 * Yayimhere * (-1) /* some complexity */
12:44:16 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136753&oldid=136752 * Yayimhere * (-383) /* some complexity */
12:44:35 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136754&oldid=136753 * Yayimhere * (+1) /* some complexity */
12:45:27 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136755&oldid=136754 * Yayimhere * (+36) /* some complexity */
12:46:11 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136756&oldid=136755 * Yayimhere * (+33) /* some complexity */
12:46:22 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136757&oldid=136756 * Yayimhere * (+1) /* some complexity */
12:47:15 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136758&oldid=136757 * Yayimhere * (+1) /* some complexity */
12:48:46 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136759&oldid=136758 * Yayimhere * (+142) /* some complexity */
12:49:11 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136760&oldid=136759 * Yayimhere * (-2) /* some complexity */
12:49:26 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136761&oldid=136760 * Yayimhere * (+71) /* some complexity */
12:49:52 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136762&oldid=136761 * Yayimhere * (+39) /* some complexity */
13:05:23 -!- FreeFull has quit (Quit: rebooting).
13:26:19 -!- X-Scale has joined.
13:26:44 <esolangs> [[SLet]] https://esolangs.org/w/index.php?diff=136763&oldid=136737 * ZCX islptng * (+54)
13:31:30 <esolangs> [[Blackboard]] N https://esolangs.org/w/index.php?oldid=136764 * Yayimhere * (+1212) Created page with "'''Blackboard''' is a esolang crated by [[User:Yayimhere]] based on [[RECT4n=GLE]], [[///]], [[Thue]], and [[Lambda calculus]] == semantics == the program is set up in two sections(separated by <code>%</code> on a single line). one the left side there are replaceme
13:41:16 -!- drwiz has joined.
13:49:47 -!- FreeFull has joined.
13:59:44 <esolangs> [[Better Burn]] https://esolangs.org/w/index.php?diff=136765&oldid=136673 * Tommyaweosme * (+34)
14:05:34 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136766&oldid=136667 * Tommyaweosme * (+587) /* Copyright violations */
14:07:30 <esolangs> [[User talk:Unname4798]] https://esolangs.org/w/index.php?diff=136767&oldid=136684 * Tommyaweosme * (+243) /* what a edit */
14:08:37 <esolangs> [[User:MihaiEso/InDev]] https://esolangs.org/w/index.php?diff=136768&oldid=131200 * Tommyaweosme * (+25) /* See also */
14:22:09 -!- X-Scale has quit (Ping timeout: 256 seconds).
14:22:36 -!- X-Scale has joined.
14:26:55 <esolangs> [[Selfmodi]] N https://esolangs.org/w/index.php?oldid=136769 * Tommyaweosme * (+1068) Created page with "{{lowercase}}selfmodi is a self-modifying esolang derived from [[brainfuck]] by [[user:tommyaweosme|user:]]~~~ == commands == 0 [[nop]] 1 increment next number 2 decrement next number 3 | (flip) 4 . (out) 5 , (inp) 6 [ (while0) 7 ] (while0) 8 > (next) 9
14:29:38 <esolangs> [[]] N https://esolangs.org/w/index.php?oldid=136770 * Yayimhere * (+1618) Created page with "{{lowercase}} '''''' but it has a few changes. it was created by [[User:Yayimhere]] == changes == * a program halts when no changes happen to any expression * theres no simplification. only beta reductions * encasing a expression in <code>{}</code> will make it loop until th
14:40:07 <esolangs> [[User:Yayimhere]] https://esolangs.org/w/index.php?diff=136771&oldid=136744 * Yayimhere * (+9)
14:43:00 <esolangs> [[This machine is a server. DO NOT POWER IT DOWN!!]] https://esolangs.org/w/index.php?diff=136772&oldid=136001 * Yayimhere * (+15)
14:51:38 <esolangs> [[Talk:3ME]] N https://esolangs.org/w/index.php?oldid=136773 * Ractangle * (+3) Created page with "4me"
14:51:54 <esolangs> [[Talk:3ME]] https://esolangs.org/w/index.php?diff=136774&oldid=136773 * Ractangle * (+92)
14:53:53 -!- X-Scale has quit (Ping timeout: 256 seconds).
14:59:32 <esolangs> [[Kava]] https://esolangs.org/w/index.php?diff=136775&oldid=136627 * Ractangle * (+75)
15:02:10 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136776&oldid=136762 * Yayimhere * (-2)
15:05:21 <esolangs> [[TAbrain]] https://esolangs.org/w/index.php?diff=136777&oldid=129677 * Yayimhere * (+5) /* Kiwiscript */
15:05:31 <esolangs> [[TAbrain]] https://esolangs.org/w/index.php?diff=136778&oldid=136777 * Yayimhere * (+5) /* A+B problem */
15:05:41 <esolangs> [[TAbrain]] https://esolangs.org/w/index.php?diff=136779&oldid=136778 * Yayimhere * (+5) /* Truth machine */
15:09:11 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136780&oldid=136776 * Yayimhere * (+0) /* a step by step version */
15:13:29 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136781&oldid=136780 * Yayimhere * (-1017) /* some complexity */
15:13:53 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136782&oldid=136781 * Yayimhere * (+58) /* some complexity */
15:14:11 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136783&oldid=136782 * Yayimhere * (+28) /* some complexity */
15:28:05 <esolangs> [[Special:Log/newusers]] create * Sourceguy * New user account
15:29:27 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=136784&oldid=136563 * Sourceguy * (+24) /* Introductions */
15:37:55 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136785&oldid=136783 * Yayimhere * (+89)
15:46:21 <esolangs> [[Better Burn]] https://esolangs.org/w/index.php?diff=136786&oldid=136765 * Unname4798 * (-34) match User prefix color with "tommy"'s color
15:50:06 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136787&oldid=136766 * Unname4798 * (+253) reply
16:01:05 <esolangs> [[Nope...?]] https://esolangs.org/w/index.php?diff=136788&oldid=136516 * Yayimhere * (+27) /* quirks */
16:16:09 <esolangs> [[The mimic]] N https://esolangs.org/w/index.php?oldid=136789 * Sourceguy * (+106) Created page with "The mimic is an esolang created by [[User:Sourceguy]]. it mimics the input == Hello world == Hello World"
16:16:27 <esolangs> [[The mimic]] https://esolangs.org/w/index.php?diff=136790&oldid=136789 * Sourceguy * (+13)
16:17:04 <esolangs> [[The mimic]] https://esolangs.org/w/index.php?diff=136791&oldid=136790 * Sourceguy * (+42)
16:21:33 <esolangs> [[User:Sourceguy]] N https://esolangs.org/w/index.php?oldid=136792 * Sourceguy * (+55) Created page with "Hi, im Sourceguy Here are my esolangs: * [[the mimic]]"
16:26:51 -!- craigo has joined.
16:50:35 <esolangs> [[RECT4n=GLE]] https://esolangs.org/w/index.php?diff=136793&oldid=136785 * Yayimhere * (+17) /* semantics */
16:51:06 <esolangs> [[User talk:MihaiEso]] https://esolangs.org/w/index.php?diff=136794&oldid=136787 * Tommyaweosme * (+267)
16:52:35 <esolangs> [[The mimic]] https://esolangs.org/w/index.php?diff=136795&oldid=136791 * Sourceguy * (+112)
16:52:45 <esolangs> [[The mimic]] https://esolangs.org/w/index.php?diff=136796&oldid=136795 * Sourceguy * (-7)
16:54:35 <esolangs> [[Talk:The mimic]] N https://esolangs.org/w/index.php?oldid=136797 * Unname4798 * (+234) Created page with "It is a duplicate of [[Text]] (the esolang, not the page). ~~~"
17:26:06 <esolangs> [[]] https://esolangs.org/w/index.php?diff=136798&oldid=136634 * Ractangle * (-323)
17:41:17 -!- fowl has quit (Quit: Ping timeout (120 seconds)).
17:44:44 -!- fowl has joined.
17:45:15 <esolangs> [[User:Gilbert189/Iternary]] https://esolangs.org/w/index.php?diff=136799&oldid=135979 * Gilbert189 * (+4141) /* Functions */
18:55:19 -!- tromp has joined.
18:58:42 <esolangs> [[Playlist]] https://esolangs.org/w/index.php?diff=136800&oldid=68238 * Kaveh Yousefi * (+167) Added a hyperlink to my implementation of the Playlist programming language on GitHub and altered the page category tag Unimplemented to Implemented.
19:01:51 <esolangs> [[Playlist]] M https://esolangs.org/w/index.php?diff=136801&oldid=136800 * Kaveh Yousefi * (+115) Improved the code fragments' formatting.
19:06:33 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[User:Ractangle/]] to [[Non-Binary Turing machine with a stack]]
19:09:43 <esolangs> [[You are in a brainforest]] N https://esolangs.org/w/index.php?oldid=136804 * Tommyaweosme * (+579) Created page with "{{lowercase}}you are in a brainforest is a non-turing complete esolang that compiles into brainfuck. its only sole purpose is to make text adventures. == commands == out() - prints characters in brackets in - stores input as temporary variable if
19:11:28 <esolangs> [[Better Burn]] https://esolangs.org/w/index.php?diff=136805&oldid=136786 * Tommyaweosme * (+34) stylistic choice
19:13:32 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
19:18:17 -!- Sgeo has joined.
19:25:59 -!- drwiz has quit (Quit: Client closed).
19:27:42 <esolangs> [[Non-Binary Turing machine with a stack]] https://esolangs.org/w/index.php?diff=136806&oldid=136802 * Ractangle * (-165)
19:40:10 -!- tromp has joined.
19:46:02 <esolangs> [[Non-Binary Turing machine with a stack]] https://esolangs.org/w/index.php?diff=136807&oldid=136806 * Ractangle * (+314)
19:48:40 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[Non-Binary Turing machine with a stack]] to [[Disan Count pesudocode]]
19:51:16 <esolangs> [[Disan Count pesudocode]] https://esolangs.org/w/index.php?diff=136810&oldid=136808 * Ractangle * (-612)
20:01:47 <int-e> Oh I'm revisiting A Monster's Expedition and I totally missed that they expanded it: https://draknek.itch.io/a-monsters-expedition/devlog/280963/the-museum-expansion-update-comes-to-a-monsters-expedition
20:10:18 <esolangs> [[Disan Count pesudocode]] https://esolangs.org/w/index.php?diff=136811&oldid=136810 * Ractangle * (+633)
20:10:37 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[Disan Count pesudocode]] to [[Disan Count Pesudocode]]
20:11:08 <esolangs> [[User:Ractangle]] https://esolangs.org/w/index.php?diff=136814&oldid=136223 * Ractangle * (+29) /* Esolangs */
20:12:10 <esolangs> [[]] https://esolangs.org/w/index.php?diff=136815&oldid=136798 * Ractangle * (+10) /* Truth-machine */
20:12:22 <esolangs> [[]] https://esolangs.org/w/index.php?diff=136816&oldid=136815 * Ractangle * (+19) /* A+B Problem */
21:10:08 -!- tromp has quit (Read error: Connection reset by peer).
21:19:44 <esolangs> [[The mimic]] M https://esolangs.org/w/index.php?diff=136817&oldid=136796 * PythonshellDebugwindow * (+144) Formatting, see also, category
21:21:29 <esolangs> [[You are in a brainforest]] M https://esolangs.org/w/index.php?diff=136818&oldid=136804 * PythonshellDebugwindow * (+108) Categories
21:31:00 -!- __monty__ has quit (Quit: leaving).
22:17:17 -!- Sgeo_ has joined.
22:17:22 -!- Sgeo has quit (Read error: Connection reset by peer).
23:38:46 <esolangs> [[Special:Log/upload]] upload * BoundedBeans * uploaded "[[File:Heptagonal tiling.png]]": Heptagonal tiling of the hyperbolic plane, used to illustrate Hyperheptefunge-98