←2020-09-22 2020-09-23 2020-09-24→ ↑2020 ↑all
00:07:17 -!- t20kdc has quit (Remote host closed the connection).
00:13:45 <esowiki> [[User:1hals]] N https://esolangs.org/w/index.php?oldid=77705 * 1hals * (+214) create
00:14:13 <esowiki> [[User talk:1hals]] N https://esolangs.org/w/index.php?oldid=77706 * 1hals * (+81) Create
02:19:50 -!- wmww1 has joined.
02:21:11 -!- myndzl has joined.
02:27:33 -!- wmww has quit (*.net *.split).
02:27:34 -!- myndzi has quit (*.net *.split).
02:34:03 <esowiki> [[Zirconium]] N https://esolangs.org/w/index.php?oldid=77707 * RocketRace * (+7381) Create the incomplete page.
03:20:30 -!- Sgeo has quit (Read error: Connection reset by peer).
03:20:57 -!- Sgeo has joined.
03:26:48 -!- adu has joined.
04:36:04 -!- adu has quit (Quit: adu).
05:09:10 <esowiki> [[Zirconium]] https://esolangs.org/w/index.php?diff=77708&oldid=77707 * RocketRace * (+33) Tweak @
05:12:14 <esowiki> [[Zirconium]] https://esolangs.org/w/index.php?diff=77709&oldid=77708 * RocketRace * (-79) Remove -
05:13:15 <esowiki> [[Zirconium]] https://esolangs.org/w/index.php?diff=77710&oldid=77709 * RocketRace * (+79) Undo revision 77709 by [[Special:Contributions/RocketRace|RocketRace]] ([[User talk:RocketRace|talk]])
05:18:07 -!- Lord_of_Life_ has joined.
05:19:10 -!- Lord_of_Life has quit (Ping timeout: 258 seconds).
05:19:28 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
05:38:17 <esowiki> [[Zirconium]] M https://esolangs.org/w/index.php?diff=77711&oldid=77710 * RocketRace * (-1) Typo
05:44:42 -!- sftp has quit (Excess Flood).
05:44:59 -!- sftp has joined.
06:39:05 -!- kspalaiologos has joined.
06:55:15 -!- Sgeo has quit (Read error: Connection reset by peer).
07:17:35 <zzo38> It look like troff uses B-spline, while PostScript uses Bezier instead. Can you convert between then, and if so, how?
07:21:40 -!- kspalaiologos has quit (Quit: leaving).
08:10:49 -!- hendursa1 has joined.
08:13:03 -!- hendursaga has quit (Ping timeout: 240 seconds).
08:40:19 -!- skiwaaaaa has joined.
08:42:20 -!- rain1 has quit (Ping timeout: 258 seconds).
08:46:11 -!- rain1 has joined.
08:53:43 -!- imode has quit (Ping timeout: 265 seconds).
09:03:50 -!- arseniiv has joined.
09:50:40 <arseniiv> given an inner product space V over K, there is a “fool’s paravector algebra” which you get from K ⊕ V by defining (s1, v1) (s2, v2) := (s1 s2 + v1 ⋅ v2, s1 v2 + s2 v1), i. e. multiplying scalars and vectors in a natural manner (using the inner product for vectors). I named it a fool’s because it’s non-associative. But at least it has unity lifted from K
09:51:12 <arseniiv> I thought this algebra may be a stepping stone to get to a Clifford algebra over the same inner product space
09:51:25 <arseniiv> didactically
09:52:29 <arseniiv> int-e: yet another non-associative algebra ^
09:53:15 <arseniiv> fungot: what do you think about silly mathematical ideas that don’t play out in the long run?
09:53:15 <fungot> arseniiv: that is a winner's attitude, and there is no particularly good human translation for this concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear c
09:53:36 <arseniiv> lucky
09:54:08 <arseniiv> fungot is this attitude long-lasting?
09:54:09 <fungot> arseniiv: you really wish your side. it's just a wrapper for your private reading material later might happen sooner than you think it's time you shift in our attention.
09:54:38 <arseniiv> ^style
09:54:38 <fungot> Available: agora alice c64 ct darwin discworld enron europarl ff7 fisher fungot homestuck* ic irc iwcs jargon lovecraft nethack oots pa qwantz sms speeches ss wp ukparl youtube
09:54:46 <int-e> fungot: do you associate well with others?
09:54:46 <fungot> int-e: it just doesn't feel secure the matriorb and hatch a new mother has any shit they want to scrape off their bulge on to a particular type of three-way relationship of a black president
09:54:50 <arseniiv> I wouldn’t thought
09:55:24 <int-e> associativity is just commutativity of left multiplication and right multiplication :-P
09:55:48 <arseniiv> let me wrap my head around it
09:56:00 <arseniiv> ah, yes
09:56:43 <arseniiv> I usually think about associativity as allowing us to multiply nonempty lists
09:56:47 -!- skiwaaaaa has quit (Remote host closed the connection).
09:57:15 <int-e> internalizing inductive inferences, intriguing.
09:57:25 <arseniiv> like that `mappend` in Haskell’s Monoid or what it’s called for Semigroup
09:58:24 <arseniiv> then of course neutral element allows us multiply an empty list and commutativity to swap lists with multisets
09:58:28 <int-e> :t Data.Semigroup.sconcat
09:58:29 <lambdabot> Semigroup a => NE.NonEmpty a -> a
09:58:38 <arseniiv> sconcat, really? :\
09:58:43 <int-e> nah
09:58:50 <arseniiv> that’s a bit hilarious
09:58:51 <int-e> You just want stimes
09:59:00 <int-e> mm
09:59:09 <arseniiv> :t stimes
09:59:10 <lambdabot> error: Variable not in scope: stimes
09:59:10 <int-e> No, it's just <>.
09:59:35 <arseniiv> ah, I remember the operation is <>
09:59:36 <int-e> I'm not thinking clearly (yet?).
10:00:18 <int-e> I don't like NonEmpty all that much :-/
10:00:22 <arseniiv> I underslept but for a while I feel more or less comfortable as if that didn’t happen
10:00:31 <arseniiv> what could we do instead of NonEmpty?
10:01:04 <arseniiv> definitely its name is unwieldily long
10:01:11 <int-e> where does that even come from...
10:01:49 <int-e> (ghci tells me it's defined in GHC.Base... but surely it's reexported from somewhere?)
10:02:01 <arseniiv> I don’t remember its constructor and that other function to cons to another NonEmpty
10:02:18 <int-e> Or is it just something internal for list fusion, hmm. Maybe.
10:02:23 <arseniiv> maybe Data.List.NonEmpty? Does Data.NonEmpty exist?
10:02:33 <int-e> Ah.
10:02:41 <int-e> Thanks.
10:02:59 <int-e> data NonEmpty a = a :| [a]
10:03:11 <arseniiv> I thought it’s a real proposed way to make `tail` and `head` total
10:03:37 <arseniiv> but :| is kinda emoting its way through
10:03:39 <int-e> But I mix empty and non-empty lists all the time.
10:04:09 <arseniiv> :t (:<)
10:04:11 <lambdabot> Cons b b a a => a -> b -> b
10:04:16 <arseniiv> wha
10:04:34 <arseniiv> :t (:>)
10:04:35 <lambdabot> Snoc a a b b => a -> b -> a
10:05:04 -!- olsner has quit (Ping timeout: 260 seconds).
10:05:21 <arseniiv> :t (:< [])
10:05:23 <lambdabot> a -> [a]
10:05:51 <arseniiv> hm I hoped there is an instance for NonEmpty, or is this just a default
10:06:41 <int-e> that would overlap
10:07:06 <int-e> (in an incoherent way even)
10:07:30 <int-e> In the absence of subtypes I don't think NonEmpty carries its weight.
10:07:49 <int-e> But obviously others disagree.
10:08:16 <arseniiv> I hadn’t seen it all that much though
10:08:18 -!- olsner has joined.
10:08:43 <arseniiv> maybe I should read less old blog posts
10:10:27 <arseniiv> I tried to advocate NE to a friend who wasn’t satisfied with `head` and `tail`’s untotality, and they even said hm but maybe NE is a lost cause after all
10:11:12 <arseniiv> s/but/, but
10:12:00 <int-e> (It's probably a good thing that we don't have subtyping in Haskell... otherwise we'd be dealing with a plethora of subtypes of questionable utility, as everybody and their dogs expresses their personal pet properties of results in the type system... because it can't hurt because you can always cast to the base type, right?)
10:12:50 -!- t20kdc has joined.
10:15:46 <arseniiv> shame it’s so hard to get yourself a free microtunable grand piano plugin. There are several pretty nice SFZs, and SFZs are playable by sforzando, but it allows only 12-notes-per-octave tunings, and IIRC even not all of them for that matter. So if one wants to write in 19edo, they would need to use 12-note modes and several sforzando instances, or hopefully it can be retuned on the fly, I don’t know
10:19:12 <arseniiv> int-e: IIRC subtyping would make things even worse but I don’t remember how specifically. Maybe ais523 was the one who said something in this vein here, though that’s not an unknown in the world, it’s just I don’t remember any other possible sources. So ping
10:23:55 -!- ais523 has joined.
10:24:13 <ais523> my experience with subtyping is that it isn't necessarily harmful to the rest of the type system, but people keep trying to use it for things that it isn't appropriate for
10:24:15 <int-e> I've assumed an ideal world where subtyping just works... ignoring type checking and type inference. I think things would go wrong from a pure software engineering perspective at large, because people will never agree on which properties are important to express in the type system.
10:24:33 <ais523> on most occasions where people assume that their problem will be solved with subtyping, they're incorrect
10:24:58 <int-e> I imagine it'll work deceptively well on a small scale though.
10:25:17 <ais523> I'm not sure how much harder it makes type inference, it generally hasn't been fatal in the examples I've tried, but you can write papers out of getting it to work
10:28:09 <shachaf> Subtyping seems deceptively complicated.
10:28:19 <shachaf> I don't understand it.
10:28:57 <Taneb> There's, like, both the type of bread, and the main filling, and all the extras you can get like lettuce and red onion
10:31:13 <int-e> Taneb: All I wanted was a burger, why are things so complicated.
10:31:39 <Taneb> int-e: burger types tend to be fairly different from sub types
10:31:55 <int-e> Oh.
10:32:00 <int-e> I missed the pun there, my bad.
10:32:07 <int-e> The description was generic enough :P
10:32:12 <Taneb> True
10:32:19 <ais523> lack of subtyping can be really annoying when it affects a program you're writing
10:32:48 <ais523> if you find that you ever have to write a recursive version of the identity function, that's something of a giveaway
10:33:16 <shachaf> int-e: At least you didn't miss the bun?
10:33:53 <shachaf> If I want to do a spot of the SMT, what theory should I use?
10:33:54 <ais523> in most cases, subtyping can be thought of as "if I put a recursive identity function here, everything will suddenly typecheck"
10:33:54 <int-e> I guess that's the one redeeming feature of Data.List.NonEmpty.NonEmpty... the conversion is not recursive.
10:34:18 <ais523> at least when it comes to sum and product types
10:34:55 <ais523> probably also for base types with subtypes, as long as the conversion is either implicit, or can be done manually in your "identity" function
10:35:55 <shachaf> Do SMT solvers want o have backtrackable union-find?
10:35:57 <shachaf> to
10:36:36 <shachaf> What do they do in practice, since persistent union-find doesn't exist?
10:37:08 <ais523> what do you mean by "union-find"?
10:37:26 <int-e> shachaf: if you don't do path compression you get something that's backtrackable
10:37:38 <shachaf> Hmm, that's interesting.
10:37:41 <int-e> ais523: disjoint set forests
10:37:52 <shachaf> Maybe path compression isn't that important?
10:38:30 <shachaf> It kind of seems like it would be.
10:38:32 <int-e> you get asymptotically logarithmic time operations then
10:38:57 <int-e> Instead of that weird almost constant inverse Ackermann.
10:39:07 <ais523> "inverse Ackermann" is a new one
10:39:23 <ais523> even log-log grows too slowly to be really observable as distinct from a constant
10:40:02 <shachaf> The fact that inverse Ackermann just shows up in the analysis of a practical algorithm is pretty great.
10:40:03 <int-e> Hmm, I've still never worked through all of Tarjan's analysis of disjoint set forests.
10:40:15 <shachaf> Neither have I. I should see how it all actually works at one point.
10:40:17 <ais523> huh, I think the inverse Ackermann function is primitve recursive even though the regular Ackermann isn't, right?
10:40:41 <int-e> ais523: sure, it's basically padding...
10:41:18 <ais523> I don't think a practical algorithm actually would have inverse Ackermann performance, you'd just pick an arbitrary constant rather than trying to deal with bignums
10:41:56 <int-e> Well this is an asymptotic cost.
10:42:18 <ais523> asymptotic costs don't practically matter when you don't reach the point where asymptotic behaviour starts kicking in
10:42:31 <int-e> n operations take O(alpha(n)n) time, where alpha is the inverse Ackermann function.
10:42:37 <ais523> there's a polynomial test for primality, nobody uses it because it isn't faster for any numbers we actually want to test for primality
10:43:05 <int-e> disjoint set forests with path compression *are* used.
10:43:48 <int-e> I agree it's rare, but this is a rare case where the asymptotically optimal thing is also very efficient in practice.
10:43:57 <ais523> or, hmm, is the point that the asymptotic behaviour is a simpler way to implement it than just hardcoding alpha(n) to alpha(A(5)) or whatever would be?
10:44:00 <int-e> double rare?
10:44:30 <int-e> It's emergent. Nobody's computing the inverse Ackermann function.
10:45:36 <ais523> heh, the easiest way to implement the inverse Ackermann function would be a fairly short if/else chain
10:45:56 <ais523> after a few entries your computer won't have enough memory to store the input to the function, even if you use bignums
10:46:19 <int-e> But this is theory :P
10:47:02 <Arcorann_> https://codegolf.stackexchange.com/questions/125397/create-the-slowest-growing-function-you-can-in-under-100-bytes <-- relevant
10:47:16 <shachaf> Why do you get logarithmic time without path compression?
10:47:30 <shachaf> Hmm, I guess the thing I was thinking to get long chains easily doesn't work.
10:48:59 <int-e> shachaf: You can keep track of the class sizes at the representatives, so you can make the new pointer point to the smaller subclass.
10:49:10 <int-e> shachaf: and that balances the tree
10:49:16 <arseniiv> ais523: recursive identity function is actually a recursive injection?
10:50:30 <ais523> arseniiv: yes, the point is that the input and output types are different
10:50:34 <ais523> so you can't just write id x = x
10:50:48 <ais523> unless the language supports subtyping
10:50:49 <shachaf> One question is, how much does backtracking matter if your SAT solver is doing many rapid restarts?
10:50:50 <int-e> shachaf: I'm not sure whether this works for the usual rank as well... my intuitive guess is that it does, probably something with Fibonacci numbers, but I have not worked it out.
10:51:02 <arseniiv> it may be interesting to compare this with μ types, for which usually the approach with explicit wrapping/unwrapping is picked as it’s not as taxing to the programmer as the alternative is to the typechecker
10:51:13 <ais523> one annoying thing about OCaml is that it has a subtyping operator, but you need to tell it what types are involved
10:51:35 <arseniiv> ow
10:51:39 <ais523> and in the cases where I've wanted subtyping, those types are often massively complicated and it's easier to write the recursive identity than it is to figure out what types to give the builtin
10:54:25 <int-e> shachaf: Oh it's powers of 2 even... the induction step is that when you create a tree of rank n+1, you're merging two trees of rank n. So that's at least 2^n+2^n = 2^(n+1) nodes. The base case is a leaf with rank 0.
10:55:19 <int-e> So ranks do work for keeping the trees balanced.
11:05:52 -!- skiwa has joined.
11:06:04 -!- skiwa has quit (Remote host closed the connection).
11:22:07 -!- adu has joined.
11:54:37 <esowiki> [[Zirconium]] https://esolangs.org/w/index.php?diff=77712&oldid=77711 * RocketRace * (+2194) Add the Q station, and consequently Turing completeness
11:55:33 <esowiki> [[Zirconium]] M https://esolangs.org/w/index.php?diff=77713&oldid=77712 * RocketRace * (+3) Typos.
11:58:02 <esowiki> [[Zirconium]] M https://esolangs.org/w/index.php?diff=77714&oldid=77713 * RocketRace * (+15) Links
11:59:10 <esowiki> [[Zirconium]] M https://esolangs.org/w/index.php?diff=77715&oldid=77714 * IFcoltransG * (+1) /* Footnotes */ Fixed category
12:11:08 <esowiki> [[Zirconium]] M https://esolangs.org/w/index.php?diff=77716&oldid=77715 * RocketRace * (+6) Wording
12:12:10 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=77717&oldid=77681 * RocketRace * (+55) Add Zirconium
12:13:36 <esowiki> [[Language list]] M https://esolangs.org/w/index.php?diff=77718&oldid=77717 * RocketRace * (-39) /* Z */
12:14:34 <esowiki> [[User:RocketRace]] https://esolangs.org/w/index.php?diff=77719&oldid=76913 * RocketRace * (+91) Ads Zirconium
13:24:04 -!- hendursa1 has quit (Quit: hendursa1).
13:24:22 -!- hendursaga has joined.
13:30:41 -!- ais523 has quit (Quit: quit).
14:03:45 -!- Sgeo has joined.
15:00:10 <b_jonas> "a recursive version of the identity function" what the heck
15:01:04 <myname> what
15:03:33 <b_jonas> "there's a polynomial test for primality, nobody uses it because it isn't faster for any numbers we actually want to test for primality" => that's not how it works. the polynomial time deterministic speed test we have (not the first proven version, a later imrpovement) is still the one with the fastest runtime bound proven in advance for large numbers that we care about, but
15:04:49 <b_jonas> we have had and used randomized prime tests that are much faster, either typically or maybe proven in average, I'm not sure, and even those we rarely use, because we rarely need to prove a number prime;
15:05:13 <esowiki> [[???]] https://esolangs.org/w/index.php?diff=77720&oldid=44701 * 1hals * (+43) Added clarification found on the Github README
15:06:37 <b_jonas> for crypto purposes we only use a randomized composite test, which can't prove a number prime, only probabilistically, but it's good enough to have a randomized test that is proved to say "prime" for a composite number with 1**128 chance when you can just get hardware errors or the adversary can make an inefficient attack that randomly succeeds more often then that
15:07:13 <b_jonas> and you can repeat the test as many times as you want to reduce the likelyhood of false positive as low as you want exponentially
15:08:16 <b_jonas> that said for certain practical reasons we usually just prefer elliptic curve crypto over anything prime-based these days
15:09:12 -!- Arcorann_ has quit (Read error: Connection reset by peer).
15:11:35 <b_jonas> oh, you mean like a recursive conversion function from what you think of is a subtype to a type. yes, that can happen, though in C++/rust we can usually just avoid it by doing forced casts that the type system doesn't understand
15:11:58 <b_jonas> because we can prove that the representation of the subtype is the same as the representation of the output
15:12:38 <b_jonas> and of course sometimes the representation really differs, so you need an actual conversion function, even if you think of it sort of as an identity that restricts the type
15:14:36 <b_jonas> examples of conversion that restricts the type but change the representation are freezing an appendable vector to an immutable vector, or sorting an appendable vector while you don't care about the order to an immutable sorted vector, or freezing a mutable balanced search tree dictionary to an immutable sorted list dictionary.
15:16:28 <b_jonas> that said, both C++ and rust support subtyping to some extent, so using a simple (non-recursive) identity function from different output type than input type does come up sometimes, but in both cases it's restricted, you can't just make any type a subtype of another,
15:18:13 <b_jonas> and for some reason both C++ and rust were really stubborn about just adding a fucking identity function to the library, even though it is actually often useful and it's trivial to implement so why not give it a standard name to make code more readable. rust standard lib now has one, C++ doesn't but has a special case with restricted type, numpy also doesn't have one built in even though it would be
15:18:19 <b_jonas> nice to have IMO.
15:23:32 <b_jonas> "one annoying thing about OCaml is that it has a subtyping operator, but you need to tell it what types are involved" => isn't it enough to tell just the type of the output, in cases when it can infer the type of the input?
15:29:06 <b_jonas> ais523: since they weren't explicit enough, the and the "inverse ackerman" and "union-find" thing is a reference to a certain famous data structure that stores an equivalence function on {0..n-1}, can initialize it to all inequivalent, can in-place modify it to make two elements equivalent (then it acts transitively), and can tell you the representative of the equivalence class of any element, and
15:29:11 <b_jonas> there's an impl of this data structure where the analysis of the runtime bound does involve the inverse ackermann function. this is described the best in Thomas H. Cormen, Charlse E. Leiserson, Ronald L. Rivest, Clifford Stein, "Introduction to Algorithms" second edition chapter 21
15:32:30 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=77721&oldid=77718 * McGoodmen * (+18)
15:32:55 <b_jonas> a useful book to know about, at least until we get the complete TAOCP
15:36:09 <b_jonas> (the other useful algorithms book that has some topics that TAOCP will cover is the ed. Iványi one, but most of its chapters covers topics that are out of TAOCP's scope, so it may still remain useful when we have the definitive 5-volume TAOCP (vol 1..2 4th edition, vol 3 3rd edition, vol 4A..5 1st edition))
15:36:40 -!- sftp has quit (Read error: Connection timed out).
15:37:15 -!- sftp has joined.
16:14:40 <b_jonas> on a different note, I'm trying to understand how openttd signal logic works, but there are too few good examples. the openttd wiki and the openttdcoop wiki have some screenshots and descriptions, and so do the old coop games, but not enough introductory material, it mostly just shows complicated bulids with lots of logic elements.
16:16:57 <b_jonas> so far I can't even reproduce the not gate from https://wiki.openttdcoop.org/Logic#NOT , and I haven't even seen an intro example for just a single flip-flop, examples that make clockful vs clockless logic clear, or explanations of how the later openttd updates and especially path-based signals affect this
16:18:15 -!- LKoen has joined.
16:19:24 <b_jonas> let me try to reproduce it again
16:19:59 <b_jonas> as far as I can see, openttd is correct in that that simple not gate doesn't work by the way, despite what that wiki says
16:20:36 <b_jonas> but it's also possible that I'm just connecting the gate output wrong and so it's read wrong
16:21:52 <b_jonas> when I tried to build the simple not gate, if the input is disconnected so the output should be red, but what I get is that the output does occasionally flash green for a short time
16:22:39 <b_jonas> I'm trying again now
16:29:03 <b_jonas> I rebuilt it in the exact orientation that the example shows, and the output still flashes green
17:06:37 -!- adu has quit (Quit: adu).
17:07:09 -!- rain1 has quit (Read error: Connection reset by peer).
17:07:54 -!- rain1 has joined.
17:19:17 -!- Lord_of_Life_ has joined.
17:21:04 -!- Lord_of_Life has quit (Ping timeout: 260 seconds).
17:22:05 <b_jonas> hmm, I found another semi-clear example image that I can look at: "https://wiki.openttdcoop.org/images/7/71/Psg172_7platform.png" on "https://wiki.openttdcoop.org/Junctionary_-_Stations_-_SRNW"
17:22:06 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
17:22:15 <b_jonas> (if only catenaries were hidden)
17:26:42 <b_jonas> heck the signal for the output is hidden by the station
17:28:10 <b_jonas> it still uses more or less the same build, just with more signals on the logic loop
17:28:28 <b_jonas> here's where I failed to reproduce: https://i.stack.imgur.com/sGc7j.png
18:02:47 -!- Remavas has joined.
18:04:36 -!- adu has joined.
18:28:13 -!- 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.”).
18:45:37 -!- Remavas has quit (Read error: Connection reset by peer).
19:15:52 -!- adu has quit (Quit: adu).
19:20:18 -!- adu has joined.
19:20:41 -!- hendursaga has quit (Remote host closed the connection).
19:21:32 -!- hendursaga has joined.
20:50:26 -!- dog_star has quit (Ping timeout: 240 seconds).
20:50:27 -!- mich181189 has quit (Ping timeout: 260 seconds).
20:50:27 -!- dingwat has quit (Ping timeout: 260 seconds).
20:50:56 -!- j4cbo has quit (Ping timeout: 240 seconds).
20:51:02 -!- glowcoil has quit (Ping timeout: 260 seconds).
20:51:02 -!- ocharles has quit (Ping timeout: 260 seconds).
20:52:14 -!- dog_star has joined.
20:52:26 -!- j4cbo has joined.
20:52:35 -!- glowcoil has joined.
20:53:04 -!- dingwat has joined.
20:53:21 -!- ocharles has joined.
20:53:30 -!- mich181189 has joined.
21:05:00 -!- imode has joined.
21:47:33 -!- arseniiv has quit (Quit: gone too far).
22:37:30 -!- adu has quit (Quit: adu).
22:43:15 -!- Arcorann_ has joined.
22:46:41 -!- adu has joined.
22:50:07 -!- dog_star has quit (Ping timeout: 240 seconds).
22:50:27 -!- ocharles has quit (Ping timeout: 240 seconds).
22:50:33 -!- dingwat has quit (Read error: Connection reset by peer).
22:50:56 -!- ProofTechnique has quit (Ping timeout: 240 seconds).
22:51:16 -!- ocharles has joined.
22:51:43 -!- glowcoil has quit (Ping timeout: 272 seconds).
22:52:59 -!- glowcoil has joined.
22:53:17 -!- j4cbo has quit (Ping timeout: 260 seconds).
22:54:40 -!- dingwat has joined.
22:55:04 -!- ProofTechnique has joined.
22:55:21 -!- j4cbo has joined.
22:55:28 -!- dog_star has joined.
22:58:32 -!- ocharles has quit (Ping timeout: 256 seconds).
23:00:58 -!- ocharles has joined.
23:19:01 -!- t20kdc has quit (Ping timeout: 258 seconds).
23:29:20 <esowiki> [[Zirconium]] https://esolangs.org/w/index.php?diff=77722&oldid=77716 * RocketRace * (-10) no stub
23:34:02 <esowiki> [[Zirconium]] M https://esolangs.org/w/index.php?diff=77723&oldid=77722 * RocketRace * (-2) Thanks, cyan
23:34:16 <zzo38> I think that a way to make a new typesetting system might be to use a combinaion of the features from TeX and troff (including the intermediate output formats of both), and also macros can contain PostScript codes (to be executed either immediately, or when the page is being shipped out; graphics operations are usually only applicable in the latter case).
23:34:23 <zzo38> What would you think of that?
23:36:01 <zzo38> (Some sets of features of TeX and troff are I don't know how you would combine them, but it would seem useful to do.)
←2020-09-22 2020-09-23 2020-09-24→ ↑2020 ↑all