Methane has 28% more energy per kg than kerosene and also produces slightly less CO2 (2.75kg CO2/kg burned vs 3.00 for kerosene) when burned [1]. SpaceX uses a 78:22 LOX to CH4 ratio, so for 34M kg of fuel burned, 20.57M kg of CO2 are produced (34×0.22×2.75).
Somewhat tangential, but as far as rocket fuels go energy per volume is also an important metric to consider. It's one of the (several) reasons hydrogen isn't quite as good for rockets in practice as it is in theory - while hydrogen has tons of energy per unit mass (120-142 MJ/kg for hydrogen vs. 50-55 MJ/kg for methane and 43.1-46.2 MJ/kg), it has a far lower density (70.85 kg/m3 vs. 422.8 kg/m3 for liquid methane and 820 kg/m3 for kerosene). As a result, you need quite a bit more tankage for a given amount of energy from hydrogen compared to what methane/kerosene requires.
IIRC there's a tradeoff between efficiency and thrust as well. Heavier fuels aren't quite as energy-efficient, but it's easier for them to develop a lot of thrust, which is important for the initial stages of launch. If I'm remembering events described in Ignition! correctly this led to "thrust density" being something that was optimized for - to the point that there were experiments with mixing mercury into the fuel!
I think as long as "feature flag entitlements" are seen as distinctly different from what engineers usually use feature flags for (small incremental changes of individual components, testing, roll-outs, A/B testing) they can work well. An entitlement should have a clear link to a customer-facing feature, which are conceptually much larger blocks of functionality. One difficulty with this approach is that you still have to take into account a lot of billing-related aspects, e.g., handling customers in arrears, overage charges if they go over a certain limit, having different pricing models for the same feature, or resetting/carrying over usage counters on plan changes/upgrades - this can add a lot of complexity over time!
That's why we decided to offer separate feature entitlements that are tightly coupled to the billing chain and metering as part of Wingback (disclaimer: I'm the CTO). In the end, depending on your plan complexity and how much you have already invested in feature flags, I think both approaches can work well. Having some kind of feature gating in place for your customers will also make your life a lot easier for provisioning customer accounts and being able to offer custom packages.
My experience has been that there are typically two types of engineers: those who have worked on billing systems before and those who haven't.
I think a lot of the issues arise from the difference between payments and billing [0]. When just starting out and signing up your first customers, you primarily care about collecting a few (recurring) payments - and it's really easy to set that up with Stripe (or even just manually invoicing your first customers).
However, over time, more billing requirements gradually sneak in, such as more complex entitlements, multiple plans, grandfathering, and eventually enterprise/high touch sales customers (where the money is!) who need custom billing cycles, terms, and entitlement provisioning. Since billing is never a technical focus, numerous additions and small hacks accumulate over time, taking engineering resources away from the actual product. Eventually, this turns into an unmanageable mess that can significantly slow down the sales process or limit what you can sell.
The complexity of billing is riddled with hidden pitfalls and edge cases, and it has become even more complex now that most plans include many different limits and usage-based components and that most SaaS companies sell globally. Many later-stage companies have teams of 15+ engineers working solely on billing. I fully agree with the author that, unless it's at the core of your product, no organization should build a billing system themselves (Disclaimer: I'm the CTO of Wingback, a SaaS Billing Platform).
Been using them on the paid plan for a 1yr+ and apart from working great and reliably I've been really appreciating how no-nonse and to the point their communication has been. Never realized it's also OSS, thank you for pointing that out!
Really easy to set up too, just make sure to also set up DKIM/SPF/DMARC to make sure the forwarded emails don't go to spam.
> If you know a site has a 4-words policy, the xkcd pw has very low entropy, but if you use this strategy on a "any pw goes" site, a bruteforcer would have to test all lengths upto 25 chars before finding yours (sort of).
How so? Iirc, the entropy calculations assume that the attacked is aware passphrases are used. The eff-long word list often used for xkcd-style passphrases has 7776 words. So on average it would take 7776^4/2 attempts to guess one (randomly generated) 4-word passphrase, comparable to a truly random 8-9 character password with special chars. As the comic points out, people tend to be pretty bad at remembering random sequences of characters and therefore often often use combinations of common words and apply non-random substitutions and patterns, resulting in much lower entropy for those passwords.
Of course, everyone should use a password manager in the first place, but for cases where people don't or they need to reliably remember it (master passwords and critical ones), xkcd-style passphrases are a good and secure option.
Have the guides been updates yet? I created my first one but it wasn't obvious whether things like pkgrel should be increased as part of the MR (I assumed not) and in what format to submit them/which information to include in general.
[1] https://www.engineeringtoolbox.com/co2-emission-fuels-d_1085... [2] https://x.com/elonmusk/status/1298426245991063554?lang=en