Preface to “Picturing Quantum Processes” showing photos with caption “Some typical sights of Tulsa, Oklahoma” picturing a pawnshop dealing in Gold, Diamonds and Guns; a statue known as the world’s largest praying hands; a triple decker hamburger

A photo from the preface to “Picturing Quantum Processes” with caption “Aleks’ beard growth as correlated with textbook completion” (photos depicting same)

Cover of “Picturing Quantum Processes” by Bob Coecke and Aleks Kissinger

I don’t understand quantum theory, but this book is always a joy to come back to.

Nice! I’ve been looking for a recording of her Fantaisie for harpsichord without any luck.

What are the contenders you have in mind? What do you see as a good balance between rigorous types and architectural approaches?

Not suggesting testing is not needed. We employ unit tests, integration tests, type directed programming, semi formal methods (TLA+), and more rigorous proofs of correctness for specific sub problems. Right tool for the job. But tests are code you have to maintain and slow you down. Types help.

I agree it is necessary to always challenge these assumptions. Types feel slower at first, so you have a runtime error/flexibility tradeoff. In my experience types are always worth it. But it took me many years to arrive at that position.

These days, I mostly domain model in types and then the architecture and implementation trivially fall out of that, establishing the modularity the author seeks. He gives no methods. And his example ignores the static and dynamic testing rigor IC designers employ due to their lack of type safety.

Sure, find good modular boundaries and establish good contracts. If your system is static and very well understood you can build it in assembly if you want and harden it over time. But for anything else, types are the tests you don’t have to write.

I’m always skeptical of “just build software better” arguments. There is a spectrum of software correctness, and types are one of the cheapest approaches. The argument falls apart when system boundaries are incorrect and need refactor. The antipatterns mentioned (class hierarchies?) are now rare.

You can also just immerse the tube in the source and pinch it or cover one end of the tube with your thumb. Then pull out that end of the tube to a lower height and release your thumb to start the siphon.

Is this state machine thinking related to defunctionalization, which takes higher ordered functions (maybe in your type checking implementation) and turns them into state/action applications? Love the visualization!

I wrote my first Quint spec today. It was fun and easy to pick up! It's like TLA+ and TypeScript had a baby. Has some obvious room to grow: you have to be gentle with the syntax and type errors to get good diagnostics. Otherwise, seems like a good alternative to Alloy or TLA+ for simple specs!

I still have my copy of “Haskell: The Craft of Functional Programming”, which I picked up in the 90s and skimmed briefly. I decided at the time to invest in C++ and focused on good imperative programming until I came back to learn Haskell 18 years later out of curiosity.

I can’t remember the last time I was at a house where people kept their shoes on indoors. I think this has changed a lot. Everyone I know takes their shoes off and people almost always ask if they should take their’s off when entering a house.

Whale Effigy The Montreal Museum of Fine Arts, a bold, innovative and caring museum that is welcoming to all disciplines such as the visual arts, history and science.

That should say 1600 CE, not 600. This whale effigy seems to be from the Montreal Museum of Fine Arts: www.mbam.qc.ca/en/works/2375/

I just learned enough ocaml to see how verbose the alternative to type classes is using modules and “functors”. Still wrapping my head around modules, but it definitely seems like code smell boilerplate to me. Are there other arguments against type classes?

I think the human propensity for pattern recognition was strong, but the timeless way of building was not yet established. GoF started with Volume 2.

“Upstate is anything north of 110th St.” is the joke answer.

You can also take a train to a beach and swim in the ocean. If you take the Q you get a nice view going over the bridge too. Coney Island is worth a visit. But it’s a ways out there. There are nicer beaches if you take the right A train to the rockaways.

Philip Zucker is my Z3 documentation.

NYC busses are underrated. The subway is oppressive compared to other city metros.🙁

Just Manhattan or are you planning to check out Brooklyn too? Enjoy your visit!

Did you by chance run across the linked paper here? I skimmed it, but it seems like a reasonable attempt at teasing out the limits of reasoning with respect to actual reasoning tasks.

Wish I could hear this talk. These bullets don’t make total sense to me. Some are known implementation patterns for feature flags, some suggest “just build it right the first time”, and GoF could mean anything (and is mostly just partial application patterns). Still very curious though

Nobody cares about correctness and do cheap things first are great takeaways from this but this article illustrates these and other points especially well: www.galois.com/articles/wha...

Jason Hickle singled out China, not me. But you are right, you have to look at all company investments and holdings globally. Follow the money and only then can you make any claims about which countries hold most responsibility. I do think it is a misguided metric.

What is the new Erlang? (Please let it not be Kubernetes orchestration.)

If you take the perspective that much of advanced Haskell is working around lack of dependent types (like you would find in theorem provers), then I posit Haskell is indeed a gremlin language.

Disingenuous. You cannot make this claim without tracking indirect Chinese investments. Looking strictly at corporate domicile is absolutely pointless in our globalized economy

It is subtle but is builds flawed foundations. If you take arrays as input there is no confusion

Alice is absolutely right. A naive reading of this can correctly say the runtime is O(n^2), but that doesn’t paint the whole picture. For scaling we need to understand if you are measuring size (of an array) vs a number. One scales and the other is useless for large numbers.