2026/03/15

Newest at the top

2026-03-16 00:29:31 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-03-16 00:26:37 +0100xff0x(~xff0x@2405:6580:b080:900:e24f:1ef:ed48:3e20) (Ping timeout: 244 seconds)
2026-03-16 00:25:15 +0100xff0x_(~xff0x@2405:6580:b080:900:1fdc:c04d:3012:9e4)
2026-03-16 00:22:16 +0100Guest24(~Guest24@94.42.242.59)
2026-03-16 00:20:32 +0100dolio(~dolio@130.44.140.168) dolio
2026-03-16 00:18:10 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 248 seconds)
2026-03-16 00:14:02 +0100dolio(~dolio@130.44.140.168) (Quit: ZNC 1.10.1 - https://znc.in)
2026-03-16 00:11:29 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-03-16 00:09:53 +0100 <jreicher> And easily understandable bells and whistles, which is why it might be a good example.
2026-03-16 00:09:36 +0100 <monochrom> PN is then just bells and whistles dressing up that stack API.
2026-03-16 00:09:29 +0100 <jreicher> Yep, I got you. :) Phew. And I agree, that's nice.
2026-03-16 00:09:08 +0100 <monochrom> The basic amortization example is a stack whose API has push, pop, multipop(n). multipop(n) worst case time is Ω(n), but amortized time stays O(1).
2026-03-16 00:08:45 +0100 <jreicher> Do you mean the question induced is what is the amortized time?
2026-03-16 00:07:17 +0100 <jreicher> I'm missing something that's probably obvious, sorry. :) I think I need you to spell it out.
2026-03-16 00:06:48 +0100 <monochrom> PN.
2026-03-16 00:06:43 +0100 <jreicher> You mean RPN can be amortized and PN can't?
2026-03-16 00:05:49 +0100 <monochrom> A single input symbol may trigger an unbounded number of stack pops. This is a great recipe for disaster^W intresting amortized time!
2026-03-16 00:05:38 +0100st_aldini(~Betterbir@136.48.46.187) (Quit: st_aldini)
2026-03-16 00:04:52 +0100 <EvanR> PN becomes more efficient if your code uses right to left language
2026-03-16 00:04:35 +0100 <jreicher> Not following, and I want to!
2026-03-16 00:03:17 +0100 <monochrom> Nice, so PN induces a great question for amortized time!
2026-03-16 00:00:47 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 244 seconds)
2026-03-15 23:56:06 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-03-15 23:56:04 +0100euphores(~SASL_euph@user/euphores) euphores
2026-03-15 23:49:31 +0100euphores(~SASL_euph@user/euphores) (Ping timeout: 264 seconds)
2026-03-15 23:45:19 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-03-15 23:42:31 +0100craunts795335385(~craunts@152.32.99.2) (Ping timeout: 268 seconds)
2026-03-15 23:40:43 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-03-15 23:37:19 +0100craunts795335385(~craunts@152.32.99.2)
2026-03-15 23:32:09 +0100 <Rembane> Also, stacks are neat!
2026-03-15 23:30:19 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 264 seconds)
2026-03-15 23:30:00 +0100 <EvanR> I guess it's simple enough there's not much room for philosophizing
2026-03-15 23:29:23 +0100 <EvanR> ok a calculator based on RPN is like a combination of programming language and UI in one
2026-03-15 23:26:49 +0100 <jreicher> I know. But I'm asking why RPN is a preferred example for an "implementation of something". I think the nature of that question mixes things, necessarily.
2026-03-15 23:26:36 +0100 <EvanR> with the bridge being a compiler as usual
2026-03-15 23:26:17 +0100 <EvanR> syntax vs (operational) semantics
2026-03-15 23:26:05 +0100 <EvanR> this sounds very mixing up levels of abstraction. RPN is a notation not an implementation backend
2026-03-15 23:25:36 +0100 <jreicher> Yes, with the (predictable?) observation that only postfix can be streamed.
2026-03-15 23:25:21 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-03-15 23:25:10 +0100weary-traveler(~user@user/user363627) user363627
2026-03-15 23:24:54 +0100 <EvanR> that sounds more like streaming is more efficient than buffering, rather than a prefix postfix thing
2026-03-15 23:14:17 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) (Ping timeout: 244 seconds)
2026-03-15 23:11:52 +0100 <jreicher> A possible argument might run like this. The most "optimal" way to evaluate a long sum (for example) is RPN, because the expression can be held outside the program (on input) while evaluation is being done. But this "relies" on the effectful nature of the world.
2026-03-15 23:11:28 +0100 <mesaoptimizer> https://coalton-lang.github.io/20260312-coalton0p2/ coalton is now less Haskell and more common lisp than before
2026-03-15 23:10:34 +0100 <jreicher> I'm not sure. I'm inclined to think it depends on the programmer's mental model of runtime, and that PN is the functional way and RPN is the imperative way. So the latter is easier if you presuppose an imperative mental model, but should we...? (I'm not sure I can argue this hunch, but I feel it strongly; it's the control stack vs data stack)
2026-03-15 23:09:58 +0100merijn(~merijn@host-cl.cgnat-g.v4.dfn.nl) merijn
2026-03-15 23:03:14 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) bitdex
2026-03-15 23:02:51 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Remote host closed the connection)
2026-03-15 23:01:35 +0100 <tomsmeding> jreicher: I'm with you, but I think we can agree that having to introduce the idea of tail calls in order to achieve a single loop is more complicated than RPN's... single loop
2026-03-15 22:59:34 +0100michalz(~michalz@185.246.207.193) (Remote host closed the connection)