Dark Blog

> * DARK - directed analysis and reasoning kit Taken: https://blog.darklang.com

https://blog.darklang.com/goodbye-dark-inc-welcome-darklang-inc/ includes this, which is a really interesting pattern that I don't remember hearing about before for this kind of company: > In conversation with our investors and the board, we believed that the best way forward was to shut down the company, as it was clear that an 8 year old product with no traction was not going to attract new investment. In our discussions, we agreed that continuity of the product was in the best interest of the users and the community (and of both founders and investors, who do not enjoy being blamed for shutting down tools they can no longer afford to run), and we agreed that this could best be achieved by selling it to the employees. Any other examples of that? I'm particularly interested in that for this kind of software product.

A follow up to this is what they did choose: F# This is posted at https://blog.darklang.com/new-backend-fsharp/

And, indeed, F#, per the followup article: https://blog.darklang.com/new-backend-fsharp/

It looks like Dark is trying to be a new language, a backend server, a CI solution, and an IDE! Then there is a blog post that everyone churns: > Currently, we get 10 user signups a day, and on average, 0 of them stick. We do have developers who love Dark, but not enough. https://roadmap.darklang.com/goals-of-dark-v2 I think the company should focus on just one of those things and it would still be an enormous lift given their size. > The problems and fixes are across the product. One problem is that undo is slow, another is that you can't put a minus sign in front of an integer, another is that we need to define how namespaces will work in the package manager. The fixes range from adding tooltips in the UI, to adding a type-checker, to making the package manager public. https://blog.darklang.com/dark-v2-roadmap/ Ayeeeee... this is like trying to carve Mount Rushmore using a spoon.

The problem with OCaml is not multicore. If it had an easier to use build system and a larger community (so more libraries), it could be great for server-side software. But dune is way harder to use than Cargo and you can often miss libraries. Here's an example of Dark moving away from OCaml to F# https://blog.darklang.com/leaving-ocaml/, which doesn't have as much this problem because you can use C# stuff. Scala also doesn't suffer as much from it, part of it because it was really popular at some point, and part of it because you can use Java anyways. I hope at some point we'll have this "garbage collected Rust", but for now OCaml, Scala and F# all have a worse developer experience than Rust. I could add Haskell to that too. I've been thinking for some time that something like Go but based on a ML would fill this "garbage collected Rust" niche quite well. Maybe something built over Rust itself to leverage all the ecosystem? You could write all of the glue code in this language, have access to a large ecosystem of libraries and have an option for high performance code. This would also complement Rust nicely: I know that OCaml has a really fast compiler, which would be a breath of fresh air for the community.

Followup post: https://blog.darklang.com/new-backend-fsharp/

Darklang is probably the closest thing that comes to mind - https://blog.darklang.com/goodbye-dark-inc-welcome-darklang-inc/

It's actually the opposite. They're buying the assets (the software), not the company. > To ensure continuity for users and fans, as well as to continue building what we regard as an important technology, Dark Inc has sold the assets – the Darklang language, the blog, the hosted service, the Discord, etc, darklang.com, etc – to a new company started by Dark Inc's former employees. (from https://blog.darklang.com/goodbye-dark-inc-welcome-darklang-inc/) In other words, there's a new company (Darklang Inc.) that has purchased the assets of Dark Inc. (for probably relatively little money). This clears the cap table, making it easier for the former employees (now founders) to raise money for the new corporation.

Some reasoning is laid out here[0], but I'm curious to hear more too. [0]: https://blog.darklang.com/darklang-goes-open-source/

There are at least a few nascent statically typed languages (as in, full static typing rather than gradual) which nevertheless let code with type errors compile for the sake of testing. The two that I know of are Darklang [0] and Roc [1] which aim to let you compile code with type errors for the same reason you suggest. [0] "Dark is designed for continuous delivery. As such, we don’t like requiring you to make large scale changes across your program, like changing a type everywhere. Instead, we want you to quickly discover that bad ideas won’t work, without first requiring you to propagate the type changes throughout your program." https://blog.darklang.com/real-problems-with-functional-languages/ [1] "If you like, you can run a program that has compile-time errors like this. (If the program reaches the error at runtime, it will crash.)" https://www.roc-lang.org/friendly

In addition to going all-in as partisans in a war, darklang is going "all in on AI": https://blog.darklang.com/gpt/ The project is doomed.

> darklang is going "all in on AI": https://blog.darklang.com/gpt/ This is absolutely the right move. SoTA LLMs are so good at code that for a devtool startup to be leveraging anything else is lunacy.

it's not yet changed, but we're working on it. You can skip here to the bit in the main post where that's discussed: https://blog.darklang.com/an-overdue-status-update/#licensing-and-sust…

Congrats on the promotion (if that’s what it is), Stachu. I was a big fan of Darklang at one point. It really is 10x easier to use for simple stuff. Reading their recent update, it sounds like they’re aware of the issues. I’m still skeptical that it needs to be a new language. https://blog.darklang.com/an-overdue-status-update/

Typescript won over people who mainly wanted static types I think but not the functional programmers. I think people preferring FP on the frontend are using ClojureScript, PureScript and ReasonML now. Eg here's Dark's interesting story going to ReasonML via automatic translation: https://blog.darklang.com/philip2-an-elm-to-reasonml-compiler/ (ClojureScript ecosystem was always much bigger in any case I think)

F# is nicer than the alternatives if you need to be (or want to be) on the Microsoft ecosystem but there are some things I miss when I use it from OCaml, like modules and functors. It also doesn't support named arguments, which are a fairly trivial thing that drastically cuts down the bugspace and increase usability for me. I also don't think F# is as fast as OCaml? Fairly relevant piece of culture on why a company switched from OCaml to F# https://blog.darklang.com/new-backend-fsharp/

The DarkLang project was originally written in OCaml and was recently ported to F# (https://blog.darklang.com/new-backend-fsharp/) > How much work would it take in term of code rewriting? There are definitely code changes required, but I think those are quite manageable as concepts mostly map 1:1 from OCaml to F#. > can it compile to native code? Yup, https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/ > how good is the language support experience in vscode? Pretty good, https://ionide.io (but I personally prefer JetBrains Rider) > any reason not to do it? Compilation speed, some OCaml language features?

I think they basically made a v1, didn't find product market fit due to some realized issues, and then scaled down the company to just one person still working on it as a result since they have significant engineering work to do before another real attempt can be made at growth. I can't find a good writeup of this anywhere, but you can see the v2 roadmap here which outlines where they are going: https://roadmap.darklang.com/goals-of-dark-v2.html as well as posts here about the F# rewrite: https://blog.darklang.com/author/paul/

That reminds me of https://blog.darklang.com/how-dark-deploys-code-in-50ms/

Hope this isn’t what’s happening with dark[0]. Saw the early demos and I think the concept is killer, and don’t see why they would focus on a rewrite instead of building on what they have. I never even got asked to pay for it before they pivoted? It kinda felt like giving up and going back to building something instead of marketing and selling what they had. I say this with much respect for what they built, and someone who also tends toward focusing on the technical when things get hard. [0]: https://blog.darklang.com/new-backend-fsharp/

He links in the blog to his previous long post explaining why he chose F#: https://blog.darklang.com/new-backend-fsharp/

It's in a separate post, referenced by the 2nd link in the article. The link text is just the word "posts", so it's easy to miss. https://blog.darklang.com/new-backend-fsharp/

Also only one person is working on it - everyone else in the dev team seems to have been let go/fired. https://blog.darklang.com/dark-and-the-long-term/

Semi-relevant: Dark is being rewritten _from_ Ocaml[0]. [0] - https://blog.darklang.com/leaving-ocaml/

OCaml. https://blog.darklang.com/leaving-ocaml/

Ultimately it was a no-brainer to choose F#. Their current code base is in OCaml. Porting code from OCaml to F# sounds about as painful as moving from Python 2 to 3[1], which while painful, is waaay better than a total re-write. F# has much better libraries and ecosystem (because it is built on .NET). Their frustration was with the libraries and ecosystem of OCaml, not its syntax[2]. So, if they switch to F#, much of their core logic remains syntactically the same, and simply needs reworking (rather than rewriting). They also have to retool/call .NET libraries instead of C/OCaml ones, of course, but this is really the point of the move anyway. So: better libraries for what they're doing, not a total rewrite (just a re-work), preserve the overall codebase's structure, less disruption. It just makes good business sense to me. [1]: https://stackoverflow.com/questions/4239121/code-compatibility-between… [2]: https://blog.darklang.com/leaving-ocaml/

I spent some time last night looking at it. Just to affirm what you're saying, there's hardly any information on their frontpage unless you go venturing into videos and blog posts. Dark is basically a language that's designed to be serverless out of the box. They've baked their own engine into the language as well as dependencies for various cloud providers, databases (postgres was highlighted a lot), etc so that you can build serverless applications quickly while having no knowledge of operating systems, infrastructure, or really even computer science. It reminds me of a number of the languages out there that are low-code or no-code. A regular programmer probably wouldn't even recognize some of the syntax and symbolization this language uses. Here's some examples: https://blog.darklang.com/spin-up-a-slack-app-in-seconds-with-dark/ Most of us have probably built a Slack app by now (or bot) so this is a good example to compare with IMO. Dark has a mission of appealing to 1B people and they say the first step is to appeal to developers.

That's a pretty weird takeaway considering the long and detailed post on OCaml's issues that motivated a full rewrite: https://blog.darklang.com/leaving-ocaml/ > One of my biggest annoyances was how often OCaml folks talk about Fancy Type System problems, instead of how to actually build products and applications. In other communities for similar languages (ReasonML, Elm, F#), people talk about building apps and solving their problems. In OCaml, it feels like people spend an awful lot of time discussing Functors. In whatever case, it appears that the author's preference was F# > Rust > OCaml. I don't have a problem with garbage collectors in general, but that's only one facet in deciding a language. There are lots of more important facets, and OCaml fares pretty poorly at these (e.g., tooling, ecosystem, community, pace of improvement, mindshare, etc). And for language toolchains in particular, I wouldn't lock myself into a language with suboptimal performance--it's too hard to back out of that decision later, and it's easy enough to recoup some of that pace of development from Rust by just refcounting everything today if necessary (optimize it later).

Congrats on Dark for making it this far! Relevent timeline: https://blog.darklang.com/dark-announces-3-5m-in-seed-financing/ (2019) https://blog.darklang.com/dark-and-the-long-term/ (2020 - in which the team is fired to extend runway I guess to today) TL;DR: We’re taking a longer term approach to building Dark. As part of this, we’ve made the difficult decision to shrink Dark’s team, and to change how we build both the product and the company." So where do we go from here? Right now, the team is just me. I am committed to realizing the full vision of what Dark should be. Dark is financially healthy for many years, and there is time to think and to plan. I plan to involve the community much more in Dark’s growth, and slowly rebuild the team at a pace appropriate to the product’s maturity, focusing on a small, tight team that can wear many hats. Then there was a pivot to a rewrite of the whole thing, which I think was just Paul at the time: Start of a new rewrite: https://blog.darklang.com/dark-v2-roadmap/ (2020) Two years later: https://blog.darklang.com/backend-rewrite-complete/ (2022) seemingly a new pivot to "all in" on AI?: https://blog.darklang.com/gpt/ (2023) No news, one year later https://blog.darklang.com/an-overdue-status-update/ (2024) Would be interesting to the Dark team to revisit this post, which is a look at PL funding models: https://blog.darklang.com/how-to-fund-caramel/ Building programming languages is hard especially when you're not…