[1] https://www.heavybit.com/library/podcasts/to-be-continuous
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
[1] https://www.heavybit.com/library/podcasts/to-be-continuous
Suppose I use 10TB of storage, and then later I delete all but 100GB of storage. Will I be paying for 10TB or 100GB?
But I had previously had experience with OO languages - Java and C++, and they often had similar challenges, though not quite as pronounced, along with problems of their own.
Eventually, I came to realize statically typed functional languages were the panacea. Sum types offered better composition than OO, and they had a good trade off between power/succintness (coming from higher order functions) and program understanding. In particular, the problems from other languages: what code is this, what type is this, where did this nil come from, were solved.
The "main" site also has many subcommunities in many languages: https://lemmy.ml/communities
(ps I literally found this an hour ago, so I don't know much about it)
- 2022 bonus and PTO paid out
- accelerated vesting
- 6 months of healthcare.
This is a phenomenal severance package and I hope one that will set the standard for companies doing layoffs. So many companies in the US do two weeks or less, with nothing else (not even healthcare) or even use it to claw back shares.
I'm curious what shuttle does once your app is deployed? Is a container cloned with the app injected, then connected to a load balancer and left running? In Darklang we just keep the AST in the DB and fetch it each request, but at some point we'll want to do better.
I don't believe we have product market fit yet, the plan goes like this:
- rebuild the technical foundations (DONE)
- fix a lot of the jankiness in the editor <- we are here now
- make sure language is fully baked (coming soon)
- add a package manager/user management
I think the last step is where we'll start to see some product market fit.
Originally, I thought a structured editor would be essential, but now while it's helpful, I think AI assist can do like 90% the benefit you get.
It probably took longer than it had to: 30% of that time was devops, I wanted it to be bug-for-bug compatible so I spent a lot of time writing tests, and we were using some stuff which wasn't mature yet (new JSON serialization lib, compile to webassembly, binary serializers)
F#/.NET certainly has everything needed, and I find it a much simpler language than OCaml (eg no module games) - really it's what I hoped OCaml would be.
I think your view on of crypto might be skewed by this. I think working in coal or surveillance tech or fracking is bad, and that isn't changed by the fact that it is someone's best chance at getting rich from it.
Note that most programmers didn't get rich out of social media or the boom from the last decade: maybe 100,000 became millionaires out of 20 million programmers, most of whom had generally middle class salaries
What's happened here is that they (and you'll see this has happened across a lot of the extreme right in America) have started to label trans people as "pedo" or "groomers", in an effort to make it seem like trans people are really child predators, which makes many people more tolerant of their attacks and more sympathetic of anti-trans policies such as bathroom bills.
Use some of the money to go to therapy, both individual and couples. If you go soon enough you might save your marriage. Either way, it's probably the best investment in yourselves that's available.
*Depends where you are but certainly true in California
a) deployments are getting complex enough that it's hard to get dev environments locally
b) it's cheaper and quicker to pay for cloud development machines anyway
c) things have enough scale that local development doesn't match production anyway
Saw this on twitter recently which supports this a bit:
I think the problem is that things we're building stuff to solve specific problems, and then expanding each of those tools until they become massive and need other tools to help them. So docker solved a problem but then it created problems that you need kubernetes for, and so on.
One of the reasons I'm working on darklang is that I think the root cause of this complexity is solvable. The solution, in my opinion, is to build tools that cover multiple layers of the stack - that removes join points where you might be tempted to customize.
For example, firebase covers multiple layers, you might otherwise need a DB, a connection pooler, a firewall, an api server, an autoscaler for the api, a load balancer, etc. But instead, the only surface area you have is the firebase API. There's lots of similar tools that cover multiple layers of the stack like this, netlify, glitch, darklang, netlify, and prisma are some examples.
In fact, it makes it so easy to add new stuff that I didn't even realize we had 21 services til I counted. My first guess was 12.
If you are accessing just one item, the O(logN) cost is likely dominated by some other cost (eg the user clicking a button, making a web request, etc).
The first problem is solved in every functional language I've used (clojure, F#, OCaml) by immutable data structures (aka purely functional data structures, which is also the name of the de facto book on the topic, which is excellent but also you don't need to know any of this to use them. [1]). I'm surprised to see this critique without a mention of this.
The second problem seems to be due to trying to do OO in FP. The thing is you don't have a glyph, you have a whole system which contains glyphs. So you can't do an update on a glyph because it won't update the system.
This is a common frustration when you're used to OO and can be really annoying in FP but it's also part of the design modelling that FP forces you to do: the problem was that he was modeling in the small and not the large.
The solution is not the 1, 2, or 3 from the article (1 and 2 are bad, 3 is not as bad but not FP), but is straightforward. When you want to update a glyph, you use a function like `updateGlyph(pathToGlyph, functionToExecuteOnGlyph)`. That's at the top-level, and it allows you compose your lower level `updateGlyph` functions.
[1] https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.64...