Dark Blog

Dark founder here. Many people remember writing directly on the server quite fondly, because it had a great turnaround. But we stopped doing it because it wasn't safe. Dark makes it safe [1], so you can start doing it again. [1] https://medium.com/darklang/how-dark-deploys-code-in-50ms-771c6dd60671

EDIT: Ha. My apologies as I just realized my stupidity - I was browsing on mobile and it turns out out I jumped into the 'What is Dark' post [1] and never finished the original! The mailing list links are in that one - I subscribed. This is a lot more interesting, cheers :) [1] https://medium.com/darklang/the-design-of-dark-59f5d38e52d2

I think the point is about far shorter feedback loops than possible with today's pervasive tech. > something even more continuous than continuous integration. It might look like real-time integration of your changes, collaborative editing, or smarter build systems that produce near-live feedback e.g. https://medium.com/darklang/how-dark-deploys-code-in-50ms-771c6dd60671

Or port over to bucklescript-tea (a port of the Elm architecture to the OCaml-to-JS compiler BuckleScript) using the Philip2 migration tool, which was announced almost a year before OP was published: https://medium.com/darklang/philip2-an-elm-to-reasonml-compiler-a210aa…

Its not necessary to speculate, the blog post about moving away from OCaml specifically talked about cloud provider SDKs (AWS and GCP): https://medium.com/darklang/leaving-ocaml-fce7049a2a40?source=rss-56c9…

Dark is another startup that wrote an Elm to OCaml translator[0] after a previous language update broke their code[1]. [0] https://medium.com/darklang/philip2-an-elm-to-reasonml-compiler-a210aa… [1] https://lobste.rs/s/1jftsw/philip2_elm_ocaml_compiler#c_hahlj8

How Dark deploys code in 50ms: https://medium.com/darklang/how-dark-deploys-code-in-50ms-771c6dd60671

Looks like one thing the infrastructure doesn't automate is using the right SSL certificate: https://hellobirb.com/ (that company is an early adopter mentioned in https://medium.com/darklang/dark-announces-3-5m-in-seed-financing-d64a… )

Should probably replace with the first-party article: https://medium.com/darklang/dark-announces-3-5m-in-seed-financing-d64a…

This is hardly "emerging from stealth". This was a blog post from February! https://medium.com/darklang/the-design-of-dark-59f5d38e52d2

I don't get it. I tried to find out anything about what Dark is, how it works, or what it looks like and found almost nothing. They make claims like "holistic programming language" but don't show me what they mean. The What is Dark[1] blog post makes a lot of claims, but I've seen these claims made many times and they rarely live up to the hype. They don't show me how they plan to meet these claims or what it looks like. Finally, their marketing focus is on deployment, but honestly, deployment really has never been the biggest pain point for me. Sure, it can be a headache, but its nowhere near as much work as actually writing the applications themselves. I'm not convinced. [1] https://medium.com/darklang/the-design-of-dark-59f5d38e52d2

It seems that Dark is designed to allow you to wrap external APIs in easy-to-use interfaces, so it should be at home as part of a larger SOA or ecosystem, of course with the caveat that it's still being developed. See the footnote at https://medium.com/darklang/dark-residency-7dbc878a5f0a .

> Instead it tells you exactly what errors can happen at every point in your code. Once you have your initial prototype/algorithm figured out, you can use that information to handle all the edge cases. While I can't say much about Dark (the available blog posts [1] are shallow), I do think that the automation may be one key aspect of future programming languages. For example, when I'm thinking about gradual typing I don't only want to mix the hodge-podge unitype and actual types but also convert the former to the latter, and a large portion of the process can be automated in various ways (for example, one can track the typical runtime types that unityped variables have; the programmer can solidify compile-time types using that fact). [1] https://medium.com/darklang

This is a really interesting take on the Silver Bullet argument - Brooks is right that big gains in productivity are only gained by reducing accidental complexity but he was wrong about how much accidental complexity there still is to reduce. I think most Software Engineers probably suffer from some cognitive bias in trying to estimate exactly how much accidental complexity exists that could be eventually removed. We tend to think about incremental improvements to tools and processes rather than thinking at a higher level about improving the overall process of translating business requirements into working software. Even with much better tooling and languages (i.e. #F, Git, AWS, etc) there's still a lot of fat that could be trimmed. I'm excited to see what the wold of low-code will do to our current assumptions about how much accidental complexity there actually is. Maybe projects like Dark[1] could actually achieve the order-of-magnitude gains that Brooks was convinced wouldn't be possible. Sure, there's no panacea, but maybe we're round the corner from a genuine "Silver Bullet" in the sense that Brooks actually meant. [1] - https://medium.com/darklang/the-design-of-dark-59f5d38e52d2

Not sure I'd want to be writing services I depend on in a language whose priority is ease of prototyping. In his post, Real problems with functional languages [0], Paul Biggar creates a false dichotomy: static types help us to write correct programs while dynamic types let us prototype faster. Dark wants to be able to do both. I believe Haskell allows us to reject outright incorrect programs sooner and allows us to prototype things faster due to its types and inference engine. I don't really see how Haskell is poor as a prototyping language. From experience it's better than dynamic languages as it has allowed me to focus on logic and domain problems instead of mucking up my code with brittle run-time and equality checks... and then chasing down bugs I've made for myself. No where is it mentioned what type system Dark is using. Will Dark allow a program to be deployed that it cannot reason about? What about higher-kinded types and polymorphism? Does it enforce termination or is bottom a type in every kind? Does the type system enforce linearity in usage? Quotient types? Row types? This looks like a cool project but I don't think I'd use it for anything without knowing more about how it works. [0] https://medium.com/darklang/real-problems-with-functional-languages-ef…