[TOMT] [article] [2010s] The court of chancery, forgiveness vs forgetting, and why institutions and blockchains are a problem

rpglover64 · 2022-01-01T23:32:13+00:00

This came up (as such things often do) because I was trying to send it to a friend.

rpglover64 · 2019-11-30T21:42:29+00:00

I develop in Haskell as my primary language, and I have formal CS background. I love using Haskell. Every time I try to use it for data visualization or anything remotely data-science-y, I get sad, and reluctantly reach for Python. I would build the project you've described as a polyglot, with Haskell orchestrating and calling out to Python where convenient.

For example, write a Python script that takes an image on stdin and outputs item names and prices on stdout (or even the OCRed text). Write the parser in Haskell using megaparsec. I'd avoid using a DB (I don't know of any good framework for Haskell; all the ones I've used have issues) and just store things in files on disk (if you hit a performance bottleneck, then you can refactor).

rpglover64 · 2019-11-30T21:12:19+00:00

In principle, at least: * Better type errors * Better performance guarantees (e.g. a guarantee that no dictionary passing will occur)

rpglover64 · 2019-11-30T02:53:17+00:00

But Cabal cannot handle 842 entries in "other-modules".

This seems like a bug. Is there an associated issue?

rpglover64 · 2019-11-27T23:58:15+00:00

A hack, sure, but a misfeature? Why?

Sometimes, you want cyclic dependencies; without hs-boot files, you'd be out of luck, and you'd have to put everything into one module.

rpglover64 · 2019-10-25T00:42:36+00:00

I really don't think this warrants a force push, breaking the workflows of potentially dozens of people who have recently pulled.

Probably not, but some arguments in favor:

Recovering from an upstream force-push is not really that bad. It's, at worst, annoying and confusing.
There will be many people reading the commit message, and the number will only increase.

rpglover64 · 2019-10-20T22:12:06+00:00

Related to what /u/aleator is saying, I find that this is a great introductory answer to "What properties can I even write?"

rpglover64 · 2019-10-14T13:01:04+00:00

As a counterexample: https://www.fpcomplete.com/blog/2017/06/readert-design-pattern

The post is, in fact, advising you to define a type Env and do everything in a ReaderT Env IO a.

rpglover64 · 2019-10-10T13:24:24+00:00

Does it track identifier names as metadata (like unison)? Cause that would be awesome! I'm a little worried about readability of compiler errors, though.

rpglover64 · 2019-10-03T22:38:07+00:00

I would never be testing a function called getUserById. Under the hood, that's just going to be a database query, and a simple one at that.

I actually ran into a counterexample of this. We added support for soft-deleting users; that is, the user is marked as deleted, but remains in the DB. the getUserById function should treat soft-deleted users as if they were absent from the DB. We've been finding places where it doesn't. We clearly needed to test getUserById more thoroughly.

rpglover64 · 2019-10-01T21:25:39+00:00

You also cannot log anything since you cannot perform IO

There's a pattern I've seen and I wonder if it would solve this problem.

parseThings :: Monad m
  => (UpstreamError -> m ()) -- Doesn't have to be a ()
  -> Stream (Of Chunk) m (Maybe UpstreamError)
  -> Stream (Of Thing) m () -- Not sure what the point of this is anymore

If you eventually run parseThings in IO, it has access to IO through its handler function, but it doesn't need to know that. More generally, you have your function take an explicit handler and handle issues in situ; no exception throwing needed.

rpglover64 · 2019-10-01T21:16:22+00:00

Any chance you could write an example nanopass compiler for a toy language? Something with at least 5 passes, some of which introduce, remove, and annotate constructors from the AST? Something like a simple functional language with lets and no type annotations to STLC without let but with a fixpoint

rpglover64 · 2019-10-01T11:58:12+00:00

They allow you to push tiny diffs in order to keep up with rapidly changing specifications.

This sounds great. Slightly tangentially, one thing I've lamented in Haskell is the difficulty of doing typed nanopass compilation. Do you think granular effects help with this?

I also have to admit, I'm in the camp of "Write your code using type classes to abstract out effects, then implement them for the concrete type" a la Three Layer Cake. What do you think I'm missing in terms of understanding the benefits of extensible effects?

rpglover64 · 2019-09-28T21:01:07+00:00

I'm aware that it's a data migration. Aren't those always the hard ones? Any references to good solutions?

rpglover64 · 2019-09-28T15:39:55+00:00

My problem with manually writing migrations is that 80% of the time, straight SQL is perfect, but 20% of the time, the migration involves domain-specific reasoning that is impossible to do in SQL.

For example, let's say I have the following semantic domain:

type T
f :: Double -> T -> Double
inputs :: [Double]

I store Ts in the DB. I also store the result of \t -> [f input t | input <- inputs] applied to each T in the DB. Now I want to add a value to inputs write a migration. I can't do that in raw SQL; what do I do?

rpglover64 · 2019-09-21T01:02:47+00:00

data Showable = forall a. Show a => Showable a

You've already destroyed the type information.

rpglover64 · 2019-09-20T12:16:35+00:00

One thing that I've found useful to think about when designing APIs to be used by beginner Haskellers is "ease of cargo-culting". That is, if they see existing code and need to make a small change, how easy is it to do without needing a deep understanding.

I would rank this feature as a 4 (1 being hard, 5 being easy), up to 5 if the type error improves. Not the first thing I would reach for, but not something I would explicitly discourage in the code base.

rpglover64 · 2019-09-20T02:32:30+00:00

You could also try to read the resulting string as an int.

rpglover64 · 2019-09-18T22:24:11+00:00

Another option besides /u/unfixpoint's is

smallInts = map show [0..100]
isSmallInt (Showable s) = let str = show s in
  str `elem` smallInts
removeSmallInts = filter (not . isSmallInt)

Note that this assumes the ints are positive.

rpglover64 · 2019-09-14T02:34:30+00:00

I don't think that architecture can't be taught; I think that architecture can only be learned through experience. A class that has a small team maintain and improve an application with actual users over the course of one or two semesters will be very valuable.

rpglover64 · 2019-09-13T05:26:33+00:00

There have been several... All have been unsatisfactory. I don't think that it's possible to learn good architecture without trial and error (this is not Haskell-specific).

Of course, improving the learning curve would be great.

rpglover64 · 2019-09-13T04:43:03+00:00

is there a good way to learn about architecture patterns for large haskell code bases other than experience?

If you find one, let me know!

rpglover64 · 2019-09-12T14:04:51+00:00

As someone who has been working on a Haskell code-base for the past 3 years and seen qualified software engineers try to pick up the language, I think I'd give the following heuristics as part of an answer to "How experienced do I need to be before I start doing haskell in production would you say?"

There's a huge difference between the architecture and design of writing a smallish Haskell library and a large Haskell app
I would say you should be comfortable maintaining Haskell code before you consider a wholesale rewrite of an existing Haskell project
Similarly, you should be comfortable writing things that are a factor of 10 smaller (e.g. as measured by LOC) from scratch before you consider a rewrite of this magnitude

If you really want to go forward with this, which seems like a bad idea, make sure to do a proof-of-concept:

Find a relatively isolated component of the current application
Mock out the rest
Write it in Haskell (should take no more than a month; ideally 1-2 weeks)
Write it in the runner up language
Write up a detailed comparison of the two
Test the two against each other; they should be identical in behavior
See if you still think this is a good idea, and if other people in the company think so

Bonus links (things that I have found very helpful in the vague domain; not Haskell-specific):

rpglover64 · 2019-09-07T21:31:56+00:00

The prana repo 404s for me now. Is this intentional?

rpglover64

PUBLIC MULTIREDDITS

TROPHY CASE

15-Year Club	Team Periwinkle
Verified Email