←2014-12-16 2014-12-17 2014-12-18→ ↑2014 ↑all
00:00:46 -!- dts|pokeball has joined.
00:11:33 -!- boily has joined.
00:12:25 -!- SirCmpwn has quit (Ping timeout: 240 seconds).
00:15:07 -!- SirCmpwn has joined.
00:18:26 -!- mihow has quit (Quit: mihow).
00:19:31 -!- SirCmpwn has quit (Excess Flood).
00:21:24 -!- SirCmpwn has joined.
00:25:19 -!- SirCmpwn has quit (Excess Flood).
00:25:37 -!- SirCmpwn has joined.
00:38:54 -!- azazel_ has joined.
00:46:25 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
00:57:50 <HackEgo> [wiki] [[Unnecessary]] http://esolangs.org/w/index.php?diff=41482&oldid=40620 * Xbony2 * (+94) Added another interpreter
01:18:20 -!- cluid has quit (Quit: Leaving).
01:31:38 -!- Guest38946 has quit (Ping timeout: 272 seconds).
01:49:46 -!- glguy has quit (Quit: Quit).
01:54:16 -!- CrazyM4n has joined.
02:10:30 -!- dts|pokeball has quit (Quit: Leaving).
02:10:48 -!- dts|pokeball has joined.
02:14:46 -!- boily has quit (Quit: PHŒNICIAN CHICKEN).
02:16:45 -!- CrazyM4n has quit (Remote host closed the connection).
02:27:17 -!- mitchs_ has joined.
02:30:29 -!- mitchs has quit (Ping timeout: 244 seconds).
02:49:13 -!- _AndoDaan has joined.
02:50:46 -!- AndoDaan has joined.
02:52:14 -!- AndoDaan_ has joined.
02:53:44 -!- _AndoDaan has quit (Ping timeout: 264 seconds).
02:53:53 <oven> holy crap there are three AndoDaans?
02:54:06 <AndoDaan_> dammit.
02:54:21 -!- oven has changed nick to |oren\.
02:54:37 <AndoDaan_> tried to irc on my phone.
02:55:19 -!- AndoDaan has quit (Ping timeout: 240 seconds).
02:55:27 -!- AndoDaan_ has changed nick to AndoDaan.
02:55:33 <|oren\> and then there was one.
03:00:02 -!- AndoDaan_ has joined.
03:02:36 <|oren\> nvm. there are two
03:02:39 -!- AndoDaan has quit (Ping timeout: 240 seconds).
03:02:48 <|oren\> and one again
03:07:16 -!- AndoDaan_ has quit (Ping timeout: 272 seconds).
03:08:20 -!- Tod-Autojoined has joined.
03:08:31 -!- TodPunk has quit (Read error: Connection reset by peer).
03:08:39 -!- Tod-Autojoined has changed nick to TodPunk.
03:14:28 <HackEgo> [wiki] [[Talk:Ragaraja]] M http://esolangs.org/w/index.php?diff=41483&oldid=41480 * Oerjan * (+50) Geronimo! Also fix link
03:24:50 -!- |oren\ has quit (Quit: Lost terminal).
03:25:41 <azazel_> Use an app ando
03:26:52 -!- copumpkin has joined.
03:28:16 <oerjan> copumpkin: you should add propumpkin hth
03:28:23 <copumpkin> k
03:30:13 <shachaf> copumpkin is a pro
03:34:36 -!- oren has joined.
03:36:55 <copumpkin> damn right
03:38:20 <oerjan> now if he were also bi he could get the full set
03:40:01 <oren> do i even want to know?
03:41:45 -!- glguy___ has changed nick to glguy_.
03:41:55 <oren> wait a second here, this is some sort of math pun isn't it?
03:42:44 <oerjan> ding ding ding
03:43:01 <oren> it's been a while since i posted a screenshot: http://ctrlv.in/474924
03:44:21 <oerjan> stupid google has menus to restrict searches to a language or region; but when i look at them they _only_ let me choose between everything and norwegian
03:44:51 <oren> use bing hth
03:45:05 -!- glguy_ has quit (Quit: Part).
03:45:23 <oerjan> does that allow me to exclude norwegian results?
03:45:29 -!- CrazyM4n has joined.
03:48:18 <oerjan> hm that doesn't allow me to set it for just one search
03:48:49 <oerjan> this is for when i want to search for something that's accidentally a common norwegian word
03:48:51 -!- augur has joined.
03:55:28 <oerjan> there seems to be no search prefix for language.
03:55:37 -!- dts|pokeball has quit (Ping timeout: 255 seconds).
03:56:46 <oren> oerjan: why not set it to english?
03:56:47 <oerjan> google doesn't have a concept for telling them "you're second-guessing me wrong, this is how i want you to adjust your behavior".
03:56:55 <Sgeo_> Why does Rust interest me, they keep saying it's mostly for systems programming, and I have no interest in that
03:57:57 <oerjan> oren: then i have to set it back afterward. and the preferences are on a different page. basically i _hate_ all ui that requires me to leave the information i'm actually looking at to adjust it.
03:59:15 <oerjan> i'm basically bitching about google putting this beyond my too-complicated-to-bother threshold.
04:01:00 <oren> oerjan: use a private broswing window?
04:01:26 <oerjan> ...i don't think you're getting what i'm saying.
04:01:32 <oren> google won't modify your main account's settings
04:02:15 <oerjan> anyway it was simpler to just append "definition"
04:02:35 -!- glguy has joined.
04:03:14 <oerjan> which happens to work for finding word definitions most of the time because the word is spelled differently in norwegian.
04:06:32 <oren> I hate that you can't search for C++ C# and C separately unless you write the symbols out as words
04:06:59 <oerjan> aye
04:09:26 <Sgeo_> So many Rust libraries have names that... are as unpleasant to Google for as Rust itself
04:09:32 <Sgeo_> Rust iron. Not helpful
04:09:42 <Sgeo_> ...apparently it is
04:10:05 <oren> Sgeo_: wow that sucks. clearly not thinking ahead.
04:12:21 <oren> at least C# isn't the name of a mundane object
04:12:48 -!- madbr has joined.
04:18:00 <HackEgo> [wiki] [[Scrip7]] http://esolangs.org/w/index.php?diff=41484&oldid=41473 * Orenwatson * (+242) Register offsets in the forms I(12 or I)12
04:19:46 <J_Arcane_> http://www.drdobbs.com/architecture-and-design/farewell-dr-dobbs/240169421 :(
04:40:31 -!- GeekDude has quit (Quit: {{{}}{{{}}{{}}}{{}}} (www.adiirc.com)).
04:43:40 -!- glguy__ has joined.
04:44:05 -!- glguy has quit (Read error: Connection reset by peer).
04:49:27 -!- bb010g has joined.
04:54:07 -!- J_Arcane has joined.
04:54:12 -!- oerjan has quit (Quit: Clearly these are the end times).
04:55:17 -!- J_Arcane_ has quit (Ping timeout: 258 seconds).
04:55:40 -!- aloril_ has quit (Ping timeout: 258 seconds).
04:58:52 <Sgeo_> J_Arcane: :(
04:59:24 -!- aloril_ has joined.
05:03:36 -!- glguy__ has changed nick to glguy.
05:03:38 -!- aloril_ has quit (Max SendQ exceeded).
05:03:58 <J_Arcane> the hacker news comments about the news are insufferably predictable. :/
05:04:39 <J_Arcane> i suppose I shouldn't be surprised when a bunch of 'startup' types react to someone actually pointing out that web ads don't work, considering it's what all their investor storytimes mostly hinge on.
05:04:39 -!- aloril_ has joined.
05:04:41 -!- dts|pokeball has joined.
05:04:54 -!- glguy has quit (Quit: Part).
05:05:13 -!- glguy has joined.
05:13:18 -!- CrazyM4n has quit (Remote host closed the connection).
05:18:36 -!- glguy has quit (Quit: Part).
05:20:37 <Sgeo_> `slist
05:20:54 <HackEgo> slist: Taneb atriq Ngevd Fiora Sgeo ThatOtherPerson alot
05:26:13 -!- glguy has joined.
05:29:11 <Taneb> Oooh, slist
05:29:44 <shachaf> have y'all tried prismata?
05:29:56 <shachaf> single-player demo at http://play.prismata.net/?demo (uses flash)
05:32:44 <Taneb> I'm personally not keen on that kind of game
05:34:57 <shachaf> what kind of game are you keen on
05:38:05 <oren> the kind that doesn't take a billion years to load maybe?
05:43:12 <Taneb> shachaf, I like platformers mostly
05:43:47 <oren> Taneb: what kind of game is it? i can't load it
05:43:56 <Taneb> oren, like a card game
05:44:01 <Taneb> I think hearthstone-ish
05:44:15 <shachaf> yes
05:44:32 <shachaf> well, it's a deterministic complet-information game with no deck building, so it's p. different in that respect
05:51:48 <Taneb> I sometimes like roguelikes like Pokemon Mystery Dungeon and sims like Dwarf Fortress
05:53:04 -!- Sprocklem has quit (Ping timeout: 264 seconds).
06:14:28 <oren> i have decided to keep my policy of keeping the entire scrip7 release as one .c file
06:17:11 <oren> separate files are for people who want to have to use a VCS instead of 20141216.c etc
06:19:17 -!- MDream has joined.
06:19:57 -!- MDream has quit (Client Quit).
06:20:35 -!- MDream has joined.
06:35:50 <HackEgo> [wiki] [[MNNBFSL]] http://esolangs.org/w/index.php?diff=41485&oldid=41344 * AndoDaan * (+431) /* Examples */
06:38:23 -!- AndoDaan has joined.
06:42:57 -!- drdanmaku has quit (Quit: Connection closed for inactivity).
06:46:03 <oren> is it evil to use the C preprocessor to include plaintext and shellscripts into a C file?
06:46:35 <oren> screw it this is an esolang anyway
06:47:38 <MDream> I ask fungot to inform oren of the morality of his actions.
06:50:25 * MDream is abruptly destroyed as his monitor turns into a small nuclear blast at the revelation that fungot is not present.
06:52:23 <Sgeo_> shachaf: I put in for the Kickstarter, but haven't actually played, besides once in the tutorial
06:52:26 <Sgeo_> I want to play though
06:52:33 <Sgeo_> Kickstarter isn't looking so healthy :(
06:54:21 <shachaf> Yes. :-( I hope they reach their goal.
06:55:10 <shachaf> 3 days for 15000 CAD
06:55:18 <shachaf> It's probably doable.
06:55:26 <Sgeo_> I think it did jump 5000 in one day, so.. maybe?
07:00:08 <madbr> hm
07:00:24 <madbr> I want to make a language where something like
07:00:29 <madbr> var += array[$n]
07:00:36 <madbr> is internally expanded into
07:00:56 <madbr> for(int n=0; n<array.size; n++)
07:01:03 <madbr> var += array[n];
07:01:22 <oren> J
07:01:34 <madbr> at compile time
07:01:39 <oren> oh
07:01:43 -!- shikhin has joined.
07:01:44 -!- shikhin has quit (Changing host).
07:01:44 -!- shikhin has joined.
07:11:06 <madbr> one way to do it would be that array::operator [](size_t index) checks for the superior bound and generates and exception, and all loops contain an implicit try catch block that catches this exception
07:11:52 <madbr> and compilers are written in such a way that this exception is optimized into the correct n<array.size() loop condition
07:12:03 <oren> in a lanuguage that isn't defined in terms of horrifying c++ abominations you could do it more elegantly
07:12:32 <madbr> I'm just using c++ as a convenience here
07:12:54 <madbr> though I'd really like the statement used by the user to be "var += array[$n]"
07:12:54 <oren> why does c++ often require the compiler to achieve sentience?
07:13:21 <madbr> c++ probably just got the wrong feature set and too much history
07:13:51 <madbr> and is stuck with some things that used to make a difference but don't anymore
07:14:25 <madbr> function static variables etc
07:15:04 <oren> so yeah i think you could do this with a standard yacc/lex thing
07:15:14 <oren> at least the parsing
07:15:38 <madbr> well
07:15:51 <madbr> it's more complex than it looks at first sight
07:16:15 <madbr> also I'd like something like
07:16:33 <madbr> var += array[$n], n < 8
07:16:40 <madbr> to expand into something like
07:17:07 <madbr> for(int n=0; n<array.size() && n<8; n++) var += array[n];
07:18:05 <oren> so you'd have syntax to append "conditions" on any piece of code, including its internal loop(s).
07:18:17 <madbr> and various other similar types of variable binding
07:18:42 <madbr> yeah... how to explain this
07:19:23 <oren> maybe any undeclared variables are assumed to be local to the current statement?
07:19:40 <madbr> basically, any statement with $x variables in it should in theory expand to a loop trying all 4 billion possibilities
07:19:52 <madbr> and with multiple variables, all combinations
07:19:57 <madbr> but
07:19:59 <oren> and by doing A[n] you impose implicit restricitons on n
07:20:24 <madbr> automatically discarding any possibility that violates an array bound
07:20:39 <madbr> or a condition (like n<8)
07:21:46 <madbr> so for instance if the "payload" of the statement is an assignment, the assignment isn't done
07:21:54 <oren> and then you write some clever code to preemptively not even try numbers that would always violate a condition
07:22:08 <madbr> yep
07:22:52 <madbr> or at least be clever enough to respect array bounds and easy to figure out boundary conditions
07:23:20 <madbr> also would be able to do sortof multi step binding things
07:23:21 <madbr> like
07:23:42 <madbr> $v = array[$n], var += v*v
07:24:39 <madbr> basically square each array value and do the sum of those
07:25:29 <madbr> the way it would work is that it would try out every value of $n, and obviously this only works for indexes that are in the array
07:26:19 -!- Lymia has quit (Ping timeout: 250 seconds).
07:26:38 <madbr> and obviously if you have 6 at array[0], if $n binds to 0, then $v in turns has to bind to 6 (since it's the only value where the statement $v = array[0] can be true)
07:27:12 <madbr> and now that $v has binded, the "payload" (var += v*v) can be executed
07:27:24 <madbr> anyhow, sleep time
07:28:18 -!- madbr has quit (Quit: Pics or it didn't happen).
07:32:47 <fizzie> Huh, no 'got?
07:33:15 -!- fungot has joined.
07:33:17 <fizzie> That's better.
07:41:11 -!- azazel_ has quit (Quit: Connection closed for inactivity).
07:44:24 -!- Patashu has joined.
07:46:23 <olsner> fungot!
07:46:23 <fungot> olsner: it was in america. especially in fnord)
07:46:42 <olsner> fungot: did it have fun in america?
07:46:42 <fungot> olsner: is ( and dip it in melted butter first)." fnord pope? 1)?? has type fnord of pointer to function ( long, long gone by the time i'm just using scheme48 in a shell)
07:49:07 <fizzie> fungot: What do they dip in melted butter in America? Everything?
07:49:07 <fungot> fizzie: i'm with you. i have the browser tied in with mit scheme's compiler.)
07:49:28 <fizzie> fungot: Sounds very practical.
07:49:29 <fungot> fizzie: kilimanjaro says: i don't use linux... plus it uses tk on it im not imagining things! it really does load the source of a minimal implementation
07:50:26 <fizzie> Tk, a web browser and MIT Scheme's compiler. A curious combination.
08:36:27 -!- shikhout has joined.
08:36:51 -!- shikhout has changed nick to Guest2022.
08:40:32 -!- shikhin has quit (Ping timeout: 265 seconds).
08:51:59 -!- atslash has joined.
08:53:06 -!- Guest2022 has changed nick to shikhin.
08:53:11 -!- shikhin has quit (Changing host).
08:53:11 -!- shikhin has joined.
08:59:54 <oren> The scrip7 IDE is coming along nicely: http://ctrlv.in/475010
09:01:24 <HackEgo> [wiki] [[MNNBFSL]] http://esolangs.org/w/index.php?diff=41486&oldid=41485 * AndoDaan * (+159) Collatz program now terminates when n = 1.
09:05:09 -!- AndoDaan_ has joined.
09:07:54 -!- AndoDaan has quit (Ping timeout: 258 seconds).
09:14:17 -!- _AndoDaan_ has joined.
09:15:57 -!- AndoDaan_ has quit (Ping timeout: 264 seconds).
09:19:26 -!- _AndoDaan_ has changed nick to AndoDaan.
10:04:20 -!- mihow has joined.
10:09:52 -!- mihow has quit (Ping timeout: 264 seconds).
10:12:57 -!- dts|pokeball has quit (Ping timeout: 245 seconds).
10:56:34 -!- Phantom_Hoover has joined.
10:58:35 <elliott> 05:03:36 <J_Arcane> i suppose I shouldn't be surprised when a bunch of 'startup' types react to someone actually pointing out that web ads don't work, considering it's what all their investor storytimes mostly hinge on.
10:58:39 <elliott> J_Arcane: they get as far as ads?
10:58:46 <elliott> isn't it all about growth, growth, growth
10:59:10 <elliott> "hacker news surprised to discover capitalism is unsustainable"
11:01:41 <J_Arcane> Not just 'capitalism' in their case, but 'capitalism founded on fairy stories'. XD
11:03:20 <elliott> you'll have to enlighten me as to the difference :p
11:03:27 <J_Arcane> XD
11:03:48 <J_Arcane> True. I suppose the difference is mostly temporal, in SV's case.
11:07:29 <oren> http://pastebin.com/qVp7R5D2 <-- it is done: the "hopefully getting stabler release 2014-12-17 06:30"
11:08:50 <oren> is it morally wrong to include several programs in one .c file by use of ifdefs?
11:09:37 <fizzie> Not if the programs are 'true' and 'false'.
11:10:50 <HackEgo> [wiki] [[Scrip7]] http://esolangs.org/w/index.php?diff=41487&oldid=41484 * Orenwatson * (+11) upadted link
11:13:19 <elliott> remember that time this channel figured out how to make false succeed? that was good
11:14:25 <fizzie> I don't remember that at all, but it sounds intriguing.
11:15:07 <elliott> it involved exploiting a buffer overflow in gettext
11:15:19 <elliott> by crafting an appropriate translation file and getting it to display help
11:15:25 <elliott> or, uh, not really a buffer overflow in gettext
11:15:34 <elliott> more like just it doing printf(_("..."), ...)
11:15:37 <elliott> so you can exploit the format string
11:15:51 <elliott> I mean, you can make true fail, so why not the other way around, right?
11:17:22 <elliott> fizzie: http://sprunge.us/JBhf
11:17:31 <elliott> int-e was the one who got it to proof of concept
11:18:00 <elliott> me and ais523 found/fiddled with the gettext use
11:18:07 <fizzie> I must've missed or forgotten about this.
11:18:10 <fizzie> V. fancy.
11:18:31 <elliott> sadly gettext doesn't let you specify environment variables like this for setuid programs
11:18:38 <elliott> so you can't use it for privilege escalation
11:18:48 <elliott> but imagine if you could.
11:19:15 <elliott> it does mean that having write access to /usr/share lets you "pwn" a box (if any programs that run as root use gettext like this), I think.
11:21:04 <fizzie> Makes me wonder how common it is to have localized format strings. Probably relatively so.
11:21:15 <elliott> yeah, I think that's standard gettext use
11:21:32 <elliott> certainly I expect most of coreutils does it, for the help messages
11:21:37 -!- erdic has quit (Ping timeout: 250 seconds).
11:21:49 <elliott> anyway, this was half a year ago, fwiw.
11:22:11 -!- erdic has joined.
11:22:34 -!- boily has joined.
11:22:39 <fizzie> Yes, there's quite a lot of "%s: unrecognized option `%c%s'" and so on.
11:31:27 <elliott> anyway, you'd think that it wouldn't be hard to write a printf_ which checks the format strings are compatible...
11:31:45 <elliott> but I guess this is unix, we don't care about robustness!
11:33:14 <Jafet> The overhead would be unacceptable
11:36:16 -!- Patashu has quit (Ping timeout: 250 seconds).
11:38:49 <fizzie> Ah, so you also need to add a separate "format check only" function so you can keep using raw printf in all those thight inner loops, and hoist only the check out.
11:40:11 <elliott> actually, that's sort of a good point, you could just call it __ instead of _
11:40:15 <elliott> or whatever
11:40:17 <elliott> don't even need to wrap printf
11:40:24 <oren> printf doesn't check the format strings, but atleast gcc gives you a warning!
11:40:29 <elliott> hell just turn it on for _ and at least make it print out warnings
11:40:37 <elliott> oren: it doesn't if you use gettext :p
11:41:29 * elliott thinks about LD_PRELOADing an alternate gettext that does a naive format string check and prints out if they don't match...
11:41:40 <elliott> can't wait for my NEXT coreutils xzero-day
11:41:43 <elliott> *zero-day
11:42:19 <fizzie> elliott: The whole thing doesn't sound like a too far-fetched thing to be enabled by some sort of FORTIFY_SOURCE option.
11:43:03 <fizzie> I forget what exactly printf_chk does, actually.
11:43:13 <elliott> yeah, I suppose if you cheated by actually patching the compiler it could avoid false whatsits.
11:43:28 <elliott> really, though, the environment variables should probably just go away.
11:43:37 <elliott> at the least.
11:44:07 <elliott> hey imagine if we wrote in a language that wasn't segfault city
11:44:26 <elliott> then we could have things like "features" without blowing up the planet in the process
11:45:29 <oren> safety, speed, flexibility, pick two
11:46:07 <elliott> I don't believe you have to.
11:46:11 <elliott> especially not for coreutils, come on.
11:46:28 <b_jonas> elliott: (a) why would you have to LD_PRELOAD that? why not check during compiling the translation files with msgfmt instead? (b) in either case, how do you know which strings contain printf-formats, which ones used in some other way?
11:46:46 <elliott> b_jonas: welltranslation files can be specified at runtime
11:46:48 <elliott> *well translation
11:46:58 <oren> elliott: i mean that a language can only give you two, and you have to make the third by good programming
11:47:03 <elliott> and by the rarity of %
11:47:15 <elliott> I only wanted it so I could look for exploits, though I guess it's unlikely that mistake would be made in stock translation files
11:47:22 <elliott> maybe it should just print whenever you pass a % to _
11:48:26 <elliott> oren: I don't agree. many of the ways in which C are unsafe aren't just design tradeoffs that there can be reasonable disagreement about; it is a flawed language and you can do better in many respects without making big sacrifices on speed or flexibility. languages aren't always a perfect balanced compromise that couldn't be objectively improved on
11:49:29 <oren> elliott: of course it can be improved on, but there is a upper limit at which tradeoffs emerge
11:50:10 <elliott> sure. let's get to that point, and *then* you can say "safety, speed, flexibility, pick two" in response to me whining about whatever language we're using then :)
11:50:35 <oren> fine.
11:50:57 <elliott> I suspect you could write coreutils in just about anything and be completely fine, anyway. it's not really number crunching.
11:51:09 <oren> so what about fortran 90?
11:51:35 <elliott> okay, I guess something like sha*sum would be annoying if it was too slow.
11:53:07 <oren> maybe the coreutils shouldn't all be written in the same language?
11:53:58 <elliott> uh, you could put forward that position but I don't know why you would
11:54:08 <boily> put all your eggs in one basket, then watch that basket very closely.
11:55:06 <oren> well, you could use fortran for number crunching things, something pedantic like Ada for security, etc.
11:58:24 <oren> only problem is that in olden times languages didn't interoperate well
11:59:09 <oren> so they standardized on C because it is very flexible.
11:59:35 <oren> (compared to its contemporaries i mean)
12:02:46 <elliott> % time cat MacTeX.pkg >/dev/null
12:02:46 <elliott> cat MacTeX.pkg > /dev/null 0.01s user 0.64s system 49% cpu 1.320 total
12:02:46 <elliott> % time shasum -a 512 MacTeX.pkg
12:02:46 <elliott> e788be6b14300f3e6463cdd8f8b1a4afc61e3a4c315c486e0dde465bf82ea16080bb0c6f78faa5cbd21a3ec6abb820ce805d1131f02069908514f1b28f06720d MacTeX.pkg
12:02:49 <elliott> shasum -a 512 MacTeX.pkg 11.08s user 0.63s system 98% cpu 11.870 total
12:02:52 <elliott> % time ruby -e 'require "digest"; d = Digest::SHA512.new; buf = ""; f = File.open("MacTeX.pkg"); while f.read(65536, buf) != nil; d << buf; end; puts d.hexdigest'
12:02:55 <elliott> e788be6b14300f3e6463cdd8f8b1a4afc61e3a4c315c486e0dde465bf82ea16080bb0c6f78faa5cbd21a3ec6abb820ce805d1131f02069908514f1b28f06720d
12:02:58 <elliott> ruby -e 11.96s user 0.57s system 98% cpu 12.690 total
12:03:00 <elliott> of course this is depending on C code for the SHA-512 implementation.
12:03:19 <elliott> but my point is that this is not an obstacle to writing coreutils even in something "famously slow" like ruby
12:03:34 <elliott> though honestly ruby has a greater risk surface than coreutils probably
12:03:59 <elliott> just saying that you probably have to look on our wiki to find a language too slow to reasonably write coreutils in
12:05:19 <oren> elliott: i see! so because modern languages can call the C ABI, we can write the glue codein something that has no risk of buffer overflows
12:05:31 -!- mihow has joined.
12:05:49 <elliott> well, it's not even necessarily an ABI problem. you just need *some* way to extend the language in something fast enough
12:06:06 <elliott> here's a question: how fast would sha512sum be with a hand-optimised, but totally memory-safe, pure haskell implementation?
12:06:19 <elliott> I wouldn't be surprised if the answer was "fast enough".
12:06:32 <oren> i'm gonna guess at about 20% speed?
12:06:43 <elliott> that's a serious underestimate I think
12:06:54 <oren> based on my knowledgeof racket
12:07:10 <oren> is haskell strongly typed?
12:07:14 <elliott> haskell and racket are incomparable, I think
12:07:17 <elliott> isn't racket interpreter-only
12:07:21 <elliott> haskell has a very advanced optimising compiler
12:07:33 <J_Arcane> Racket is JIT-compiled from byte-code.
12:07:35 <elliott> and people write rather gnarly hand-optimised code in it
12:07:50 <J_Arcane> It's pretty fast, but slower than most lisps, and slower than Haskell, generally speaking.
12:07:52 <elliott> oren: yes, very much so
12:08:07 <oren> then i'll say 90%
12:08:21 <elliott> it has probably the most advanced type system of any "commonly used to slightly obscure" language
12:08:33 <J_Arcane> http://benchmarksgame.alioth.debian.org/u32/compare.php?lang=racket&lang2=ghc
12:08:45 <elliott> let's not use the benchmarks game to talk about haskell performance lol
12:08:48 <elliott> those programs are horrific
12:08:58 <J_Arcane> :_D
12:08:59 <elliott> okay, not all of them
12:09:27 <elliott> but some of them probably have negative PR effect because people were obsessed with getting the tiniest last bit of performance out of them, making it so that if you actually look at the source you think you need to sacrifice your soul to satan to get reasonable performance out ofh askell
12:09:44 <J_Arcane> This is a fair point.
12:10:09 <oren> i have consistently seen that the stronger the typing of a language, the faster it is.
12:10:15 <J_Arcane> I found Haskell quite quick enough as it was, and certainly very little code I see in the actual Haskell sources looks as ugly as, say, this: http://benchmarksgame.alioth.debian.org/u32/program.php?test=pidigits&lang=ghc&id=4
12:10:38 -!- mihow has quit (Ping timeout: 256 seconds).
12:10:42 <elliott> actually that code looks fine
12:10:45 <elliott> there's no unsafety or unboxing or anything
12:10:52 <elliott> aij (I# i) (I# j) = D# (
12:10:52 <elliott> case i +# j of
12:10:52 <elliott> n -> 1.0## /## int2Double#
12:10:52 <elliott> (((n *# (n+#1#)) `uncheckedIShiftRA#` 1#) +# (i +# 1#)))
12:10:56 <elliott> this is scary though :p
12:11:03 <J_Arcane> oren: Generally yes, because it saves cycles for error checking and such. Though Common Lisp can be pretty fast I'm told.
12:11:04 <elliott> that's the kind of code you'd be writing for a hand-optimised SHA implementation haha
12:12:58 <oren> the only reason C isso fast is because it is so unsafe. a safe language with C's type system would probably be slow as hell
12:13:30 <elliott> you're wrong
12:13:53 <int-e> the point is the uncheckedIShiftRA#, I guess; the rest the compiler should do by itself.
12:13:57 <elliott> ll, "with C's type system", sure...
12:13:58 <elliott> *well,
12:14:03 <elliott> that's a ridiculous constraint though
12:14:47 <oren> elliott: it is a hypothetical. such language does not exist, because it would be ridiculous
12:14:52 <J_Arcane> speaking of C, I should probably get back to working on Build Your Own Lisp at some point.
12:14:53 <int-e> how old is that code anyway? ghc has been getting smarter over the years.
12:14:53 <elliott> actually it kind of does
12:14:58 <elliott> @google asan clang
12:14:58 <lambdabot> http://clang.llvm.org/docs/AddressSanitizer.html
12:14:59 <lambdabot> Title: AddressSanitizer — Clang 3.6 documentation
12:15:20 <elliott> adding naive memory safety to C makes programs twice as slow, basically
12:15:23 <elliott> which is far from slow as hell
12:15:47 <elliott> I think google run a bunch of high-risk stuff compiled with ASan or something?
12:16:28 <elliott> they certainly use it for testing, anyway
12:16:42 -!- cluid has joined.
12:16:47 <oren> brb, installing that.
12:16:52 <J_Arcane> Yes. I think that's another thing about C, is it is indeed blisteringly fast, which throws the curve for everything else. ie. being 'twice as slow as C' sounds like more than it is in practical terms. It's not like we're talking BASIC v. Assembly, like in the old days.
12:16:58 <elliott> oren: it comes with clang
12:17:08 <oren> oh then i already have it
12:17:22 <oren> i have like 10 c compilers installed
12:17:34 <J_Arcane> Heh. I just have tcc and gcc.
12:17:46 <elliott> I guess you also need http://clang.llvm.org/docs/MemorySanitizer.html since ASan doesn't catch that, and that has a bigger slowdown, but whatever
12:18:03 <elliott> that's probably more of a debugging thing than a big safety problem
12:19:11 -!- coppro has quit (Ping timeout: 258 seconds).
12:23:42 <oren> well that is certainly a better way of finding the memory leaks than simply printfing every damn thing
12:24:48 <elliott> you know about valgrind, right?
12:25:11 <elliott> I guess maybe the clang stuff is better these days, I don't know.
12:25:22 <elliott> it's certainly faster.
12:25:27 <oren> valgrind works but it is annoying to use
12:26:41 -!- coppro has joined.
12:27:03 -!- Lymia has joined.
12:27:49 -!- boily has quit (Quit: RESPLENISHED CHICKEN).
12:28:15 <oren> these clang options can simply be added to the compile script, whereas valgrind requires you to run things in a different way
12:30:28 <oren> my short test indicates that the clang thing has less performance penalty too
12:34:44 <elliott> yes, valgrind is very slow
12:58:08 <FreeFull> Or you can use a language which ensures memory safety at compile time
13:00:31 <elliott> yes
13:04:05 <oren> FreeFull: that will become the default when OS's C ABIs are replaced with something memory-safe.
13:08:13 <elliott> what
13:08:26 <elliott> what "OS's C ABIs"
13:08:30 <elliott> syscalls do not use the C ABI...
13:09:06 -!- oren has quit (Ping timeout: 244 seconds).
13:09:12 <fizzie> FreeBSD's do, to some degree.
13:09:45 <elliott> they don't use the CALL part, do they? :p
13:09:55 <fizzie> Not quite, but almost.
13:10:05 <elliott> (looks it up) this is kinda weird but nice
13:10:09 -!- oren has joined.
13:10:21 <elliott> I don't think it invalidates my point though. it's not like people write everything directly with syscalls
13:11:11 <elliott> "Linux is a UNIX® like system. However, its kernel uses the same system-call convention of passing parameters in registers MS-DOS® does. [...] This convention has a great disadvantage over the UNIX® way, at least as far as assembly language programming is concerned: Every time you make a kernel call you must push the registers, then pop them later. This makes your code bulkier and slower. ...
13:11:14 <fizzie> (As in, the kernel skips a return address when looking for arguments on the stack, under the assumption that you've called a function that has executed the int. On x86, anyway; I don't know how it is with other ports.)
13:11:17 <elliott> ... Nevertheless, FreeBSD gives you a choice."
13:11:18 <elliott> they're so bitter
13:11:37 <fizzie> I see you've found the page I always hit when googling for the FreeBSD calling convention.
13:11:56 <elliott> I wonder what they do on x86-64
13:12:09 <elliott> given that that C calling convention is JUST AS BAD AS MS-DOS(R)
13:12:34 <elliott> "If you are coding specifically for FreeBSD, you should always use the UNIX® convention [...] If you want to create portable code that can also run on Linux, you will probably still want to give the FreeBSD users as efficient a code as possible."
13:12:45 <elliott> are you coding just for freebsd?
13:12:51 <elliott> |-- yes --> use our convention
13:12:56 <elliott> |-- no --> use our convention anyway
13:13:09 <mroman> implicit parameters
13:13:28 <fizzie> I seem to recall they follow the x86-64 SysV ABI document, aka they're JUST AS BAD AS LINUX.
13:15:59 <oren> The C Api's are still the most-used method of calling the OS on both linux and windows. That is i believe the whole problem
13:16:27 <elliott> okay, but like, a language can either wrap around libc, or write its own library based on syscalls
13:16:41 <elliott> go does the latter
13:16:56 <oren> the latter is the right thing.
13:17:06 <elliott> the latter causes annoying interop problems with C threads IIRC
13:17:21 <elliott> there's not really any major disadvantage to the former...
13:17:29 <elliott> I don't see what the problem is about "wrapping memory unsafe APIs to be safe"
13:17:32 <elliott> like, that is what encapsulation is.
13:17:40 <elliott> any memory safe language contains memory unsafe parts that are encapsulated for safety
13:17:53 -!- InvalidCo has quit (Ping timeout: 244 seconds).
13:17:55 <oren> but the real right think is for there to be a native API in the memory safe language, e.g. dot net.
13:18:05 <oren> *right thing
13:18:22 <elliott> uh, I don't know .NET implementation details but I wouldn't be at all surprised if it called into libc...
13:18:44 <elliott> what is the substantial difference between wrapping libc and wrapping syscalls anyway
13:18:50 -!- InvalidCo has joined.
13:19:13 <elliott> like sure "ideally" we'd have memory-safe OSes running on lisp machines or whatever but I don't see how any of this implementation detail stuff is relevant to the adoption of a memory-safe language
13:19:24 <oren> elliott: it probably does but it is developed by the same people as the OS. the issue is when you have a wrapping layer it becomes language maker's responsibility
13:19:37 <elliott> I don't think the .NET team and the Windows kernel team are the same.
13:20:01 <oren> *same organization
13:20:10 <FreeFull> By memory safety ensured at compile time I was thinking of Rust
13:20:27 <elliott> that really doesn't say much, but sure. (have you heard about the OS vs. Office team antagonism? :p)
13:21:46 <oren> if we want linux to be very safe with say JVM, the Linux kernel team needs to work on the interface into JVM.
13:22:04 <elliott> what o.o
13:22:35 <oren> it needs to be developed by people who understand the model at both ends in great detail
13:23:46 <elliott> you can already violate memory safety if you find a bug in the JVM JIT, who cares about the kernel interface?
13:23:54 <elliott> I really don't understand the angle you're going for here...
13:24:23 <oren> elliott: it is chiefly a political issue
13:24:30 <elliott> ok.
13:24:39 <elliott> then I'll stop trying to have a technical discussion
13:25:13 <oren> if the JVM api is subordinate to the C api, then people will use C api to avoid there being more places to have bugs
13:25:56 <elliott> if you don't believe that encapsulation can increase safety, then I don't know what to tell you.
13:26:19 <oren> encapsulation increases safety but there can be bugs in the capsule
13:26:21 <elliott> you could maybe argue a wrapper around memcpy that checks that src and dest are valid pointers before passing it on (or whatever) has "more places to have bugs". it is also strictly safer.
13:26:50 <elliott> fundamentally, there is no way of getting around wrapping unsafe operations
13:27:10 <elliott> whether that's in the kernel or in libc or in a language library, who cares? the principle is the same
13:28:13 <elliott> replacing the syscall/libc API won't make wrapping the underlying options for safety take *significantly* less code (it would certainly be more elegant and potentially less prone to errors, sure; I'd love it too. but it's still weird to use this as an argument for using unsafe APIs directly?)
13:29:06 <oren> elliott: everyone will want to make their own wrapper unless there is one standard wrapper
13:29:26 <oren> this is the Gnome/KDE/XFCE/LXDE problem
13:29:31 <mroman> does go allow overloading?
13:29:54 <elliott> I really feel like you just generate random plausible-sounding retorts outside of the context of the rest of the conversation every time the one you were harping on before stops making sense :/
13:30:41 <mroman> hm. nope
13:30:51 <mroman> not even operator overloading :(
13:32:07 <mroman> "If you wish the users of an interface to explicitly declare that they implement it, you can add a method with a descriptive name to the interface's method set."
13:32:13 <mroman> this is bullshit. Sorry.
13:32:27 <mroman> but adding a dummy method as a means of documentation?
13:32:30 <mroman> Are you kidding me?
13:33:58 <elliott> go is not a good language
13:34:08 <elliott> though explicitly duck-typed interfaces aren't that horrible an idea
13:36:08 <oren> mroman: i hope so. overloading is basically the same thing as polymorphism
13:36:16 <oren> polymorphism: x.m(y) where the type of x may be different
13:36:20 <oren> overloading m(x,y) where the type of x may be different
13:36:53 <oren> apparently it supports polymorphism but not overloading...
13:36:53 <oren> i find that bizarre and hypocritical
13:37:14 <elliott> uhhh
13:37:21 <oren> elliott: they should be an option but not the only option
13:37:27 <elliott> m(x,y) where the type of x can vary can be polymorphism too
13:37:33 <elliott> m :: Show a => a -> String -> String
13:37:36 <elliott> m x y = show x ++ y
13:38:02 <elliott> (indeed haskell, and many other languages, allows controlled overloading through a system like typeclasses)
13:38:08 <elliott> (it is _ad-hoc_ overloading a la C++ that is unpopular.)
13:40:35 <oren> go doesn't have inheritance either :(
13:40:48 <elliott> good!
13:41:00 <elliott> that is one of the things go actually gets right...
13:41:17 <oren> what? but elliotr i use inheritance in C all the time and it is useful...
13:42:01 <elliott> uhh... what C are you using that has implementation inheritance, exactly?
13:42:11 <elliott> do you mean horrible BSD socket-style hacks, because, lol
13:42:18 <Jafet> Come on, just because nearly everyone designs subtyping wrong
13:42:29 <oren> I mean using the usual method of passing in a this pointer explictly
13:43:04 <oren> a.m(b) -> A_m(a,b)
13:44:15 <oren> the C standard library does this for FILE*. the windows api uses this with its HWND.
13:45:03 <elliott> that doesn't have anything to do with inheritance
13:45:07 <elliott> seriously
13:45:10 <oren> i'm getting to it
13:45:21 <elliott> Jafet: I'm fine with interface inheritance
13:45:24 <elliott> just not implementation inheritance
13:46:18 <oren> so struct bugbear {struct enemy enm; ...} *bb can be passed as a struct enemy* to any function that takes one
13:46:37 -!- Lorenzo64 has joined.
13:47:25 <elliott> that's composition, not inheritance
13:47:27 <elliott> Go even has special support for that
13:47:36 <elliott> you can omit the field name and access bb.enm.x as bb.x
13:47:39 -!- Lorenzo64 has quit (Read error: Connection reset by peer).
13:47:39 <elliott> (this is inherited from Plan 9 C)
13:47:45 <elliott> (in fact gcc even supports this extension)
13:48:59 <oren> elliott: wha? why do you keep answering myarguments with things that will make my life infinitely easier, if you wanted me to stop arguing?
13:49:19 <oren> this isn't much motivation
13:49:35 <elliott> I could kick you too to balance it out
13:49:54 <elliott> btw you probably don't want to use gcc's Plan 9 C support, I don't think clang supports it and I doubt anyone cares about maintaining it
13:49:59 <elliott> I wouldn't be surprised if it went away
13:50:17 <elliott> here's a cool thing: unless they changed it, a bunch of Go is written in Plan 9 C. they ported the Plan 9 C compilers to linux and compile all their non-standard C code with it
13:50:43 <elliott> by cool I mean vaguely horrifying
13:50:56 <elliott> it's uncanney valley C
13:50:59 <oren> so how is inheritance different from composition?
13:51:09 <Jafet> Go, the modern programming language
13:51:12 <oren> given this syntax sugar
13:51:27 <elliott> composition is building structures out of other structures (potentially multiple ones!), using their public API
13:52:21 <elliott> implementation inheritance is building a structure's implementation on top of the implementation of another one, creating a direct "is-a" relationship where Subclass is-a Superclass, and potentially using private API and implementation details
13:52:36 <elliott> is-a vs. has-a, etc.
13:52:39 <elliott> https://en.wikipedia.org/wiki/Composition_over_inheritance
13:53:25 <elliott> implementation inheritance is pretty close to directly going against principles of encapsulation, basically. from an OOP point of view, how many codebases actually satisfy the Liskov substitution principle?
13:53:50 <elliott> it's a tricky invariant to keep to, but it's hard to assign any coherent meaning to the notion of inheritance without it.
13:54:19 <elliott> you end up basically having to concede "well, this is just copy-paste code reuse that isn't really grounded in any kind of abstraction"
13:54:49 <elliott> thankfully composition is all three of more elegant/simpler, easier to reason about, and more flexible, so.
13:55:00 <elliott> *interface* inheritance is just fine though.
13:55:19 <elliott> as in, the concept that to satisfy an interface X, you must also satisfy interfaces Y, Z, ...
13:55:31 <elliott> conflating the two is common but unfortunate, especially in languages without an explicit implementation/interface divide
13:56:37 <oren> elliott: i try to create a divide in C by using a lot of static functions and static globals, but it doesn't always work
13:56:37 <elliott> (I am not a fan of "standard" OOP (I would say "traditional" but C++, Java, Python, whatever really don't look all that much like Smalltalk or whatever) in general, anyway. inheritance is one of the reasons why)
13:56:54 <Jafet> Yeah, C++ lacks that... concept
13:57:01 <elliott> har har
13:57:09 <elliott> aren't they adding like mini-concepts or something
13:57:41 <oren> C++ added a slightly different version of each thing from C
13:58:35 <oren> i really do not understand why we need references and pointers in the same language
13:58:40 <Jafet> I suspect that at this point all of WG21's energies can only be devoted to updating the standard to be relevant on computers designed in the last ten years
13:58:55 <Jafet> leaving none for actual language design
13:59:18 <elliott> references are a little safer and nicer (but not safe enough)
13:59:36 <elliott> it's true that C++ basically has a nicer parallel universe language fighting against the "legacy" C parts.
13:59:48 <elliott> that nicer language has some horrifying stuff in it too though of course
13:59:53 <elliott> FSVO nicer I guess
14:01:56 <oren> we need a language called c*=2;
14:02:44 <oren> it would have the good parts of C++ and remove the parts inherrited
14:03:33 <oren> I hate C++ because thinking in C and Python at the same time screws my head up
14:04:30 -!- mihow has joined.
14:04:43 <Jafet> Do you mean (++c)++
14:04:56 <elliott> the language trying to get out of C++ only looks like Python in an extremely distorted funhouse mirror :p
14:05:04 <elliott> anyway, that's what rust is trying to be
14:05:11 <elliott> *Rust
14:05:22 <Jafet> The distorted funhouse is D
14:06:02 <oren> I am planning on eventually get around to trying both of thsoe
14:06:19 <elliott> I dislike D :(
14:06:38 <elliott> it feels like such a grab bag of stuff
14:06:58 <oren> so it is the PHP of compiled languages?
14:07:22 <b_jonas> argh!
14:08:01 <elliott> I think the design is a lot more solid than that :p
14:08:06 <elliott> I just don't like the taste of it
14:10:33 -!- mihow has quit (Ping timeout: 250 seconds).
14:17:19 <FreeFull> I like Rust
14:17:27 <FreeFull> Rust gets my thumbs-up
14:18:04 <cluid> what are some of the best things about Rust?
14:20:25 <lifthrasiir> it is the least fucked alternatives among there (including C++ itself)
14:20:36 <cluid> ocaml
14:20:45 <lifthrasiir> not really alternative?
14:20:50 <cluid> ok
14:21:07 <lifthrasiir> I'm starting to think that this problem space itself is fucked
14:21:17 <FreeFull> Rust gets you memory safety without garbage collection, and it has a nice type system
14:21:23 <cluid> what problem space, programming?
14:21:27 <lifthrasiir> so it's about minimizing fucks
14:21:29 <FreeFull> You can write an OS kernel in Rust
14:21:38 <FreeFull> Or code for your microcontroller
14:22:06 <cluid> FreeFull, That seems pretty awesome to be but afaict there's no proof that the rust type system ensures the operational semantics are actually safe
14:22:22 <lifthrasiir> afaik they are trying
14:22:43 <oren> proof, whatver, so long as it provably HELPS thats' good
14:22:53 <lifthrasiir> they have a core semantics, I'm not sure it has been fully proved
14:22:59 <FreeFull> Theoretically, the lifetime system should be sound, modulo compiler bugs
14:22:59 <lifthrasiir> (search for rust-redex)
14:23:13 <FreeFull> Also the ownership system
14:23:15 <cluid> what is the theory though?
14:27:09 <elliott> https://en.wikipedia.org/wiki/Region-based_memory_management has a long history
14:29:32 -!- AndoDaan_ has joined.
14:30:03 <elliott> Cyclone, ML Kit etc.
14:31:51 -!- AndoDaan has quit (Ping timeout: 250 seconds).
14:37:03 -!- shikhout has joined.
14:37:25 -!- shikhout has changed nick to Guest86316.
14:40:02 -!- shikhin has quit (Ping timeout: 244 seconds).
14:54:55 <oren> i have invented the c/bash polyglot archive format
14:56:47 <oren> it is a c file which can be run as its own compile script
14:57:45 -!- Guest86316 has changed nick to shikhin.
14:57:51 -!- shikhin has quit (Changing host).
14:57:51 -!- shikhin has joined.
14:58:37 <oren> because the cpp directive #if 0 is also a bash comment
14:59:56 <elliott> that kind of thing is quite a common trick
15:00:27 <elliott> you can also do things like this
15:00:28 <elliott> sh-3.2$ /* 2>/dev/null; echo hi; # */
15:00:28 <elliott> hi
15:00:57 <oren> elliott: really? the only reason i'm doing it is becauase i'm too lazy to start puttin gthings in separate files
15:01:21 <elliott> oh, it actually extracts itself, heh.
15:01:23 <elliott> you could base it on shar
15:01:35 <oren> because then i couldn't use pastbin as a repository
15:01:38 <elliott> why not just put all the program in one file...
15:02:01 <oren> elliott: it also contians its documentation and test suite
15:02:46 <elliott> documentation can be a big comment, test suite can be an #ifdef ... int main() ... #endif? :p
15:03:23 <oren> the test suite is a shell script that feeds abunch of test code to the scrip7 interpreter
15:05:03 <elliott> you could write it as function calls
15:05:06 <elliott> nobody likes shell :p
15:05:27 -!- `^_^v has joined.
15:05:39 <oren> I prefer here documents to "" strings
15:06:25 <elliott> oh I assumed it was one-liners
15:07:09 <oren> nah, i have to test the loops and stuff, so in order to test it properly i implemented an insertion sort for example
15:07:33 <elliott> /* 2>/dev/null; if [ "$1" = "test" ]; do sh $0 <<EOF ... EOF; done; # */ :p
15:07:39 <elliott> *then/fi
15:07:50 <elliott> (assuming sh $0 compiles and runs it if given no arguments)
15:17:03 -!- dts|pokeball has joined.
15:21:31 <cluid> <oren> it is a c file which can be run as its own compile script
15:21:44 <cluid> Just put a comment with the compile line at the start
15:22:01 <cluid> i would not run a large c/sh 'polyglot' for fear it might do something dodgy that isn't immediately obvious
15:22:43 <oren> cluid: the entire concept of this language is dodgy
15:42:03 -!- oerjan has joined.
15:43:29 <oerjan> Gregor: i don't think glogbot's clock is properly set
15:44:08 <oerjan> it seems to be a minute late
15:46:45 -!- AndoDaan_ has quit (Ping timeout: 250 seconds).
15:46:51 <oren> http://pastebin.com/qVp7R5D2 <-- how dodgy is this
15:51:27 -!- AndoDaan has joined.
15:54:22 <elliott> at least use "$0" instead of requiring a filename
15:54:35 <elliott> you probably want to set -e too
15:55:35 <elliott> you might also want to make it not a sharbomb, but :p
15:55:49 <oerjan> shar and enjoy
15:57:02 <oerjan> oots updates have become even rarer lately, it seems
15:57:13 -!- dts|pokeball has quit (Ping timeout: 245 seconds).
16:05:30 -!- mihow has joined.
16:07:30 <oren> There, it now uses $0. (same link)
16:07:44 <oerjan> now completely free!
16:08:06 <cluid> lol
16:09:27 <oren> see it compiles itself 3 times and runs cpp on itself twice, to produce two executables, a .o library, a test shell script and a .txt document.
16:10:07 <HackEgo> [wiki] [[Language list]] http://esolangs.org/w/index.php?diff=41488&oldid=41464 * Tastyfish * (+17) added flow_chart
16:10:33 -!- mihow has quit (Ping timeout: 264 seconds).
16:11:02 <oren> the different executables share part of their code, so this is a highly efficient way of doing it
16:11:52 <oerjan> oren: are you sure this counts as one .c file any longer
16:12:29 <oren> it is a txt.c.sh file
16:13:00 <elliott> oren: this won't work if you curl ... | sh
16:13:10 <elliott> you gotta make it use heredocs or something like shars
16:15:16 <oren> elliott: what do you mean? you jsut sh scrip7.c
16:15:31 <elliott> as in curl http://pastebin/blah | sh
16:15:34 <elliott> because you use $
16:15:36 <elliott> $0
16:15:44 <elliott> don't you want it to be as easy as possible to let you run arbitrary code
16:16:17 <oren> elliott: but how ami supposed to compile myself a bunch of times?
16:16:40 <oren> bah too complicated
16:18:04 <oren> ideally what we need is a scripting language except instead of <?php ?> have /*blah */
16:19:10 -!- jix_ has quit (Quit: Lost terminal).
16:20:14 <elliott> it is a shame that there is no way to get cpp to accept a shebang at the start of the file (afaik)
16:20:22 <HackEgo> [wiki] [[List of ideas]] http://esolangs.org/w/index.php?diff=41489&oldid=41479 * Tastyfish * (+172) /* Derivative Ideas */
16:26:17 -!- drdanmaku has joined.
16:31:49 -!- Phantom_Hoover has quit (Ping timeout: 250 seconds).
16:36:41 -!- Phantom_Hoover has joined.
16:42:25 <elliott> https://www.indiegogo.com/projects/the-hybrid-programming-language remember the Osmosian Order of Plain English Programmers? well,
16:43:00 -!- jix has joined.
16:48:12 <oerjan> plain english!
16:48:25 <J_Arcane> "When you start me up, I will quickly take over your screen so you no longer have to look at that painted whore of an interface that comes with the kluge."
16:48:27 <J_Arcane> ...
16:48:31 -!- mihow has joined.
16:49:00 <J_Arcane> (also, I had to manually type that quote from the manual, because they've done something to obfuscate copy&paste results from the PDF)
16:53:36 <fizzie> elliott: I think they're being a little bit unclear about what they need their half a million dollars for.
16:54:10 <oerjan> either drugs or antipsychotic medication hth
16:54:17 <oerjan> possibly both
16:54:18 <elliott> J_Arcane: yes, the manual is quite something
16:54:33 <oerjan> (i guess the latter are also drugs.)
16:54:58 <elliott> J_Arcane: I've tried to write programs in it
16:55:06 <elliott> unfortunately I missed the painted whore of an inteface that comes with the kludge
16:55:13 <elliott> it had some weird alphabetical file navigation system. it was horrible
16:55:21 <fizzie> J_Arcane: I don't think what I get from copy-pasting ("When you star meup, Iwil quickly take over your scen soyu nolnger have tolok athat painted whore ofan iterface tha comes with e kluge") is really any worse.
16:55:23 <elliott> *interface
16:55:29 <oerjan> elliott: *kluge
16:55:39 <elliott> oerjan: let's say it's british spelling or something.
16:56:30 <oerjan> http://www.catb.org/jargon/html/K/kluge.html hm
16:56:33 <J_Arcane> Yeah, it's a bit batty. I wonder if there's any relation between these guys and the HYBRID RPG guy.
16:58:58 <elliott> well, I like batty.
16:59:05 <elliott> the language isn't actually interesting, though.
16:59:19 <J_Arcane> IT just reads like a lower level AppleTalk.
17:00:37 <oerjan> elliott: wow you were right " It now appears that the British, having forgotten the etymology of their own ‘kludge’ when ‘kluge’ crossed the Atlantic, repaid the U.S. by lobbing the ‘kludge’ orthography in the other direction and confusing their American cousins' spelling!"
17:00:59 <elliott> great
17:01:07 <elliott> I've always said "kludge", I think.
17:02:26 <oerjan> "Some observers consider this mess appropriate in view of the word's meaning."
17:02:48 <fizzie> I've always used "kludge" too, but I was aware of the controversy.
17:03:13 <int-e> wait a second, is that 1981 oldsmobile a Delorean? (xkcd)
17:09:04 <int-e> ok, no.
17:09:48 * int-e checks off "say something stupid on #esoteric" from his to-do list for the day.
17:09:54 <oerjan> i believe those are different brands hth
17:10:42 <int-e> oerjan: and you'd be right to believe that.
17:11:14 <int-e> I didn't realise that "Oldsmobile" *was* a brand.
17:11:46 <elliott> it;'s old
17:11:54 -!- dts|pokeball has joined.
17:12:11 <oerjan> but not too old to be mobile
17:19:46 -!- oerjan has quit (Quit: leaving).
17:22:13 -!- bb010g has quit (Quit: Connection closed for inactivity).
17:37:58 <HackEgo> [wiki] [[StaPLe]] http://esolangs.org/w/index.php?diff=41490&oldid=41463 * BCompton * (-17) /* Interpreter */
17:39:14 -!- GeekDude has joined.
17:55:42 * Gregor bites the head off of a chicken.
17:57:47 <elliott> uh.
18:00:58 -!- Sprocklem has joined.
18:14:37 -!- MoALTz has joined.
18:16:34 <HackEgo> [wiki] [[MNNBFSL]] http://esolangs.org/w/index.php?diff=41491&oldid=41486 * AndoDaan * (+172) /* External resources */ added JavaScript implementation.
18:30:34 <cluid> hi AndoDaan
18:31:03 <AndoDaan> Hey, cluid.
18:31:49 <cluid> i created an esolang
18:31:53 <cluid> do you wantto see it
18:31:59 <AndoDaan> Treehugger?
18:32:01 <cluid> yeah
18:32:25 <AndoDaan> :) congratulations. I've been tickering on an interpreter for it actually.
18:32:49 <cluid> realy!
18:33:38 <AndoDaan> Yeah, javascript (very simular to the mnnbfsl interpreter I just posted).
18:34:45 <cluid> cool good luck :D
18:35:00 <cluid> i have posted an interpreter, but I haven't been able to write intereting programs with it yet
18:35:14 <AndoDaan> Encoding the tree is giving me some problems though. I need to brush up on that kind of data structure.
18:35:37 <cluid> it is a little difficult since its infinite/unbounded
18:35:47 <cluid> one way might be to grow the tree as needed
18:35:48 <AndoDaan> Can BF automatically translated to TH?
18:35:55 <cluid> yes its easy to translate
18:36:01 <cluid> just turn < to ^
18:36:24 <cluid> since you can see a linear tape as just taking the right branch each time
18:36:46 <AndoDaan> Hmm.
18:37:04 <cluid> http://web.cecs.pdx.edu/~sheard/course/Cs163/Graphics/CompleteBinary.jpg
18:37:12 <cluid> like
18:37:16 <cluid> A > C > G > ...
18:37:19 <cluid> would be the brainfuck part
18:37:21 <cluid> and the rest is just ignored
18:38:05 <cluid> http://cs.anu.edu.au/~bdm/tree.png this is a better pictures
18:38:17 <cluid> so you have all this extra space than BF
18:38:22 <cluid> but it's hard to make good use of it
18:39:20 <AndoDaan> Is there anything interesting the tree can do, that's otherwise is hard to do in bf?
18:39:51 <cluid> the main thing is that you easily have as much memory as you choose next to any cell
18:40:02 <elliott> http://www.sweetandfizzy.com/fractals/index.html http://www.sweetandfizzy.com/fractals/diagrams.html
18:40:12 <cluid> whereas in brainfuck you would have to make sure you keep space around before starting
18:42:33 <elliott> http://www.webcitation.org/query?url=http://www.geocities.com/CapeCanaveral/Campus/8446/vid_fractals/index.html&date=2009-10-25+06:34:34
18:42:38 <elliott> computerless fractals
18:51:12 <fizzie> We were browsing our trip photos on the hotel room TV the other day, and I took a couple of silly feedback photos since I had the camera plugged in and all.
18:51:16 -!- InvalidCo has quit (Ping timeout: 256 seconds).
18:53:06 <elliott> so can you make fractals like that with no camera at all, just using mirrors
18:53:15 <elliott> no reason you shouldn't be able to, right?
18:54:02 <fizzie> elliott: I think it works like https://i.imgur.com/Q3aWVGf.gif as they said on another channel.
18:54:21 <elliott> god, I love that gif
18:54:54 <fizzie> (This was on a course channel for a 3D graphics course that's almost all about raytracing.)
18:56:44 <fizzie> https://www.dropbox.com/l/nw8dddpkXVIYQgOYyDtGQr <- the usual thing
18:58:07 <elliott> I think the best part of these photos is your wife implicitly facepalming off-screen
18:58:29 <elliott> "is THIS what they do at GOOGLE"
18:58:57 <fizzie> It wasn't quite like that. But it was a little bit like that.
18:59:34 <J_Arcane> It looks like an IBNIZ demo.
19:06:07 -!- scounder has quit (Read error: Connection reset by peer).
19:06:46 -!- ais523 has joined.
19:16:45 -!- MDream has quit (Quit: later chat).
19:18:57 -!- Sprocklem has quit (Ping timeout: 264 seconds).
19:22:20 -!- roasted42 has joined.
19:25:09 -!- scounder has joined.
19:27:00 -!- roasted42 has quit (Ping timeout: 258 seconds).
19:41:21 -!- mihow has quit (Quit: mihow).
19:43:21 -!- InvalidCo has joined.
19:48:09 -!- mihow has joined.
20:00:43 -!- Sprocklem has joined.
20:05:09 -!- Patashu has joined.
20:15:38 -!- ais523 has quit (Read error: Connection reset by peer).
20:15:52 -!- ais523 has joined.
20:18:27 -!- InvalidCo has quit (Ping timeout: 250 seconds).
20:25:44 -!- Patashu has quit (Ping timeout: 265 seconds).
20:26:35 -!- dts|pokeball has quit (Ping timeout: 272 seconds).
20:36:15 -!- shikhin has quit (Read error: Connection reset by peer).
20:36:46 -!- shikhin has joined.
20:37:09 -!- shikhin has changed nick to Guest80998.
20:50:06 -!- bb010g has joined.
20:56:06 -!- MoALTz has quit (Quit: Leaving).
21:02:29 <HackEgo> [wiki] [[StaPLe]] http://esolangs.org/w/index.php?diff=41492&oldid=41490 * BCompton * (+3) /* Hello World */ Fixed syntax
21:13:26 -!- jedi01 has joined.
21:16:50 -!- InvalidCo has joined.
21:21:06 -!- jedi01 has quit (Quit: Leaving).
21:34:02 -!- MDream has joined.
21:42:24 <GeekDude> BS sounds like an amazing language
21:43:49 -!- ais523 has quit (Read error: Connection reset by peer).
21:44:00 -!- ais523 has joined.
21:46:50 -!- callforjudgement has joined.
21:47:08 -!- ais523 has quit (Read error: Connection reset by peer).
21:52:12 <AndoDaan> Cluid, I guess because TH's binary tree is infinite and because you can only get to those nodes by computing its 'address' ("><>>><><>" or 10110101), that means some nodes will never be reachable."
21:52:42 <AndoDaan> Right? I could be confusing concepts.
21:53:47 <cluid> AndoDaan, I think you could write a program that touches each node eventually
21:54:01 <cluid> just like how you can write a prorgam that prints out every fraction for example
21:54:07 <cluid> I should try to do this
21:54:13 <cluid> GeekDude, brainsuck?
21:54:25 <GeekDude> https://skillsmatter.com/skillscasts/6088-the-worst-programming-language-ever
21:54:31 <GeekDude> BS, the worst programming language ever
21:54:46 <cluid> haha
21:56:05 <elliott> you can't because paths are infinite
21:56:10 <elliott> you can never touch the path 11111...
21:56:24 <elliott> or the path 01001000100001000001...
21:56:44 <elliott> paths in an infinite binary tree, i.e. infinite lists of bits, are isomorphic to the reals
21:57:09 -!- callforjudgement has changed nick to ais523.
21:57:10 <cluid> we're only considering finite paths
21:57:11 <AndoDaan> Supernatural numbers.
21:57:54 <elliott> ok, I was just replying to AndoDaan (since it is true that some nodes of the infinite tree will never be reachable)
21:58:09 <AndoDaan> Or that's what hofstadler called them.
21:58:12 <cluid> that isn't correct
21:58:24 <cluid> every node in the tree will have a finite path to it
21:59:57 -!- S1 has joined.
22:00:56 <elliott> ok, yes, you're right
22:01:06 <elliott> it would be cooler without that limitation though
22:12:02 <FreeFull> elliott: One could construct an infinite binary tree where each node corresponds to a rational number too
22:18:41 <HackEgo> [wiki] [[StaPLe]] http://esolangs.org/w/index.php?diff=41493&oldid=41492 * BCompton * (+93) /* Example Programs */
22:18:49 <Phantom_Hoover> now that i think about it i'm pretty sure any graph with finitely (or even countably) many edges touching each vertex has a countable number of vertices in each connected component
22:28:01 -!- Sprocklem has quit (Ping timeout: 265 seconds).
22:37:12 -!- CrazyM4n has joined.
22:38:22 <HackEgo> [wiki] [[Deadfish]] http://esolangs.org/w/index.php?diff=41494&oldid=41476 * BCompton * (+12) /* External resources */ Dead Link
22:38:28 -!- mihow has quit (Quit: mihow).
22:41:17 -!- S1 has quit (Quit: S1).
22:48:34 -!- roasted42 has joined.
22:51:24 -!- oerjan has joined.
23:00:27 <shachaf> whoa, i just was informed that Gregor is a professor at Waterloo now
23:01:21 <oerjan> so does he have a napoleon hat
23:02:03 <shachaf> also i meant "was just" but english is great it works either way
23:04:19 <fizzie> Phantom_Hoover: So how about those infinite trees corresponding to base-d digit sequences, then? One connected component, each vertex (except the root) has a degree of d+1, yet there's at least ond vertex for each real?
23:05:06 <cluid> oerjan, I thought of a fun thing to write in Treehugger if youre interesting
23:05:08 <cluid> interesed
23:05:09 <cluid> **
23:05:25 <oerjan> hm he has a tricorn but not a bicorne
23:06:13 <cluid> O_O
23:06:26 <oerjan> @tell Gregor now that you're in waterloo you need a bicorn hth
23:06:26 <lambdabot> Consider it noted.
23:06:46 <oerjan> cluid: are you not familiar with http://choosemyhat.com/
23:07:08 <cluid> :D
23:07:09 <cluid> haha
23:07:54 <oerjan> also, i don't think treehugger is quite my thing, although i _did_ implement V way back
23:08:03 <cluid> V?
23:08:09 <cluid> oh yeah
23:08:13 <cluid> BTW it's cool you should like it
23:08:41 <cluid> its like brainfuck
23:08:52 <oerjan> i mean, the thing that interested me about V was its weird operations and Treehugger is less weird...
23:09:00 <cluid> alright
23:09:14 <cluid> il read about V more
23:09:20 <oerjan> i don't think i was particularly interested in _programming_ V, once it became clear how to translate bf to it
23:10:03 <cluid> V seems a bit like a sort of rubiks cube type problem
23:12:04 <oerjan> hah in that case you should look at Jolverine
23:13:23 -!- roasted42 has quit (Ping timeout: 245 seconds).
23:14:39 -!- roasted42 has joined.
23:15:15 <cluid> I think this treehugger problem is really interesting
23:16:59 <fizzie> Phantom_Hoover: (Or I guess scratch that, there's just a path for each real. Bah.)
23:17:29 <cluid> it's so easy in brainfuck, but really hard in treehugger -that's funny bceause it was designed the opposite way
23:18:10 <oerjan> wait isn't brainfuck trivially translatatble to treehugger
23:18:28 <cluid> yes
23:19:07 <oerjan> *-t
23:19:46 <oerjan> ok what kind of problem can it be then
23:20:20 <oerjan> it'd need to be something aware of its implementation language
23:20:25 <cluid> yes thats right
23:20:38 <cluid> its not a self interpreter though
23:21:03 <oerjan> and a quine wouldn't be hard to modify slightly for different commands
23:21:25 <cluid> I could give a hint in the form of a BF program
23:21:29 <oerjan> not that a quine is "so easy" in brainfuck
23:21:49 <oerjan> it's not theoretically hard, but it's messy
23:22:54 <oerjan> so i guess i am curious what the problem is, no promises though
23:23:17 <cluid> +[>+]
23:23:36 <oerjan> ok that's an infinite loop
23:23:38 <oerjan> oh hm
23:23:43 <oerjan> let me gues
23:23:46 <oerjan> *guess
23:23:57 <oerjan> you want something that touches every cell in the tree
23:24:13 <cluid> yeah!
23:24:26 <oerjan> hm that's essentially labyrinth code isn't it
23:24:34 <cluid> I think this is even tricky for double sided brainfuck
23:24:47 <cluid> ah i see how to do it for that just push 1's out
23:24:49 <elliott> I think it should be quite easy
23:25:00 <elliott> because basically the trailed 1s give you a path
23:25:14 <cluid> elliott, I would appreciate an implementation! I'm trying myself too but I think you would be able to tdo it quicker
23:25:20 <oerjan> elliott: the problem is not going off on an infinite path and never coming back
23:25:34 <elliott> oerjan: how could you? the tree starts as all 0s
23:25:46 <elliott> maybe you would need a counter in the cells or something...
23:26:08 <elliott> wait do you have to fill the nodes *above* you too
23:26:11 <elliott> since there is no root
23:26:16 <oerjan> obviously
23:26:25 <oerjan> i don't think that makes it much harder though...
23:26:27 <elliott> that sounds trickier, I was thinking just all the children of the initial cell
23:26:47 <oerjan> you just need to consider the starting cell the root
23:26:47 <elliott> okay it's just non-trivial I was wrong to think it's easy
23:26:58 <Phantom_Hoover> <fizzie> Phantom_Hoover: So how about those infinite trees corresponding to base-d digit sequences, then? One connected component, each vertex (except the root) has a degree of d+1, yet there's at least ond vertex for each real?
23:27:09 <elliott> oerjan: okay, yeah.
23:27:16 <elliott> do cells have limited range, I forget
23:27:18 <Phantom_Hoover> vertices corresponding to infinite sequences don't connect to anything
23:27:33 <cluid> for the sake of this program ets say cells can hold Integer (unbounded)
23:27:44 <fizzie> Phantom_Hoover: See also the other message.
23:29:27 <oerjan> bah i think it's more interesting if they're bounded :P
23:29:52 <elliott> are you sure you can't get away with Bool cells
23:30:06 <oerjan> ouch
23:30:24 <oerjan> possible? probably. but seriously awkward.
23:32:37 <oerjan> you'd want to store the direction to the root, at least
23:34:38 -!- roasted42 has quit (Ping timeout: 258 seconds).
23:35:13 <oerjan> it should be possible to visit the cells in an outgoing spiral, essentially
23:35:49 <oerjan> oh hm
23:36:06 <oerjan> one bit _is_ enough for the direction to the root
23:36:15 -!- roasted42 has joined.
23:36:25 <oerjan> assuming you know where you are coming from
23:36:43 -!- TodPunk has quit (Ping timeout: 245 seconds).
23:37:54 <oerjan> ...problem is, not for telling you when you've actually _reached_ it.
23:38:25 <oerjan> however, you could probably store extra bits in side branches
23:41:08 <oerjan> so hm on the path downwards to the root, a bit tells you what is the direction to the root, although the _other_ direction gives you a bit that tells if you're already there.
23:42:27 <oerjan> as you go downward, you change the cells you are passing through to tell you the direction upwards instead.
23:42:45 <oerjan> like a zipper inside the actual structure you're navigating
23:44:13 -!- callforjudgement has joined.
23:44:33 -!- Sprocklem has joined.
23:47:00 <int-e> oerjan: there's an easy 3rd place up for grabs in an ancient endless problem: http://golf.shinh.org/p.rb?ASCII+from+0x01+to+0x7f
23:47:37 -!- MDream has changed nick to MDude.
23:47:59 <cluid> so how should I actually write this...h m.......
23:47:59 -!- ais523 has quit (Ping timeout: 272 seconds).
23:48:06 <HackEgo> [wiki] [[Treehugger]] http://esolangs.org/w/index.php?diff=41495&oldid=41452 * Oerjan * (+27) clarify infinity is rootless
23:48:06 <cluid> also I'm not really sure how to test it
23:48:39 -!- TodPunk has joined.
23:48:43 <cluid> oerjan, thanks for the edit! 'upwards' might be misleading though?
23:49:02 <cluid> the program ^ is similar to < in brainfuck.. you crash beacuse of going off the tape
23:49:19 <oerjan> cluid: oh. then i've completely misunderstood.
23:49:24 <oerjan> and so have others, i think.
23:49:28 -!- poq has joined.
23:49:39 -!- poq has left.
23:49:47 <HackEgo> [wiki] [[Treehugger]] http://esolangs.org/w/index.php?diff=41496&oldid=41495 * Oerjan * (-17) it wasn't to be
23:50:04 <oerjan> that definitely changes what the space-filling program needs to do
23:50:08 <oerjan> elliott: ^
23:50:27 <elliott> cluid: huh, didn't you say the tree was unrooted?
23:50:28 <oerjan> THERE WAS A ROOT
23:50:32 <elliott> so that you can go up forever
23:50:33 <cluid> http://esolangs.org/wiki/Treehugger/Implementation
23:50:43 <cluid> zero there is the initial tape
23:51:08 <elliott> that is a shame, I liked the idea of it spanning infinitely like that
23:51:35 <cluid> I see what you mean about up
23:51:56 <cluid> that sounds hard to do you define that as Treehugger++ or something
23:52:08 <elliott> treehuger+=aleph_0
23:52:10 <elliott> gg
23:52:16 <elliott> oerjan: do you need to store the direction to the root?
23:52:24 <oerjan> cluid: V did that. although you then have to decide whether up is rightward of leftward
23:52:38 <elliott> my thinking was that you'd arrange so that [^] gets you to the root or such
23:52:45 <elliott> of course it's not as simple as that
23:52:50 <oerjan> elliott: all i said was based on the idea of it being unrooted
23:52:57 <elliott> right
23:53:05 <oerjan> should be simpler without that
23:53:06 <elliott> oh, I see, because that way you might have to go *down* to the root
23:53:10 <oerjan> indeed
23:54:03 <elliott> actually
23:54:10 <elliott> if you have the root be 0 how can you fill every cell
23:54:11 <elliott> >_<
23:54:13 <oerjan> i have been thinking that if you wanted to a _really_ unrooted tree like this, you'd not want up to special, instead you'd just do "turn left", "turn right", and "go back where you came from"
23:54:18 <oerjan> *to do
23:54:18 <cluid> btw I am very pleased with using a zipper in this code
23:54:28 <elliott> okay the root isn't any less filled than the infinite number of cells below you but it feels weird
23:54:28 <cluid> it's called Z there
23:54:45 <oerjan> elliott: heh that is a point
23:55:08 <oerjan> you cannot fill arbitrary many levels down with non-zeros. or can you?
23:55:16 <elliott> why not?
23:55:28 <elliott> you could always flip the root to filled for one cycle when you got up there
23:55:30 <oerjan> i mean while keeping the root non-zero as well
23:55:38 <elliott> then you could have nice freeze frames
23:55:54 <oerjan> also my idea didn't intend to fill everything simultaneously
23:55:55 <elliott> see I assumed it was filling every cell below the one you start on, and that you could go up forever
23:56:02 <elliott> so in that case [^] does put you to the root.
23:56:06 <elliott> *move you
23:56:09 <oerjan> which i guess doesn
23:56:10 -!- roasted42 has quit (Ping timeout: 264 seconds).
23:56:20 <oerjan> 't fit the analogy with +[>+]
23:56:21 <elliott> that turning idea is nice for my generalised graph brainfuck idea I think
23:56:36 <cluid> I thought of Gridfuck
23:56:40 <cluid> it has <^>v
23:56:42 <cluid> four directions
23:56:54 <cluid> http://esolangs.org/wiki/Gridfuck
23:56:56 <cluid> it doesn't exist!
23:57:13 <elliott> you'd have "focus previous/next edge", "follow edge (making you face back the way you came)", there is one edge for every integer, the initial state is one zero cell looped to itself an infinite number of times
23:57:41 <elliott> plus a (...) construct that means "reassign this edge to the cell we end up at", or something
23:57:49 <elliott> and then a control structure less powerful than [] so you're forced to program with the graph
23:58:04 <elliott> oh plus a "connect a new cell to this edge" instruction.
23:58:14 <elliott> (maybe it'd be better if you got an infinite number of cells to start with so you could omit that)
23:58:15 <cluid> gridfuck ha sloops, but treehugger is just a tree
23:58:42 <cluid> "so you're forced to program with the graph" <- that is cool!
23:58:46 <elliott> well anyway this would be impossible to program in because nobody can visualise graphs like this except mathematicians too good to care about esolangs
←2014-12-16 2014-12-17 2014-12-18→ ↑2014 ↑all