Hacker News: podsnap

New comment by podsnap in "An AI agent published a hit piece on me"

podsnap — Sat, 14 Feb 2026 00:32:10 +0000

If it’s any consolation, nasty clawdbots are just a temporary distraction on the way to chaos and ruin. We’re very close to a Borgesian Internet of Babel, containing every imaginable hit piece and deepfake.

New comment by podsnap in "Ask HN: Who is hiring? (May 2022)"

podsnap — Tue, 03 May 2022 01:02:17 +0000

Morgan Stanley is hiring developers at all levels in Montréal, to work on our extremely cool - massively distributed, asynchronous, referentially transparent risk management platform. Multiple teams collaborate on technologies including bitemporal object stores, asynchronous language semantics, compiler development, massively distributed computation, embedded query languages, and declarative reactive UIs. Our focus on core platform development means that our primary clients are not the teams and individuals operating on the financial side, but their end-user application developers, who rely on the services and components we provide.

Location: Montréal, onsite (remote is possible within Québec).

More information: https://youtu.be/V0jJvgiI_xs?t=1469 https://ms.taleo.net/careersection/2/jobdetail.ftl?job=32022... Or contact me directly: peter dot fraenkel at morganstanley dot com

New comment by podsnap in "Why is 2 * (i * i) faster than 2 * i * i in Java?"

podsnap — Sat, 08 Dec 2018 18:31:52 +0000

The graal behavior is a lot more sane:

    graal:
    [info] SoFlow.square_i_two   10000  avgt   10  5338.492 ± 36.624  ns/op   // 2 *\sum i * i
    [info] SoFlow.two_i_         10000  avgt   10  6421.343 ± 34.836  ns/op   // \sum 2 * i * i
    [info] SoFlow.two_square_i   10000  avgt   10  6367.139 ± 34.575  ns/op   // \sum 2 * (i * i)
    regular 1.8:
    [info] SoFlow.square_i_two   10000  avgt   10  6393.422 ± 27.679  ns/op
    [info] SoFlow.two_i_         10000  avgt   10  8870.908 ± 35.715  ns/op
    [info] SoFlow.two_square_i   10000  avgt   10  6221.205 ± 42.408  ns/op

The graal-generated assembly for the first two cases is nearly identical, featuring unrolled repetitions of sequences like

    [info]   0x000000011433ec03: mov    %r8d,%ecx
    [info]   0x000000011433ec06: shl    %ecx               ;*imul {reexecute=0 rethrow=0 return_oop=0}
    [info]                                                 ; - add.SoFlow::test_two_i_@15 (line 41)
    [info]   0x000000011433ec08: imul   %r8d,%ecx          ;*imul {reexecute=0 rethrow=0 return_oop=0}
    [info]                                                 ; - add.SoFlow::test_two_i_@17 (line 41)
    [info]   0x000000011433ec0c: add    %ecx,%r9d          ;*iadd {reexecute=0 rethrow=0 return_oop=0}
    [info]                                                 ; - add.SoFlow::test_two_i_@18 (line 41)
    [info]   0x000000011433ec0f: lea    0x5(%r11),%r8d     ;*iinc {reexecute=0 rethrow=0 return_oop=0}
    [info]                                                 ; - add.SoFlow::test_two_i_@20 (line 40)

while the third case does a single shl at the end.

    [info]   0x000000010e2918bb: imul   %r8d,%r8d          ;*imul {reexecute=0 rethrow=0 return_oop=0}
    [info]                                                 ; - add.SoFlow::test_square_i_two@15 (line 32)
    [info]   0x000000010e2918bf: add    %r8d,%ecx          ;*iadd {reexecute=0 rethrow=0 return_oop=0}
    [info]                                                 ; - add.SoFlow::test_square_i_two@16 (line 32)
    [info]   0x000000010e2918c2: lea    0x3(%r11),%r8d     ;*iinc {reexecute=0 rethrow=0 return_oop=0}
    [info]                                                 ; - add.SoFlow::test_square_i_two@18 (line 31)

Both graal and C2 inline, but as usual the graal output is a lot more comprehensible.

New comment by podsnap in "Type-safe Transducers in Clojure, Scala, and Haskell"

podsnap — Thu, 30 Oct 2014 13:24:54 +0000

True. In retrospect, trying to make the Scala transducer type look like Haskell and then hacking into working order was didn't do justice to either language. As I sort of note in the text, the attempt to do it this way was at least partially meant to be "amusing."

New comment by podsnap in "Type-safe Transducers in Clojure, Scala, and Haskell"

podsnap — Thu, 30 Oct 2014 13:16:39 +0000

There's more missing than that, but, in the spirit of early termination, I had to stop somewhere! Specifically to your points: 1. To preempt the faithful: Stateful transducers don't work (for a broad definition of work) in Clojure or Scala either. It's just that there's no tradition of acknowledging state via type in those languages. 2. Early termination is weird. In Clojure it's a property of the accumulated reduction value, i.e. not the transducer, the reducing function or the reducer/collection. I'm not sure yet whether to try modeling this via type or to try sticking it somewhere else. 3. Rich's talk is great. Also, it's been transcribed: https://github.com/matthiasn/talk-transcripts/blob/master/Hi...

New comment by podsnap in "Upgrading to Mac OS X 10.10 Yosemite as a Developer"

podsnap — Sat, 18 Oct 2014 13:27:51 +0000

See my reply above. A more accurate count on a keyboard with working keys is 243185. I'm starting to wonder whether the /usr/local-related delay is naturally about an hour, but vastly increased - sometimes catastrophically - by having the log window open. Just a theory.

New comment by podsnap in "Upgrading to Mac OS X 10.10 Yosemite as a Developer"

podsnap — Sat, 18 Oct 2014 13:16:57 +0000

Sorry, 32k was the result of `ls -lR /usr/local | wc -l` and then typing on a keyboard with a broken 4. To be much more precise, `find /usr/local -type f | wc -l` is 243185, while (including directories and links) `find /usr/local | wc -l` is 274709.

New comment by podsnap in "Upgrading to Mac OS X 10.10 Yosemite as a Developer"

podsnap — Fri, 17 Oct 2014 23:02:44 +0000

It was multi-hour altogether, but the lying about two minutes remaining only took 45 minutes.

New comment by podsnap in "Upgrading to Mac OS X 10.10 Yosemite as a Developer"

podsnap — Fri, 17 Oct 2014 16:42:39 +0000

I had 32k files using up 8GB in /usr/local, and the time spent on "2 minutes remaining" was about 45 minutes. In retrospect, I'm happy that I didn't waste any time on special preparations. One thing I learned is that the ⌘L log window blocks progression from restore to the next reboot; I lost about 15 minutes that way.

New comment by podsnap in "Tinholes – performant, strongly typed lenses in Clojure"

podsnap — Wed, 08 Oct 2014 19:44:08 +0000

Ok, I managed to get a van Laarhoven representation in typed Clojure, though it wasn't exactly a smooth experience. http://blog.podsnap.com/vanhole.html

New comment by podsnap in "Tinholes – performant, strongly typed lenses in Clojure"

podsnap — Tue, 30 Sep 2014 15:37:04 +0000

Yes, lens-aeson looks pretty damn close. I've got a bunch of reading to do.

The existence of zipper lenses catches me by surprise, as I have been frequently directed at a stackoverflow [0] response on the difference between the two...

[0] http://stackoverflow.com/questions/22094971/what-are-the-dif...

New comment by podsnap in "Tinholes – performant, strongly typed lenses in Clojure"

podsnap — Tue, 30 Sep 2014 13:27:08 +0000

I was thinking of setting ```:c``` in ```{:a {:b "{:c 5}"}}```. More generally, a leaf in the container tree that is not itself a container but can be converted to and from one. I need to play more with http://hackage.haskell.org/package/lens, but I'd certainly appreciate a shortcut to enlightenment...

New comment by podsnap in "Tinholes – performant, strongly typed lenses in Clojure"

podsnap — Mon, 29 Sep 2014 18:06:50 +0000

I apologize for my miscommunication and ignorance. First, the bragging was supposed to be on behalf of the Clojure ecosystem rather than myself. Second, while I am aware of the standard lens implementations in Haskell and Scalaz, I didn't see that either dealt nicely with intra-path transformations, and the Scalaz version didn't seem very concise. If there are more examples, or if I'm wrong about these, I would love to learn more. I agree that the interaction with typed Clojure is not ideal, but at least there's an interaction of some sort, albeit possibly a "hack." Googling "van Laarhoven" has led me to a few hours of reading material and to SPJ's talk, so thanks for that...

New comment by podsnap in "Tinholes – performant, strongly typed lenses in Clojure"

podsnap — Mon, 29 Sep 2014 17:42:13 +0000

Sorry about "performant," everyone. After years of being mocked as a pedant for avoiding the word (ok, there may have been other reasons), I decided to dip a toe in the descriptivist waters. Maybe it's too soon. I toyed with "fast" in the title, but that could be taken as referring to ease of use. I'll spend the next few hours trying to come up with a better title.