←2024-01-16 2024-01-17 2024-01-18→ ↑2024 ↑all
00:38:49 <esolangs> [[Backtracking INTERCAL]] M https://esolangs.org/w/index.php?diff=122062&oldid=12110 * PythonshellDebugwindow * (+26) Wayback
00:39:54 <esolangs> [[Malcolm Ryan]] M https://esolangs.org/w/index.php?diff=122063&oldid=34081 * PythonshellDebugwindow * (+26) Wayback
00:45:06 <esolangs> [[Threaded INTERCAL]] M https://esolangs.org/w/index.php?diff=122064&oldid=120969 * PythonshellDebugwindow * (-13) Wayback; implementation appears to be dead
01:29:13 -!- Lord_of_Life_ has joined.
01:29:56 -!- Lord_of_Life has quit (Ping timeout: 268 seconds).
01:30:37 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
01:55:04 <esolangs> [[(?!)]] https://esolangs.org/w/index.php?diff=122065&oldid=122061 * Kaveh Yousefi * (+43) Supplemented the lapsed output command entry in the Extended Backus-Naur Form (EBNF) formulation.
02:01:38 <esolangs> [[An Esolang That Refuses Files]] N https://esolangs.org/w/index.php?oldid=122066 * None1 * (+19) Redirected page to [[AETRF]]
03:08:47 <esolangs> [[SpinGate]] M https://esolangs.org/w/index.php?diff=122067&oldid=122058 * None1 * (+19) /* Logic Gates */
05:40:00 <esolangs> [[Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee/99 bottles]] M https://esolangs.org/w/index.php?diff=122068&oldid=122057 * None1 * (+12)
05:43:52 <esolangs> [[.fuck cat program]] M https://esolangs.org/w/index.php?diff=122069&oldid=113012 * None1 * (+1)
05:45:32 <esolangs> [[Dotfuck]] M https://esolangs.org/w/index.php?diff=122070&oldid=119100 * None1 * (+29) /* See also */
05:46:03 <esolangs> [[Dotfuck]] M https://esolangs.org/w/index.php?diff=122071&oldid=122070 * None1 * (-1) /* Why is it brain-exploding */
05:46:17 <esolangs> [[Dotfuck]] M https://esolangs.org/w/index.php?diff=122072&oldid=122071 * None1 * (-1) /* Why is it brain-exploding */
05:47:31 <esolangs> [[OCPL]] M https://esolangs.org/w/index.php?diff=122073&oldid=119103 * None1 * (-2)
05:50:32 <esolangs> [[OCPL]] M https://esolangs.org/w/index.php?diff=122074&oldid=122073 * None1 * (+29) /* Members */
05:54:52 -!- tromp has joined.
06:05:55 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
06:27:40 -!- tromp has joined.
07:42:40 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
08:06:55 -!- chiselfuse has quit (Ping timeout: 240 seconds).
08:09:34 -!- chiselfuse has joined.
08:23:19 -!- b_jonas has quit (Quit: leaving).
08:30:51 -!- chiselfuse has quit (Remote host closed the connection).
08:31:04 -!- tromp has joined.
08:31:25 -!- chiselfuse has joined.
08:56:51 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic]] https://esolangs.org/w/index.php?diff=122075&oldid=121967 * None1 * (+801) /* Example Programs */ Added [[99 bottles of beer]]
08:57:29 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic]] https://esolangs.org/w/index.php?diff=122076&oldid=122075 * None1 * (+22) /* Print */
08:58:26 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic]] M https://esolangs.org/w/index.php?diff=122077&oldid=122076 * None1 * (+100) /* 99 bottles of beer */
08:58:41 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic]] M https://esolangs.org/w/index.php?diff=122078&oldid=122077 * None1 * (+1) /* 99 bottles of beer */
08:59:27 <esolangs> [[99 bottles of beer]] https://esolangs.org/w/index.php?diff=122079&oldid=117500 * None1 * (+920) /* Win Golf */
08:59:52 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic]] M https://esolangs.org/w/index.php?diff=122080&oldid=122078 * None1 * (-21)
09:00:18 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++]] https://esolangs.org/w/index.php?diff=122081&oldid=121234 * None1 * (+60) /* External resources */
09:09:19 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++]] https://esolangs.org/w/index.php?diff=122082&oldid=122081 * None1 * (+933) /* Example Programs */
09:10:39 <esolangs> [[99 bottles of beer]] https://esolangs.org/w/index.php?diff=122083&oldid=122079 * None1 * (+1139) /* WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic */
09:10:56 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++]] https://esolangs.org/w/index.php?diff=122084&oldid=122082 * None1 * (+186) /* 99 bottles of beer */
09:12:03 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++]] M https://esolangs.org/w/index.php?diff=122085&oldid=122084 * None1 * (-4) /* 99 bottles of beer */
09:14:31 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++]] M https://esolangs.org/w/index.php?diff=122086&oldid=122085 * None1 * (+0) /* 99 bottles of beer */
09:14:48 <esolangs> [[99 bottles of beer]] M https://esolangs.org/w/index.php?diff=122087&oldid=122083 * None1 * (+0) /* WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++ */
09:14:57 <esolangs> [[99 bottles of beer]] M https://esolangs.org/w/index.php?diff=122088&oldid=122087 * None1 * (+1) /* WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic */
09:15:13 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic]] M https://esolangs.org/w/index.php?diff=122089&oldid=122080 * None1 * (+0) /* 99 bottles of beer */
09:18:26 <esolangs> [[WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++]] M https://esolangs.org/w/index.php?diff=122090&oldid=122086 * None1 * (+61) /* 99 bottles of beer */
09:18:44 -!- Koen_ has joined.
09:19:04 <esolangs> [[99 bottles of beer]] M https://esolangs.org/w/index.php?diff=122091&oldid=122088 * None1 * (+57) /* WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++ */
09:25:29 <esolangs> [[SpinGate]] https://esolangs.org/w/index.php?diff=122092&oldid=122067 * Jacobl * (+4)
09:26:46 -!- Sgeo has quit (Read error: Connection reset by peer).
09:32:35 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=122093&oldid=122015 * Jacobl * (+15)
09:32:43 <esolangs> [[User:Kiken/Construction Site/Descriptions/Operation]] https://esolangs.org/w/index.php?diff=122094&oldid=122045 * Kiken * (+2398)
09:33:43 <esolangs> [[SpinGate]] https://esolangs.org/w/index.php?diff=122095&oldid=122092 * Jacobl * (+27)
09:49:10 <esolangs> [[User:Kiken/Construction Site/Implementations/Operation]] N https://esolangs.org/w/index.php?oldid=122096 * Kiken * (+318) Created page with "<pre> import os # takes in a file name as input def operation(filename): data = '' with open(filename) as f: stat = os.stat(filename) inode = stat.st_ino for char in inode: if int(
09:49:15 <esolangs> [[User:Kiken/Construction Site/Descriptions/Operation]] https://esolangs.org/w/index.php?diff=122097&oldid=122094 * Kiken * (+706)
09:50:31 <esolangs> [[User:Kiken/Construction Site/Descriptions/Operation]] M https://esolangs.org/w/index.php?diff=122098&oldid=122097 * Kiken * (+14) /* Interpretation */ fixing formatting errors
09:51:35 <esolangs> [[User:Kiken/Construction Site/Descriptions/Operation]] M https://esolangs.org/w/index.php?diff=122099&oldid=122098 * Kiken * (+46) /* Controlling */ fixing formatting errors
09:52:44 <esolangs> [[User:Kiken/Construction Site/Descriptions/Operation]] M https://esolangs.org/w/index.php?diff=122100&oldid=122099 * Kiken * (-8) /* Controlling */
09:52:49 -!- cpressey has joined.
10:11:53 -!- ais523 has joined.
10:15:56 -!- ManDeJan has joined.
10:16:52 -!- __monty__ has joined.
10:57:49 -!- cpressey has quit (Quit: Client closed).
10:59:19 -!- cpressey has joined.
11:41:40 -!- dutch has quit (Ping timeout: 268 seconds).
12:15:36 <cpressey> IRC seems really... dead.
12:17:06 <cpressey> Since I only use Libera maybe I should be fair and say "Libera seems really dead", but from what I understand Libera is the most popular IRC server.
12:17:08 <cpressey> https://netsplit.de/networks/top10.php?year=2023
12:17:52 <cpressey> Wonder what happened in Aug 2023.
12:20:11 -!- ais523 has quit (Remote host closed the connection).
12:21:25 -!- ais523 has joined.
12:32:06 <cpressey> All this other stuff now.  https://matrix.org/ecosystem/bridges/
12:37:04 -!- cpressey has quit (Ping timeout: 250 seconds).
12:56:57 <int-e> "Wonder what happened in Aug 2023." -- "As of 2023-08-05, the official Libera.Chat bridge operated by Element Matrix Services (EMS) was taken down."
12:59:04 <fizzie> "Anyhow... It seems that the Internet Relay Chat has its best times well behind." As they say on the top-10 page.
13:03:11 <int-e> young people these days ( :-P ) are socialized differently.
13:04:32 <fizzie> They had an "here's how to use IRC" primer in the welcome leaflet for CS students at the university, I wonder what they have now.
13:05:00 <int-e> "You already know Discord, maybe have a look at Matrix too"
13:05:01 <int-e> :-P
13:05:05 <fizzie> I think I heard a rumor they even closed down the local NNTP server.
13:08:13 <fizzie> Looking at the student association web page, looks like they use Telegram now.
13:08:21 <int-e> Anyway, I think "dead" is an exaggeration but it is definitely winding down, and I think it will continue to do that for 2-3 more decades before it truly dies.
13:09:27 <int-e> Simply because IRC servers are cheap to keep alive, and IRC clients don't take up much screen space so you can leave them running forever.
13:51:11 -!- Soni has quit (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.).
13:51:38 -!- cpressey has joined.
13:51:43 -!- SoniEx2 has joined.
13:53:19 <int-e> cpressey: https://logs.esolangs.org/libera-esolangs/2024-01-17.html#lhb
13:55:22 -!- SoniEx2 has changed nick to Soni.
14:00:03 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
14:07:07 -!- tromp has joined.
14:07:36 * cpressey clicks "like" on int-e's "status update"
14:11:40 <int-e> Hmm. "I tried IRC but I can't 'like' it."
14:11:40 -!- cpressey has quit (Quit: Client closed).
14:14:16 <esolangs> [[ThreadFuck]] N https://esolangs.org/w/index.php?oldid=122101 * None1 * (+3909) Created page with "{{lang|a=User:None1|i=[[Bukkake]] and [[Brainfuck]]}} ==Subprograms== ThreadFuck programs consists of lines called '''subprograms'''. If the program is empty, it errors. Otherwise the main thread will execute the first line. When a thread's instruction pointer reaches
14:14:50 -!- cpressey has joined.
14:16:03 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=122102&oldid=122093 * None1 * (+17) /* T */
14:16:47 <esolangs> [[User:None1]] https://esolangs.org/w/index.php?diff=122103&oldid=122055 * None1 * (+66) /* My Esolangs */
14:16:56 <cpressey> "As of 2023-08-05, the official Libera.Chat bridge operated by Element Matrix Services (EMS) was taken down." <-- wait, does that mean you can no longer connect to Libera.Chat using Matrix? If so then the esowiki page about this channel might need updating.
14:18:06 <int-e> The seamless bridge (where you become an IRC user) is gone, yes.
14:18:39 <fizzie> Oh, I didn't even think of that. Yeah, the instructions are probably now incorrect.
14:20:46 <fizzie> Well, it says #esolangs:libera.chat "should" work, arguably that's not totally incorrect. It doesn't, but in a hypothetical perfect world, it probably should.
14:21:06 <int-e> :) (I thought the same thing)
14:21:32 <int-e> just add <s> </s> around it
14:23:13 <int-e> do I dare to check whether that #esocrypt channel on the network that shall not be named is still around?
14:23:25 -!- __monty__ has quit (Quit: leaving).
14:24:25 <int-e> it's empty.
14:25:17 <esolangs> [[ThreadFuck]] https://esolangs.org/w/index.php?diff=122104&oldid=122101 * None1 * (+501) /* Examples */
14:25:25 -!- int-e_ has joined.
14:25:27 -!- int-e_ has changed nick to meh.
14:26:09 -!- meh has quit (Client Quit).
14:26:36 <int-e> (meh, I didn't think that would pick up all the autojoin channels)
14:26:49 <esolangs> [[ThreadFuck]] M https://esolangs.org/w/index.php?diff=122105&oldid=122104 * None1 * (+35) /* Example 2 */
14:28:02 <esolangs> [[ThreadFuck]] M https://esolangs.org/w/index.php?diff=122106&oldid=122105 * None1 * (+28) /* Example 2 */
14:28:06 <esolangs> [[Esolang:Community portal]] https://esolangs.org/w/index.php?diff=122107&oldid=118890 * Int-e * (-374) no matrix, no leenode
14:28:58 <esolangs> [[Special:Log/newusers]] create * MaroonCoffee * New user account
14:31:54 <fizzie> Which reminds me, we never actually made https://esolangs.org/wiki/Esolang:IRC_cloaks happen, it just kind of stalled.
14:32:22 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=122108&oldid=122026 * MaroonCoffee * (+193) Signed my name on the introduce_yourself page
14:40:22 -!- supercode has joined.
14:55:27 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
15:04:51 <int-e> `'
15:04:53 <HackEso> 197) [on Walter Bright] <nddrylliog> I went to chat with him after his talk at the ELC and he was like "hum, right - humans. How do they work again... oh, hi!"
15:05:00 <int-e> fizzie: tbh I never cared about those
15:08:28 <int-e> What a timely quote, D just got forked. https://dpldocs.info/this-week-in-arsd/Blog.Posted_2024_01_01.html
15:08:42 -!- wib_jonas has joined.
15:09:46 <cpressey> TIL enough people still care about D to disagree with some other people who also still care about D
15:10:24 <int-e> Oh sure, I only noticed it because there was drama.
15:10:40 <int-e> D felt... unnecessary, I guess, to me.
15:11:14 <supercode> yes, ditto for me. I know the D author is active on  HN and responds to many programming language threads and always shows examples from D about how D does something in programming language threads.
15:11:14 <int-e> If I had named the fork thogh I would've called it D++
15:11:16 <int-e> ;-)
15:11:33 <int-e> *though
15:11:39 <supercode> but recently I learnt there is a community and forking about it which means enough people care. didn't know that before.
15:12:46 <supercode> where did that quote come from? source of that quote?
15:14:40 <int-e> Almost all quotes produced by `' (= `quote) are from this channel.
15:16:12 <supercode> '197
15:16:35 <supercode> sorry new here. but how do I get it to print this quote: 197) [on Walter Bright] <nddrylliog> I went to chat with him after his talk at the ELC and he was like "hum, right - humans. How do they work again... oh, hi!"
15:17:29 <int-e> https://logs.esolangs.org/freenode-esoteric/2011-01-22.html#lSA
15:17:39 <int-e> `' 197
15:17:40 <HackEso> 197) [on Walter Bright] <nddrylliog> I went to chat with him after his talk at the ELC and he was like "hum, right - humans. How do they work again... oh, hi!"
15:17:48 <supercode> `' 197
15:17:50 <HackEso> 197) [on Walter Bright] <nddrylliog> I went to chat with him after his talk at the ELC and he was like "hum, right - humans. How do they work again... oh, hi!"
15:18:01 <supercode> ah! eso-syntax for esolang channel!
15:18:06 <shachaf> `5 q
15:18:10 <HackEso> 1/2:599) <Phantom__Hoover> Minecraft has made me view all trees as ridiculously slender. \ 695) <ais523> bleh, why doesn't tab-complete work in mkdir for the name of the new directory \ 565) <elliott> ais523: those suck <elliott> hmm, those are all pretty good \ 529) <hagb4rd> jesus, yes.. he was human <hagb4rd> and that is fantastic <hagb4rd> more than beeing able to speak with fish.. like seaman does \ 886) <ais523> in Smalltalk, as in Fe
15:18:13 <shachaf> `n
15:18:14 <HackEso> 2/2:ather, in order to do I/O, you must first create the universe <Sgeo> ais523, it seems quite capable of I/O... GUI is a form of I/O <ais523> Sgeo: yeah exactly <ais523> where does the GUI come from? <ais523> it's written in Smalltalk, clearly <ais523> and how does the GUI do its I/O? <ais523> if you think about the issue for too long, you end up inventing Feather
15:18:35 <int-e> `help
15:18:36 <HackEso> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch [<output-file>] <URL>" downloads files. Files saved to $HACKENV are persistent, and $HACKENV/bin is in $PATH. $HACKENV is a mercurial repository, "`revert <rev>" can be used to revert, https://hack.esolangs.org/repo/ to browse. $PWD ($HACKENV/tmp) is persistent but unversioned, /tmp is ephemeral.
15:18:57 <int-e> `pwd
15:18:57 <HackEso> ​/hackenv/tmp
15:18:58 <supercode> `run ls -l
15:18:59 <HackEso> total 396 \ -rwxr-xr-x 1 1000 1000 163 May 27 2021 🌱 \ -rw-r--r-- 1 1000 1000 0 Nov 1 2022 3 \ -rw-r--r-- 1 1000 1000 1192 Jul 22 2021 a.o \ -rwxr-xr-x 1 1000 1000 16608 Sep 26 2022 a.out \ drwxr-xr-x 7 1000 1000 4096 Dec 31 2019 asmbf-1.2.7 \ -rw-r--r-- 1 1000 1000 103 Nov 12 2019 banana.txt \ -rwxr-xr-x 1 1000 1000 32686 May 27 2021 bef2 \ -rwxr-xr-x 1 1000 1000 17296 Nov 18 2019 bfi \ drwxr-xr-x 2 1000 1000 4096
15:19:12 <supercode> `run who am i
15:19:13 <HackEso> No output.
15:19:15 <supercode> `run who
15:19:16 <HackEso> No output.
15:19:20 <int-e> `` whoami
15:19:21 <HackEso> int-e
15:19:29 <int-e> magic!
15:19:58 <int-e> (not really: https://hack.esolangs.org/repo/file/tip/bin/whoami )
15:23:32 <ais523> cpressey: I think most online communities tend to be pretty quiet at this time of year
15:23:48 <ais523> october/november are often very busy, with december/january much more empty
15:24:59 <ais523> I've had even more trouble doing anything at all this month than I have had over most of the past year
15:27:03 <ais523> and it's quite possible I'm not the only person in that situation
15:31:06 -!- cpressey79 has joined.
15:32:20 <cpressey79> Well, maybe... but I remember noticing how quiet it seemed when I came back to IRC in autumn of last year.
15:32:32 <cpressey79> Quiet and different somehow.
15:32:49 <ais523> I think a parallel esolangs community has sprung up on Discord, which is a place that I intentionally avoid
15:32:59 <ais523> but I think it may have been becoming more quiet too
15:33:50 <ais523> and codegolf stack exchange's chat also became more quiet over time
15:34:14 <wib_jonas> int-e: what is the relationship between D and golang? are they trying to fill the same role, kind of like how rust is a more modern language with goals similar to C++, and zig is a more modern language with goals similar to C? or are they for completely different purposes?
15:34:18 -!- cpressey has quit (Ping timeout: 250 seconds).
15:34:38 <ais523> wib_jonas: I don't think Go is trying to fill C's niche
15:35:13 <ais523> (although it was written by some of the same people)
15:35:20 <wib_jonas> ais523: yes, I'm asking about D versus golang, as in is golang trying to be a more modern language used for the same thing as D?
15:35:28 <ais523> oh, I see
15:35:33 <wib_jonas> ais523: I said that zig is trying to fill C's niche, and rust C++'s
15:35:40 <wib_jonas> these are just more than niches though
15:35:46 <ais523> go has found a niche mostly in writing network services/servers
15:36:22 <ais523> that said, I have not had a good experience with it – I haven't tried to write it myself, but regularly use one Go program written by someone else and it is a bit of a mess
15:36:37 <wib_jonas> "D felt... unnecessary, I guess, to me." => I perceived it as a research language, in the sense that it was made by someone who also made a C compiler and so probably wanted to experiment on how to make a better language. then it got somewhat succesful and popular.
15:37:14 <int-e> wib_jonas: I guess "systems programming language with support for garbage collection" makes it sound like golang. Except that maybe 2002 (rounding december 2001) was too early for people to embrace GC?
15:37:23 <ais523> the thing about making a better C, is that making a better C is easy, but making a better *enough* C is hard
15:37:48 <ais523> like, C has tons of well-known problems, many of which have well-known and simple solutions
15:38:12 <wib_jonas> supercode: there is some documentation at https://esolangs.org/wiki/HackEso , though it's really incomplete
15:38:14 <fizzie> int-e: Re cloaks, apparently a widely shared opinion based on nobody asking after them.
15:38:23 <ais523> but, the costs of switching language are high enough that something that simply fixes some/many of C's problems isn't better by enough to persuade people to make the switch
15:39:03 <ais523> Rust was the first language that was better by enough to persuade me to stop using C
15:39:35 <ais523> (and even then, it has a lot of issues, but they're manageable)
15:39:42 <int-e> D defintely predates the trend of every big company making their own programming language (unless you count Objective C and I guess Cocoa along with it)
15:40:12 <int-e> But I also never took D seriously enough to look at it closely.
15:40:13 <ais523> does Amazon have its own programming language?
15:40:22 <wib_jonas> ais523: yes, which is why zig is trying to be so fricking easy to mix with C, though this doesn't seem to be the aspect that they advertise the most. in particular, the zig compiler can parse C headers, including with macros, so you need less glue to use libraries with a C API than in eg. rust or haskell or zig. this is a large part of what made
15:40:22 <wib_jonas> C++ succeed.
15:40:49 <ais523> wib_jonas: I have definitely seen Zig evangelists advertise that their compiler is better at building C than a typical C compiler is
15:40:50 <int-e> ais523: Hmm, I guess not. They also don't have their own OS.
15:41:07 <int-e> That I know of.
15:41:14 <ais523> they do have the entire mess of AWS support libraries and services, that's kind-of like an OS
15:41:26 <wib_jonas> ais523: also zig manages to ship a working C and C++ compiler and libc for win32, and that's pretty hard these days, so you can use the same compiler toolkit and library to compile mixed C and C++ and zig for win32
15:41:28 <ais523> it's definitely a "platform you can write for"
15:42:17 <fizzie> They've also got an Android distribution on those Fire things. And an SDK for third-party apps to do special Amazon-integrated things on them, I think.
15:42:20 <ais523> int-e: also I get the feeling that in the past, it was more common for companies (even small ones) to have their own languages, rather than less
15:42:22 <int-e> ais523: And they have so many abstractions in the form of AWS services that they probably don't need a programming language to lock in people further.
15:42:35 <int-e> ais523: Anyway, yes, Amazon looks like an exception to the rule.
15:42:39 <cpressey79> One of Amazon's values is "frugality".  It repurposes desks out of old doors and things like that.
15:42:59 <cpressey79> Providing their own language doesn't quite match with that value.
15:43:02 <wib_jonas> ais523: it is very likely better than other compilers that you can get for win32. you know how both intel and msvc have difficulty with their own compilers and so are experimenting with using clang as the compiler backend but with their own libraries, right? zig also ships clang, which is the easy part, the hard part is getting the libraries to
15:43:03 <wib_jonas> work on windows as well.
15:43:11 <int-e> And I should probably not discount Sun's Java which is an older big company programming language... though they made the core fairly open.
15:43:33 <ais523> wib_jonas: when I need to build C programs on Windows I normally use Strawberry Perl, which ships with a working C toolchain
15:43:50 <wib_jonas> ais523: hmm, I haven't tried that, interesting
15:43:55 <ais523> based on mingw I think
15:44:24 <int-e> funny
15:44:26 <cpressey79> Does Microsoft's 8-bit BASIC racket (and then later, Visual Basic) count as a "big company programming language"?
15:44:50 <ais523> cpressey79: that's kind-of inverted I think, in that them doing Basic predated them becoming a big company
15:44:51 <int-e> I'd look at C# for that.
15:44:56 <ais523> (and in fact they may have become big partly due to it)
15:45:29 <ais523> Microsoft has been making its own languages for ages, but few of them really caught on for non-Windows platforms
15:45:50 <ais523> C# is very commonly used on Windows, and TypeScript is somewhat popular on the web (but very recent compared to the other big Microsoft languages)
15:45:53 <int-e> cpressey79: "racket" - wasn't BASIC the original product
15:46:25 <int-e> before Digital Research botched their negotiations with IBM and MS got do make DOS for them?
15:47:03 <cpressey79> "racket" as in "Hey, you, micro manufacturer, your users are gonna need a way to USE that micro of yours ain't they? Well we got the solution for you!"
15:47:15 <int-e> Ah.
15:48:21 <cpressey79> In the phrase "Applesoft BASIC" the word "Applesoft" is a portmanteau of "Apple" and "Microsoft".
15:49:13 <cpressey79> But anyway.  They own GitHub now, so they got their "Developers! Developers! Developers!" wish.
15:49:31 <ais523> the relationship between Apple and Microsoft over the years has been hard to follow
15:50:29 <wib_jonas> it doesn't seem like supercode has been welcomed yet
15:50:32 <wib_jonas> `welcome supercode
15:50:34 <HackEso> supercode: Welcome to the international hub for esoteric programming language design and deployment! For more information, check out our wiki: <https://esolangs.org/>. (For the other kind of esoterica, try #esoteric on EFnet or DALnet.)
15:51:43 <supercode> thanks!
15:54:46 <wib_jonas> as for languages with inconveniences, do these modern javascript thingies have an array type yet that just throws an error if you try to index it out of bounds, or are they still mostly doing the perl for array types?
15:55:22 <wib_jonas> because that sounds like you don't need an entirely new language for, just some library addition
15:56:47 <ais523> wib_jonas: there's TypedArray
15:57:09 <ais523> although that only stores integers of a specified bit size
15:57:19 <ais523> or IEEE floats
15:58:43 <ais523> modern JavaScript does have a proper map type Map (as opposed to the old-fashioned Object) – fixing that was more urgent than fixing the arrays, I think
15:59:13 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=122109&oldid=122102 * PythonshellDebugwindow * (+0) /* T */ Alphabetise
16:00:29 <wib_jonas> sure, fixing Map was more important
16:00:37 <wib_jonas> and possibly easier too
16:01:56 <ais523> fwiw, "arrays that grow when you index past the last element" make a lot of sense for memory-safe langauges
16:03:24 -!- tromp has joined.
16:03:50 <ais523> actually I think a lot of the conceptual interest with array types is that they're a sort of general-purpose type that can be used to represent a lot of different sorts of data, and the "optimal" array behaviour is different in each case
16:04:12 <APic> *nod*
16:04:28 <ais523> for example, an array can be used to represent a map from integers to values, or an ordered list, or an unordered list
16:04:48 <ais523> and all three of those data structures are somewhat general in their own right
16:05:56 <ais523> but, the map grows in a different way from the lists, and the lists grow in a different way from each other (in particular, when an array is used to represent an unordered list, it grows only at the end, and can be deleted from efficiently via swapping the element you're deleting to the end)
16:06:40 <ais523> actually no, the swap-delete isn't efficient because actually finding the element you want to delete is O(n)
16:07:00 <ais523> this is a common fallacy with unordered data structures, e.g. non-intrusive linked lists are slow to delete from for the same reason
16:07:18 <ais523> sorry for making the mistake (although I am glad I caught myself quickly)
16:08:20 <int-e> I mean it's true in that the actual act of deleting is cheap
16:09:28 <ais523> it is strange that intrusive linked lists aren't more widely supported in high-level languages, given that their performance properties are hard to obtain in other ways
16:09:46 <int-e> So you can have a nice little container whose operations are: insert, pick random element, and delete
16:10:08 <int-e> if you need to track elements as they're swapped it easily becomes expensive
16:10:26 <ais523> that reminded me of an idea I had for playing TCGs
16:10:55 <ais523> where, instead of your deck being an ordered pile of cards, only the cards that had been placed on the top or bottom of the deck by a card effect were tracked in a pile
16:10:58 <int-e> ah
16:11:12 <ais523> and the other cards were placed in a not-necessarily-random order on a grid with coordinates
16:11:20 <int-e> ...saving one indirection shouldn't have a fancy name
16:11:25 <int-e> IMHO
16:11:38 <ais523> to draw a card, if there were no nonrandom cards on top of the deck, you would roll dice to see which card was on top
16:12:03 <ais523> int-e: intrusive linked lists isn't just a case of saving an indirection
16:12:13 <ais523> they let you start with a pointer to an object that's on a list, and discover its place in the list
16:12:36 <ais523> if the list is doubly-linked, which it almost always is for intrusive linked lists, you can then delete it without having to search for it first
16:13:45 <int-e> Sure, I get all that. I have used what is apparently called intrusive linked lists myself.
16:13:54 <int-e> I called them linked lists.
16:13:55 <int-e> :P
16:14:13 <ais523> well, the LinkedList type in languages that have one is almost always non-intrusive
16:14:33 <ais523> (and you can't write an intrusive linked list in safe Rust because the borrow checker doesn't understand them, so linked lists go almost unused there)
16:15:25 <int-e> that's true regardless of whether they're intrusive or not...
16:15:44 <ais523> you can write a singly linked non-intrusive list in safe Rust, it's just basically useless
16:16:46 * int-e wonders whether Knuth makes this distinction
16:18:33 <wib_jonas> "a lot of the conceptual interest with array types is that they're a sort of general-purpose type that can be used to represent a lot of different sorts of data" => sure, and it'
16:18:56 <wib_jonas> and there's a sort of evolution towards type safety where something is first implemented on normal arrays, then later moved into a new type
16:21:48 -!- cpressey79 has changed nick to cpressey.
16:21:48 <wib_jonas> that's why we now have binary heap types, sorted array types (flat_map and flat_multimap), vectors with a capacity, typically-small arrays that store a few elements inside them but can allocate into the heap when they outgrow that, string types, matrix types, types for triangular matrix, symmetric matrix, hermitian matrix, as well as just stack and
16:21:48 <wib_jonas> queue types, and sometimes even multi-threaded queues with an associated condition variable and all that jazz
16:22:17 <cpressey> I first learned about linked lists so long ago that "intrusitivity" was just an assumed property of all linked lists
16:22:21 <int-e> Knuth doesn't dwell on linked lists all that much but his default linked list is intrusive.
16:22:47 <cpressey> If you want to link records together you need to add a link to the record, duh
16:22:59 <int-e> exactly
16:23:29 <wib_jonas> "Knuth doesn't dwell on linked lists all that much" => what? isn't like half of chapter 2 about linked lists (including doubly-linked and other variants), plus memory allocation schemes that use linked lists to chain free blocks?
16:25:34 <wib_jonas> "it is strange that intrusive linked lists aren't more widely supported in high-level languages, given that their performance properties are hard to obtain in other ways" => yes, but you rarely need those performance properties. you can do most of what they do with various array types.
16:26:08 <wib_jonas> also lists are hard to support in a memory-safe language because you need a way to have a smart pointer (iterator) onto a list element
16:26:24 <ais523> fwiw, I think generally for situations where intrusive linked lists are good, the only alternative with comparable performance properties is a relational database with indexes
16:26:25 <int-e> wib_jonas: oh you're right, that section is longer than the index suggests. probably because I looked for the wrong keyword.
16:26:37 <int-e> anyway, it's still true that his default is "intrusive"
16:26:39 <ais523> which is O(log n) slower for some important operations and has worse constant factors
16:27:00 <wib_jonas> and if the code does not use pointers into the list elements, then it probably only wants either a dequeue, which you can make from two arrays, or a list that you can sort
16:27:26 <ais523> (these are also situations in which a garbage collector doesn't help at all – if you don't know when the last reference to an object is disappearing anyway, you have a logic bug)
16:27:41 <wib_jonas> now for low level languages, sure, if you're writing a kernel then use intrusive lists where appropriate, but then it's on you to make sure you don't reference stale pointers
16:28:03 <ais523> why *should* it be on me? why can't I have a language that can guarantee memory safety and still give me intrusive lists?
16:29:40 <cpressey> Short answer: economics
16:29:48 <int-e> Anyway, fine, I'll get over it... eventually.
16:29:57 <cpressey> Come to think of it, that's the short answer to everything
16:32:43 <wib_jonas> ais523: I guess you can, you just have to use weak references with backlinks and all that sort of nonsense, but it's not often that that case comes up, because in most of the cases it's easier to use arrays, possibly also with backlinks to references, and in the rest a list isn't powerful enough and you need some kind of tree structure
16:33:17 <ais523> wib_jonas: the weak references are pretty hard to prove to be memory-safe, though (which in this case means "do not unexpectedly null themselves out")
16:34:05 <ais523> oddly, the memory-unsafe languages are much easier to get this right in, because you only have to check the invariants on the references in a few places
16:34:07 <wib_jonas> basically in each node in the list (or each element of the array) you have to track the references to it, clear the reference if you delete that node (or element in the array), for an array or singly-linked list only update the link when you move the element, and
16:34:24 <wib_jonas> if you want to make copies of the full list (such as for undo purposes) then it gets much worse
16:34:43 <ais523> right
16:35:23 <wib_jonas> and this applies regardless whether your reference to the node is a normal or weak reference
16:35:27 <ais523> this reminds me of the "reverse strong reference" concept (a reference from A to B that holds A alive for as long as B is alive – a regular strong reference holds B alive for as long as A is alive)
16:36:45 <ais523> (they have to be combined with objects that have weak references to A in order to make any sense at all, but allow you to do things that you couldn't otherwise automatically do in GCed languages)
16:37:22 <wib_jonas> I did this in a very small scale when I implemented a structure that whose elements are both a binary heap by weight and in a dictionary by another key. to implement this, the dictionary stores indexes into the heap, and whenever I move items in the binary heap I have to update the indexes in the dictionary.
16:38:32 <ais523> this seems like the sort of thing that a language really should be able to do automatically (if nothing else, it would be less error-prone than doing it by hand)
16:38:51 <ais523> but it's also the sort of thing that encourages me to use databases, which are normally very good at it
16:39:00 <ais523> SQL has ON DELETE CASCADE, for example
16:39:57 <esolangs> [[Special:Log/upload]] upload * MaroonCoffee * uploaded "[[File:Cube.jpg]]": Traversal of a cube for Cube and Tesseract
16:40:52 <wib_jonas> oh, I have a question. rust's rc module (and, IIUC, python's weak references) implement a kind of weak reference, where instead of the back references being on an intrusive list, the weak-referencable object just has a counter of the weak references, and when the object would die but has weak references then the allocation (but not the object
16:40:52 <wib_jonas> contents) is kept alive until the last weak reference disappears. why is this ever better than just putting the weak references on a backlink?
16:41:25 <ais523> what do you mean by "backlink" here?
16:42:04 <ais523> in Rust's case I strongly suspect it's caused by arbitrary objects being movable via memcpy
16:42:24 <ais523> and you can't move an intrusive list via memcpy because it would break the pointers
16:42:43 <ais523> so it may be the most efficient solution that's compatible with the language invariants
16:43:30 <esolangs> [[Special:Log/upload]] upload * MaroonCoffee * uploaded "[[File:Unfolding tesseract.gif]]": Gif of a tesseract unfolding into its net. From: https://commons.wikimedia.org/wiki/File:Net_of_tesseract.gif licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
16:44:55 <wib_jonas> I mean, if I have to implement weak references, then in each weak-referencable object I'll have a pointer field that points to the first weak reference to the object, and each weak reference has a pointer field to the next weak reference to the same object, thus forming an intrusive singly-linked list (hopefully short) of the weak references to any
16:44:55 <wib_jonas> one object. before I destroy a weak reference I traverse the whole list to find that weak reference and delete it from the list. if the referenced object is destroyed then I iterate the list of weak references and mark them as invalid (null them out). (you could even do a doubly-linked list of weak references if you expect there will be many for
16:44:56 <wib_jonas> the same object.) this is what I mean by a backlink in the case of weak references.
16:45:05 <esolangs> [[Special:Log/upload]] upload * MaroonCoffee * uploaded "[[File:Tesseract Traversal.jpeg]]": Traversal of a tesseract for Tesseract
16:45:25 <esolangs> [[Special:Log/delete]] delete * Ais523 * deleted "[[File:Unfolding tesseract.gif]]": Copyright violation: original image is CC-by-sa-3.0, and thus not public domain
16:45:49 <int-e> wib_jonas: as ais523 said you can't rely on objects in Rust to have a fixed location during their lifetime because of move semantics.
16:46:00 <wib_jonas> hmm yes, you have a point about rust and how intrusive list wouldn't be movable, yse
16:46:22 <wib_jonas> that would make the weak references immovable, which makes them very hard to use
16:47:31 <esolangs> [[User talk:MaroonCoffee]] N https://esolangs.org/w/index.php?oldid=122113 * Ais523 * (+625) I deleted one of your images for copyright reasons
16:48:18 <wib_jonas> ais523 may be right about how it may be worth in a high-level language to support intrusive structures, because it may help the programmer avoid errors, either memory safety errors, or inconsistency between redundant data
16:48:39 <wib_jonas> and about how relational databases are doing that
16:49:10 <wib_jonas> but SQL databases also don't easily let you do the things that you can do with a doubly-linked list, like insert or delete elements in the middle or cut and glue lists
16:49:32 <ais523> the other thing that languages like Rust seem to be missing is a concept that I don't have a good name for yet, but it's basically "values that are conceptually part of the object, but instead of being stored in the object, are stored by the users of the object and provided whenever you call a method on it"
16:49:37 <cpressey> "High level" goes hand-in-hand with "Don't make me think about memory management"
16:49:55 <cpressey> If you need to think about memory management you pick a lower-level language
16:50:15 <ais523> e.g. instead of storing the length of an array in the array itself, the users of the array remember how long it is, and tell it each time, and this is enforced in the type system for correctness
16:50:23 <cpressey> This is a slightly expanded version of my earlier short answer, "economics"
16:50:24 <ais523> cpressey: I think memory is a bit of a red herring
16:50:42 <ais523> what's actually important for mutable things is tracking object identity
16:51:05 <ais523> i.e. if I mutate this object, what references to similar-looking objects also get mutated?
16:51:08 <cpressey> Tracking object identity is a form of memory management
16:51:19 <ais523> yes, they're very similar
16:51:19 <wib_jonas> ais523: you mean when this value isn't known at compile-time, right? because rust has got better at the compile-time version where a type is parametrized by compile-time data
16:51:33 <ais523> wib_jonas: yes, for non-compile-time values, Rust can already do it for values known at compile time
16:51:49 <ais523> I want something that works almost exactly like a const generic except that the value is determined at runtime
16:53:14 <ais523> (this may mean that we need types that exist only for a certain scope, and functions that are generic over them, but that's OK – due to Rust tracking lifetimes, it already has plenty of types that work like that, such as &'a)
16:53:43 <cpressey> My answer sort of implies that Rust is a lower-level language though.  I'm sure you can get a certain amount into Rust without having to think about memory management.  But I'm also sure if you get serious enough, you hit a point where you can't avoid it.
16:56:17 <cpressey> And I'm sure this is why I like pure functional languages - I don't even have to think about object identity in them.
16:56:21 <ais523> my current viewpoint is very much "if you have mutable things, you need to track what you know about their identities to avoid logic bugs, and then working out when to delete them is normally trivial – however, a garbage collector is useful for immutable things, and the language should be able to check your manual deletion logic for memory safety"
16:56:39 <wib_jonas> ais523: the particular case I was thinking about is how to make a text editor that lets you do any of the following and its algorithms are asymptotically efficient in theory (as opposed to efficient in most practical cases): insert or delete text anywhere, delete or copy a block of text; place any number of named bookmarks, and use two or three of
16:56:39 <wib_jonas> those bookmarks to tell which block to delete or copy, or one bookmark to tell where to insert or delete text; if you copy a block and there was a bookmark inside, let you find where the bookmark goes in the copy and turn that into a new bookmark; have an undo/version history. as far as I can tell this is possible, but gets really ugly. the problem
16:56:40 <wib_jonas> is that undo interacts in an ugly way with an already complicated structure.
16:56:42 <cpressey> [1, 2, 3] == [1, 2, 3] and I wonder which bot will give me an error for starting a message with [
16:57:28 <cpressey> oh nice, not a single one.  Well then.  Looks like I need to write a bot that responds to [
16:58:05 <wib_jonas> cpressey: j-bot is down right now, sorry
16:58:49 <wib_jonas> though it probably wouldn't have responded, the grammar requires a space (or certain punctuation) after the [ shortcut
17:00:02 <wib_jonas> ais523: this is why I was asking about your 2-3 tree library by the way. but as far as I can tell it wouldn't be *enough* for this theoretical editor, it would just help.
17:00:07 <ais523> I think equality operators are awkward because they don't clearly convey intent
17:00:26 <ais523> for immutable objects, the equality you care about is generally "are these two objects interchangeable/indistinguishable"
17:01:03 <ais523> for mutable objects, it could be either "do these objects currently contain equal values" (a sort of "snapshot equality") or "do these objects have the same identity, i.e. mutating one mutates the other"
17:01:23 <ais523> wib_jonas: ah, I see – yes, I doubt it would be enough
17:03:22 <esolangs> [[AssemblerFuck]] https://esolangs.org/w/index.php?diff=122114&oldid=121766 * Kaveh Yousefi * (+275) Added a hyperlink to my implementation of the AssemblerFuck programming language on GitHub and supplemented several category tags.
17:03:53 <wib_jonas> what I would need is a (tree of trees) inside a tree. tree of trees is easy, it's just a tree with a tree in each leaf. but tree inside a tree means that the inner tree is implemented such that what would normally be pointers are indexes, and the outer tree is keyed by these indexes, so that the outer tree is immutable and you modify it only by
17:03:53 <wib_jonas> copying a logarithmic number of nodes, and the indexes stay valid in both the old and new version of the outer tree.
17:03:54 <cpressey> The problem where "you say equality but what you really want is equivalence" seems to be quite a deep one actually.  I see mathematicians talking about these sorts of things, at least I imagine that is what the things that they say must mean.
17:05:28 <esolangs> [[AssemblerFuck]] https://esolangs.org/w/index.php?diff=122115&oldid=122114 * Kaveh Yousefi * (+280) Added a truth-machine as a further example.
17:05:36 <cpressey> "Setoid", that's the word I was looking for
17:05:39 <ais523> I've co-written some CS papers, precisely defining the notion of "these programs do the same thing" is surprisingly nuanced
17:07:10 <wib_jonas> and in a (tree of trees) inside a tree, both the trees inside have to use indexes (that are keys of the outer tree) instead of pointers
17:07:53 <wib_jonas> that said, a (tree of trees) inside a tree is probably not the only data structure that can do what I want, I was thinking about alternatives
17:08:15 <ais523> cpressey: so one of these deep equivalence problems I've wondered about is "is a pointer to an immutable thing any different from the thing it points to"
17:08:31 <ais523> and my conclusion is, that sometimes in practice it is, but it shouldn't be
17:08:57 <ais523> although it is not necessarily clear what "immutable" means if mutable things also exist the same language
17:09:07 <cpressey> "These programs produce the same outputs from the same inputs with the same performance except one of them exhibits some timing characteristics that can be exploited to expose security loopholes."  Oops!
17:10:06 <ais523> oh right, side-channels too
17:10:09 <wib_jonas> .oO( nothing is immutable anymore, nobody makes ROM chips, even the CPU has a non-volatile RAM in it so you can upload security fixes)
17:10:46 <ais523> actually a major part of my research prior to my PhD was in a field which tries to precisely define the notion of "timing is irrelevant"
17:11:14 <ais523> wib_jonas: non-volatile? I thought CPU microcode updates were stored in volatile RAM and uploaded during early boot
17:11:37 <cpressey> Everything's mutable if you have a big enough plasma discharge
17:12:04 <ais523> that said, I think there is NVRAM in the CPU but it's used for something else
17:12:28 <ais523> possibly the keys for verifying that the bootloader is signed correctly
17:12:30 <wib_jonas> ais523: uh, possible, I don't know
17:13:45 <wib_jonas> cpressey: right, melting down the very wires
17:14:56 <wib_jonas> there are a few people who specialize on destructively examining chips, so yes, even ROM is mutable in that sense
17:16:57 <wib_jonas> they're allowed to be more destructive than the medical imaging folks who merely paint my organs with chemicals that either show up easily on x-ray/CT or MR or are radiocative and show up on a radiation detector
17:17:36 <wib_jonas> the medical imaging folks have to ensure that I survive, the chip microscope folks usually don't have to ensure that the chip survives
17:21:23 <cpressey> So, OK: reframe "immutable" as "X is prevented from changing Y by Z".  In practice, X being able to see Y is a prerequisite for X being able to change Y sensibly.  Sometimes, programming language work these things out, according to their own theories, and sometimes they don't.
17:21:47 <cpressey> Obvious example, "private" fields in OO languages.
17:25:24 <wib_jonas> I don't remember all details, but I think rust has some hidden language rules that depend on what things are mutable and immutable.
17:28:08 <ais523> wib_jonas: the main one is that anything that is mutable via an & pointer has to either be UnsafeCell, or else contain its immutable portion within an UnsafeCell (possibly indirectly)
17:28:15 <ais523> * contain its mutable portion
17:31:38 <wib_jonas> right, that's the main thing, but there are more details that I don't remember
17:33:03 <wib_jonas> also Rust has done library improvements so there are a lot of new abstractions to express stuff, but by "new" I mean in the last five years
17:34:10 <cpressey> The "memory must be moveable" thing in Rust, I hadn't heard of.  Is that a library level thing or is the language itself imposing that restriction?
17:35:13 <ais523> cpressey: it's almost a language level thing
17:35:25 <ais523> in that the language does implicit moves in a lot of cases
17:35:47 <ais523> if you want to use immoveable memory, you can, but you can only access it via pointer types that have been carefully designed to ensure that the thing they point to can't ever move
17:36:48 <ais523> (and although the compiler can verify that they're being used safely once created, it can't verify that they're being created safely, so you need some amount of unsafe to use them)
17:36:55 <cpressey> I'm always confused about where they want to draw the lines in Rust
17:37:14 <cpressey> (responding to "almost a language level thing")
17:37:24 <ais523> well, technically it's an explicit move: function calls and assignments always move
17:38:01 <ais523> except when they copy, and the move versus copy decision is a documented property of the type that's being moved/copied (and that you can choose for your own data types)
17:38:10 <ais523> also, the move or copy is always bitwise
17:38:20 <ais523> it's just that these moves and copies are really pervasive and have very lightweight syntax
17:38:25 <ais523> so it feels like they're happening automatically
17:38:27 <cpressey> wait wait what
17:38:39 <cpressey> "assignments always move"?
17:38:54 <ais523> yep, a=b will always move b, unless b is a bitwise-copy type in which case it copies b
17:40:35 <ais523> cpressey: here's an example: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=1446dfeee2c6c527ec508397f7cfc599
17:40:50 <cpressey> I think you must mean "move" in some way different from how I was using the word
17:41:24 <ais523> the Rust definition is "the bits are copied from the memory that stored b into the memory that stores a, and the memory that stored b is now considered uninitialized"
17:41:46 <ais523> so trying to do anything with b after that will give you a use-after-free error
17:42:20 -!- supercode has quit (Quit: Client closed).
17:42:39 <ais523> in practice, therefore, you have to use references a lot (so it's the reference that gets moved/copied rather than the thing it references)
17:42:41 <cpressey> OK, I see that as a typing thing.  The ownership moves.
17:43:05 <ais523> ownership moves, but if you decompile the code, the bits move too (unless the move can be optimised out)
17:43:27 <ais523> if I write a function fn b(x: u8) -> Box<u8> { Box::new(x) }
17:43:29 <cpressey> Bits never move
17:43:47 <ais523> well, the bits are copied and then the original is considered uninitialised
17:43:54 <ais523> err, u8 is a bad example because it's copied
17:44:12 <ais523> but the value comes into the function in a register, and then is copied/moved to the heap
17:45:21 <cpressey> I hesitate to ask whether a=3 is considered to have moved 3 and now 3 is considered uninitialized
17:46:36 <cpressey> This is esolang territory.
17:46:39 <ais523> cpressey: 3 has a copiable type
17:46:47 <ais523> so it's considered to copy the 3 from the program, but it stays there
17:47:36 <ais523> if you tried that with an uncopiable type you would get a compile error because the code wouldn't run properly the second time, except that I can't think of any ways to create a literal that isn't Copy
17:51:31 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
18:05:20 -!- sprout has changed nick to sproutX.
18:16:41 -!- tromp has joined.
18:21:15 -!- wib_jonas has quit (Quit: Client closed).
18:24:21 -!- Koen_ has quit (Remote host closed the connection).
18:24:52 -!- Koen_ has joined.
18:28:04 -!- cpressey has quit (Ping timeout: 250 seconds).
18:29:05 -!- Koen_ has quit (Ping timeout: 245 seconds).
18:50:30 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=122116&oldid=122108 * Ais523 * (-39495) delete entries older than 1 December 2023 to prevent this page becoming too large / slow to load / triggering edit filters (older entries are still available in the page history)
19:24:03 <esolangs> [[Tesseract]] N https://esolangs.org/w/index.php?oldid=122117 * MaroonCoffee * (+13384) Created initial Tesseract page
19:27:31 -!- Guest13 has joined.
19:29:24 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=122118&oldid=122109 * MaroonCoffee * (+16) Added Tesseract to the language list
19:30:54 -!- Guest13 has quit (Client Quit).
19:32:08 -!- cpressey has joined.
19:34:42 <esolangs> [[Special:Log/newusers]] create * Shamrocky * New user account
19:35:19 <cpressey> There is still a small knot in my understanding about why Rust hates intrustive linked lists but I think it is probably minor.
19:35:43 <cpressey> I'm probably never going to write anything in Rust so I'm just happy to forget it.
19:37:04 <esolangs> [[Tesseract]] M https://esolangs.org/w/index.php?diff=122119&oldid=122117 * MaroonCoffee * (+143) Added to infobox
19:38:01 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
19:40:29 <esolangs> [[Tesseract]] https://esolangs.org/w/index.php?diff=122120&oldid=122119 * MaroonCoffee * (+127)
19:43:09 <esolangs> [[Tesseract]] M https://esolangs.org/w/index.php?diff=122121&oldid=122120 * MaroonCoffee * (+4) Added applicable categories
19:44:16 <esolangs> [[Tesseract]] M https://esolangs.org/w/index.php?diff=122122&oldid=122121 * MaroonCoffee * (+0) Capitalized usage of 2D
19:44:22 -!- b_jonas has joined.
19:51:16 -!- cpressey has quit (Ping timeout: 250 seconds).
19:54:00 <esolangs> [[Tesseract]] M https://esolangs.org/w/index.php?diff=122123&oldid=122122 * MaroonCoffee * (-24) Fixed various grammatical errors and capitalization
19:58:45 -!- cpressey has joined.
20:00:23 -!- tromp has joined.
20:01:33 <cpressey> If adoption of a thing comes down to "social proof" (i.e. everyone else in our network has adopted this so we need to adopt it too in order to stay in the network), then all the other argumentation for or against that thing is just... I could say "useless" but I suspect there is a mot juste here that I can't quite get my butterfly net around.
20:03:42 <cpressey> "Sophistry" isn't quite right because it's not necessarily sophistry, but there is also absolutely nothing preventing it from degrading into sophistry.
20:04:55 <cpressey> "Vacuous" is pretty close.  It's no longer tethered to anything, so it can go anywhere, anywhere at all.
20:11:12 -!- cpressey has quit (Ping timeout: 250 seconds).
20:32:47 -!- cpressey has joined.
20:38:04 -!- cpressey has quit (Ping timeout: 250 seconds).
20:46:51 -!- vyv has joined.
20:56:02 -!- cpressey has joined.
21:05:22 -!- cpressey has quit (Ping timeout: 250 seconds).
21:16:14 -!- cpressey has joined.
21:26:36 <esolangs> [[Cube]] M https://esolangs.org/w/index.php?diff=122124&oldid=103612 * PythonshellDebugwindow * (+129) Categories
21:28:20 -!- cpressey has quit (Ping timeout: 250 seconds).
21:35:05 -!- vyv has quit (Quit: Konversation terminated!).
22:01:18 <esolangs> [[Befunge]] https://esolangs.org/w/index.php?diff=122125&oldid=121885 * Loganz * (+129) Add compact DNA program
22:15:19 <zzo38> I still prefer IRC and I think it is better than the other one. I also still use NNTP and I think it is better than the other one, too.
23:41:09 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
←2024-01-16 2024-01-17 2024-01-18→ ↑2024 ↑all