Question about your approach: what happens if the code is syntactically invalid? Dark prevents code from being syntactically invalid cause it's AST only, but for example ocamlformat just refuses to run if it can't parse the whole file.
7,962 karma · joined January 26, 2009
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
Question about your approach: what happens if the code is syntactically invalid? Dark prevents code from being syntactically invalid cause it's AST only, but for example ocamlformat just refuses to run if it can't parse the whole file.
We built a structural editor for an OCaml-like language (Darklang). Our first version was very AST-based, with all movement using the AST. The feedback we got was that AST-based editing is hard to grok and that you need line-based editing too. So we re-implemented and now we have both (although we broke and are re-adding a bunch of the editor refactorings).
This is hilarious! Does anyone really believe the pretense that these are multiple different companies?
Anywhere where you're tempted to crash because it's not possible, I add
recover debug_string debug_values return_value
Recover prints a stack trace, notifies Rollbar, and then continues with the return value. As a result, we see whatever is going wrong with the code, but the program doesn't crash on users. And since we're using OCaml (strongly typed), we end up having decent guarantees of safety.Works pretty well for us.
Everything - the editor, semantic analysis, version control, execution engine, everything - all use the same data structures (the same abstract syntax tree).
We use functional data structure everywhere and we do functional updates within the AST all the time; that's even how text entry in the editor updates the program.
Our concept is to allow the decoupling of microservices, with the tooling of a monolith. Kinda hard to describe and we haven't done it yet, but basically give you the ability to write it as a monolith, but also have the separate scalability/deployment of a microservice.
> forcing everyone to chase the same set of SaaS companies
> everyone can read the gridiron of SaaS metrics
There was a perfect storm: huge seed rounds leading traditional firms to move upmarket, VCs raising larger funds and so needing to hit the winners hard, which caused Series A metrics to swell, and so VCs are all chasing the same deals.
Of course those deals don't need them: those companies are already winning and don't need their expertise, just their money, which is commoditized by the swelling of funds.
The answer is simple: chase less successful. Stop just trying to get into the big SaaS deals, and target smaller companies, lower metrics, earlier stage companies.
Of course, if the firm staffed up and raised a larger fund as the article says, then it may be structurally impossible to survive. Innovator's dilemma in action.
I'm super interested in what folks want to use this for?
The first concept we've been calling deployless, and discussed it here: https://medium.com/darklang/how-dark-deploys-code-in-50ms-77...
The second one is just an idea right now, suggestions welcome. The observation is that comments on a particular line of code are spread in as many as a dozen places (a google doc, slack, trello, the code itself, an old version of the same code, PRs on github, comments on commits on github, commit messages, another place in the codebase referencing this one, the docs folder in your repo, another repo that uses this API, your 3rdparty docs on README.io, etc). This is weird and bad, and it must be possible to do better.
Our plan in Dark (https://darklang.com) is to combine all the different ways that people "branch" (deployment, feature flags, git branches, staging/dev/prod environments) into a single concept. And then we also plan to combine all the ways to "comment" (PRs, slack messages, commit message, code comments) into a single concept.
Not sure if you'd call that a git replacement, but it's a displacement of sorts - the function of git is replaced by non-git.
Which is probably why YC is so homogenous.
I think you could address the issue that "readers reacted negatively, even violently, to seeing junk on HN's front page" by making it clear with a special visualization, that this slot is special. You could also add a "report low quality" button which would make that story less likely to appear in the random slot in the future.
You could even add a "show me another" which fetches another random story instead.
So roughly:
- somewhere near slot 5 we add a special "new" slot, visually identified as such
- on each page load, the slot is given to something randomly posted in the last 8 hours
- the slot is different for each request/user, so everything on new gets seen a little bit
The downsides: a bit of a learning curve for programmers used to OO; some classes of problems are easier with OO, though not as many as you'd expect.
The real downside I've seen is that so much valuable information is in academic papers that aren't approachable.
https://en.wikipedia.org/wiki/Douglas_Crockford#%22Good,_not...
I feel confident with my assessment. He showed no indication that he understood the current movement to hold powerful men accountable for their actions. For example, where's the due process for the women Stallman excluded by his horrible behaviour for decades?
Stallman went down for being a creepy perv for decades. He should have gone down for one of the many lines he crossed before today. Eventually, when you give a creep enough passes he'll say something so creepy it's indefensible, Yet here you are trying.
However, the author did not pay the same regard to Salam G., the author of the original post reporting on the most recent of Stallmans shitty proclamations. The author shows no sign of understanding why it's important that Stallman was fired, nor did he show he had done to work to try and get it.
You can safely ignore this. I came away worse for having read it.
Given that, whatever language we'd pick we'd have to hack them to get what we needed, and then we wouldn't have JS (realistically, if we were to pick some existing language it would have to be JS), we'd have some shitty version of JS.
Which is what App Engine did with their early versions: I worked on an app engine project that had a hacked version of Django where nothing worked.
> Have multiple projectional views of the system,
Some amount of this works already (you can see callers and callees, you can see the DB schema); we want a callgraph view for sure, and I like the idea of seeing the handler at the bottom of the call stack.
> Easy example based testing
Yes, this is planned to work similar to traces, and it should be trivial to turn a trace into a test
> History of each function,
Yup, planned
> 'diff' of a snapshot against another one is great.
Planned, but low on the priority list compared to the other stuff you've mentioned.
> Annotations
Planned. We've implemented some grouping (similar concept but obviously different use cases to tagging). Some of these annotations would be automatic or semi-automatic.
> A standard CRUD UI for DBs
Planned :)
> DB/field annotations for privacy
We plan two aspects to this. There is the "PII indicator" which says this is PII and shouldn't be logged at all. Then there's access-control lists where we decide who (if anyone) can view certain attributes (eg: this dev is a contractor, do not show them live values).
Thanks for all the suggestions!