839 karma · joined April 19, 2012
1) Everyone in the world gets the same puzzle every day
2) The "share to Twitter" message just shows the green/yellow squares, so it shares your journey and teases the puzzle, without spoiling the answer.
Almost no one had heard of Lingo/Wordle before this, now they have, so that counts for something.
At the end of the day, if you're running code that you didn't write or verify yourself, you're taking on risk.
IMO the next hugely successful package manager (in whatever programming language) will be the one with a really good capabilities model, so you can run untrusted code with much less worry.
In other words.. If there isn't a trusted test pipeline then there's no benefit in delaying the latest version. Might as well just get latest.
Another thing about setting exact dependencies is reducing duplication. Libraries are encouraged to use loose ranges, because if everyone pins exact versions for every dependency, then you could end up with 10 to 20 different copies of 'colors' in your tree, instead of having just 1 or 2 copies that work across the board.
It definitely uses a lot of network-theory language so it reads like a foreign language to me (in a good way).
If we're talking about code monkeys, devs who just take in requirements and churn out code, then no, there are no 10x code monkeys. At best the senior devs are like 3x better.
If we're talking about developers that are also planners and trailblazers, devs that understand the business needs, and are constantly thinking about how to leverage their own tech knowledge and the company's assets to get maximum business value for minimum effort, then yeah there's definitely 10x engineers. Arguably there are even 10000x engineers (thinking about those startup entrepreneurs that created working prototype apps that grew into multi-million dollar businesses)
Before people get mad that Facebook is trying to control the truth, don't forget that their algorithms already manipulate the news and it's been happening for years. Their algorithms prioritize user engagement, which means prioritizing news that provokes conflict and fear and conspiracy. That creates a huge bias, it makes people feel like the world is much more divided and dangerous than it really is.
That's a problem that's on them to fix, and the solution is probably more curation not less. For them to get it wrong on the man-made theory, that's one of the less harmful things they've done so far.
You could set up a plausible history ahead of time by doing innocent TSLA trades. Maybe establish a pattern of regularly scheduled trades. And then it just so happens that the fake tweet comes out right around when your scheduled trade was going to execute.
Click through each test and read through some of the descriptions. They do a lot of advanced techniques that are important for web performance.
Those optimizations are another big part of why modern Javascript build tools are so complicated. There's no other language where we care nearly as much about optimizing for code delivery. On the web, a frontend app should (hopefully) be around 100k of Javascript bytes, and it should have good caching and CDN behavior. Compared to other platforms where 10mb to 100mb binaries are considered just fine.
If we measure success by the amount (not the percentage) of high-quality packages available, NPM is easily the best package management ecosystem yet. But there's definitely room for improvement.
One major improvement I'd like to see is some solution for unwanted indirect dependencies. If I depend on package A, and A provides features X and Y, and I only need it to do X, and the code for doing Y depends on package B, then it shouldn't download B. The recommended solution is to split up A into a family of packages (like lodash's per-method packages), but that just creates a mess of versioning that's annoying for both the authors and the consumers. And those massively-multipackage libraries (like Babel) just seem to create dependency hell situations that semantic versioning is not good enough at solving. So maybe instead of package splitting, the next-gen package manager could have first-class understanding of ES6 modules, with tree-shaking logic to prevent unused indirect dependencies.
But even with Tesla it's not 100% crystal clear. There might be some buyers who pick Tesla specifically because of the fancy tech features like Summon mode. It's impossible to use Summon mode without the app. So for one of those buyers, the app is an essential part of the purchase, just like HEY subscribers who expect to read emails on their phone.
"Making your bed will also reinforce the fact that little things in life matter. If you can't do the little things right, you will never do the big things right."
"If you want to change the world, start off by making your bed."
No one really thinks that renaming "master" branches is going to save the world, or really, do much of anything. I'm going to do it because it's a little thing that takes less than a day. After that I'll move on to something else.
Instead of a box-and-lines diagram, I think the stuff that people really want is:
- Structured editing. Valid change operations are obvious (maybe listed in a menu). No invalid states.
- Cross-cutting connections are explicitly displayed (with lines or arrows or etc) instead of being implicit.
- UI does a better job of highlighting just the relevant information and hiding everything else.
- Overall more simplicity. As in, I think some people imagine that their thousand-lines-of-code project could be fully represented as a few boxes and lines with labels. There's some unrealistic expectations tied up in this area. But simplicity is still a good goal.
Those are all good goals and there's different approaches to solve them. A lot of those asks can be solved by keeping the text document interface and adding enough cleverness on top of that (like EVE / LightTable). And there's other visual systems other than boxes-and-lines. People just need to think outside the box. (ha ha, sorry)
Although this year, Microsoft came out with Teams which is just as good IMO. So we finally stopped using Zoom here.
Also it's not just asymptomatic cases, it's also symptomatic but not tested. Some people ignore it since it can present as a minor cold. Some people want a test but can't get one.
If we assume that the growth chart is similar everywhere, then with our 1,000 confirmed cases in the US, we probably have around 30,000 unconfirmed dark cases.
Also a really crazy fact is that South Korea did a good job of containing 30 out of 31 of their initial cases in the early days. But then the 31st was responsible for thousands of infections.
At some point, if a human error is common enough, it makes pragmatic sense to change the design so the error is impossible.
I'm skeptical if the situation would be better without an app store. The app store provides monetization and that leads to higher quality apps. I think what we'd really want is for iPadOS to open up to more integrations, like an integration app that offers a different home screen / app switcher / task manager experience.