danidiaz

From this article about a different emperor: https://www.lrb.co.uk/the-paper/v41/n04/christopher-kelly/a-...

Lots of thoughtful sf book reviews with a heavy (but not exclusive) focus on the New Wave.

"In modern mathematics, an analytic theory is one whose basic objects are defined in some other theory, whereas a synthetic theory is one whose basic objects are undefined terms given meaning by rules and axioms"—Michael Shulman

In programming terms, I guess "synthetic" mathematics feels a bit like programming to an abstract interface.

https://ncatlab.org/nlab/show/synthetic+mathematics

In the first part of this video Cédric Villani gives (in French) a nice explanation of the distinction: https://youtu.be/xzVk56EKBUI?t=258

Edit: an English explanation, also by Villani: https://www.youtube.com/watch?v=AIrLXbwyYXQ

> However, even for these tasks, its performance has dropped measurably since the early 2060s and is now considered subpar compared to more recent uploads. This is primarily attributed to MMAcevedo's lack of understanding of the technological, social and political changes which have occurred in modern society since its creation in 2031. This phenomenon has also been observed in other uploads created after MMAcevedo, and is now referred to as context drift.

Agree! And I would add that you can "purify" a monadic function without having to rewrite it in non-monadic style. You can make it polymorphic over all monads and relegate the "impurity" to monadic functions that you pass as arguments/dependencies. A trivial example:

  twice :: IO ()
  twice = do
      putStrLn "foo"
      putStrLn "foo"
  
  twice' :: forall m. m () -> m ()
  twice' action = do 
      action
      action

Haskell lets you express the idea of "program logic that only has effects through its dependencies" by being polymorphic over all monads.

Collections of marvels and extraordinary things were their own genre called ‘aǧā’ib. Here is an open-access example, "The Marvels Found in the Great Cities and in the Seas and on the Islands" https://library.oapen.org/handle/20.500.12657/46307

The classical world had a similar genre, paradoxography: https://en.wikipedia.org/wiki/Paradoxography

There's also the documentary "Sisters with transistors" about women pioneers of electronic music https://www.youtube.com/watch?v=7r-3hlzpV7M

Did you encounter some part of the domain which was difficult to "push down" into SQL?

Also, how would this compare with encoding your domain code in a bunch of stored procedures, largely skipping a "conventional" programming language?

This would be a fun task to attempt with the new linear features of Haskell https://hackage.haskell.org/package/linear-base-0.1.0/docs/D...

> type theory is not about syntax. It is a mathematical theory of constructions, just like set theory is a mathematical theory of collections. It just so happens that the usual presentations of type theory emphasize syntax, and consequently people end up thinking type theory is syntax. This is not the case.

This approach is being adopted in GHC itself to compose errors happening at different stages of the compilation pipeline: each stage has its own error type which later becomes a branch of the global error type.

Another interesting post about errors-as-values in Haskell is "The Trouble with Typed Errors": https://www.parsonsmatt.org/2018/11/03/trouble_with_typed_er...

Grothendieck once flunked an exam due to—in his own words— "une erreur idiote de calcul numérique".

Spring takes care of that, but doing it manually (and without dynamic proxies) would add to the verbosity.

rfc2616 says:

> Methods can also have the property of "idempotence" in that (aside from error or expiration issues) the side-effects of N > 0 identical requests is the same as for a single request.

https://datatracker.ietf.org/doc/html/rfc2616#page-51

Perhaps changes in the underlying data could be considered "expiration issues". Otherwise not even GET could be considered idempotent in many cases.

A way to square creation of response resources with idempotency could be: the second identical QUERY that arrives should always reuse the result resource created by the first QUERY.

The possible creation of extra HTTP resources (response resorces?) seems to me contrary to idempotency. That seems more like the territory of POST.

If two identical QUERY requests might produce different response resources, how to square that with the the fact that QUERY will be cacheable?

It's also notable for being a continuous integration-driven talk!

DI frameworks also provide aspect-oriented-programming services (transactionality, logging...). Doing that with plain functions in an arity-polymorphic way is possible, but not completely trivial, in my (Haskell) experience. http://web.cecs.pdx.edu/~ntc2/haskell-decorator-paper.pdf

In a real dependently-typed language the friction would be lower, because it's easier to put "normal code" at the type level.

Perhaps I could have skipped some type-level tests by introducing more kind-safety...