←2019-06-04 2019-06-05 2019-06-06→ ↑2019 ↑all
00:00:59 <tswett[m]> > let eea _ xa xb 0 _ _ = (xa, xb); eea x xa xb y ya yb = (let s = x `mod` y in eea y ya yb (y - s * x, ya - s * xa, yb - s * xb) in eea 314 1 0 100 0 1
00:01:01 <lambdabot> <hint>:1:129: error: parse error on input ‘in’
00:01:20 <tswett[m]> > let eea _ xa xb 0 _ _ = (xa, xb); eea x xa xb y ya yb = (let s = x `mod` y in eea y ya yb (y - s * x, ya - s * xa, yb - s * xb)) in eea 314 1 0 100 0 1
00:01:22 <lambdabot> error:
00:01:22 <lambdabot> • Couldn't match type ‘c -> c -> (c, c)’ with ‘(c, c)’
00:01:22 <lambdabot> Expected type: c -> c -> c -> (c, c, c) -> (c, c)
00:01:49 <tswett[m]> > let eea _ xa xb 0 _ _ = (xa, xb); eea x xa xb y ya yb = (let s = x `mod` y in eea y ya yb (y - s * x) (ya - s * xa) (yb - s * xb)) in eea 314 1 0 100 0 1
00:01:56 <lambdabot> mueval: ExitFailure 1
00:02:19 <tswett[m]> 🤔
00:03:48 <tswett[m]> > let eGCD 0 b = (b, 0, 1); eGCD a b = (let (g, s, t) = eGCD (b `mod` a) a in (g, t - (b `div` a) * s, s)) in eGCD 314 100
00:03:50 <lambdabot> (2,-7,22)
00:05:06 <tswett[m]> > let eGCD (_, 0, b) = (b, 0, 1); eGCD (_, a, b) = (let (g, s, t) = eGCD (undefined, (b `mod` a), a) in (g, t - (b `div` a) * s, s)) in iterate eGCD (undefined, 314, 100)
00:05:10 <lambdabot> [(*Exception: Prelude.undefined
00:05:23 <tswett[m]> > let eGCD (_, 0, b) = (b, 0, 1); eGCD (_, a, b) = (let (g, s, t) = eGCD (undefined, (b `mod` a), a) in (g, t - (b `div` a) * s, s)) in iterate eGCD (123456789, 314, 100)
00:05:26 <lambdabot> [(123456789,314,100),(2,-7,22),(-1,-3,-1),(-1,0,1),(1,0,1),(1,0,1),(1,0,1),(...
00:06:10 <tswett[m]> I conclude that 314/100 is approximately 22/7.
00:08:41 <int-e> tswett[m]: you seem to be an approximately rational person
00:09:01 <tswett[m]> Thank you, more or less.
00:09:14 <shachaf> Can you name a number that is not approximately another number?
00:12:56 <int-e> shachaf: let's be discrete...
00:13:25 <int-e> But I guess you'll say that 42 is approximately 0.
00:15:22 <shachaf> I wasn't making any claims.
00:15:45 <shachaf> But I suppose that, for example, an infinite hyperreal isn't approximately equal to any finite number.
00:17:05 <int-e> I did consider mentioning \omega. But then that's approximately \omega + 1, if we allowed 0 to be approximately 1.
00:18:56 <int-e> OTOH hyperreals give you better-than-rational approximations.
00:24:07 -!- zhiayang has joined.
00:28:56 <zhiayang> hello, not entirely sure if this fits, but: say i'm targeting a limited stack vm as a backend for a compiler, and the vm only has the constants 0-9 (so to get 20 i'd need 4 5 *). so, how do i do relocations, given that the "size" of each relocation is not fixed?
00:30:03 <kmc> perhaps something like this https://www.sifive.com/blog/all-aboard-part-3-linker-relaxation-in-riscv-toolchain
00:31:18 <shachaf> int-e: Oh, well, I meant "do there exist x,y such that x is not approximately y"
00:31:30 <shachaf> Not "does there exist x such that for all y, x is not approximately y"
00:33:42 <zhiayang> kmc: hm, the thing is most of these places have an "upper bound" for the address/offset
00:33:50 <zhiayang> like i can 100% say it will either be 32-bits or less
00:34:25 <zhiayang> whereas if my offset happens to be some prime number or something, the number of instructions i need to generate it might be unpredictably large
00:34:32 <zhiayang> so it's hard to reserve a set amount of space for it
00:35:43 <shachaf> I was reading about fancy assemblers that try to optimize the number of bytes used for jump instructions.
00:35:51 <shachaf> In some cases you need a lot of passes.
00:35:52 <kmc> hmm
00:36:12 <kmc> zhiayang: you can set a maximum, and anything bigger gets turned into a function call to a function created by the linker
00:36:33 <shachaf> Don't functions have the same issue?
00:36:46 <shachaf> I guess the linker could place them at a particular place.
00:36:59 <kmc> or depending on your memory instructions you could place them in a data section http://www.keil.com/support/man/docs/armasm/armasm_dom1359731147760.htm
00:37:10 <shachaf> You could maybe have some nops around jump targets, which gives you more leeway in avoiding prime numbers.
00:37:11 <zhiayang> ah, there's nothing as fancy as a linker here, tbh
00:37:23 <zhiayang> i'm currently going from IR -> vm opcodes
00:37:28 <zhiayang> (which is just text)
00:39:17 <shachaf> ahttps://board.flatassembler.net/topic.php?t=20249 is the post I was thinking of.
00:39:23 <shachaf> s/a//
00:39:35 <shachaf> Not really relevant to you.
00:39:40 <esowiki> [[Special:Log/newusers]] create * Aquirel * New user account
00:42:54 <zhiayang> interesting read, nontheless
00:44:25 <zhiayang> also, to read from the data section would require the same kind of shennanigans, so i don't think it might be useful
00:44:45 <zhiayang> i might just set an upper limit of 32 and complain if it's exceeded
00:47:15 <shachaf> kmc: did you ever see http://slbkbs.org/serp.html
00:47:50 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=63083&oldid=62922 * Aquirel * (+114)
00:50:52 <kmc> yes
00:51:03 <shachaf> still works
00:51:22 <shachaf> i guess browser people don't care
00:53:54 <esowiki> [[ABCR]] https://esolangs.org/w/index.php?diff=63084&oldid=50392 * Aquirel * (+237)
01:04:39 -!- unlimiter has joined.
01:11:38 -!- unlimiter has quit (Quit: WeeChat 2.4).
01:15:14 <shachaf> ais523: https://secretgeek.github.io/html_wysiwyg/html.html is arguably different from the types of quines we talked about.
01:15:24 <shachaf> Though I think you can classify it as cheating.
01:18:32 <kmc> that's cute
01:18:34 <kmc> > The only other style that is special is "style" itself, which has to include an escape character to avoid being taken literally. I like to think that may be a parser bug created by browser developers who did not suspect that people would engage in such an atrocity.
01:18:36 <lambdabot> <hint>:1:55: error: parse error on input ‘,’
01:18:39 <kmc> it's not really a bug
01:18:43 <kmc> it's a consequence of nesting parsers
01:18:59 <kmc> or perhaps nesting tokenizers within parsers
01:19:01 <shachaf> I remember a capture the flag thing we both did that uesd that bug.
01:19:11 <shachaf> Though I think I used it and you used some other method.
01:19:15 <shachaf> I mean, that non-bug.
01:19:24 <kmc> where you sneak a </script> inside a string in a <script> block?
01:19:27 <shachaf> Yes.
01:19:30 <kmc> yeah
01:19:32 <kmc> the web is so bad
01:19:38 <kmc> I could go on and on but you already know
01:19:42 <shachaf> the worst
01:21:59 <shachaf> kmc: i wrote a simple program in server-side javascript a few years ago and i have to npm it up when i want to use it
01:22:02 <shachaf> it was a mistake
01:22:31 <shachaf> my new goal is to never interact with npm again
01:22:45 <shachaf> also docker
01:22:52 <shachaf> (which fortunately i wasn't using)
01:24:30 <adu> http://left-pad.io/
01:25:26 <kmc> shachaf: what about rust
01:25:32 <shachaf> not sure
01:25:45 <kmc> how long before the same kind of people finish ruining it
01:25:45 <shachaf> it's probably better
01:26:04 * adu <3 Rust
01:26:22 * adu <3 Risc-V
01:27:08 * adu <3 AlpineLinux
01:27:29 <kmc> risc-v is cool
01:27:44 <shachaf> kmc: you should watch the mill videos imo
01:27:57 <adu> I can't wait until I can run a rust cross compiler in alpine that compiles to riscv
01:28:27 <adu> riscv is how all processor design should be
01:29:07 <adu> 1) good, slow, thoughtful, extensible, etc.
01:29:16 <adu> 2) open, available, documented, etc.
01:30:16 <adu> none of this "AMD has decreed that the Intel arch is no longer 32-bit!"
01:30:51 <shachaf> AMD didn't decree that?
01:30:59 <adu> AMD64, look it up
01:31:21 <shachaf> AMD extended it.
01:31:35 <shachaf> Modern amd64 chips can still run 32-bit x86 code.
01:31:56 <shachaf> Intel was the one that made an incompatible 64-bit architecture.
01:32:17 <adu> IA-64, IA-32, AMD-64, Intel-64, it's all a mess
01:32:37 <adu> it's almost as if it was designed by 12 companies
01:33:52 <shachaf> IA-IA-Cthulhu-Fhtagn
01:34:33 <kmc> shachaf: can you please shut up about the mill videos
01:34:46 <kmc> at least tell me something interesting about it rather than just nagging me over and over
01:38:55 <shachaf> no
01:39:12 <shachaf> (to the second thing)
01:40:16 <adu> shachaf: did they release yet?
02:06:56 -!- Lord_of_Life has quit (Ping timeout: 248 seconds).
02:09:46 -!- Lord_of_Life has joined.
02:32:38 <esowiki> [[Special:Log/newusers]] create * CraftSpider * New user account
02:35:31 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=63085&oldid=63083 * CraftSpider * (+242)
02:45:33 -!- CraftSpider has joined.
02:46:53 <esowiki> [[Jungle]] M https://esolangs.org/w/index.php?diff=63086&oldid=62733 * CraftSpider * (+0) Fix decrement code preview
03:29:22 -!- sprocklem has quit (Quit: brb).
03:30:32 -!- sprocklem has joined.
03:40:41 -!- FreeFull has quit.
03:57:17 <esowiki> [[Talk:Pointless]] https://esolangs.org/w/index.php?diff=63087&oldid=63082 * A * (+221)
03:59:49 <esowiki> [[Collide]] M https://esolangs.org/w/index.php?diff=63088&oldid=63074 * A * (+226) Add a characteristic
04:01:50 <esowiki> [[Pointless]] https://esolangs.org/w/index.php?diff=63089&oldid=63007 * A * (+116) /* Computational class */
04:02:58 <esowiki> [[EnScript]] M https://esolangs.org/w/index.php?diff=63090&oldid=63065 * A * (+77)
04:05:03 <esowiki> [[EnScript]] M https://esolangs.org/w/index.php?diff=63091&oldid=63090 * A * (+86) /* Examples */ Come and prove the computational class!
04:08:05 <esowiki> [[Pointless]] M https://esolangs.org/w/index.php?diff=63092&oldid=63089 * A * (-28) /* Computational class */
04:09:46 <esowiki> [[Talk:Pointless]] https://esolangs.org/w/index.php?diff=63093&oldid=63087 * A * (+178)
04:12:10 -!- A_ has joined.
04:13:04 <A_> `?learn pretend pretend(v.) To pretend is to do something before others expect it to be done.
04:13:05 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: ?learn: not found
04:15:36 <A_> `? learn pretend pretend(v.) To pretend is to do something before others expect it to be done.
04:15:38 <HackEso> learn pretend pretend(v.) To pretend is to do something before others expect it to be done.? ¯\(°​_o)/¯
04:16:54 <A_> `? python -i "print"
04:16:56 <HackEso> python -i "print"? ¯\(°​_o)/¯
04:17:02 -!- A_ has left.
04:41:18 -!- Sgeo_ has joined.
04:44:11 -!- Sgeo__ has quit (Ping timeout: 248 seconds).
04:51:59 -!- CraftSpider has quit (Ping timeout: 256 seconds).
04:52:32 -!- sebbu3 has joined.
04:56:34 -!- sebbu has quit (Ping timeout: 268 seconds).
05:29:39 -!- S_Gautam has joined.
07:29:54 -!- AnotherTest has joined.
08:05:19 -!- b_jonas has joined.
08:05:51 <b_jonas> zhiayang: couldn't you generate any integer constant using just two registers by writing it in bas 9?
08:06:20 <b_jonas> like, a_4+9*(a_3+9*(a_2+9*(a_1+9*a_0)))
08:06:35 <shachaf> b_jonas: The issue is the length of the code.
08:07:23 <myname> why would the base matter for the number of registers?
08:07:28 <b_jonas> shachaf: oh, you mean this is for jump offsets?
08:07:39 <shachaf> It's for relocations.
08:07:51 <b_jonas> what kind of relocations?
08:08:36 <shachaf> It wasn't specified.
08:09:22 <b_jonas> anyway, yes, that complicates stuff, you might need an assembler that does two or more passes to determine the address of everything
08:09:37 <b_jonas> because it doesn't know first how long an instr sequence it needs to assemble a constant
08:12:16 -!- Sgeo__ has joined.
08:16:00 -!- Sgeo_ has quit (Ping timeout: 248 seconds).
08:18:29 -!- adu has quit (Quit: adu).
08:27:22 -!- b_jonas has quit (Quit: leaving).
08:33:18 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
08:52:00 -!- Bowserinator has quit (Quit: Blame iczero something happened).
08:52:05 -!- moony has quit (Quit: Bye!).
08:56:15 <zhiayang> oh he left
09:01:08 <esowiki> [[Special:Log/newusers]] create * Rusiv * New user account
09:31:17 -!- wob_jonas has joined.
09:31:36 <wob_jonas> zhiayang: nah, I'm still here. this channel is logged and low-traffic so I read most of the logs.
09:31:53 <zhiayang> o
09:32:49 <zhiayang> but yea the issue is for jump offsets, not quite relocations
09:48:40 <wob_jonas> zhiayang: we use a two-pass method for that even on mainstream cpus. x86_64 has conditional and unconditional branch instructions that have both short and long versions. the short versions take up two bytes and have a 8-bit signed jump offset; the long ones take 6 bytes and have a 32-bit jump offset.
09:49:32 <zhiayang> right, but in this case you know the maximum is 6 bytes
09:49:43 <wob_jonas> typical code has lots of short branch instructions, beacuse there are conditionals and loops with a small body, so it would be a waste never to use them. but to determine whether you can use a short jump, you have to know the code addresses, and to determine the code addresses, you have to know how long instrs are.
09:50:33 <wob_jonas> yeah, so what the assemblers or compilers actually do is to first compute a worst case assumption of code addresses in the compilation unit, assuming that each jump instr is 6 byte long,
09:51:31 <wob_jonas> then in the second pass, put a short jump if the distance fits in the signed 8 bit offset, and assign the real addresses that way, then fill out all the addresses that refer to code.
09:52:40 <wob_jonas> (actually the unconditional jump is 5 bytes long, only the conditional ones are 6 byte long)
09:55:01 <wob_jonas> (and then there's the odd LOOP instruction, but I don't know if compilers use that)
10:23:14 <esowiki> [[Talk:EnScript]] M https://esolangs.org/w/index.php?diff=63094&oldid=63075 * A * (+161) /* The ENC Command */
10:43:19 -!- Sgeo__ has quit (Read error: Connection reset by peer).
10:43:44 -!- Sgeo__ has joined.
11:33:54 <esowiki> [[Talk:EnScript]] M https://esolangs.org/w/index.php?diff=63095&oldid=63094 * JonoCode9374 * (+201) /* The ENC Command */
11:35:56 <esowiki> [[EnScript]] M https://esolangs.org/w/index.php?diff=63096&oldid=63091 * A * (-77) An implementation will be easy...
11:58:46 <esowiki> [[Deadfish]] M https://esolangs.org/w/index.php?diff=63097&oldid=62978 * A * (+147) /* Variants of deadfish */
12:00:47 <esowiki> [[Deadfish "self-interpreter"]] M https://esolangs.org/w/index.php?diff=63098&oldid=63054 * A * (+162)
12:04:20 <esowiki> [[Deadfish]] M https://esolangs.org/w/index.php?diff=63099&oldid=63097 * A * (+112) /* Deadfish */
12:23:21 -!- ais523_ has joined.
12:23:49 -!- ais523_ has quit (Client Quit).
13:13:21 -!- arseniiv has joined.
13:17:55 <wob_jonas> yeah, they didn't receive my email. what a good excuse.
13:18:31 <wob_jonas> this one is about a hard to get book that I'm trying to read through interlibrary loan
13:19:19 <wob_jonas> and they didn't get it for me when I requested it earlier because they didn't receive my request in email
13:19:31 <wob_jonas> I called them now in telephone and resent the mail, so they said they'll get it
13:43:34 <esowiki> [[Stack]] M https://esolangs.org/w/index.php?diff=63100&oldid=46573 * A * (+76) /* Usage in esolangs */
13:44:59 -!- moony has joined.
13:46:45 -!- Bowserinator has joined.
13:50:28 -!- sebbu3 has changed nick to sebbu.
13:51:22 -!- Bowserinator has quit (Ping timeout: 252 seconds).
13:52:17 -!- moony has quit (Ping timeout: 252 seconds).
13:55:01 -!- Bowserinator has joined.
13:56:15 -!- moony has joined.
14:08:47 -!- Lord_of_Life has quit (Ping timeout: 244 seconds).
14:10:25 -!- Lord_of_Life has joined.
14:13:58 <arseniiv> how do you think, is CommonLisp’s format string language (used in `format` macro) esoteric?
14:14:54 <arseniiv> all those escape tildes surely are unusual at least
14:15:44 <wob_jonas> arseniiv: the more complicated parts of it might be, like the part where it defines a modifier to print the clock version of roman numerals
14:16:29 <arseniiv> :o
14:17:32 -!- bobby has quit (Ping timeout: 245 seconds).
14:19:37 <wob_jonas> and yeah, there are crazy conditionals and iteration, as if someone wanted to make a turing-complete language
14:20:05 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=63101&oldid=63079 * A * (+572)
14:20:21 <wob_jonas> mind you, you could compare this to the format escapes in terminfo strings, those have even more complicated control stuff
14:20:37 <wob_jonas> has a whole stupid small virtual machine that can do general purpuse computations
14:21:30 <wob_jonas> despite that that gets mostly unused, because the actual logic you could put there is mostly done in the curses or similar terminal handler implementation
14:21:42 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=63102&oldid=63101 * A * (-44) /* A simple concentrative language in 29 lines of code */
14:24:08 <arseniiv> <wob_jonas> and yeah, there are crazy conditionals and iteration, as if someone wanted to make a turing-complete language => my friend used them to format an internal list representation of backgammon moves to the standard one
14:24:41 <arseniiv> this is precisely why I asked :D
14:25:21 <wob_jonas> I think it was designed for quirky terminals that receive a number (eg. a column number) as a raw character code, but certain characters are not allowed because they're interpreted as a different control code, so the conditionals in the terminfo format code work around that
14:27:01 <arseniiv> mhm
14:27:18 <esowiki> [[User talk:A]] M https://esolangs.org/w/index.php?diff=63103&oldid=63102 * A * (+133) /* A simple concentrative language in 29 lines of code */
14:27:47 <wob_jonas> let me look up how those work actually
14:28:51 <wob_jonas> http://man7.org/linux/man-pages/man5/terminfo.5.html at "Parameterized Strings"
15:13:50 -!- Sgeo__ has quit (Read error: Connection reset by peer).
15:14:17 -!- Sgeo__ has joined.
15:16:57 -!- john_metcalf has joined.
15:18:22 -!- wob_jonas has quit (Remote host closed the connection).
15:30:35 -!- LKoen has joined.
16:09:38 <esowiki> [[]] M https://esolangs.org/w/index.php?diff=63104&oldid=57454 * Arseniiv * (+303) /* Syntax */ I forgot I was craving let expressions
16:10:04 <arseniiv> damn I used == in place of ===
16:10:42 <esowiki> [[]] M https://esolangs.org/w/index.php?diff=63105&oldid=63104 * Arseniiv * (+2) /* Let expressions */ subsubsectioned it
16:34:52 -!- ais523 has joined.
16:35:14 -!- LKoen has quit (Remote host closed the connection).
17:01:47 -!- AnotherTest_ has joined.
17:02:51 -!- AnotherTest has quit (Ping timeout: 248 seconds).
17:02:51 -!- AnotherTest_ has changed nick to AnotherTest.
17:20:13 -!- moei has joined.
18:15:52 -!- ais523 has quit (Quit: quit).
18:31:42 -!- adu has joined.
18:38:48 -!- clog has quit (Ping timeout: 245 seconds).
19:18:21 -!- clog has joined.
19:21:01 -!- b_jonas has joined.
19:30:52 <b_jonas> hi
19:31:58 <kmc> hello b_jonas
19:38:05 -!- Phantom_Hoover has joined.
19:43:24 -!- ais523 has joined.
19:43:43 <ais523> <adu> http://left-pad.io/ ← I actually reported a possible security bug in that (it was fixed)
19:43:57 <adu> lol
19:44:37 <adu> I was mostly joking
19:44:40 -!- ais523 has quit (Remote host closed the connection).
19:44:52 -!- ais523 has joined.
19:45:25 <ais523> <shachaf> ais523: https://secretgeek.github.io/html_wysiwyg/html.html is arguably different from the types of quines we talked about ← yes, I think that's a separate quining technique, it relies on a pretty specific evaluation order though, you need a language in which commands appearing anywhere in the program can globally and simultaneously redefine each other
19:45:55 <ais523> which is a pretty eso operation, come to think of it
19:46:06 <shachaf> Yes.
19:46:31 <shachaf> I wonder what a Magic: The Gathering quine would be.
19:47:51 <ais523> that depends on how output works, and how you define what a program's source code is
19:48:17 <ais523> it's like asking what a quine is in one of those flowchart languages which are designed to control microcontrollers
19:48:20 -!- FreeFull has joined.
19:48:43 <shachaf> Yes.
19:48:47 <ais523> the program is programmed in a GUI by dragging little rectangles and arrows and diamonds around, and the software it runs on outputs by toggling logic levels on wires
19:49:20 <shachaf> There are answers that involve encoding the output or something, but maybe there can be a more direct answer.
19:56:08 <b_jonas> oh, you mean the stupid _modern_ flowchart languages, not the ones used as pseudocode in old printed textbooks
19:57:35 <ais523> b_jonas: like the old printed textbook languages, except executable for some reason
19:57:54 <ais523> rather than pseudocode where you're allowed to be sloppy because the human readers can guess what you mean
19:58:55 <arseniiv> hm, are there known quines in Funciton?
20:00:31 <ais523> I think so
20:01:47 <ais523> hmm, apparently not, there isn't one on CG&CC's huge list of quines
20:01:53 <ais523> and I'd expect there to be one there if there's one anywhere
20:02:07 <ais523> that is, unless either I or they misspelled the name of the language
20:04:38 <arseniiv> btw I was thinking about a source code realized as various cartesian-axes-aligned rectangles with rectangular holes, but no clever ideas how to interpret them; one specific operation would be joining of two rectangles in such a way it’s impossible to cut the result into two rectangles in different ways—so we could make something like sequencing of structures; holes may contain another rectangular blobs, and maybe it’s fine for the
20:04:38 <arseniiv> m to be joined from several rectangles too
20:05:21 <arseniiv> <ais523> that is, unless either I or they misspelled the name of the language => yeah, for some time I have thought it’s simply “Function”
20:07:10 <ais523> I'm normally quite good at picking up on intentional misspellings in esolang names, but then I've modded the esowiki for ages
20:08:21 <arseniiv> if someone would be bold enough to make something of those rectangles, I suggest naming the result Rectangel
20:10:09 <arseniiv> hm maybe they should have thick borders (in pseudographics, just another type of character, color in images), it makes for many new possible configurations
20:30:34 <kmc> ais523: meh CSS is just another declarative language
20:30:37 <kmc> it doesn't seem that eso to me
20:34:35 <shachaf> Declarative languages where you can declare things that change the meaning of the program's code are pretty unusual.
20:35:13 <kmc> how do you mean
20:35:17 <kmc> and also how is that what's happening here
20:37:31 <kmc> the CSS is a declarative language that changes the way HTML is displayed
20:39:44 <shachaf> It also modifies <style>x</style> to mean "display this text verbatim"
20:42:38 <kmc> meh, it's just like any other HTML element
20:42:44 <kmc> it happens to be display: none in the default stylesheet
20:42:55 <kmc> so that is only changing one style attribute
20:43:05 <kmc> it doesn't actually change the meaning of <style> which is why the CSS still works
20:43:39 <shachaf> OK.
20:44:15 <kmc> what is the minimum complete set of HTML tags
20:44:47 <shachaf>
20:45:51 <kmc> I think you can render pretty much any page you want with div and style
20:46:03 <rain1> so div is HTML-complete
20:46:07 <shachaf> Or just div?
20:46:11 <shachaf> style is an attribute.
20:46:27 <kmc> ah true
20:46:35 <int-e> https://validator.w3.org/nu/?doc=https%3A%2F%2Fint-e.eu%2F~bf3%2Ftmp%2Fvalid.html
20:46:43 <kmc> although it'd be cumbersome to put the same style in every div
20:46:52 <kmc> (you could also use span, or any other single tag, even a custom one)
20:47:07 <kmc> of course if you want scripts or videos or iframes or something like that then you need the relevant tag
20:47:12 <kmc> unless you want to cheat and make it from javascript
20:47:18 <int-e> html5 is so "nice"... many tags are implicitly inferred.
20:47:28 <kmc> actually, can you set a video as content with CSS?
20:47:35 <kmc> that sounds like the kind of madshit thing that you could do
20:47:45 <kmc> int-e: oh yes... I wrote a conforming HTML5 parser so I know all about that
20:47:52 <int-e> I guess the question is... "complete" for what?
20:47:55 <shachaf> html ∈ scow
20:48:04 <shachaf> imo scrap the web
20:48:42 <kmc> keep the web and invite web people to ruin systems programming too
20:48:55 <int-e> and it's so weird that <title> of all elements should not be optional.
20:49:12 <shachaf> You know how people are doing WebAssembly-on-the-server nowadays?
20:49:24 <shachaf> I haven't seen any real justification for it yet.
20:49:49 <shachaf> people seem p. gung-ho about it, though
20:50:18 <kmc> are they the kind of people who think computer science started when brendan eich invented javascript
20:50:19 <ais523> int-e: metadata is important, <title> is probably the most important metadata?
20:50:34 <ais523> (arguably encoding is more important but often you can safely guess ASCII, also often it's sent out-of-band)
20:50:54 <ais523> kmc: many results in computer science predate computers and programming
20:51:05 <int-e> Google, yes, I knew that: "Someone just used your password to try to sign in to your account."
20:51:11 <shachaf> I suspect kmc is aware of that fact.
20:51:12 <kmc> there are rules for auto detecting the encoding so you can rely on that
20:51:15 <ais523> back then they were classified as part of philosophy, possibly because philosophers study logic, possibly because nobody knew what they were useful for
20:51:30 <kmc> what would you say is the earliest problem that would now be considered part of computer science
20:51:31 <int-e> Now if you have not blocked *my* attempt to send an email I would be much happier.
20:51:39 <kmc> I mean logic has applications in CS but most of logic is not considered CS per se
20:51:41 <ais523> the last day before I submitted my thesis I was sitting in the library looking up results in old philosophy books
20:51:57 <kmc> Hilbert's 10th Problem is basically a programming problem though
20:52:24 <ais523> ugh, I hate it when people refer to hilbert's problems by number because it makes it so hard to remember which is which
20:52:59 <ais523> 10th = solve arbitrary diophantine equations
20:53:08 <ais523> which is probably impossible because they're Turing-complete
20:53:10 <b_jonas> arseniiv: https://esolangs.org/wiki/Funciton/Quine
20:53:19 <b_jonas> (haven't tested it)
20:53:27 <Phantom_Hoover> 'probably'?
20:53:36 <Phantom_Hoover> oh you're hedging for the church-turing thesis being false
20:53:43 <ais523> yes, that's exactly the hedge
20:53:49 <kmc> lol https://blog.rust-lang.org/2019/06/03/governance-wg-announcement.html
20:53:55 <ais523> I don't see any reasonable way we can /know/ that the church-turing thesis is true
20:53:56 <kmc> your committees are dysfunctional? add more committees
20:54:21 <Phantom_Hoover> was there idiot drama leading up to this
20:55:00 <b_jonas> "<ais523> I'm normally quite good at picking up on intentional misspellings in esolang names" => I wonder what you thought of when I wrote "Amycus" instead of "Amicus" half of the time, including even in the article title
20:55:13 <ais523> b_jonas: oh, I thought the language was actually called Amycus
20:55:18 <kmc> Phantom_Hoover: I have no idea, I try not to pay too much attention
20:55:24 <ais523> if you make a mistake half the time then sometimes the other half looks like the mistake
20:55:26 <kmc> it may relate to the new website clusterfuck
20:55:31 <Phantom_Hoover> kmc, i increasingly find the word 'folks' to be a suggestive marker of someone being a wanker
20:56:15 <shachaf> oh no
20:56:24 <kmc> Phantom_Hoover: at least it's not "folx"
20:56:29 <kmc> which is 1000% that
20:56:34 <Phantom_Hoover> oh yes
20:56:56 <b_jonas> kmc: you wrote a conforming HTML5 parser? now I'm interested. can you tell me what the proper way is to get the list of classes from the whitespace-separated list in the class attribute?
20:57:05 <kmc> b_jonas: no
20:57:19 <shachaf> there's no problem that can't be solved with a working group with a charter
20:57:44 <b_jonas> kmc: also, I'd like to know how to properly put mathml and fallback html code for when the browser doesn't support mathml together on the same page, but without relying on javascript
20:58:09 <ais523> now I'm wondering how insane a parser can be while still conforming to HTML5
20:58:22 <ais523> ^ul (Diagnostic.)S
20:58:22 <fungot> Diagnostic.
20:58:26 <ais523> ^ a conforming C implementation
20:58:42 <ais523> or not quite, you need a preprocessor too
20:58:54 <ais523> but it'll handle C that's already been preprocessed according to the standard
20:59:03 <kmc> I wish things had gone differently with rust :/
20:59:06 <kmc> it really is a good language
20:59:21 <ais523> (the preprocessor is needed to handle #error directives, which actually have a standard-defined effect on the compile process)
20:59:26 <kmc> but here we are and my #1 goal for this year is to stop caring about rust
20:59:39 <ais523> maybe you can use it without caring about it?
20:59:45 <kmc> doubtful
20:59:48 <b_jonas> "<kmc> what would you say is the earliest problem that would now be considered part of computer science" => my guess is the classical algorithms for doing arithmetic ops on numbers in radixal representation
20:59:50 <kmc> that's like being friends with an ex
21:00:00 <kmc> it works sometimes
21:00:04 <ais523> my use of Rust is pretty much limited to looking at what the specification says atm and writing programs to it
21:00:08 <kmc> I don't think it will work here
21:00:09 <b_jonas> the TAOCP has historical remarks in some of its sections, including about that
21:00:17 <kmc> b_jonas: ok
21:00:22 <Phantom_Hoover> i don't want to seem judgemental but that does seem to be a kmc thing
21:00:22 <shachaf> the art of cuddly pooches
21:00:35 <Phantom_Hoover> you have become alienated and embittered about a lot of communities iirc
21:00:40 <kmc> indeed
21:00:51 <b_jonas> ais523: well, it was probably called Amycus back then by mistake, but even then, I did use "Amicus" a few times in the article
21:01:07 <kmc> if you have any advice on how to stop doing that pls let me know
21:01:10 <Phantom_Hoover> also a friend just sent me this https://twitter.com/spectatorindex/status/1134883280996642817
21:01:12 <ais523> now I wonder if you can set this sort of situation up in an esolang intentionally
21:01:13 <b_jonas> ais523: later I retconned it so now there's both an "Amicus" and and "Amycus"
21:01:26 <Phantom_Hoover> at last everyone will have countless opportunities to tell the US government that they're dril
21:01:40 <ais523> there's that esolang that's named after the first sentence of a Wikipedia article, and the name changes whenever the article changes…
21:01:43 <b_jonas> but "Amicus" should have been the name I used if I wasn't stupid
21:02:05 <ais523> they're both pronounced the same in English, anyway (at least, the dialects I know about)
21:03:34 <b_jonas> kmc: I have the opposite goal, I want to start using rust
21:03:47 <kmc> b_jonas: cool, well, fortunately the path to that is well documented
21:04:01 <Phantom_Hoover> the road to rust is paved with good intentions
21:04:17 <b_jonas> kmc: yes, and there's also some IRC channels where people can help me
21:04:18 <shachaf> rust+aluminium is tg
21:04:20 <kmc> b_jonas: just don't get involved with "the community"
21:04:27 <b_jonas> kmc: sure sure, I know
21:04:30 <ais523> I've got most of the way through writing my own suffix tree impl in Rust
21:04:36 <b_jonas> kmc: I'm not saying I want to use the dependency hell on their package repository
21:04:37 <Phantom_Hoover> do you mean posting about rust with them or like
21:04:39 <Phantom_Hoover> getting Involved
21:04:44 <ais523> the one currently on Cargo isn't flexible enough for what I want
21:05:04 <kmc> don't get into a position where you care which thoughts they do and don't allow to be expressed
21:05:05 <b_jonas> have you seen how many dependencies the most widely used regex package has? I won't be using that shit when I can just wrap a dependency-less regex engine with a C interface
21:05:19 <kmc> don't get emotionally invested
21:05:25 <shachaf> rust people keep saying rust is way ahead of the competition because of all the packages and things
21:05:33 <kmc> and avoid the shitheads like steve, ashley and manish
21:05:36 <shachaf> is that actually true or are the majority of them nonsense
21:05:37 <b_jonas> but the core language and standard library is made pretty well
21:06:05 <b_jonas> shachaf: obviously most of the hype they say about the language is false, but the same applies to any big language or library
21:06:17 <b_jonas> also I want to use python3 a little
21:06:24 <ais523> shachaf: I personally don't consider Rust to really /have/ competition, it's managed to find a niche that didn't previously exist (which is why it's interesting from an esoprogramming point of view)
21:06:54 <shachaf> What's the niche?
21:07:01 <b_jonas> I didn't use to get too invested in python, but I realized recently that it has grown to become a decent language,
21:07:07 <ais523> low-level/systems programming with hard static safety guarantees
21:07:12 <Phantom_Hoover> steve klabnik? he's always seemed ok when he posts on reddit (which he does a lot)
21:07:14 <b_jonas> with a good standard library and stuff,
21:07:18 <ais523> I guess Ada's in the same category, but has issues of its own
21:07:32 <Phantom_Hoover> also it's just oooold
21:07:39 <ais523> e.g. Ada has a malloc equivalent, but (in safe Ada) not a free equivalent, because freeing referenced memory would be unsafe
21:07:44 <Phantom_Hoover> a big part of rust's niche is being the New Hotness
21:07:59 <b_jonas> and that my main objection to it is still the indent-dedent syntax (which makes it hard to use it in one-liners or on irc), but that is actually a very specific objection that I can fix with a compatible syntax addition if I really want to
21:08:23 <ais523> whitespace sensitivity in Python annoys me too, I find it's way too easy for whitespace in a program to get corrupted
21:08:23 <b_jonas> with rust too I have some problems, but I figured they're problems that I can fix by writing some library functions that I'll then use in many programs
21:08:49 <ais523> my personal problems with Rust tend to be things that are so specific and eso that probably nobody else has run into them
21:09:00 <kmc> like?
21:09:01 <b_jonas> the context is that the main thing that pushes me to python is that perl has grown to be a much worse language that it used to be
21:09:02 <Phantom_Hoover> well now im curious
21:09:13 <shachaf> remember when rust looked like http://slbkbs.org/curry.rs.txt
21:09:36 <b_jonas> ais523: yes, but are they problems that you can fix easily by writing a library with functions and macros etc, or ones where to fix you'd have to replace everything in the core language?
21:10:57 <ais523> ugh, I can't remember the exact details of the problem, but know that it would have been fixed by making it possible to declare a trait as not being implementable by third-party modules, and then implicitly causing the trait to inherit from every trait implemented by every type that implements it
21:11:06 <ais523> I was considering PRing that but never got around to it
21:11:23 <ais523> as it is, my only workaround involved very large where clauses that had to be repeated all over the program
21:11:42 <b_jonas> I see
21:11:59 <shachaf> ais523: Another niche that Rust is in is "low-level language made in the past decade"
21:12:00 -!- FreeFull has quit (Ping timeout: 248 seconds).
21:12:26 <ais523> shachaf: I don't agree with that, there are plenty of attempts to make "better C" or "better C++"
21:12:36 <ais523> but they're not better by enough to be worthwhile
21:12:44 <shachaf> I didn't say it's alone in that niche.
21:12:49 <ais523> hmm, OK
21:12:57 <shachaf> But I think a lot of people are interested in it for that reason.
21:12:58 <ais523> I don't care about creation date of a language when evaluating it, though, normally
21:13:13 <shachaf> OK, really I mean "other than C and C++"
21:13:25 -!- FreeFull has joined.
21:13:56 <ais523> (there's the correlation that if a language was created a long time ago and is well-known and has features I like, I'd probably be using it already, so being new makes it less likely that I've already rejected it)
21:14:20 <shachaf> Is Ada good? Maybe I should just use Ada.
21:14:22 <shachaf> Probably not.
21:14:23 <shachaf> `? sgeolang
21:14:25 <HackEso> Sgeolang used to change frequently, but eventually it rusted in place.
21:14:54 <ais523> I think Ada is worth looking at; I am not convinced it's worth using
21:15:24 <ais523> Ada fans tend to be really fanatical about it for some reason (much as is seen with Lisp fans), which is arguably a positive
21:15:33 <esowiki> [[Talk:EnScript]] https://esolangs.org/w/index.php?diff=63106&oldid=63095 * JonoCode9374 * (+2513) /* Partial Interpreter */ new section
21:15:44 <ais523> but I'm worried that the sort of environments which would push someone to learn Ada (typically military) wouldn't leave a lot of scope for learning about the alternatives
21:16:06 <shachaf> I've never met an Ada fan.
21:16:18 <ais523> they're rare but not nonexistent
21:16:35 <shachaf> Are they existent?
21:16:48 <ais523> I know quite a bit of Ada by proxy (having learned VHDL which is mostly the same)
21:17:57 <ais523> but yes, on any sufficiently large programming forum, you'll likely get Ada fans turning up eventually
21:18:42 <Phantom_Hoover> there's a resident weirdo on /r/programmingcirclejerk who insists that freepascal is basically the perfect language which does everything rust, d and c++ do but better
21:18:49 <shachaf> ada mubarak
21:19:15 <shachaf> Phantom_Hoover: Is it true?
21:19:21 <ais523> as it's /r/programmingcirclejerk they are probably being ironic
21:19:22 <b_jonas> kmc: I want to add that I'm somewhat thick-skinned and hard to pull into flamewars, so I tend to function reasonably well in online communities that some people consider toxic,
21:19:24 <kmc> Phantom_Hoover: lol I like that guy
21:19:25 <Phantom_Hoover> i am sceptical
21:19:30 <Phantom_Hoover> ais523, no he absolutely is not
21:19:31 <kmc> I don't think they're being ironic
21:19:42 <kmc> b_jonas: the Rust community isn't like that
21:19:44 <b_jonas> the canon example being the perl community, which is someone split among the people who like what p5p are doing now, and schmorp, who keeps cricicizing them
21:19:49 <ais523> why would you try to argue a serious point on a circlejerk forum?
21:20:08 <b_jonas> and I managed to remain in speaking terms with people from both halves
21:20:29 <kmc> b_jonas: the Rust community is the opposite, everyone is expected to be super nice to the point where you can't criticise anything without couching what you say in the most deferential terms and a bunch of empty praise
21:20:31 <shachaf> I think I know the thing Phantom_Hoover is talking about and if so that person isn't ironic but self-aware of how they sound kind of ridiculous.
21:20:31 <Phantom_Hoover> well it's more of an /r/buttcoin style 'circlejerk' where it's not aping the targets of your mockery but just, you know, mocking them
21:20:32 <b_jonas> ais523: well, sometimes I do want a bugfix to get patched
21:20:53 <kmc> any trace of emotion in a negative viewpoint and you are "not being constructive"
21:20:54 <arseniiv> b_jonas: ah. Now I remember I have seen that probably :D thanks!
21:20:54 <shachaf> It's like me talking about Chu spaces.
21:20:56 <kmc> they also self congratulate themselves a whole lot on being friendly
21:21:06 <kmc> and the leadership seem to be exempt from following their own rules
21:21:37 <b_jonas> kmc: thank you for the hints, but I think I can manage
21:21:40 <kmc> ok
21:21:41 <kmc> good luck
21:21:50 <kmc> you probably don't suffer from the same specific issues as me, anyway
21:21:52 <b_jonas> and that does very often mean that I stop talking in some thread or parts of the forum
21:22:04 <b_jonas> which is the way you avoid flamewars
21:22:22 <b_jonas> not by being nice, but by not replying when there's no need because you won't be able to convince the other person anyway
21:22:30 <Phantom_Hoover> the ashley williams shitstorm is now my go-to example of how morally bankrupt ''social justice'' standards of acceptable conduct are
21:22:52 <ais523> on the subject of "attempts to make a better C created in the last ten years", there was one that became public just 3 days ago: https://odin-lang.org/
21:22:54 <b_jonas> I'm not perfect in this of course, and I do remember a few mistakes when I did get pulled into a pointless debate and I should have known better
21:23:00 <kmc> Phantom_Hoover: I wasn't going to bring it up directly
21:23:01 <kmc> but yes
21:23:06 <ais523> I don't really care about it, just thought that it was interesting that people were still trying
21:23:13 <b_jonas> ais523: do you count golang in this?
21:23:15 <shachaf> ais523: 3 days ago?
21:23:24 <ais523> b_jonas: yes, but it's more than 3 days old
21:23:26 <b_jonas> ais523: are you involved in that project? just curious
21:23:26 <Phantom_Hoover> yeah i glanced at that thing
21:23:27 <kmc> Phantom_Hoover: it's unclear what value she even provides
21:23:34 <shachaf> I remember Odin from last year at least.
21:23:37 <ais523> I don't consider Go to be better enough than C to be worthwhile, and may be worse in some respects
21:23:39 <kmc> besides dating steve
21:23:46 <ais523> shachaf: well, 3 days ago since it was announced as a public-beta type thing
21:23:55 <b_jonas> ais523: I don't either
21:23:56 <Phantom_Hoover> applying wadlers law i only looked at the lexical syntax and said to myself 'aha, it's rust'
21:23:57 <shachaf> b_jonas: I don't think languages with garbage collection are a practical alternative to C.
21:24:01 <Phantom_Hoover> i left satisfied
21:24:09 <b_jonas> I'm just asking whether it was _trying_ to be a better C
21:24:22 <b_jonas> I have examined golang and decided it was not really worthwhile,
21:24:25 -!- adu has quit (Quit: adu).
21:24:26 <ais523> b_jonas: I'm not involved iin that project
21:24:36 <shachaf> I think Odin is very close to a copy of what'shisname's language.
21:24:37 <b_jonas> though I do commend them for their spreading the idea of channels as a thread synchro primitive
21:24:56 <ais523> hasn't Java had BlockingQueue for longer than that?
21:25:10 <b_jonas> ais523: sure, there were implementations of it,
21:25:21 <b_jonas> but golang put them in focus so people notice it
21:25:38 <ais523> in my day job I've used so many different thread synchronization primitives…
21:26:51 <b_jonas> (see https://esolangs.org/logs/2019-05.html#lvOb on ais's recent question about thread synchronization)
21:27:00 <shachaf> day convolution is tg
21:27:21 <kmc> my biggest complaint with golang is not the language but the anti-intellectual blub attitude of the community
21:27:26 <b_jonas> also, I have an algorithms question. I'd like to know if a certain NP problem is NP-complete.
21:27:33 <kmc> "I've never learned or used generics so I don't need them"
21:27:39 <kmc> b_jonas: oh?
21:27:53 <ais523> I think BlockingQueue is one of the main things I use to actually block threads on each other in my day job
21:28:11 <ais523> kmc: I think it's a bit more nuanced than that, it's "we want to be able to hire programmers who don't understand generics so we'll leave them out of the language"
21:28:30 <kmc> I mean that's what rob pike said
21:28:34 <kmc> that they want to hire mediocre programmers
21:28:40 <kmc> but the rank and file go programmers have to pretend that's not them
21:28:43 <kmc> at least the ones who post about it online
21:28:50 <kmc> so they come up with excuses for why it's actually a brillinat design decision
21:29:07 <Phantom_Hoover> i once snarked on a reddit thread that you wouldn't want to use go if you wanted to take advantage of ideas invented after 1980
21:29:16 <Phantom_Hoover> someone replied 'but go has CSP!'
21:29:20 <Phantom_Hoover> i looked up CSP
21:29:28 <Phantom_Hoover> invented by tony hoare in 1979
21:29:30 <int-e> "To use this script, you'll need to have registered with Google as an OAuth application and obtained an OAuth client ID and client secret." -- what if I don't want to be an OAuth application?
21:29:31 <shachaf> to be fair, who needs generics when you have canadian aboriginal syllabics
21:29:31 <b_jonas> the inputs are a set of tuples, the tuples contain three integers: two are incoming and one is outgoing. these integers are indexes to imagined nodes, two of which are special, say 0 is the source and 1 is the goal. the input also has a number that serves as a size limit.
21:29:31 <ais523> hmm, what programming ideas /were/ invented after 1980?
21:29:55 <ais523> most ideas have a really long history, it just takes a while to find practical uses for them
21:30:11 <kmc> that is partly the premise of rust
21:30:11 <ais523> IMO the best programming ideas are the ones which are immediately obvious why they're useful, but hard to implement
21:30:16 <kmc> but I think some of the borrow checker stuff is newer
21:30:31 <kmc> I don't exactly remember when the work on region types was done
21:30:33 <ais523> people are likely to have those pretty much right away and then get stuck
21:30:42 <kmc> also typeclasses weren't even in Haskell until after '90, I'm pretty sure
21:30:48 <kmc> and most of the elaboration on how to make typeclasses work well is later
21:30:50 <b_jonas> you have to decide whether there's a sequence of length at most that limit, where each element of the sequence is one of the triples from the set, both of the two incoming nodes are either 0 or have appeared as outgoing nodes in a previous tuple of the sequence, and one of the tuples has 1 as the outgoing node number.
21:31:02 <shachaf> I'm not sure how important a feature generics are.
21:31:14 <Phantom_Hoover> i think you can trace most ideas back to some form prior to 1980
21:31:16 <b_jonas> does this have a polynomial algorithm? or can you prove that it's NP-complete?
21:31:19 <shachaf> It seems that better metaprogramming features are probably more useful.
21:31:22 <ais523> kmc: are we talking about higher-kinded typeclasses like Monad and Functor? or are even base typeclasses newer than that?
21:31:31 <Phantom_Hoover> but a lot of them took decades to be realised in even research languages
21:31:31 <kmc> also the calculus of constructions was from 1988
21:31:35 <kmc> I don't remember ais523
21:32:14 <shachaf> Do you know the sum of square roots problem, speaking of problems?
21:32:23 <ais523> b_jonas: polynomial in what? you have two sizes in your input (the number of nodes and the length limit)
21:32:38 <shachaf> The problem is "given two lists of positive integers, which has a larger sum-of-square-roots?"
21:32:50 <b_jonas> ais523: polynomial in the number of nodes (with some log adjustment because the numbers grow)
21:32:54 <b_jonas> no
21:32:56 <b_jonas> sorry
21:33:03 <b_jonas> polynomial in the number of tuples in input
21:33:06 <b_jonas> which is the size of the input
21:33:10 <b_jonas> sorry for confusion
21:33:22 <shachaf> It seems to be surprisingly tricky.
21:33:26 <ais523> b_jonas: there's a trivial O(n³) algorithm
21:33:34 <b_jonas> ais523: is there?
21:33:39 <ais523> and probably you can do it quadratic, possibly faster
21:33:56 <b_jonas> what's the trivial O(n**3) algorithm?
21:34:39 <ais523> start with the empty set as the set of nodes you can reach in length 0
21:34:44 <b_jonas> shachaf: I know an algorithmic solution for that, but it's pretty slow
21:35:01 <ais523> then look over the whole list of tuples for the reachable ones, add their target nodes to a set of nodes that you can reach in length 1
21:35:18 <ais523> err, actually you can reach node 0 in length 0
21:35:38 <shachaf> It's not known to be in NP. It probably isn't?
21:35:42 <ais523> then look over the whole list of the tuples for the ones you can reach from the nodes reachable in lengths 0 and 1, add their target nodes to a set of nodes that you can reach in length 2
21:36:00 -!- LKoen has joined.
21:36:33 <b_jonas> ais523: the problem is that you may have a step where you use two nodes that you reached with paths that have an intersection
21:36:34 <ais523> once you reach a length equal to the number of tuples, all reachable nodes will have been found already, so even if the length happens to be higher, you can just stop at that point
21:36:37 <b_jonas> so it's not enough to just add the lengths
21:36:56 <b_jonas> (this won't be a problem for length 2 yet)
21:37:24 <ais523> oh, I see, the length is the number of nodes that are used, not the length of the longest path to get there
21:37:29 <ais523> err, the number of tuples
21:37:34 <b_jonas> yes
21:39:04 <b_jonas> ais523: whoa, that first example problem that they give on the homepage https://odin-lang.org/ is oddly familiar. didn't they steal that from rust or python or something?
21:39:10 <b_jonas> what the program does that is
21:39:18 <b_jonas> obviously not the exact source code
21:39:42 <b_jonas> not that this would be a bad thing, just unusual
21:39:52 <ais523> the example for bison is pretty similar to that, but then it's the sort of program bison specialises in
21:40:27 <ais523> …what does it say to me that the first thing that jumped out of me is that they've demonstrated that the string `program` can be successfully used twice without an issue?
21:40:43 <ais523> it's not like it's even modified in the loop!
21:40:59 <int-e> b_jonas: oh, so addition chains are an instance of your problem?
21:41:18 <b_jonas> int-e: something like that, yes
21:41:26 <int-e> (decide whether there's an addition chain of length k that computes n)
21:41:43 <b_jonas> yes, exactly
21:42:22 <b_jonas> int-e: only it's not quite a special case in the sense you'd need for a reduction for NP, because to reduce an addition chain problem to this one, you have to blow it up exponentially
21:43:54 <b_jonas> ais523: thanks for the link, I'll take a look at what this Odin is
21:44:05 <b_jonas> it's interesting to know about new tries like this
21:44:38 <b_jonas> and of course worth to bring up projects like that on #esoteric
21:44:40 <shachaf> Did you see Zig, which probably has similar goals overall?
21:45:02 <b_jonas> even if their a priori chance of success is low because there are so many attempts
21:45:07 <b_jonas> shachaf: I don't think I've seen it
21:45:11 <ais523> shachaf: yes but I can't remember much about it
21:45:22 <b_jonas> but "similar goals" doesn't tell much because I don't yet know what the goals of Odin are
21:46:16 <int-e> b_jonas: This is mainly for intuition. Finding optimal addition chains is pretty hard.
21:47:56 <b_jonas> int-e: yeah
21:52:21 <b_jonas> int-e: and I've also been reading TAOCP ch. 7.1.2 at "Determining the minimum cost" of evaluating boolean functions with two-input gates and reusable outputs, which is an example of this and is also pretty hard
21:53:12 <ais523> I think this boils down to the subproblem of "given a graph of nodes, with known minimum length to reach all but one them but the last, work out the minimum length to reach the last node"
21:53:50 <ais523> if you can solve that in polynomial time, you can solve the whole thing in polynomial time with a vaguely A*ish search
21:53:55 <b_jonas> ais523: it's not really a graph, because the arcs have two input nodes, not just one
21:53:55 <int-e> hmm? no, you're building dags rather than paths.
21:54:36 <b_jonas> it's more like a hypergraph
21:54:36 <int-e> (dags with fixed in-degree; binary trees plus sharing)
21:55:23 <b_jonas> and I don't understand what you mean about that known minimum length thing
21:55:28 <int-e> I'm describing the shape of the witness, not the input.
21:56:47 <b_jonas> shachaf: as for the sum of square roots thing, let me tell a bit more about that
21:57:02 <int-e> It really feels like it should be NP-hard to me.
21:57:04 <ais523> b_jonas: for each node other than node 1, we know what the minimal solution would be if that node were numbered 1
21:57:20 <ais523> now we need to find the minimal solution given that information
21:57:38 <b_jonas> there's the general problem where you have an expression built of integer constants, addition, subtraction, multiplication, division, square root, nested to arbitrary depths, and you want to determine whether it's positive or negative or zero
21:57:56 <ais523> isn't that believed to be impossible? although IIRC unproven
21:57:56 <b_jonas> and there's an algorithm for this, which is effectively taught in school, and can be formalized
21:58:20 <ais523> it might be that that set of operations is small enough to make it possible
21:58:22 <b_jonas> and it's a real algorithm that always finishes if you formalize it properly
21:58:32 <b_jonas> but it's very slow in general
21:58:37 <b_jonas> ais523: it's small enough, yes
21:58:39 <int-e> ais523: the thing is, a solution is a set of tuples. If you have a triple (a,b,c) (from a and b, go to c) and solutions reaching a and b, described by sets A and B, the corresponding solution is A \cup B \cup {(a,b,c)}... and just knowing the size of A and B tells you very little about the size of that union.
21:58:47 <b_jonas> it gets much worse if it can involve cube roots too
21:59:17 <b_jonas> in that case just the grade school methods don't work, you need the complicated minimal polynomial and guaranteed boundaries for roots and that sort of shit
21:59:30 <b_jonas> or at least I think you need it, I definitely don't know an algorithm that works without
21:59:48 <int-e> ais523: and it's quite conceivable that the minimum solution for c does not even use minimal solutions for a and b but some larger ones that happen to share a lot of triples.
22:00:06 <b_jonas> for square roots, the simple grade school algorithm works, it doesn't do anything too tricky, just keeps manipulating formal expressions of the same sort all along
22:00:12 <b_jonas> and I can explain how it works if anyone cares
22:00:27 <b_jonas> int-e: yeah
22:01:30 <ais523> b_jonas: apparently Richardson's Theorem has been tightened as far as (and slightly further, but in an uninteresting way) addition/multiplication/subtraction/divison/integer constant/sin
22:02:04 <ais523> but it's decidable if you remove sin from that set
22:02:37 <int-e> b_jonas: A (now ex-) colleague of mine has been working on formalizing algebraic numbers.
22:03:24 <b_jonas> there are two basic tricks you have to know, one to rewrite a division so that square root doesn't occur in the denominator; and the other is to choose a most complicated square root expression, rewrite the expression as a + b * sqrt(c) where sqrt(c) doesn't occur in a or b, and square both sides
22:04:34 <int-e> So I can appreciate some of the difficulties. I've also worked out the special case of square roots once. As far as I can see, you can eliminate prime square roots one by one by conjugation. It's tedious, and you get two subproblems each time...
22:04:39 <int-e> So it's quite expensive :)
22:04:39 <ais523> oh, the theorem also requires one existential quantifier, that makes a pretty big difference
22:04:39 -!- unlimiter has joined.
22:04:57 <b_jonas> ais523: right, that's the trick. with just radicals or even roots of polynomials it's decidable; with exponentials it's probably not
22:05:59 <b_jonas> although I don't really fully understand the details of how you work with roots of polynomials, I at least understand some of the basic ideas and it seem belivable
22:06:59 <b_jonas> I don't really know much about the undecidable cases and in which classes it's been proven
22:07:21 <int-e> b_jonas: in his case the representation of a real algebraic number was a square-free polynomial together with an interval that contains the root of interest.
22:07:46 <b_jonas> int-e: yeah, one part I don't understand is how you handle that with complex numbers
22:07:50 <int-e> and complex algebraic numbers were pairs of real algebraic numbers... probably not the best choice :-(
22:08:01 <b_jonas> hmm
22:08:08 <b_jonas> I don't think you can just choose to ignore complex numbers
22:08:21 <arseniiv> <ais523> kmc: are we talking about higher-kinded typeclasses like Monad and Functor? or are even base typeclasses newer than that? => they say typeclasses were proposed by Wadler and Blott in a 1989 paper. Though I don’t know anything about actually working versions of Haskell compilers in those days
22:08:22 <b_jonas> they come up all the time when you try to do computations with algebraic stuff on reals
22:08:40 <int-e> b_jonas: you can still represent them this way.
22:09:08 <b_jonas> int-e: represent in theory, sure, but I don't understand how the algorithms to handle them would work
22:09:09 <ais523> Rust traits remind me of Haskell typeclasses except they're (currently) base-kinded only; I'm not sure whether there are mathematical differences
22:09:38 <b_jonas> int-e: heck, I'm not sure I even understand the basic algebra enough to be able to prove that the algebraic numbers are closed to field operations
22:09:42 <b_jonas> Galois theorem and whatnot
22:09:54 <ais523> there's a syntax for higher-kinded traits, and they work in the case of lifetimes, but not in the case of types; presumably that's just a matter of implementation though
22:09:55 <int-e> b_jonas: well you'll end up using tricks like Re(x) = (x + conj(x))/2 all the time.
22:10:11 <arseniiv> I don’t like in Haskell its insufficient incapsulation/modularization. I need to write a module to hide some names, e. g. homonymous record labels
22:10:15 <b_jonas> I passed the exam and got a degree technically, but that doesn't mean I know that stuff
22:10:19 <arseniiv> it makes me sad and frustrated
22:10:31 -!- LKoen has quit (Remote host closed the connection).
22:10:57 <b_jonas> arseniiv: come to rust or C++ then, their module systems aren't perfect, but much better than nothing
22:11:01 <arseniiv> they could had added something like `namespace` and `using` as seen in C++
22:11:21 <arseniiv> yeah, but I’m don’t like C++ either :D
22:11:38 <int-e> arseniiv: it's really not that bad, IMHO. you just make many small modules
22:11:42 <b_jonas> ais523: rust then?
22:11:55 <ais523> Rust's module system is pretty flexible, maybe more so than was intended
22:12:06 -!- LKoen has joined.
22:12:13 <int-e> arseniiv: it's far from perfect of course
22:12:18 <arseniiv> and I definitely don’t know how to learn these glittery contemporary versions of it in one take, there seems to be no singular book concentrated on that
22:12:22 <int-e> arseniiv: I wish there were qualified *exports*.
22:12:29 <ais523> you can pretty much implement `impl Trait` using it, for example, which is nice because `impl Trait` doesn't work in most cases yet
22:12:43 <ais523> (it does work in the most important case, but the less important cases can be relevant too)
22:12:46 <arseniiv> alternative being gradually taking all the new features in in a historic manner
22:12:48 <b_jonas> ais523: I think it was intended, whoever designed it basically knew what you could do in C++ and what you couldn't do, and chose one of the several paths to make something like that but fixing the problems
22:12:58 <int-e> arseniiv: but I don't really mind having many small files. I mind having long import lists that are repeated all over the place.
22:13:49 <arseniiv> int-e: yeah it’s more like a minor splinter. But when I prototype something or experiment, it’s too problematic to write many modules
22:14:11 <b_jonas> it's not the fix that I expected, but it makes sense and might be better
22:14:23 -!- unlimiter has quit (Quit: WeeChat 2.4).
22:15:20 <arseniiv> hm also on “better typeclasses” proposals
22:15:36 <b_jonas> what I expected is similar to what rust has, but with the important difference that every mod other than the root implicitly imports every name (including private ones) of its containing mod
22:16:11 <b_jonas> the good thing is that that can be easily reduced to what rust has, because you can add such a wildcard "use super::*;" import
22:16:14 <arseniiv> they say there was an (implemented) proposal for Agda about something implicit something I forgot, is it viable in a some abstract new language?
22:16:14 <ais523> int-e: what would be your opinion on files containing an import list, but it was automatically managed by the IDE so you never actually had to look at it?
22:16:33 <ais523> even if it was really long and specific (e.g. importing every symbol you used individually)
22:16:39 <ais523> * if it were
22:16:52 <arseniiv> I’ll find what it was called to be more specific
22:17:32 <arseniiv> OK, the paper is called Dominique Devriese, Frank Piessens. On the Bright Side of Type Classes: Instance Arguments in Agda
22:17:40 <b_jonas> (this is about the mod part itself; not the inter-crate stuff)
22:17:45 <arseniiv> maybe anybody had read it already
22:17:55 <ais523> with rust 2018 the inter-crate stuff is pretty nice too
22:18:11 <b_jonas> ais523: I'm still not sure if I like that
22:18:32 <b_jonas> I've read the rules and they're not as bad as I first feared when I read non-precise stuff about the changes
22:18:35 <arseniiv> ais523: I’m not int-e but I’d be totally in favor
22:18:53 <b_jonas> but I'm not sure the new system is the right one
22:18:55 <ais523> b_jonas: they're simpler and more intuitive than the old rules, which is good
22:22:24 <int-e> ais523: Hmm, I would want it to collapse imports (somebody else might see the code who's not using that IDE), and I would want to be alerted when a new module is added (it's possible that I made a typo in calling the function). And there are qualified imports to consider...
22:22:39 <int-e> ais523: So... yes that sounds good but it also sounds hard to get right.
22:23:11 <int-e> And no, I don't think hiding the list from the IDE user is an excuse for making the imports messy and unecessarily long-winded.
22:24:06 <ais523> the way it works in NetBeans is that when you type a symbol prefix and press Ctrl-Space, you get a list of symbols starting with that prefix that you can get from currently imported modules; press ctrl-space again and it removes the "currently imported modules" restriction
22:24:32 <ais523> I find that pretty fast to use (faster than typing the whole symbol name, given Java's typical verbosity) and it makes it very hard to include a module by accident
22:24:48 <ais523> (it'll list the exact module the symbol comes from, and put up pop-ups with documentation and the like)
22:25:18 <b_jonas> ais523: yeah, I've seen people write programs with ides that let you find symbols. I recognize it easily because their code has symbols with typoed names that they define. my code doesn't usually have those, because I won't make the same typo in every mention of the symbol.
22:25:21 <ais523> I have this idea that languages that are commonly used with IDEs aren't making full use of the IDE's power
22:25:56 <ais523> b_jonas: well it's normally fairly easy to do a global rename in an IDE, it knows which names correspond to each other
22:26:00 <ais523> so the typo's at least easy to fix
22:26:15 <ais523> but most of the programmers I've seen do that really will make the same typo consistently…
22:26:47 <b_jonas> ais523: it's a bit harder if it's a project developed by multiple people, and the symbol is an exported one that other people will use (which is why I usually find out about the typo)
22:27:14 <ais523> I'm the sort of person who would rename the typo out from underneath the other developers :-D
22:27:29 <b_jonas> and sure, there are typos I make somewhat consistently
22:28:17 <b_jonas> ais523: oh, they are the sort of person who auto-reformat the entire source file and don't notice that their ide has broken the proper formatting of some part of the code and replaced it with nonsense, I have to admit that
22:29:01 <b_jonas> sometimes the big global changes they make (not just whitespace) requires workarounds when trying to do merges or other version control stuff
22:29:33 <b_jonas> though I have to admit that I've also made the mistake of comitting some code files with lf as line terminator, and some with crlf, and it is fair game to make those consistent even if that breaks some automatic diffs
22:29:52 -!- AnotherTest has quit (Ping timeout: 248 seconds).
22:30:22 <b_jonas> that they use an ide is also obvious from how they somehow have large sections of code commented out with line comments (// in front of every line)
22:30:32 <ais523> b_jonas: I have my IDE set to autoformat on save
22:30:33 <b_jonas> I usually just if(0) or #ifdef them out instead
22:30:55 <b_jonas> ais523: does that ever lead to cycles where you and another person autoformats the same file to different styles?
22:31:12 <ais523> no, because I set their IDEs to do the same thing
22:31:21 <b_jonas> ais523: hehe
22:32:46 -!- moei has quit (Quit: Leaving...).
22:33:01 <b_jonas> ais523: does it never happen that you're not the team leader or dominant person to be able to define what the proper formatting style is?
22:34:02 <ais523> b_jonas: so far it's never come up
22:34:09 <b_jonas> ok
22:45:39 <shachaf> Is Rust pretty tightly bound to the philosophy of doing malloc/free all the time? This is my impression.
22:46:09 <ais523> no
22:46:15 <shachaf> I'd like a language that helps with lifetimes, but also doesn't insist so much on Box/Rc/etc. and lets you manage your own lifetimes.
22:46:32 <shachaf> Which might be more stack-shaped or something else.
22:46:44 <ais523> there's a Rust library I'm writing which has very few standard library dependencies
22:46:50 <ais523> the only dependency on core::alloc is one use of Vec
22:46:53 <ais523> that's it
22:47:13 <ais523> however, if you aren't using Box, Rc, Vec, and friends, you will probably have to store things on the stack
22:47:40 <b_jonas> shachaf: no, I don't think it's bound to that philosophy
22:47:54 <shachaf> Am I limited to "the" stack or can I put things in my own stacks?
22:48:18 <ais523> you can create your own smart pointer classes
22:48:28 <ais523> which can have any allocation behaviour you want
22:48:41 <ais523> (and might or might not need to contain `unsafe` internally, depending on just how insane the allocation behaviour is)
22:49:37 <shachaf> Can't it just help with lifetimes for regular pointers instead of making smart pointer classes?
22:49:37 <b_jonas> wtf
22:49:53 <b_jonas> https://odin-lang.org/docs/overview/ says "where a..b denotes an open interval [a,b], i.e. the upper limit is inclusive, and a..<b denotes a half-open interval [a,b), i.e. the upper limit is exclusive."
22:50:12 <b_jonas> I think that's a mistake, it should say s/an open/a closed/
22:50:40 <ais523> it's self-contradictory, indeed
22:51:15 <ais523> fwiw, my favoured range syntax is to always be explicit about the upper end, ..^ for half-open, ..= for closed (operator spellings taken from Perl 6 and Rust respectively)
22:51:28 <b_jonas> the part above makes it clear that the .. means a closed interval with both ranges included
22:51:47 <ais523> hmm, does ..= in Perl 6 replace something with a range that has that thing as its lower endpoint?
22:51:48 * ais523 tests
22:52:07 <b_jonas> ais523: yeah, sadly plain .. is tainted because perl and ruby and rust use them in different ways
22:52:30 <ais523> <Rakudo> Cannot make assignment out of .. because structural infix operators are too diffy
22:52:43 <ais523> well, it understood what I was trying to do
22:52:56 <ais523> I'm not sure I underestand why it couldn't do it though
22:53:04 <b_jonas> in perl, x..y and x...y are both closed ranges; in ruby, x..y is a closed range and x...y is a half-open range; in rust x..y is a half-open range and x..=y is closed range
22:53:09 <ais523> I'm not convinced "diffy" is a real word :-D
22:53:40 <ais523> @wn diffy
22:53:41 <lambdabot> No match for "diffy".
22:53:57 <b_jonas> ais523: isn't it trying to invoke the method named ".=" on the lhs?
22:54:21 <ais523> no, it mentioned the .. operator by name
22:54:48 <ais523> I'm pretty sure it at least lexed the line as expected, and the parser knew what I was trying to say
22:55:28 <ais523> "because structural infix operators are too diffy" has 0 hits on duckduckgo, btw, which is pretty impressive as I assume Perl6's source code is online somewhere
22:55:40 <ais523> https://docs.perl6.org/language/glossary#diffy
22:55:43 <ais523> aha, here we go
22:55:50 <ais523> "It means the type of the operator result is sufficiently different from its arguments that op= makes little sense"
22:55:54 <b_jonas> ais523: perhaps the error message is composed from strings in different parts
22:55:59 <b_jonas> I mean
22:56:08 <b_jonas> composed from strings stored in different part of the compiler source code
22:56:19 <ais523> so it looks like it lexed and parsed correctly, and yet there's a special case in the compiler to complain that what you're trying to do is completely insane :-D
22:56:41 <ais523> only being Perl6, they invented a new word for that specific sort of insanity that you have to look up
22:57:11 <int-e> b_jonas: http://paste.debian.net/1086461/ <-- it's NP-hard by reduction from the set cover problem.
22:57:23 <b_jonas> int-e: oh thanks, I'll look at that
22:58:04 <ais523> oh right, set cover
22:58:09 <ais523> it's obvious when you mention that
22:58:23 <ais523> I just couldn't find the right NP-complete problem to reduce from
22:58:47 <int-e> yeah that took a me while as well, as you can see :)
22:59:16 <b_jonas> int-e: oh nice
22:59:18 <b_jonas> good proof
22:59:23 <b_jonas> thank you, that decides it
23:00:00 <b_jonas> ais523: that construction wouldn't have been obvious to me given "set cover", I'd have tried to search for a different construction, though it's possible that the different construction would have led to a proof too
23:00:24 <b_jonas> that trick of chaining among the original nodes in a given order isn't obvious to me
23:04:17 <int-e> b_jonas: that was a last-minute refinement... I originally had n more auxiliary nodes that just witnessed wither each of the numbers 1..n was covered or not
23:07:14 <int-e> wither?
23:07:21 <int-e> @slap int-e
23:07:21 <lambdabot> *SMACK*, *SLAM*, take that int-e!
23:07:31 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
23:09:47 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
23:10:03 <b_jonas> int-e: I see
23:11:36 <ais523> here's me describing the bug in left-pad.io, which has since been fixed: https://www.reddit.com/r/programming/comments/4bqj7q/left_pad_as_a_service/d1btdp3/
23:14:11 <b_jonas> ais523: hmm, can that left-pad.io thing do zero-padding in such a way that a + or - sign goes before the padding? if so, what are the options to do that?
23:14:19 <ais523> I don't think it can
23:14:53 <ais523> the JS ecosystem it's parodying favours every module having as little functionality as possible
23:15:21 <ais523> (because it's effectively statically linked, and redundant functions are difficult to remove in JS because it's hard for a static analyser to know they're redundant)
23:15:23 <b_jonas> sure, it's just that I sometimes want to zero-pad numbers
23:16:20 <ais523> so what you'd need is a separate service, left-pad-number.example.com or whatever
23:16:27 <b_jonas> yeah
23:16:38 <b_jonas> or maybe zero.left-pad.io
23:16:43 -!- adu has joined.
23:16:44 <b_jonas> it could be under a subdomain
23:17:28 <ais523> no, it can't be, NPM doesn't have namespaces
23:17:41 <b_jonas> but this isn't on NPM
23:17:47 <b_jonas> it's a service on the web
23:18:05 <b_jonas> it surprised me at first that it returned fancy json
23:18:11 <b_jonas> but it makes sense for the parody
23:18:17 <ais523> the original left-pad module that caused all the trouble was on NPM
23:18:21 <b_jonas> I assumed it would just give plain text in the HTTP body
23:18:27 <b_jonas> yeah
23:19:36 <ais523> b_jonas: see https://api.left-pad.io/?str=test&len=1200&ch=%22 for the reason it returns JSON
23:20:17 <b_jonas> ais523: ah
23:20:32 <ais523> otherwise, how could you signal an error?
23:20:52 <ais523> (you'd also expect to get an error in the case of other API misuse issues, but maybe you could go RESTful and return an appropriate HTTP status code)
23:21:03 <b_jonas> yeah, it also serves as a parody for those JSON services
23:21:11 <ais523> actually, there's an HTTP status code for this situation too, isn't there?
23:21:12 <b_jonas> ais523: the error would be signaled in a HTTP code
23:21:16 <b_jonas> yes, HTTP status code
23:21:25 <ais523> 402, apparently
23:21:27 <b_jonas> with explanation details about the salesperson in the body
23:22:00 <ais523> invalid parameters would be 400
23:22:17 <b_jonas> mind you, the JSON thing has the advantage that if you submit batch requests, it can give an error for some of them and success for others
23:22:24 <b_jonas> as in, multiple requests in the same HTTP request
23:22:47 <ais523> the API doesn't allow that, I don't think? because it's all encoded into the URL
23:23:07 <b_jonas> yes, it doesn't currently allow that
23:23:27 <ais523> besides, future chaining makes that sort of request batching difficult
23:23:52 <ais523> ooh, actually invalid parameters is 422 I think
23:24:02 <b_jonas> future chaining?
23:24:09 <b_jonas> what's that?
23:24:26 * kmc is trying to send herself an email through ham radio
23:24:29 <b_jonas> do you mean that the input of later requests depend on the result of earlier ones?
23:26:09 <ais523> b_jonas: it's a programming technique for when you're using webservices as though they were libraries
23:27:00 <kmc> it's continuation passing style isn't it
23:27:01 <ais523> Future is a monad, which chains asynchronous computations as they complete
23:27:10 <kmc> I mean all monads are CPS
23:27:15 <kmc> THE MOTHER MONAD
23:27:22 <kmc> the ur-monad. the god monad
23:27:27 <kmc> the monad of monads
23:27:39 <ais523> CPS is how it's implemented, but the Future concept is more about hiding the CPS from the programmer
23:27:57 <kmc> sure
23:28:04 <b_jonas> ais523: right, although left padding is something of which I often naturally want to do multiple instances together, eg. how printf can take several parameters
23:28:31 <ais523> yes, but you might not have all the arguments available at the same time
23:29:06 <ais523> like, say two of the parameters are being left-padded, but for one of them you have the value locally, and for the other, you're getting hold of the value from, say, a multiply-as-a-service API
23:29:20 <b_jonas> sure, and I'm not saying that left-pad.io should require you to always use batch requests
23:29:22 <int-e> generate-a-password-as-a-service
23:29:25 <b_jonas> single requests should still be possible
23:29:30 <ais523> so one of them is just leftpad(value), the other is multiply(value).then(leftpad)
23:29:46 <ais523> int-e: I'm pretty sure that already exists
23:29:58 <ais523> there were even some sites which let you generate cryptocurrency wallets as a service
23:30:02 <int-e> ensure-99%-or-less-availability-as-a-service
23:30:04 <ais523> you can probably guess what happened next
23:30:37 <int-e> I can imagine a few things, yes.
23:30:39 <b_jonas> int-e: your password is "zcvZkIfzDGaN"
23:30:45 <int-e> Lots of crying.
23:30:56 <b_jonas> int-e: I can define you a HackEso command if you want
23:31:07 <int-e> `pwgen
23:31:08 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: pwgen: not found
23:33:21 <fizzie> `` pwgen # hth
23:33:22 <HackEso> Koh1vaib
23:34:51 <b_jonas> whoa
23:35:20 <int-e> `` pwgen -N 5 -n 13 --sha1=quotes#esoteric
23:35:20 <HackEso> iG9bohpohpeeb \ lee8oNgac3mee \ EeQuier7ceigo \ ohZuijie2Eu5s \ lien5jeeShoh7
23:35:39 <int-e> `` pwgen -N 5 -n 13 --sha1=quotes#esoteric
23:35:40 <HackEso> iG9bohpohpeeb \ lee8oNgac3mee \ EeQuier7ceigo \ ohZuijie2Eu5s \ lien5jeeShoh7
23:35:41 <b_jonas> so https://odin-lang.org/docs/overview/ seems to imply that their function parameters have the stupid problem that python is trying to fix about now (but is hard because of compatibility), where you can call any function with named parameters, even if the person who defined it didn't expect that
23:35:44 <int-e> yay :)
23:35:49 <kmc> is leftpad async in javascript
23:36:35 <int-e> `quote
23:36:35 <HackEso> 458) <elliott> I MIGHT BECOME GHOST
23:36:51 <int-e> sounds a bit like a BABA quote...
23:37:19 <int-e> . o O ( BABA is FORGET )
23:37:30 <kmc> finally managed to send an email
23:37:35 <kmc> of course the lines ended up out of order
23:38:06 <b_jonas> kmc: oh, that shuffled source lines things again?
23:38:28 <b_jonas> kmc: was the round trip time long?
23:40:19 <kmc> there are unpredictable delays yeah
23:40:21 <kmc> i'm using APRSlink
23:40:32 <kmc> the APRS packets get lost and retransmit is slow
23:40:51 <kmc> it is packet radio on 144.39 MHz
23:40:54 <kmc> 1200 baud
23:40:57 <b_jonas> kmc: yes, but I mean was it long in this case?
23:41:02 <kmc> yeah
23:41:05 <kmc> i mean a couple minutes
23:41:16 <b_jonas> that's not too long, ok
23:41:24 <kmc> there's an aprs igate (base station which relays to the internet) just a few blocks away but I still can't hit it so well with my handheld radio
23:41:36 <kmc> but I busted out a more powerful radio and a bigger antenna and it works fine
23:41:52 <kmc> supposedly this could be useful for sending emails/sms from outside of cell coverage range
23:41:54 <b_jonas> that may depend on what's between you and that station
23:41:59 <kmc> but i'll start by tring to make it work at all
23:42:00 <kmc> yes
23:42:06 <b_jonas> I guess there are ... blocks
23:42:09 <b_jonas> tall houses
23:42:10 <kmc> yeah
23:42:23 -!- adu has quit (Quit: adu).
23:42:26 <b_jonas> ones with iron in the walls
23:42:45 <kmc> these little radios work best with repeaters that are on top of mountains or tall buildings
23:42:45 -!- adu has joined.
23:42:48 <b_jonas> s/iron/steel/
23:43:00 <b_jonas> sure
23:43:10 <b_jonas> just like cell phones
23:43:34 <b_jonas> the cell phone antenna nearby is on the house across the street, which is the tallest house around
23:43:37 <kmc> yeah
23:43:38 <kmc> cool
23:44:56 <b_jonas> some months ago, there was a blackout in the whole neighborhood, at which point I could even hear the aggregator spinning up as the first noticable sign that more than my home was affected
23:45:05 <b_jonas> also I was in a mobile phone call, and it disconnected
23:45:05 <kmc> aggregator?
23:45:20 <b_jonas> aggregator is a diesel engine that provides backup power
23:46:02 <kmc> my "shack" (aka coffee table) is getting pretty cluttered https://i.imgur.com/QmTTyCa.jpg
23:46:18 -!- ais523 has changed nick to callforjudgement.
23:46:21 -!- callforjudgement has changed nick to ais523.
23:46:59 <kmc> those are nice headphones and i shouldn't keep them on the floor
23:48:43 <b_jonas> kmc: wires! and a bicycle too
23:48:53 <kmc> yes
23:48:58 <kmc> that's my bicycle
23:49:01 <kmc> that i don't ride enough
←2019-06-04 2019-06-05 2019-06-06→ ↑2019 ↑all