6,755 karma · joined August 18, 2008
I think it's reasonable for people to wish that more of user-facing software worked this way, even though it's out of sync with how Silicon Valley and Venture Capital tend to work.
Here's a key paragraph:
> I am not solution-oriented. I don’t see a problem and get giddy at the idea of solving it, patching it up and sending it on its merry way. I want to poke it and ask it questions. Where did it come from, what is it doing, what’s its story? I want to take it to tea and hear about its life and understand it to its core. And if, at that point, I’ve come to a wholistic understanding and am able to solve the problem, by all means, let the problem-solving commence! But my instinct is never to solve, but to understand.
This is not a statement of perfectionism, but rather a deep yearning for like-minded people who believe in trying to understand the problems they're trying to solve.
The RFC process, which has gained more prominence through projects like Ember, Rust, Swift, and Yarn, operate on the same principle: that we should try to make sure we understand, not just rush in with the first solution that comes to mind.
Iteration and contact with reality are important. A desire to understand is not in conflict with a desire to iterate and work with communities. But too often, the tech community makes a virtue out of moving fast, breaking things, and never coming to a deep understanding even in many of the most successful cases.
I think we owe it to ourselves and our community to get past a knee-jerk reaction to this post.
Yarn does offer a `--flat` option that enforces the highlander rule, and I'm hopeful that the existence of this option will nudge the ecosystem towards an appreciation for fewer semver-major bumps and more ecosystem-wide effort to enable whole apps to work with `--flat` mode.
Plz send halp!
TLDR:
- open, community governance that will support long-term evolution
- the technical details get a lot right out of the gate (decent performance, predictability, and security)
Just to clarify, unlike TC39, the WHATWG HTML ("Living Standard") spec requires no consensus at all in order to add new features. Consensus is arrived at once all implementers have implemented the relevant features to the stable versions of their browsers.
To say that what is in the spec has consensus at the same time as browser implementers are beginning implementation (and expressing some concern over details) gets the WHATWG process backwards.
In this case, the coercion needs to ask Ruby for the encoding tag and ask Ruby to validate the encoding (which is does often enough that it's often cached) but after that we can safely coerce directly into a UTF8 string.
If we wanted to support other encodings, we could fall back to using Ruby's transcoding support (string.encode("UTF8")) and again, once someone does the work once it'll work for all helix users.
> This seems very reasonable, and the easiest to implement. It also has the nice effect of being a captcha to the publish operation, which gives it some of the gravitas it deserves in an open ecosystem like npm.
I agree, especially since Google Authenticator makes this pretty easy to implement.
That mechanism could easily be used to achieve the same goal, even if there was no explicit "post-script" mechanism.
Any application package manager with a lockfile-based-workflow (like Bundler, Cocoapods, Cargo, etc.) would at least have this mitigation as a default part of the workflow.
At the time, I wrote a script that hammered git commits into a repository using different strategies and looked at what the git repository would look like after 100,000 and a million commits. The "one version per file, nested in a flat structure" had serious issues.
There may still be scaling limits with the Cargo approach, but if we reach them, we have plans to create a new registry with a new initial commit and let the old registry age out, then rinse/repeat. At the moment, we haven't hit limits yet (with about 1/3 of the packages that Cocoapods has).
Generally speaking, Ruby eschews syntax that invokes a protocol behind the scenes for a consistent 1:1 mapping between method syntax and the methods they invoke.
I personally consider compound operators (asymmetrical) to be pretty risky (the do, indeed, depend on background), and I like '->' because it has a clear meaning outside of programming.
But you're right, this is a bikeshed.
I'd prefer either version of the pipeline operator to bind.
(and of course 'sortBy' is nonstandard)