We’re building BLUO - https://bluo.cms a modern multi-website CMS focused on simplicity and performance.
Key features:
- Multi-website management with single sign-on (one dashboard for all sites)
- Static rendering via Cloudflare KV for 100% uptime and blazing speed
- Real-time editor with AI-powered automated internal backlinks
- Theme switching without breaking functionality
We're currently serving 100+ websites. It's completely free for non-profits.
Would love feedback from anyone managing multiple content sites!
This only happens because people treat build code at a lower standard than app code. IMO you should treat all code with the same rigour. From build scripts to app code to test code.
Why write hacks in build tools when you wouldn’t do in your app code.
We build tool code with the same quality as the app code. That’s why most tooling we use are written in typescript: type safety, code reuse…
I would argue the main reason is that Make is just bad. There are easier to use alternatives such as scons or rake that don't have this effect applied to them.
Getting a 260% (and this is a lower estimate) return might be great depending on the duration. If 10 years would be around 26% ROI. I wonder if there is any ETF that invests in all startups.
———-
Calculation below:
To calculate your net return based on the provided percentages and their associated returns, we need to determine the weighted average return for each category. The net return is the sum of all these weighted returns.
Here are the steps:
1. *25% of investments make zero return (100% write-offs)*:
- Return = 0
- Contribution to total = \( 0 \times 25\% = 0 \)
2. *25% of investments produce a return greater than zero but less than 1x (are losses)*:
- Let's assume the average return is 0.5x (midpoint between 0 and 1x).
- Contribution to total = \( 0.5 \times 25\% = 0.125 \)
3. *25% produce a return between 1x-3x*:
- Let's assume the average return is 2x (midpoint between 1x and 3x).
- Contribution to total = \( 2 \times 25\% = 0.5 \)
4. *15% produce a return between 3x-10x*:
- Let's assume the average return is 6.5x (midpoint between 3x and 10x).
- Contribution to total = \( 6.5 \times 15\% = 0.975 \)
5. *10% produce a return of 10x or greater*:
- Let's assume the average return is 10x (the minimum in this category).
- Contribution to total = \( 10 \times 10\% = 1 \)
### Total Net Return:
Summing all the contributions:
\[
0 + 0.125 + 0.5 + 0.975 + 1 = 2.6
\]
So, your *net return* is 2.6x or *260%* of your total investment.
This means, on average, you would get 2.6 times your initial investment overall.
> Once you have less skin in the game, it is easier to make bad decisions. The author argues this is due to a) having a capital buffer to cushion you, and b) having more time to waste.
It’s not wrong per se but worded to hide the benefit. Having less skin makes it easier to take higher risk. Which means more “bad” decisions but also with higher potential.
———-
While the prepayment strategy described here is interesting, I'm skeptical about some of the claims and implications. Here's why:
> So how much should they discount it? So let's say we're going to buy steaks. We're going to pay $34 a pound wholesale for dry aged rib-eye, we get net-120 (normally). So I call the guy and say "I'm going to use 400 pounds of your beef a week for the next 4 months, for our menu, which is about about $300,000 of beef, what (would) we get, if we prepay you?" And he was like "what do you mean?" I'm like "I want to write you a cheque tomorrow for all of it, for four months." And he was like, "Well, no one has ever said that." So he called me the next day, he said "$18 a pound" … so … half. Half price.
1. The 50% discount seems implausibly high. Even considering the benefits of prepayment and volume commitment, typical early payment discounts in most industries range from 1-5%, rarely exceeding 10%.
2. The story implies this strategy reduces waste, but the restaurant's beef consumption remains unchanged. The butcher isn't selling more beef overall, just securing a guaranteed sale for a portion of their product.
3. While prepayment does reduce risk for the supplier and improve their cash flow (which justifies some discount), it doesn't fundamentally alter the supply-demand dynamics or the perishable nature of the product.
4. If such extreme discounts were readily available, it suggests either highly inflated initial prices or an incredibly inefficient market. In reality, these price disparities would likely be arbitraged away quickly.
5. The net-120 terms do carry risks (default risk, cash flow pressure, inventory carrying costs), but it's unlikely these factors account for such a large portion of the price.
The principle of prepayment providing mutual benefits is sound, but the magnitude described here is likely overstated or oversimplified. A more realistic scenario might involve a combined discount of 20-25% at most, factoring in prepayment, volume commitment, and possible seasonal factors.
This story, while engaging, highlights the importance of critically evaluating business anecdotes, even from seemingly authoritative sources. The restaurant industry certainly has room for innovation in supply chain and financial practices, but the impacts and benefits may be more nuanced than presented here.
I don't think that is correct. HTTP is managed by applications, but TCP packets are managed in the OS kernel. That distinction determines your options of approach and how things interact when parsing transport negotiation mechanisms.
What the other user says is that maybe those companies will only let 1 device per account to be registered. So you can’t have 2 devices to login. Harder to share.
In this case, Google, that isn't true and just they're mostly treated as special Security Keys ("yubikeys" etc).
To limit it to just one defeats the purpose of all this work. You really will only see that where there is a technical limitation (like... why does AWS only allow a single hardware key per user? If you setup SSO then you can have any number of keys)
But it's not that simple, for an example I have older personal projects as well which I'm unable to run without doing considerable changes to the code after moving to M1 chip.
Just because I'm unable to run older versions of node and thus unable to run some of the dependencies and thus need to update the dependencies and then the code etcetc.
Yes, I could use docker and containers...
Yes, I could use Rosetta...
Exactly. Dependency hell is easy to avoid by avoiding dependencies. Modern JS with modules and classes is really good for simple projects, esp. prototypes that don't have to work everywhere. No framework, no special utilities that all have their quirks. And no packaging either. Much, much simpler this way.
Likewise, concurrency stops being a problem if I avoid threads and async as much as possible.
I'm starting to feel old now that I can no longer pretend I've only got two threads, network and UI, where everything is fine if I wrap the network response with "do on main thread" and crashes reliably and instantly whenever I forgot.
This comment here is exactly the problem with JS people.
If you are making a big thing out of learning(!) cmd(!!!) then you shouldn't be working in software development, period.
7 years is a flex only in a JS world. As others mentioned, try 35.
