HNHacker News
TopNewBestAskShowJobs

abathologist

595 karma · joined November 18, 2014

I am interested in functional programming and logic programming and have a background in philosophy.

Find me at http://shonfeder.net/

submissionscomments
abathologist··on Hidden Changes in GPT-4, Uncovered
> Physical property is a consequence of the laws of physics. If I have a gold coin in my hand, then you don't have that gold coin in your hand.

So do you believe people should only be able to own real estate that they are currently physically occupying? By your reasoning, no one could ever own a piece of land larger than what they were currently standing or lying on. So no one could own land. So abolition of all property rights, essentially.

I'm hella down for this, but then we should also be able to walk into the OpenAI offices and inspect their source code, cause that shit won't fit in any one hand afaik.

This is incredibly naive misunderstanding of how property rights work: they are 100% a social and conceptual construct. IANAL, but I believe you are confusing property with possession.

But, yeah. I'm down: no one can own anything that isn't currently in their hand. Let's go liberate a lot of fake property that is "owned" in violation of the laws of physics!

abathologist··on Quint: A specification language based on the temporal logic of actions (TLA)
CORRECTION:

> find and diagnose typing errors prior to running any type checker

Should read

> find and diagnose typing errors prior to running any model checker

abathologist··on Quint: A specification language based on the temporal logic of actions (TLA)
That's what I meant! Thanks for the correction :)
abathologist··on Quint: A specification language based on the temporal logic of actions (TLA)
I think you and Ron are confusing the relevant phase distinction the rest of us have in mind when we talk about type checking in this context.

What we mean is that quint, the language, is expressed on top of a many-sorted logic which allows our tooling to find and diagnose typing errors prior to *running* any type checker. The TLA Toolbox doesn't support this, and TLA+, like TLA itself, is untyped. TLC can (and will) raise errors while in the process of checking your model due to the kinds of problems we usually call "typing errors". Quint and apalache shouldn't do this.

I hope this helps clarify a bit.

We understand that, viewed purely theoretically, TLA+ has no dynamic aspect at all, etc. However, our team is very focused on the fusion of theory and practice, and we think it's important to ground our understanding and our discourse in the way the specification languages are actually used by real people given the existing tools. While it may be true in theory that

> What TLA+ is missing is any notion of executing code.

The file `TLC.tla` in the `StandardModules` includes these lines:

  ```
  Print(out, val) == val
  PrintT(out) == TRUE 

   (* This expression equals TRUE, but evaluating it causes TLC to print   *)
   (* the value of out.                                                    *)   
  ```
https://github.com/tlaplus/tlaplus/blob/master/tlatools/org....

In any case, our whole team thinks TLA is great, and we're happy people like you and Ron find it so useful and insightful. We also think it is a very insightful tool for guiding understanding :)

abathologist··on Quint: A specification language based on the temporal logic of actions (TLA)
This is great feedback, thanks! Probably the first step tutorial should just be on something very straightforward, like an hour clock or a counter. I'll file an issue to introduce something more focused.

Thanks again :)

edit: https://github.com/informalsystems/quint/issues/1319

abathologist··on Quint: A specification language based on the temporal logic of actions (TLA)
Those are great questions! Let me add a one addendum to bugarela's excellent explanation, to help disambiguate these three formalism:

1. TLA[0] is a logical calculus invented by Leslie Lamport.

2. TLA+[1] is a formal specification language, also invented by Leslie Lamport, with semantics based on and reducible to TLA.

3. quint is also a formal specification language with semantics based on and reducible to TLA.

TLA+ can be understood as TLA extended with syntax sugar to help describe systems. On top of the logical calculus it adds niceties like `LET` bindings, syntax to represent common data structures, `CASE` expressions, a module system, etc. But TLA+ also exposes the underlying logic directly, making the language extremely expressive. The flip side is that nonsensical formulas which may not be checkable are pretty easy to write.

quint is a (programmer friendly) syntax that, while also desugaring to TLA, gives up expressivity to add the guardrails that we've found most helpful when specifying the systems we work on.

Please let us know if you have any followup questions :)

---

[0]: https://en.wikipedia.org/wiki/Temporal_logic_of_actions [1]: https://en.wikipedia.org/wiki/TLA%2B

abathologist··on Quint: A specification language based on the temporal logic of actions (TLA)
I can sympathize! We are aiming to maintain most of the expressive power of TLA+ -- ideally everything you need for a concise, high-high level specification, that can be simulated and/or verified -- but with surface syntax that is more approachable coming from a programming background. If you're interested in seeing how it maps to TLA+, you can find much of that in this document: https://github.com/informalsystems/quint/blob/main/doc/lang....

We still have lots of ways to improve, and -- we think -- lots of opportunities to improve our interop and complementary qualities in relation to TLA+ and TLC. But we have found the tools in their current state useful enough to be worth sharing :)

abathologist··on Quint: A specification language based on the temporal logic of actions (TLA)
That is our aim! If you give it a shot and find things that aren't so approachable, we'd live to hear how we can improve.
abathologist··on Welcome to Wikifunctions
That page seems totally reasonable and admirable to me. It’s literally just advocating for including the wide and varied history of algorithm development, in order to encourage readers from many different backgrounds to find ways to connect with the important topic.
abathologist··on Programming languages going above and beyond
It's still in pretty early development, but you may be interested in https://github.com/informalsystems/quint

> It combines the robust theoretical basis of the Temporal Logic of Actions (TLA) with state-of-the-art static analysis and development tooling.

And it is typed ;)

abathologist··on Should I step down as head of Twitter? I will abide by the results of this poll
Confidence men like Musk are brilliant in this respect at least: they can so bedazzle some segments that they are willing to reinterpret every possible outcome, no matter how obviously detrimental, as a secretly planned win, only under altered game rules. Cf https://en.wikipedia.org/wiki/When_Prophecy_Fails.
abathologist··on OCaml 5.0 Multicore is out
here are a few

- https://github.com/coq/coq

- https://github.com/mirage/mirage

- https://github.com/returntocorp/semgrep

- https://github.com/bcpierce00/unison

See https://v2.ocaml.org/learn/companies.html for some more leads, as lots of those companies maintain useful OSS software.

abathologist··on Balloon framing is worse-is-better (2021)
> Most Houses need to last 30 or 50 years

Why? It seems absurd to me to only have a dwelling last for half a lifetime. This view seems to assume a disposable, consumerist logic, which seems at odds in my view both from reasonable use of energy and time and with a sustainable civilization.

abathologist··on OCaml Programming: Correct and Efficient and Beautiful
That's funny. This has been a problem for every experienced Haskell programmer I've known who works in Haskell professionally. I wonder what domain you work in where performance and space leaks haven't been a concern?
abathologist··on OCaml Programming: Correct and Efficient and Beautiful
>Haskell is equal or better (sometimes significantly so) in almost every relevant domain. For domains in which ocaml is a better choice, it is not the globally best choice (i.e. both ocaml and haskell are bad in those domains).

I think this assertion is false, but it would take a lot of careful evaluation to prove it one way or the other. The most salient counterexample that comes to mind is modularity and namespacing.

Of course it's possible I'm wrong, and Haskell is objectively superior in every regard. But the OCaml language and ecosystem has [a decades long track record of stable and evident success stories](https://ocaml.org/industrial-users) and I find it well suited for the kinds of problems I like to tackle. I also like the prevailing vibe in the (still) small community.

This exchange reminds of a difference I've observed in the cultural tendencies in the OCaml and Haskell ecosystems: in my experience, OCamlers tend to not be very invested in arguing for the supremacy of OCaml.

abathologist··on OCaml Programming: Correct and Efficient and Beautiful
Indeed it is :)

Dropping an example in TryOcaml[0]:

    let f : int -> int = fun _ -> 1 ;;
    val f : int -> int = <fun>
    let ex : int list = [f] ;;
    Line 1, characters 21-22:
    Error: This expression has type int -> int but an expression was expected of type
      int

[0]: https://try.ocamlpro.com/
abathologist··on OCaml Programming: Correct and Efficient and Beautiful
Haskell is a great language but has plenty of its own warts. The value prop and trade offs between OCaml and Haskell really makes it hard to use one as a drop in for the other imo.
abathologist··on OCaml Programming: Correct and Efficient and Beautiful
Looks like that is exactly the error message predicted. It’s expecting a list of result values, but is getting a list of functions from some stuff to that result.

IME, it’s definitely true that OCaml doesn’t have the didactic error messages that many have come to like in Rust et al. They said, imo they generally give the information needed solve problems and I like their concision. It takes a bit of time to learn to read them however.

abathologist··on Git as a NoSql Database (2016)
Related https://irmin.org/ (and in development since 2013)

> A distributed database built on the same principles as Git (and which can use git as a backend)

abathologist··on Configuration Files in Terms of User Empowerment
I wrote a note on configuration file formats, trying to take a long view and to consider the choice of format in light of empowering user-authors. I advocate for a flexible approach leveraging “configurationless”, Dhall, or bespoke DSLs, depending on the circumstance.

I think I probably omitted some key considerations and options, but it did help us clarify our thinking on the subject at Informal.

I'd welcome any criticism or additional considerations.

abathologist··on Show HN: Jhall – A JavaScript Alternative to Dhall
Another principle virtue of Dhall (stemming from the type system) is that it's total, so you know no funny business can go on when computing the configs. Even if you use typescript for (unsound) static type checking, you're definitely not going to get totality out of it.

If someone wanted dhall in JS, they could implement it, as has been done for Go, Ruby, Clojure, etc.[1]

iiuc, this library is much more akin to the approach described in https://beepb00p.xyz/configs-suck.html

[1]: https://docs.dhall-lang.org/howtos/How-to-integrate-Dhall.ht...

abathologist··on I Want Decentralized Version Control for Structured Data
https://irmin.org/ seems like it it may fit the bill:

> A distributed database built on the same principles as Git

I haven't used it myself, but it has been around for years and seems pretty mature.

abathologist··on Code is Engineering; Types are Science
CTT addresses this line of thinking: http://www.scholarpedia.org/article/Computational_type_theor...

btw, I think you're missing an important qualification, which is that a given formalism can always be enriched with new axioms to increase the scope of what it's able to prove. This is relevant for type theoretic approaches, which generally have a mechanism for adding new axioms.

abathologist··on Code is Engineering; Types are Science
iiuc, the dichotomy "programming language vs. type system" doesn't hold for type-theoretic programming. E.g., languages based on System F (like Haskell) are based on a programming language that is inherently typed.
abathologist··on The 2,500 year old history of why Python’s all([]) returns True
I like the algebraic point of view as a way of spotting essential patterns like this :) The essential missing step here is to point out that conjunction is multiplicative, not additive, and this is why `all` gives the unit under conjunction, rather than the unit under disjunction. Corresponding to `sum` is `any`, which gives the unit under disjunction for the empty list, since disjunction is additive.

That said, I do think there is something to the perspective presented in the article. Something which is not accidental to the algebraization of logic...

abathologist··on The FAQ of comp.lang.prolog is maintained as a Prolog source file
Plans change :) If/when you find you do need to change something, having preferred suitable tools in your main language will make this easier.
abathologist··on Functional Programming in OCaml
To be clear, Bucklescript also works with standard OCaml (because Reason is just an alternative surface syntax).
abathologist··on Mondragon Corporation
My suspicion is that the worker-owned cooperative model, especially if it emphasizes the more important worker self-directed part, will tend towards much smaller units of self-organization. I predict we will see confederations and networks of smallish coops, and I suspect this is for the best.
abathologist··on Mondragon Corporation
I've found this list of tech-coops useful as well: https://github.com/hng/tech-coops
abathologist··on Mondragon Corporation
"not profit driven" does not mean "forcing no profits". The former means that your highest driving purpose and governing logic is not oriented around the accumulation of profit. The latter means you make it impossible to accumulate profit.

We can pursue self-organization that pursues escape from the pathological patterns of profit driven production without advocating for, striving for, or tolerating a totalitarian, bureaucratic nightmare. See, e.g., https://thenextsystem.org/start-with-worker-self-directed-en...

← PreviousPage 5 of 6Next →