2,024 karma · joined December 20, 2015
The book ends.
You may be engrossed for a while, or a long while, or even a very long while, but eventually you get bored. You have to close it for a while and look around, or talk to someone, or just sit there.
A phone with internet is infinite. You get bored of (a) and then you can go to (b) then (c) then back to (a) for hours and hours and hours and hours on end.
This means you don't have to code defensively: if your code crashes, it's ok.
This is important because in erlang/elixir you have pattern matching, which allows you to code declaratively. Example:
Imagine you have a function that expects a two-element list, `[a, b]` and then adds them.
In elixir, you could write the function this way:
``` def add([a,b]) do a+b end ```
Note that the program will crash if you call: `add([1,2,3])` or `add([1])`.
In other words, you can write code such that the shape of the code matches the shape of the data.
If the data looks any other way than the expected one, it will crash. But this is a good thing! It's better than operating on data that has the wrong shape, and thhe OTP architecture should restart the process intelligently.
Since tweets have no title, I followed the convention used in poetry where a poem with no name is referred to by its first line.
I guess technically then I should have titled the post [A crazy experience — I lost my earbuds in a remote town in Chile].
Its addition into the next minor verision (1.17) will bring warnings that address some of the most common footguns in the language, like comparing structs.
If you have a parallelizeable workflow, it's very easy to make it (properly!) parallel locally, where by "properly" I mean having supervision trees, sane restart behavior, etc.
And once you have that you can extend that parallelism to different nodes in a network (with the same sanity around supervision and discovery) basically for free. Like, one-line-of-code for free.
Nonetheless, it's all message-passing, and so pretty high level. AFAIK it's not designed for parallelizing compute at GPU scale.
That being said, if you have multiple GPUs and multiple machines that have to coordinate between them, Elixir/Erlang is pretty much perfect.
But for purposes of global warming, you care about the total amount of carbon in the air. The cumulative sum. The integral.
If a company becomes profitable today, it survives.
If emissions were to magically stop today...warming continues!
A lot of feel-good articles and tweets will often talk about the plummeting costs of solar, or how the share of renewables is higher than ever, or stuff like that, which is, from a global warming point of view, absolutely irrelevant.
The only thing that matters as far as warming is concerned is how much CO2 is there in the air. The cumulative number. It doesn't matter if the growth is slowing, it doesn't matter if there's more solar than ever, etc etc.
So yeah, we're producing more clean energy than ever, but we're also using more carbon than ever.
[0]: https://ourworldindata.org/grapher/annual-co2-emissions-per-...
Basically, when we talk about a substance's temperature, that temperature is the average temperature of the system.
Temperature is just "how quickly are the atoms/molecules here jiggling?" When the atoms/molecules collide, some of them speed up, some slow down. That means that some atoms are "hotter" than the average temperature, and some are cooler.
Liquids have a certain energy above which a molecule is ejected from the puddle. This is evaporation.
Even if the average temperature (read: energy) is below that threshold energy, some molecules are moving faster, because they have collided with other molecules in just the right way. Those fast molecules get ejected. Evaporation!
But now that the puddle lost the fast (read: hot, read: high energy) molecules, the average energy of the system is lower. The whole thing cools down!
In dry environments, it's possible for sweat to evaporte (cool) at a rate that is faster than the rate at which your body heats up from hot colliding air.
In humid environments two things happen: evaporation slows down, and you heat up faster.
So there is a combination of temperature & humidity at which, if either of those parameters is exceeded, you gain heat faster than you lose it.
Pre-empting the accusation that "cayman companies are about tax dodging": Cayman companies are a great fit for heavily international businesses that do not reside in the USA, but that want to be governed as if they were, because cayman corporate law is basically delaware's.
A good example is Nubank, which is a cayman corp that does most of it's business in LatAm.
The reason a company like this should not be a delaware c-corp is so that, in case of an acquisition of the companies assets, the holding company doesn't have to pay usa taxes (which is reasonable, since the company didn't have usa operations to begin with).
There are a few principles that I think can be helpful here:
1. The vast, vast majority of work remains to be done, and the vast majority of value your startup will have has not yet accreted. Unless your startup depends on some like critical patent or something I'd wager that 90%+ of the value is yet to be created.
2. At exit, a person's equity ownership in the startup should be roughly proportional to how much they value they helped accrete over the life of the company.
3. The above is the only thing that matters. Opportunity cost, professional reputation, relationship status, prior experience—all of those are irrelevant. The only thing that matters is contribution to the value accumulated by the startup over its lifetime.
Unfortunately, most big equity decisions are taken at the beginning of a company's life, not at the end--where most of the information needed is not known!
Because of that, no matter what you do, you will probably end up with something that is significantly far from optimal. There's just not enough information. Tough luck, them's the breaks, that's the price of success.
However, there are a few things you can do now to help guide the process:
1. Agree, explicitly, to the above principles. That is key.
2. Agree, explicitly, to everyone's role and responsibilities over the next year.
3. Given the above, distribute equity in a way that is simple, broadly aligned with the stated principles, and probably over-indexing on "fairness" than accuracy. It's better to make other people a bit richer than they "deserved" and be happy than the opposite.
4. Make sure that everyone's equity has a vesting schedule. The longer the better. 4 years is standard but honestly a bit too short when in the current world startups exit after 10+ years.
5. So that might look (at very first approximation) like you and your cofounder starting with 35% each and your new cofounder with 30%, or 40-40-20, or something like that.
5. Get to work.
Good luck!
Decarbonization is the best thing to do by a large margin, both in a cost-benefit sense and in a net impact sense. It's stupid to burn coal to produce $X worth of electricity and then spend many multiples of $X just to remove a tiny fraction of the carbon.
But you're also right that decarbonization won't occur in the amount required by 2060.
Which, quite frankly and plainly, just means we're fucked. Not even going into positive feedback loops of natural methane emissions due to warming arctic and tropics.
The lack of discussion about LiveView tradeoffs is one of the few things I actively dislike about the Elixir community: and I love elixir and reach for it for almost everything.
1. A tech stack that isolates crashes such that they do not affect the rest of the system. Example: you receive a malformed API response. The code responsible for parsing it crashes, but the rest of your application does not.
2. You use this to code in a declarative style.
Coding declaratively means your code has the shape of the data you expect to have.
Example (in elixir):
Let's say you are calling an external API where you expect to get back a list with a single element.
If you code non decleratively, your code might look like this:
thing_i_want = List.first(my_api_response)
Now imagine that for some reason the external API sent you a list with two elements. That code still runs! It doesn't crash, but you are now in a strange state. The data you are passing into the system is unexpected.Coding declaratively you would write:
[thing_i_want] = my_api_response
In that case, if for whatever reason the external API sends you a list with more than one element the code will crash. In BEAM languages that is fine--the rest of the application should be ok, and you should log why you crashed and when, so you can look into it, but you are not ingesting bad data into the system.The alternative is to code defensively: check the lenght of the list before extracting the first/only element. That works, but it tends to be very verbose and more importantly it means the entire call stack needs to be aware that you might get exceptions bubbled up from anywhwere.
Of course, for this to work you need software that has lightweight processes and a supervisor architecture..not usually worth it unless you're getting it for free! (as with elixir/erlang).
It's "just another machine," but that's not obvious when you're setting it up! Two bits of documentation that are lacking here are:
1. How does this affect billing, especially if you're on the hobby plan? (Answer, as far as I can tell: since it's just another machine, it can be free if and only if you resource it such that it fits in your free "allowances." The defaults are NOT these, however, so you have to be careful if you want to mess around for free).
2. Once the db machine is created...how can I get credentials for it? A connection string is generated upon machine creation but...what if you don't write it down?
Very impressive, but also slightly worrying since some parts of fly.io have such terrible DX/documentation. I've only recently started using them, but the documentation around billing and databases is shockingly bad for a team that is clearly so deeply stacked.
However, as much as I hate the Sacklers, I have to pipe in here out of a respect for the truth (Gell-Mann Amnesia style).
The Purdue bankruptcy was not some sort of Machiavellian "get out of jail free" card. Rather, it is what is normally done when there are so many lawsuits on a company that it is likely they exceed the value of the company itself.
Everyone who sues and wins against Purdue will become a creditor of the company. But they will be owed much more than the company is worth. So who should get paid? The first person to sue? The last? The one worst off?
Parceling out the assets of a company among its creditors is the job of a bankruptcy court, and that is why Purdue declared bankruptcy preemptively. Not to screw over the creditors, but rather to protect them so that a judge can decide who gets what.
This is standard operating procedure when a company believes there are more creditors than it can pay, even if the creditors have not filed suit yet.
There are certainly horrible things about the way Purdue has been handled—chiefly among them that the members of the Purdue family are not being criminally prosecuted—but the whole bankruptcy thing is not one of them.
I would suggest reading Matt Levine's analyis of the whole debacle, both "The purdue bankruptcy didn't work (2021)" [0] and the follow up "Purdue Pharma's Bankruptcy works now (2023)" [1]
It meant admitting to myself and our team that we had fucked up and miss-executed.
It meant giving up on a dream and market opportunity that I thought--and think--is still fruitful.
So deciding to quit was very difficult. And in general I'm a pretty tenacious guy, I hate giving up.
I didn't have to quit. I could have kept going in some diminished form. But the reason I decided to quit is that I had started to do damage.
I was doing damage to my health. I was doing damage to personal and professional relationships. Damage understood not as "pain" but as "an irreparable worsening."
So my advice: quit before you start to do damage.
I'd say that advice applies to most endeavors. Push through the pain, but quit before the tendon pops.
Which tire wears down more:
A tire that rolls around a circle of circumference D.
A tire that rolls down a flat surface, total distance D?
The difference between a coin lasting a thousand (10^3) years and 100 million years (10^8) is five orders of magnitude.
That's the difference between 1,000 years and...3 days.
"I collect sandwiches. I have some that are 3 days old and in excellent condition. I expect that in the right conditions one could last 1000 years"
Namely:
- we know a mechanism that causes global warming, which is empirically proven and theoretically backed.
- multiple scenarios of positive feedback loops that result in rapid warming
- very few ideas even for positive feedback loops that result in cooling
- little to no demonstrated political will to act decisively.
Seems to me like we know a lot!
An increase in plant growth could be one, but methane is sooooo potent that we're kind of screwed--you can pump an arbitrary amount of methane into the air but foliage is pretty limited in area.
https://www.nature.com/articles/s41598-021-00555-5#:~:text=I....
Says who? We've been parroting the opposite message ("there's still time! go solar! electric cars!") is CLEARLY not working.
I'm a climate change doomer, in that I'm certain our children will live in a very different world than us, and there's a real (10%+?) chance of total environmental collapse in our lifetimes. The positive feedback loops are inescapable.
The science is the science...who are we to lie to people hoping that the lie somehow inspires mass coordinated change?
"Rubber ducks float because they are made of a material less dense than water" both is wrong but sounds reasonable. Call it a "bad grade school teacher" kind of mistake.
Pre-gpt, however, it's not the kind of mistake that would make it to print: people writing about rubber ducks were probably rubber duck experts (or had high school level science knowledge).
Print Is cite-able. Print perpetuates and reinforces itself. Some day someone will write a grade school textbook built with GPTs, that will have this incorrect knowledge, and so on.
But what will become of us when most gateways to knowledge are riddled with bullshit like this?