I find myself getting a sort of writer's block a lot more in Dark

[pbiggar]

A user says:

I've been playing with Dark for about 2 days now and would love to share some feedback in the hopes it's valuable to you.

For context, I'm an Architect at ___________, an online education platform for K-8, specializing in Adaptive Math practice. We are entirely Haskell on the Backend. I have been doing Haskell for about 13 years now, professionally for close to 10. I mention this because it seems to be both a benefit and a curse when working in Dark: I can see the types, I can see I'm in some sort of quasi-Monad, but the limitations and leaky abstractions are a constant source of irk for me. So, keep that in mind when reading this feedback, that I may not be your target audience.

The idea's overall execution

The experience demos really well. I can't see this scaling to "real" apps, but I wouldn't expect it to at this stage. I love the idea of just calling the thing, then using the 404 to drive out development. Trace-driven in lower levels has been hit or miss for me: I love cycling through historical calls of the thing I'm working on and seeing how it executes, what's missing IMO is being able to immediately add a new set of inputs to test with right there, rather than having to find some other execution and re-running it (recursively), until you have to trigger some Cron or make some Curl multiple levels above. Sometimes you don't want to re-run with different inputs from that far away, it'll have many other side-effects in any non-trivial application. I guess this is what the REPL is for, but it'd be nicer if I could do it right from the hamburger menu of the Function. I think I might be unique in that I write almost all my code as Functions, with the Handler/Cron/Worker components as just thin layers that call my functions. Functions seem to be the least mature part of this system, so I encounter some pain there. I'm also generally skeptical of trace-driven development when side-effects aren't encoded in the types. It's a little to easy to Replay your fireTheMissles Worker, IMO.

One interesting-or-perhaps-useless thing: I find myself getting a sort of writer's block a lot more in Dark. I think when you strip away all of the inessential complexity, and you don't have any need to exercise craft with your editor, your SCM, your test framework, etc, etc, you're confronted with only your idea and its execution. And it just kind of stalls me out a lot. I'm not sure what to do with this information, I just found it a bit wild.

The editor

I cannot find the words to tell you how much I want to MURDER the structured code editor. I'm sorry, I'm sure you work hard on it and it's absolutely amazing in what it can do. But when it gets in the way, it REALLY gets in the way, and is so frustrating.

If you know how to sketch your expression, from start to finish, from line 1 character 1 to EOF, it's great. You spell it out, maybe leaving some input holes, calling pre-defined functions all the way, and you're guided through to working code. Wonderful.

The second you need to:

1. Move a chunk of expressions around
2. Call a function you haven't defined yet
3. Try to make a let expression into the implicit return, or vice versa
   It becomes a harrowing experience of me trying not to snap my keyboard in half.

As just one rant about example of the kind of thing I run into roughly every 2-3 minutes:

match x
Nothing -> {lots of code structures}
Just y -> {lots of other code structures}

Oh hey, I need that to be

let _ = match x
Nothing -> {lots of code structures}
Just y -> {lots of code structures}

You think you can just put your cursor ahead of match and type "let _ ="? NOPE! Can't be done.

You have to add a new line above:

let _ = match
match x
Nothing -> {lots of code structures}
Just y -> {lots of other code structures}

And then slowly, copy and paste EACH STRUCTURE up into the holes, as you create the new expressions. HEAVY SIGH.

Oh, but now I need it to be:

let _ = match x
Nothing -> let _ = {lots of code structures}
Just y -> let _ = {lots of other code structures}

throws keyboard through window.

Have you ever used Slack's "smart" formatting and tried to convince it to behave in some specific way while it refuses? Or to prevent Confluence from constantly changing your { character into a macro? This is like 10x that "just let me type markdown!" pain.

/rant

I could probably report a lot of bugs in this area, but I'm sure you're aware. This is a super hard problem and I applaud you and I know it'll just take time. But full disclosure: while there's a lot I could say about the DB or type system not being mature enough yet, it's the editor that is going to make me put down Dark for a good long while.

In closing:

I like

1. 404-driven development
2. Versioned functions
3. Smart rename and parameter changes
   I wish
4. I could edit in vim
5. I could organize the Canvas better
6. I could give my Functions a return type (and not have ErrorRail there)
7. All types were available as function parameter types (e.g. Option, Datastore)
8. The type Any didn't exist