←2019-07-25 2019-07-26 2019-07-27→ ↑2019 ↑all
00:40:54 -!- zzo38 has joined.
00:54:29 -!- atslash has quit (Quit: Leaving).
00:54:47 -!- atslash has joined.
01:02:06 <esowiki> [[Realm]] M https://esolangs.org/w/index.php?diff=64710&oldid=64695 * Hakerh400 * (-14) Thanks User:Plokmijnuhby for the nice example! We adapted it to make it work with the abovementioned I/O format, since, as said in the paragraph before, bits of each byte are reversed.
01:09:28 -!- adu_ has joined.
01:09:30 -!- FreeFull has quit.
01:11:45 -!- adu has quit (Ping timeout: 244 seconds).
01:11:45 -!- adu_ has changed nick to adu.
01:30:46 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=64711&oldid=64709 * Areallycoolusername * (+399)
01:43:50 <zzo38> b_jonas: Yes, I suppose it can be difficult without the cards. (Although, when ais523 was designing the card game, I did not see any cards either. Did they update the document since then?)
02:06:02 -!- sprock1em has quit (Ping timeout: 258 seconds).
02:56:36 -!- xkapastel has quit (Quit: Connection closed for inactivity).
03:43:19 <zzo38> LLVM has a norecurse attribute. When compiling for Glulx, since there is no addressable frame memory in Glulx, it must be emulated. But, it may be avoided for norecurse functions. One thing to do is to perhaps use the first argument as the frame address, but a calling convention for functions without a frame address may be useful to avoid adding this extra argument.
03:43:32 <zzo38> Or, maybe there may be a better way.
04:01:10 <zzo38> (The emulated frame memory is also not needed if you never take the address of any local variable.)
04:05:52 -!- atslash has quit (Ping timeout: 244 seconds).
04:08:10 <doesthiswork> are you writing a compiler?
04:10:07 <zzo38> Not at this time, but I mention the idea, if it can be used to compile LLVM codes into a Glulx story file.
04:13:59 -!- Sgeo has joined.
04:16:33 -!- Sgeo__ has quit (Ping timeout: 268 seconds).
04:17:18 <zzo38> Non-packed structures should align the elements of the structure according to the type of the elements (and at most four bytes), but the address where the structure begins does not need to be aligned.
04:19:15 <zzo38> In Glulx, you cannot take the address of local variables, and all local variables are 32-bits (smaller local variables are actually possible, but they do not work very well, and the assembler does not support local variables smaller than 32-bits).
04:35:36 -!- adu has quit (Ping timeout: 272 seconds).
04:38:44 <zzo38> Some LLVM functions would be supported in Glulx, but some aren't. Some may be possible if emulated. @llvm.memcpy() and @llvm.memmove() both correspond to the mcopy instruction. @llvm.memset.p0i8.i32() has a single instruction supported but only if the value to write is zero.
04:42:06 <zzo38> The @llvm.debugtrap() function would correspond to the "debugtrap" Glulx opcode (although in Glulx it takes an argument and in LLVM it doesn't).
04:51:07 <zzo38> Glulx does support setjmp() and longjmp(), although there are a few limitations which are unlikely to matter in C, as long as the code generator is aware of these limitations.
04:57:19 -!- adu has joined.
04:58:10 -!- doesthiswork has quit (Ping timeout: 248 seconds).
06:35:05 -!- user24 has joined.
07:37:35 -!- user24 has quit (Quit: Leaving).
07:45:57 -!- atslash has joined.
07:56:18 -!- Lord_of_Life has quit (Ping timeout: 248 seconds).
07:57:56 -!- Lord_of_Life has joined.
08:23:36 -!- Frater_EST has joined.
08:23:55 -!- Frater_EST has left.
08:35:22 -!- cpressey has joined.
08:47:59 <cpressey> Design for a pathological language. Fix an enumeration of Turing machines T0, T1, ... Tω. Programs in this language are integers. For a program i, if there is a j s.t. Ack(j,j) = i, simulate Tj. Else do nothing.
08:49:21 <cpressey> It's Turing-complete, because you can simulate any Turing machine with it - just find a suitable i.
08:53:39 <cpressey> I'm also pretty sure it has inherently high complexity (what ais523 and I were talking about a few days ago.)
08:59:01 <cpressey> It's also horribly "non-compositional" in the sense that the structure of the Turing machine isn't going to bear any resemblance to i. But that's nothing special.
08:59:49 <cpressey> By which I mean, you'll see that in any construction that starts off with "Fix an enumeration of TMs", which happens in a lot of proofs
09:00:00 <shachaf> What is inherently high complexity?
09:01:27 <cpressey> You can simulate any Turing machine, but you can't simulate it efficiently.
09:03:31 <cpressey> It came up because of a stmt in an article from 2002 that tag machines can simulate TMs but that it was not known if that they could do so in poly time, that the best known simulation had an exponential slowdown.
09:11:41 <cpressey> The TC proof for https://esolangs.org/wiki/An_Odd_Rewriting_System has an exponential slowdown, but it's not known if it's inherent.
09:12:55 <cpressey> The pathological thing I wrote above has a slowdown which is more(?) than exponential, and appears inherent (if you could find which Tj to simulate efficiently, you could compute Ackermann function efficiently)
09:14:30 <cpressey> But it's just an ugly little pathological counterexample. I can't call it an esolang. I can't even bring myself to give it a name.
10:00:18 <cpressey> Currently considering implementing AORS in Haskell in order to understand it better.
10:02:52 <int-e> cpressey: sorry, but checking whether Ack(j,j) = i for some j *given i* does not strike me as expensive.
10:03:37 <cpressey> int-e: "for some j" -> "discover j for given i"
10:03:56 <int-e> yeah but you're using a fast-growing function.
10:04:24 <int-e> so we will stop very soon, and we can stop before ack(j,j) is fully computed (it's enough for an intermediate result to exceed i)
10:04:28 <Taneb> A fast-growing, strictly monotonic function
10:04:44 <int-e> (except maybe in some corner cases, I have not thought this through completely)
10:05:45 <int-e> Taneb: right, that's what I meant
10:07:14 <cpressey> I don't follow. Call Ack(1,1), Ack(2,2) "Ackermann numbers". I give you a number, you tell me if it's an Ackermann number or not. You're saying you can do this efficiently?
10:07:28 <cpressey> (I missed the ... after Ack(2,2) there, sorry)
10:07:32 <int-e> I'm pretty sure I can.
10:07:35 <Taneb> I can do it as efficiently as you can give me numbers, I feel
10:09:07 <cpressey> And if I give say "Give me the n'th Ackermann number", can you do that efficiently too?
10:09:13 <int-e> no
10:10:05 <int-e> I know that I can't really grasp just how fast that function grows.
10:10:37 <Taneb> If I can fit i into my brain I can be confident j <= 6
10:11:08 <cpressey> Well, I agree that the number of bits in the programs in this language might be expoentially more than the number of bits needed to describe the TMs, but, not sure if that's relevant for what it's trying to show or not.
10:11:50 <cpressey> (I say exponential because I'm looking for something that is at least exponential)
10:16:24 -!- wob_jonas has joined.
10:17:55 <wob_jonas> cpressey: Julia seems like a typical new language, just like how you complained about what rust was like in the past: I ran julia from the debian oldstable and looked up the docs of the latest version online, and already found two obvious differences
10:18:44 <wob_jonas> In the old version, $ was the bitwise xor function; in the new version it's renamed to xor, also available under some non-ascii alias
10:19:19 <int-e> I see no reason why testing whether j exists should take more than quadratic time in the size of i, given that we have a fairly nice closed formula for ack(3,j): ack(3,j) = 2^(j+3)-3... so we don't have to evaluate the recursion down to the base cases (which would likely become exponential, simply because we have to compute, say, ack(4,4), exactly if given that as input).
10:19:42 <wob_jonas> The docs does reflect this of course
10:20:06 <cpressey> int-e: What if I give you a much smaller i and ask you for the smallest Ackermann number that ends in the digits of i?
10:20:25 <int-e> cpressey: that might be undecidable
10:21:15 <cpressey> True, that's not a good thing in a TC reduction.
10:22:05 <int-e> (Gut reaction. There should be some shortcuts when computing ack(i,j) modulo n. But I'm not sure how effective they really are.)
10:23:39 <wob_jonas> int-e: there definitely are. I have a post relevant to that on SE. but more importantly, every positive integer is an ackermann number of form A(0, n),
10:24:20 <int-e> wob_jonas: we've restricted the notion to Ack(n,n), I think.
10:24:25 <wob_jonas> and even if you forbid that and ask for ackermann numbers of form A(m, n) where M<=m for some fixed M, then every ackermann number like that is of form A(M, n).
10:24:26 <wob_jonas> OH!
10:24:32 <wob_jonas> you want only A(n, n)? that's harder
10:26:05 <esowiki> [[Talk:Swissen Machine]] M https://esolangs.org/w/index.php?diff=64712&oldid=64692 * A * (+756) /* Conclusion */
10:26:18 -!- arseniiv has joined.
10:26:28 <cpressey> wob_jonas: Yeah, Julia 1.0 only came out last year. There's a 1.1 already. I hope they keep 1.x stable.
10:27:26 <shachaf> Taneb: Are you guanxing?
10:27:36 <Taneb> shachaf: when I can
10:27:57 <cpressey> What if I give you an i and you give me the smallest Ackermann number that has at least i digits in its decimal expansion
10:28:07 <cpressey> Oh never mind
10:28:10 <shachaf> Are you doing fancy SAT/QBF/exact cover/ILP/whatever solver things?
10:28:16 <cpressey> This is just like last time I tried to do this
10:28:22 <Taneb> I am doing nothing of the sort myself
10:28:45 <Taneb> Just trying to document some of the data structures
10:29:07 <shachaf> Are there any good data structures?
10:29:21 <int-e> cpressey: How something more computational, like checking whether T_i executes for at least 2^i steps before it halts?
10:29:40 <Taneb> shachaf: there's the type-threaded catenable list, which is pretty neat
10:29:50 <shachaf> Apparently many SAT solvers support producing certificates of unsatisfiability.
10:30:00 <shachaf> I wonder what kinds of problems that's feasible for.
10:30:06 <Taneb> ( https://github.com/ekmett/guanxi/blob/master/src/Aligned/Internal.hs#L207 )
10:30:56 <shachaf> How do catenable lists work?
10:31:07 <cpressey> int-e: That sounds almost too simple, but it might work.
10:31:14 <shachaf> Maybe if I unthread the types it'll be easier to see.
10:31:18 <int-e> shachaf: https://en.wikipedia.org/wiki/Boolean_Pythagorean_triples_problem
10:31:56 <wob_jonas> cpressey: anyway, yes, in that case you can tell easily if a number is an ackermann number, and with what argument, because (\n -> A(n, n)) is monotonic
10:31:57 <Taneb> shachaf: the purpose of them is to be a sequence type with O(1) cons, snoc, and append
10:32:04 <int-e> cpressey: I guess it's not really all that easy because simulating a TM might be faster than the original TM.
10:32:06 <Taneb> I'm not too sure how they work so far but they deem to
10:32:07 <shachaf> int-e: Yes, we talked about that the other day.
10:32:08 <Taneb> *seem
10:32:11 <wob_jonas> and grows very fast
10:33:20 <shachaf> I should probably learn the details of CDCL better.
10:33:33 <shachaf> data Cat a = E | C a (Q (Cat a))
10:34:31 <shachaf> data Q a = Q -- hang on, what's this existential?
10:34:47 <Taneb> What existential?
10:34:53 <Taneb> Q can be any reasonably efficient queue type
10:34:54 <shachaf> data Q f a b where Q :: !(Thrist f b c) -> !(Rev Thrist f a b) -> !(Thrist f b x) -> Q f a c
10:35:03 <shachaf> What's that x about?
10:35:04 <esowiki> [[Talk:Swissen Machine]] M https://esolangs.org/w/index.php?diff=64713&oldid=64712 * A * (+23) /* Conclusion */
10:35:07 <Taneb> Oh yeah, that existential
10:35:26 <Taneb> There's one in the definition of Cat I linked to, too
10:35:34 <wob_jonas> um
10:35:39 <shachaf> Which definition?
10:35:56 <wob_jonas> you're writing crazy gadt types?
10:35:59 <Taneb> data Cat f a b where E :: Cat f a a; C :: f b c -> (Q (Cat f) a b) -> Cat f a c
10:35:59 <shachaf> Oh, sure, Cat has an existential, but it's used twice.
10:36:04 <Taneb> wob_jonas: no, I'm only documenting them
10:36:14 <shachaf> This x is only used once. What's that about?
10:36:31 <shachaf> The Thrist to Nowhere
10:36:32 <Taneb> Oh, the one in Q, it's to do with how the queue is implemented. It's somewhere in PFDS
10:37:52 <shachaf> instance Cons Q where cons a (Q f r s) = Q (a :. f) r (undefined :. s)
10:37:59 <shachaf> I find myself slightly skeptical of ths type.
10:38:13 <wob_jonas> where do these come from?
10:38:22 <shachaf> Taneb's link.
10:38:55 <shachaf> OK, there's some invariant, which isn't documented of course. I guess that's what Taneb is doing.
10:39:21 <shachaf> Man, how can Haskell people stand how inefficient their code is?
10:39:42 <wob_jonas> oh
10:39:58 <int-e> shachaf: I don't care as long as it's fast enough
10:42:08 <shachaf> Taneb: OK, is this third Q field literally just a natural number?
10:42:56 <shachaf> I think that's what's going on. For the amortization, or something.
10:47:50 <shachaf> Golly. You should simplify this code before or after documenting it.
10:48:46 <cpressey> Sometimes I don't want fast, if fast means I have to write the program differently
10:49:50 <cpressey> Optimizations interfere with aesthetics, y'know
10:53:58 <wob_jonas> cpressey: one possible solution for that is to write the parts that you have to optimize in two versions, a straightforward version that works but you ifdef it out, and an optimized version.
10:56:11 <cpressey> wob_jonas: Yes, that works well if you have a suite of tests that you can run on both versions
10:56:42 <shachaf> Ugh, I wish any programming language was good.
10:57:15 <wob_jonas> cpressey: right, maybe you can make the part deterministic enough and repeatable enough that you can compare the output of the two of them
10:57:29 <wob_jonas> sometimes it's hard when it can have difficult side effects
10:57:50 <wob_jonas> but often enough it's good
10:58:26 <wob_jonas> my code are usually full of assertions to catch stupid errors I make
11:00:22 <int-e> shachaf: the !(Thrist f b x) just acts as a counter... x is a type somewhere in the middle of the first list.
11:02:47 <shachaf> Yes, that's the conclusion I came to above.
11:04:11 <shachaf> Except I think x is any type because the list is just full of undefineds?
11:04:14 <shachaf> I already closed the page.
11:04:17 <int-e> shachaf: I had not seen that yet. I was studying the code.
11:04:28 <int-e> shachaf: no, it starts out as nil = Id
11:05:13 <shachaf> Right, that's the empty list.
11:05:17 <int-e> shachaf: and then at each cons step the undefined is forced to match the function added to the first list
11:05:41 <int-e> shachaf: and then in 'exec' it actually uses a copy of the first list when it knows that the second list is empty
11:06:14 <int-e> (and I guess that copy is the reason for this awkward type... it might actually be more efficient than a unary counter of a different type this way)
11:06:47 <shachaf> I know of a secret technique for representing natural numbers that's more efficient than unary.
11:06:55 <shachaf> But I'm sworn not to reveal it.
11:07:30 <wob_jonas> more efficient than a unary counter... wow, that must be some fancy magical algorithm
11:07:53 <shachaf> I mean a unary counter where each successor is a new heap-allocated node, of course.
11:09:15 <int-e> yeah I'm not convinced that this is more efficient than keeping track of the counter in an Int.
11:09:19 <int-e> (or Word)
11:10:37 <int-e> It's not clear though. You'd also have to keep track of the length of xs (the first list) at all times. And `rotate` would have to return two values.
11:13:03 -!- sprocklem has joined.
11:14:37 <cpressey> Design for a pathological language, take two. The bits of the program are simultaneously intepreted as a brainfuck program, and as a sentence in Presburger arithmetic. If the sentence is a theorem of PA then the output is the output of running the brainfuck program, otherwise the output is empty.
11:15:03 <cpressey> Presburger arithmetic is decidable, but it's 2-EXP-hard.
11:15:28 <cpressey> sorry, 2-NEXP.
11:16:24 <wob_jonas> cpressey: that's probably not too hard to use, unless you design the syntax such that any reasonable BF program is always a syntax error in Presburger Arith. you just have to write your programs with some extra stuff that makes them _easy_ theorems
11:17:00 <cpressey> It might be a better idea to interleave the bits instead of overlap them.
11:17:51 <cpressey> "better" in the sense of "make it easier to show that it works" rather than "more interesting"
11:19:14 <wob_jonas> although it would be annoying, because most brainfuck programs have a lot of >>>>>> things in them, and now you have to change those to pad them out like 1>0&&1>0&&1>0&&1>0&&1>0&&1>0&&1>0 to avoid a syntax error
11:19:39 <int-e> cpressey: interleaving is basically pairing. so you're saying M(T,X) = if X in L then T(X) else <empty>, where T is a Turing machine (Brainfuck program), and L is a hard but decidable language? (Presburger arithmetic).
11:19:55 <cpressey> int-e: yeah that's what makes it boring
11:20:36 <int-e> sorry, not T(X), just T(<empty>) I suppose.
11:21:00 <int-e> (But while we are building tuples, you could add the input as a third component.)
11:22:27 <shachaf> I think I once talked about a language which is just like some other language except it's a syntax error for the sha1 hash of your program to be nonzero.
11:22:56 <shachaf> I don't remember the context now.
11:23:39 <int-e> we also had this idea of restricting C to programs with a particular hash (I forgot which hash, but the idea was to hash the hello world program.)
11:24:00 <cpressey> It seems trivial to say "This language is complex because it insists on solving an unrelated complex problem before it tries to run your program in an otherwise normal fashion"
11:24:04 <int-e> So same idea, but with the benefit that we can actually write *a* program.
11:24:36 <shachaf> I think it's hard to prove things about hash functions like surjectivity.
11:25:01 <cpressey> Still, counterexample is counterexample, so I guess I can't object if it's annoying, boring, trivial, etc
11:25:06 <shachaf> Maybe there are some cryptographic hash functions that also let you prove nice uniformity properties.
11:25:53 -!- arseniiv has quit (Ping timeout: 245 seconds).
11:28:39 <cpressey> Could go with overlapping, but give both alphabets (brainfuck's and PA's) a certain amount of redundancy, so that structure of bf program does not necessitate certain structure of pa sentence, and v-v
11:31:53 <wob_jonas> there's also a variant where the extra condition unrelated to the program is hard to even verify, but you just document that the program causes an undefined behavior unless that condition is satisfied, and the interpreter doesn't try to verify it
11:32:19 <wob_jonas> you can make the program cause an undefined behaviour unless whoever runs the compiler has payed me a hundred dollars,
11:32:47 <wob_jonas> or make the program cause an undefined behaviour unless the program was typed entirely by a cat walking on the keyboad,
11:33:03 <wob_jonas> or make the program cause an undefined behaviour unless whoever wrote the program is pure in heart,
11:33:20 <wob_jonas> or make the program cause an undefined behaviour unless whoever wrote the program really regrets having written it,
11:34:07 <wob_jonas> etc. I'm even thinking of adding such a restriction to some of the library functions of Consumer Society (not to the core language, just a few functions).
11:35:17 <Taneb> shachaf: it's a counter, but it uses a lot of sharing with the first field
11:37:38 <Taneb> shachaf: it's described on page 87 of my copy of Purely Functional Data Structures, so if you can find another copy maybe it's the same page
12:01:10 <esowiki> [[Talk:Swissen Machine]] https://esolangs.org/w/index.php?diff=64714&oldid=64713 * Jussef Swissen * (+446)
12:05:17 <cpressey> *Main> take 6 $ run testProg1
12:05:19 <cpressey> ["Cwg","CCwg","Ccwwg","CCCCwg","CcCcwwg","CCccwwwg"]
12:05:29 <cpressey> I seem to have written an AORS interpreter.
12:09:04 <cpressey> https://gist.github.com/cpressey/c8e42eb7223becae2e11aac676d1713e
12:09:45 <cpressey> You can laugh at my Haskell writing style if you like.
12:09:57 <int-e> shachaf: Hmm what kind of property would provably ensure surjectivity of a hash without making preimages or collisions easier?
12:13:54 <int-e> > zip "abc" [0..]
12:13:57 <lambdabot> [('a',0),('b',1),('c',2)]
12:16:07 <cpressey> Turns out it doesn't need indexes (I was confused, thought the spec talked about "odd positions", but it doesn't)
12:17:58 <int-e> yeah I just started wondering about that
12:19:29 <int-e> I would forego the fold there, I think, in favor of an explicitly recursive function that takes a list and the number of seen odd symbols so far.
12:21:01 <int-e> (the main reason being that accumulating a list by appending singleton lists feels horrible)
12:22:50 <cpressey> To each their own. Would it help if I explained that I wrote it because I wanted to better understand how it differs from a conventional rewriting system?
12:23:38 <cpressey> It looks like it's a kind of context-sensitive string rewriting.
12:32:24 <int-e> inserting odd characters has an odd effect in that rewriting flavor :P
12:49:48 <esowiki> [[Talk:An Odd Rewriting System]] N https://esolangs.org/w/index.php?oldid=64715 * Chris Pressey * (+388) Haskell implementation
13:21:59 -!- arseniiv has joined.
13:26:58 -!- arseniiv has quit (Ping timeout: 272 seconds).
13:36:19 <esowiki> [[Talk:Swissen Machine]] M https://esolangs.org/w/index.php?diff=64716&oldid=64714 * A * (+545) /* Conclusion */
13:36:59 <esowiki> [[Talk:Swissen Machine]] M https://esolangs.org/w/index.php?diff=64717&oldid=64716 * A * (+61) /* Conclusion */
13:37:28 <esowiki> [[Talk:Swissen Machine]] M https://esolangs.org/w/index.php?diff=64718&oldid=64717 * A * (-4) /* Conclusion */
13:40:23 <esowiki> [[Talk:An Odd Rewriting System]] https://esolangs.org/w/index.php?diff=64719&oldid=64715 * Chris Pressey * (+2428) Towards a non-exponentially-slowing-down simulation of a 1D-1D-CA
13:42:13 <esowiki> [[Talk:Swissen Machine]] M https://esolangs.org/w/index.php?diff=64720&oldid=64718 * A * (+233) /* Conclusion */
13:42:13 -!- xkapastel has joined.
13:46:36 <cpressey> In other news, effect systems are pretty cool.
13:50:27 -!- Reallycooluserna has joined.
13:51:18 -!- Reallycooluserna has changed nick to ARCUN.
13:54:28 <ARCUN> Why does Java have such a hellish grammer?
13:55:51 <ARCUN> I could write a program in C++ that's roughly the same length as an equivalent program in Java, and only the Java program would have issues
14:16:59 -!- arseniiv has joined.
14:19:53 -!- ARCUN has quit (Remote host closed the connection).
14:38:16 -!- atslash has quit (Quit: This computer has gone to sleep).
14:40:48 -!- atslash has joined.
14:52:20 <cpressey> There is a candy on the table. Alice and Bob, at the same time, see it and try to grab it. Alice gets it, Bob does not. Is this a race condition? No.
14:52:31 <cpressey> If they somehow both got a candy, that would be a race condition.
14:56:56 <int-e> race conditions are a violation of physics. (that's what I got from this scenario)
15:03:30 <cpressey> Physics provides some good built-in locking mechanisms "for free".
15:04:25 <cpressey> I'm actually trying to come up with an analogy to explain why I'm not worried about a particular concurrency scenario, but it's not the best analogy.
15:05:00 <cpressey> It's more like: you can cancel a task, but you will never be guaranteed that you cancelled it in time.
15:05:16 <cpressey> The task might terminate just before you cancelled it.
15:06:41 <int-e> can this be seen as a variation of the byzantine generals problem somehow?
15:06:42 <cpressey> Since you effectively never have a guarantee of that, it's not worth worrying about whether "cancel" will be scheduled before or after "terminate".
15:07:11 <cpressey> I don't know what Byzantine generals refers to, but I heard it used in relation to this already, so I'll look it up. (Thanks!)
15:07:34 <int-e> Hmm, that's the wrong general's problem...
15:07:56 <cpressey> '"Byzantine generals" redirects here. For military generals of the Byzantine empire, see Category:Byzantine generals.'
15:07:59 <cpressey> <3 u Wikipedia
15:08:01 <int-e> I wanted https://en.wikipedia.org/wiki/Two_Generals%27_Problem which is different (and simpler).
15:10:33 <int-e> The similarity I'm seeing is that cancellation implies synchronization between the two tasks... and termination introduces a source of unreliability. It's a stretch, probably doesn't make sense outside of my mind :)
15:10:53 <esowiki> [[Seabass]] https://esolangs.org/w/index.php?diff=64721&oldid=64676 * Sec-iiiso * (+40) /* Hello, world! */
15:11:15 <esowiki> [[Seabass]] https://esolangs.org/w/index.php?diff=64722&oldid=64721 * Sec-iiiso * (+1) /* Hello, world! */
15:14:16 -!- wob_jonas has quit (Remote host closed the connection).
15:14:54 <cpressey> The Generals problems seem to relate mainly to distributed systems? What I'm thinking of isn't a distributed system, it's just a multithreaded program.
15:15:14 <int-e> Sure I knew that
15:15:36 -!- Sgeo_ has joined.
15:15:52 <int-e> As I just wrote, it probably doesn't make sense :)
15:16:34 <int-e> brains are weird.
15:16:35 <cpressey> Well, it lets me figure that the previous reference to it that I heard probably doesn't make sense either :)
15:17:37 -!- Sgeo has quit (Ping timeout: 258 seconds).
15:19:33 <zzo38> I got involved in a discussion on news.software.nntp about the problem when article numbers will have to exceed 31-bits. My own software (both the client and server) already support 63-bit article numbers, although the protocol specification limits it to 31-bits. Some proposed solutions are increasing the version number to 3, adding a new BIGNUM command, and violating the protocol.
15:19:36 <int-e> Obviously you don't *need* any distributed system for this. You need some kind of unreliable communication channel. It's just hard to come up with sources of unreliability on a single system that's operating fine :)
15:19:45 <zzo38> Do you have any comments about fixing this?
15:20:17 <cpressey> zzo38: I would totally just violate the protocol.
15:21:41 <int-e> . o O ( do a hard fork of the block chain )
15:22:03 <zzo38> cpressey: Yes, that is what I do too (but not until it becomes necessary to do so); although Michael think that it can cause a problem with a client that doesn't expect it. But I think that if they do what they suggest instead, then you may fail to notice new articles and fail to notice that there even is a problem.
15:25:16 <zzo38> Did you ever write any NNTP software?
15:28:52 -!- Sgeo__ has joined.
15:29:39 <zzo38> See the thread starting at <5cd011d5$0$15174$426a74cc@news.free.fr>
15:32:25 -!- Sgeo_ has quit (Ping timeout: 268 seconds).
15:39:27 <cpressey> zzo38: No, and I haven't used Usenet in ages.
15:40:46 <cpressey> int-e: If you believe your local event queue is unreliable, you have way worse things to worry about than this, I imagine
15:49:33 -!- doesthiswork has joined.
15:50:29 <cpressey> I wrote a dynamic race-condition analyser once: https://catseye.tc/installation/Matchbox
15:50:54 <cpressey> It's just a toy, but it can be fun to watch as it displays all the possible interleavings
15:56:41 <cpressey> On the subject of programming languages, should I care about Pony?
15:57:29 <int-e> cpressey: what do you think of this... there are water boilers with a mechanical switch that turn themselves off when the water is boiling. If you wait for the water to boil and switch them off, you can never be completely certain that they didn't switch themselves off first.
15:57:52 <cpressey> int-e: That's a good analogy. Thank you!
15:58:48 <cpressey> Indeed, the electric kettle in my kitchen has exactly that feature.
15:59:08 <cpressey> And in many kitchens across the country, one imagines
16:00:50 <cpressey> Pony looks better than I imagined it to be based on how twee it presents itself (that kind of presentation kind of turns me off y'know)
16:01:29 <cpressey> (What's the adjverbial form of the adjective twee? twee-ly?)
16:01:54 -!- xkapastel has quit (Quit: Connection closed for inactivity).
16:01:58 <cpressey> (Elm's presentation is also far too twee for my taste)
16:03:45 <int-e> Do you mean the hand-holding ala "Working your way through the tutorial but in need of more help?"?
16:04:08 <int-e> (I didn't know "twee".)
16:06:07 <int-e> maybe shachaf could read https://www.ponylang.io/media/papers/opsla237-clebsch.pdf and tell us if it's any good. ("Fully Concurrent Garbage Collection of Actors on Many-Core Machines")
16:06:11 <cpressey> In a tutorial, it's forgivable, you want to try to make it readable and friendly, I understand that.
16:06:36 <cpressey> Sometimes it starts to permeate an entire project though.
16:07:19 <cpressey> Related: including an emoji in the description of your project (very popular to do this on Github now.)
16:08:36 <doesthiswork> uWu ~*what's this?*~
16:08:37 <int-e> That reminds me of the fact that I never liked "Learn you a Haskell for Great Good", starting with the title, and the -- twee, I guess -- style.
16:09:11 <cpressey> Yeah I was going to mention that book as a sort of watershed moment in this regard
16:09:26 <doesthiswork> you need to make the emojis an integral part of your language's syntax
16:13:54 <cpressey> doesthiswork: That's a different matter. I approve of that, so long as they are grossly overused in incoherent ways in the program source.
16:14:52 <doesthiswork> I suppose If I do that then the documentation must be as serious and professional as possible
16:18:37 <cpressey> "Incorrectness is simply not allowed." Thank you, Pony project, for engaging in that other rhetorical habit that irritates me: hyperbole.
16:19:16 <Taneb> Hyperbole is the worst possible thing that any form of writing could ever include, with the possible exception of irony
16:21:14 <cpressey> Taneb: That's very good, I'll have to remember that one.
16:21:56 -!- Melvar has quit (Quit: thunderstorm).
16:22:58 <int-e> . o O ( Show me a proogramming language that ensures that all programs are correct and I'll show you a programming language that is useless. )
16:23:40 -!- atslash has quit (Quit: This computer has gone to sleep).
16:29:55 <cpressey> Alas I must away. À la prochaine.
16:29:57 -!- cpressey has quit (Quit: WeeChat 1.4).
16:44:27 -!- lldd_ has joined.
16:48:49 -!- lldd_ has quit (Client Quit).
16:52:03 -!- b_jonas has joined.
16:53:20 -!- Phantom_Hoover has joined.
17:01:33 <b_jonas> oh, that could be evil! make the language so that most things are written in ascii, but there's some rare feature that disables some optimization that you occasionally need to use in programs that do something tricky with pointer aliasing, and make the syntax for that rare syntax a brocoli emoji or something.
17:02:22 <b_jonas> when the next person to maintain your program sees that, they'll believe it's nonsense, because all programs they've seen are written in ascii only, they remove the brocoli from the source code, the program still compiles, but months later they'll get mysterious hard to debug failures when the phase of the moon influences the optimizer the wrong way.
17:03:26 <b_jonas> we should propose that for C++.
17:11:45 <b_jonas> or maybe for one of those features where the code doesn't compile unless you use some crazy incantation, and that incantation is a vomiting rocket emoji. the person learning rust can't figure out how to convince the borrow checker that some code is valid. he asks on StackOverflow or something. he gets an answer with working code with a vomiting rocket in the middle. he ignores that, thinking that must
17:11:52 <b_jonas> be a troll, no programming language actually uses vomiting rockets.
17:11:55 <b_jonas> the answer might even get deleted if other people don't take it seriously either.
17:15:17 <doesthiswork> what is the vomiting cocket emoji?
17:16:12 <doesthiswork> *rocket (a bit of a freudian slip there)
17:33:51 <arseniiv> b_jonas: please let’s not do C++ that big a favor
17:37:48 <b_jonas> doesthiswork: https://www.xkcd.com/1813/
17:38:21 <b_jonas> but that's just an example, other emoji characters could work
17:39:03 <b_jonas> presumably they would match the meaning somewhat, so the emoji spelling for std::launder would be a washing machine or something
17:58:44 <doesthiswork> that's the same as what Steele was doing with fortress right?
19:07:17 -!- Melvar has joined.
19:30:45 <shachaf> int-e: What about it?
19:31:10 <shachaf> The idea is that it can prevent global pauses by doing local GC?
19:40:29 <adu> shachaf: that's called Rust
19:43:42 <shachaf> No it isn't?
19:55:46 -!- Lord_of_Life_ has joined.
19:57:32 -!- Lord_of_Life has quit (Ping timeout: 245 seconds).
19:58:33 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
20:18:54 <b_jonas> also I'm visiting London tomorrow, but only for three days
20:41:37 <zzo38> You can make the syntax to use U+FFFE character
20:59:54 -!- atslash has joined.
21:20:10 -!- xkapastel has joined.
21:43:05 -!- moei has joined.
21:53:14 <b_jonas> I'll be seeing the non-vacuum versions of the tube.
21:58:17 <kmc> ooh
21:58:24 <kmc> what are your other plans in london?
21:58:43 <kmc> adu: Rust hasn't had local GC in a really long time, it was removed before 1.0
21:59:03 <kmc> and actually rustc's @T wasn't real GC, it was a janky refcounting system
21:59:27 <kmc> (but the rustboot implementation before that had real GC)
22:00:11 <kmc> there now are attempts to add hooks to enable GC libraries
22:00:29 <kmc> however I think Rust has enough "no GC" inertia that they're not going to end up with the D problem where half the libs depend on GC
22:00:33 <kmc> it'll be more for specialized things
22:00:45 <kmc> Servo had a bunch of hooks to enable Rust objects to be managed by SpiderMonkey's GC
22:00:51 <kmc> that was really really janky
22:00:52 <kmc> and unsafe
22:01:11 <kmc> not less safe than the way Gecko does it in C++, but not as safe as Rust is supposed to be
22:01:41 <kmc> in the early days, Rust was more like a native-code Erlang or a not dumbed down Go
22:01:50 <kmc> it gradually evolved towards being a "bare metal" systems language
22:32:27 <b_jonas> nice, the big museums in London are open almost every day. I'm used to most museums being open only 6 days a week
22:32:43 <b_jonas> kmc: I don't have too much plans. I'm going with family, so the plan mostly involves being with them.
22:32:55 <kmc> i see
22:32:57 <b_jonas> I definitely want to visit museums, as well as just walk on the streets of the inner city, because both of those are my kinds of fun
22:32:59 <kmc> are they cool
22:33:14 <esowiki> [[Talk:An Odd Rewriting System]] https://esolangs.org/w/index.php?diff=64723&oldid=64719 * Ais523 * (+1304) what causes the issue with AORS
22:33:22 <b_jonas> also they're planning to go to some sort of concert on saturday evening
22:39:16 -!- arseniiv has quit (Ping timeout: 246 seconds).
23:15:46 -!- sprocklem has quit (Ping timeout: 248 seconds).
23:17:31 -!- sprocklem has joined.
23:31:13 <Phantom_Hoover> kmc, oh hey i talked to someone on discord the other day who swore that he had run into a bug where firefox's JS engine was garbage collecting live variables in the middle of a function
23:31:33 <Phantom_Hoover> i still don't really believe him but extremely lol if true
23:34:07 <zzo38> Do you have a example program to test it? Then you can see if that is the case.
23:37:19 <Phantom_Hoover> i do not, and it sounded like one of those baffling bugs that's buried very deep in a giant project
23:38:48 <Phantom_Hoover> wouldn't be surprised if it turns out not to be reproducible. the guy was saying he suspected it might actually be some JS library or other instead
23:38:52 <Phantom_Hoover> but a man can dream
←2019-07-25 2019-07-26 2019-07-27→ ↑2019 ↑all