HNHacker News
TopNewBestAskShowJobs

pbiggar

7,962 karma · joined January 26, 2009

Cofounder of Tech for Palestine (https://techforpalestine.org)

Previously founder/CTO of Dark (http://darklang.com), and founder/CEO of CircleCI (https://circleci.com). PhD in CS.

https://hachyderm.io/@paulbiggar

https://bsky.app/profile/paulbiggar.com

https://twitter.com/paulbiggar

https://blog.paulbiggar.com

Contact: paul@techforpalestine.org or paul.biggar@gmail.com

submissionscomments
pbiggar··on Leaving OCaml
Honestly surprised I was able to keep this any kind of mystery, since the repo is open and it's plain as day what I've been working on. But congrats on being the only person that actually looked!
pbiggar··on Leaving OCaml
Followup post: https://blog.darklang.com/new-backend-fsharp/
pbiggar··on Leaving OCaml
I wouldn't say I had experience with Rust, tbh (1 day in 2010 doesn't count!)

I don't remember considering F#, so probably just never occurred to me.

pbiggar··on Leaving OCaml
Right, Clojure is dynamically typed, and I'm not interested in dealing with the challenges of that again (esp nulls).
pbiggar··on Leaving OCaml
I'd love to read through some production Saturn and Giraffe setups - is any of your stuff public?
pbiggar··on Leaving OCaml
I think the disconnect here is that for much of the world these days, "ordinary" programming is a backend for a web or mobile app, using REST (or maybe GraphQL if you're avant garde). I'm sure Jane Street does lots of web stuff too, but I haven't see a bunch of Core libraries to do, for example, a CRUD app on Postgres in the cloud somewhere.
pbiggar··on Leaving OCaml
I think .NET Core (esp v5) has had lots of good performance work: https://devblogs.microsoft.com/dotnet/performance-improvemen...
pbiggar··on Leaving OCaml
OP here. I don't know Scala or Haskell well enough to make a "correct choice" either now or then, but basically I had some experience with ML type systems (from Elm and Haskell) and thought sum types were great.

Scala seemed like a mess at the time (from a distance - no idea whether I'm right).

My attempts at Haskell had honestly not gone all that well, the lazyness and pure functional-ness I felt were not great. Basically, I wanted server-side Elm, and OCaml was pretty close.

Tried it, didn't hate it, figured could always do a rewrite later. And here we are.

pbiggar··on Leaving OCaml
I don't think that's accurate. The Benchmark game [1] shows F# winning more and by larger margins. My own benchmark [2], which was reimplementing Dark in three languages, had F# with 2x the throughput.

(standard caveat that benchmarks suck)

[1] https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

[2] https://github.com/darklang/fizzboom/issues/13

pbiggar··on Leaving OCaml
OP here. I don't mean this to be negative, this is just my ongoing developer blog to keep the Dark community appraised about what's going on.

There's some really great stuff about OCaml. I don't think we could have gotten through the first 2 years without OCaml, we repeatedly made very large scale changes to what our product was and how it worked, and that would have been 10x harder in something else.

I actually think OCaml stands to be in a great place in the next few years with the work being done by core community members. See https://twitter.com/patricoferris/status/1323330884515356672.

pbiggar··on Leaving OCaml
> When you're searching for product-market fit, you do the simplest, easiest thing. If you lack a good SDK for your cloud provider, the simplest, easiest thing is often a terrible architectural choice.
pbiggar··on Why Is There a Full-Scale Replica of the Parthenon in Nashville, Tennessee?
I thought this was a joke, but nope: https://www.golakehavasu.com/london-bridge
pbiggar··on Ask HN: If you could invent a new programming paradigm what would it be?
Thanks for mentioning us. The core idea of Dark is "can we take away steps and so reduce accidental complexity", which is very much in line with OP's point that we're stuck in an old way of writing software. I think the live programming that's allowed in Dark really changes how people can write code.
pbiggar··on Dark v2 Roadmap
Thanks, appreciate it!
pbiggar··on Y Combinator Failed Startups
Missing Airware - $112M raised.

(https://techcrunch.com/2018/09/14/airware-shuts-down/)

pbiggar··on No script is too simple
This is exactly what we do for Dark: https://github.com/darklang/dark/tree/main/scripts

Not only that, but each script automatically runs itself in our docker container so it's fully repeatable. They all start with

    . ./scripts/support/assert-in-container "$0" "$@"
which is just this:

    if [[ ! -v IN_DEV_CONTAINER ]]; then
      scripts/run-in-docker "${@}"
      exit $?
    fi
And this is run-in-docker: https://github.com/darklang/dark/blob/main/scripts/run-in-do...
pbiggar··on Haskell RecordDotSyntax language extension proposal (Accepted)
Yes, the languages use immutable values so I understand the semantics.

I agree that's quite nice, however updating nested values is very painful.

pbiggar··on Haskell RecordDotSyntax language extension proposal (Accepted)
To clarify, the thing I want is to make it nice and simple to create a new record with a nested field updated. It's easy to read a.b.c.d, but updating that field painful:

    let a = {a with b = { a.b with c = { a.b.c with d = 5 } } } }
pbiggar··on Haskell RecordDotSyntax language extension proposal (Accepted)
True, and so there might be a need for something like:

    e = e.lbl <- value
(I didn't reuse the '=' because two '=' like that looks weird.

The main thing I want to address is that a.b.c.d is so much work to write to.

pbiggar··on Haskell RecordDotSyntax language extension proposal (Accepted)
My goal isn't to look _exactly_ like C++/etc, but rather to have a fairly natural duality between read and write. You can read with:

    a.b.c.d
but a write is:

    let a = {a with b = { a.b with c = { a.b.c with d = 5 } } } }
which is much much more verbose than the OO/imperative:

    a.b.c.d = 5
pbiggar··on Haskell RecordDotSyntax language extension proposal (Accepted)
The syntax to update records doesn't seem particularly nice:

    e{lbl = val}
Though this has been a part of haskell for a while it seems:

> Note: e{lbl = val} is the syntax of a standard H98 record update

FSharp, OCaml and Elm have not got great solution here either:

   { e with lbl = value } // ocaml/fsharp
   { e | lbl = value }
Do any functional languages have anything as nice as:

   e.lbl = value
pbiggar··on No-Code vs. Pro-Code: A New Hope
Firm agreement about the goals! Over at Dark (https://darklang.com), we've been referring to the space adjacent to Low/No-code as "Just code", to indicate that there's only code there and nothing else. Would be curious what other languages/frameworks the JourneyApps folks would include in "Pro-code"?
pbiggar··on Motivation – Keli Language
I'm very sympathetic to the problem. I'm working on Dark (https://darklang.com) which is a functional language, explicitly because we believe that functional languages are easier to learn, understand and provide great tooling for.

It seems to me there's a lot of focus on syntax, and I don't think they've gotten to a great place. For example:

  (this Int).square | Int = this.*(this)
In Rust, they do

  impl Int {
    fn square (self) -> Int {
      self * self
    }
  }
I can read the Keli version, but I'm note sure that `(this Int)`, `|`, and `.*` are great inventions. You need a good reason to deviate from commonly recognized syntax, and Keli doesn't feel like it's made things simpler with this.

In Dark, we use piping heavily to get the benefits of the dot-syntax. In particular, it can be type directed:

  8 |> Int::square |> Int::log 2
The autocomplete will only show you integer functions in this case.

For the problem of "which parameter" - our IDE shows parameter names when your cursor is in a position to type the next parameter, so you know what you're adding it is. We also show the parameter names when your cursor is in the completed argument so you know what parameter it is. (I couldn't see if Keli did this, it might not be possible in modern editors).

pbiggar··on Venture capital firms to include “diversity riders” in term sheets
Hey Dan, didn't mean to violate the rules. To be clear, my comment was intended to be about his argument and it's lack of rigour. Also, his bio links his twitter, so I thought that made it within bounds. But yeah, that was a bit harsh, sorry.
pbiggar··on Venture capital firms to include “diversity riders” in term sheets
If you're going to try to be contrarian, at least do the research to do it well. You think you're being clever but you're showing no understanding of the positions you're trying to make fun of. As a result, you come across like a moron.

You should have used a throwaway, not because you have non-politically-correct views, but rather because you hold extremely strong opinions about something you can't even articulate credibly.

I looked up your twitter and saw this from March:

> Despite everything happening I’m still not worried. Corona is a bad flu and the markets will recover. I’m choosing to relax #CoronaOutbreak #relax

Similar confidence, similar ignorance.

pbiggar··on Hazel: A live functional programming environment featuring typed holes
I work on Dark (https://darklang.com), which uses a similar concept about holes to Hazel. I've looked at Hazel but amn't totally familiar, so take this answer in that context.

In the first case, the hole has a type. I believe this type is inferred by the compiler/editor/type-checker, and I believe it will tell you if they type is wrong (in Dark, we'll tell you if the type is wrong, though we'll still let you put that variable in that hole to support the transition from one valid state to another).

In the configuration file example, you can't change the type: these are statically typed functional languages, and they don't permit "later-time" type changes.

pbiggar··on Thoughts on Rust vs. OCaml
I'm not aware of any, sorry. You can look at the dark repo to see how we do it though: https://github.com/darklang/dark
pbiggar··on Thoughts on Rust vs. OCaml
I've thought about it a few times, I'm so far from that ecosystem that I know nothing about it at all
pbiggar··on Thoughts on Rust vs. OCaml
What a great writeup, thank you! I think I followed all that . Two things leap out at me:

- I can see arenas for a compiler, but I'm not so sure for an interpreter. While most of the memory allocated in Dark will be done within a single HTTP call (and so an arena might actually be appropriate), there are contexts where a GC cycle or two to cleanup might be appropriate. I'm guessing that arena's are an all-or-nothing approach?

- I'm using `im`, which I think also gets in the way of my nice pattern matching, right? Any solutions to that?

pbiggar··on Thoughts on Rust vs. OCaml
> Please don’t. This is probably one of the biggest mistakes I see in people coming from languages with garbage collection to languages like Rust or C++. They attempt to use smart pointers as a replacement for garbage collection.

Thanks for the feedback. I'm new here, so the advice is appreciated.

I've been using the rule of thumb "does the lifetime of this variable exceed the lifetime of this function" to decide whether to put it in an Rc. Given I'm implementing an interpreter for a GCed language, it seems like I'm pretty much going to have to put everything into an Rc, no? (Another commented mentioned an Arena, but either way it's not the stack).

← PreviousPage 14 of 34Next →