Iβm learning more about the social aspects of ecosystems. In javascriptβs case, a single technical decision - to assume that transitive dependencies can be compiled in the same way that dependencies are, and to stay off of a clear decision to standardize a build process or module configuration for a long time.
Maybe staying away from administering standards is good, but this happens time and time again; I have personal experience with Nix flakes friction, Rustβs erorr type / nighlies, Haskellβs mess of a βlanguage extensionsβ idea, and so forth.
When do you want to institute a standard? How do you know where to start? Where?
Friction happens when interfaces are expected to be opaque, but arenβt (or, conversely, are transparent). Build system errors are akin to internal compiler errors - they arenβt problems in your code or even that of the upstream library, but somewhere in the processing pipeline to assemble everything. Build systems in javascript leak abstraction boundaries.
Library programmers have to build for every build system that end users could use down the line - and if Iβm contributing in 2010, I have no way to conceive what people will want in 2020 something or how those standards might change!
The nix problem is one of a standard with a lack of appropriate tooling. The proposal was made and accepted by a minority of the community, then immediately implemented in βproductionβ by major Nix characters - making it industrial for some, but without the practice, backing or documentation to make this stuff broadly adoptable. Nix should be experimental - but instead of making it an external, experimental feature, it should have been implemented outside of the core - not strongarmed into the internals. Sure, flakes were hidden behind a flag - but half of the nix guides werre recommending flipping that flag without elaboration beyond pointing to the Tweag blog posts. Flakes are good; the launch was not and the community is still fragmented today.
Rust? They chose not to administer a standard that they knew they would need. The right decision for the Error trait was to provide a default, easily extensible error system that functions generically. A concrete Error was a bad move, and fragmented the ecosystem around all of these specific errors that people wanted but werenβt supported by Error. Special casing would have been fine here - unnecessary but fine. The community deserved to be able to modify their system in ways that Rustβs opaqueness doesnβt tolerate.
Common Lisp runs the other way. Everything is explicitly modifiable, and that means you donβt know what system youβre working with. You can start from a tight core, but the core is a mess of hacks that have been accumulated, and none of them were built for the 21st century. Haskellβs the same way - I dare you to walk into a production codebase, obfuscate the language extensions, and try to figure out whatβs going on. Too much could be going on on the other side of the interface, and the process of finding out is a mess. This is reasonable - Haskell was built for language experimentation, and Common Lisp was built to be a modifiable foundation - and fast.
Iβve had trouble with all of these because Iβve expected software systems that βjust workβ and follow the same rules - heterogenous systems assembled with lots of simple, opinionated tools that serve their roles well. Type systems reach if not managed correctly. My current interface take is that users should be able to express ideas however theyβd like within the rules of the system, but they shouldnβt have to worry about a βmeta levelβ like a type system right away; types are useful to help document and solidify information across interfaces. I donβt want to think about types; I want to think about values and data that will never be properly represented. Most Haskellers and Rustaceans will admit that over-perscription of representation - narrowing types of strings and numbers to minutiae - is a sin because it prevents iteration entirely. Maybe for system services, types are good glue - but for anything with a UI, your feedback is primarily delivered with visuals - not through any sort of type system. We donβt need stronger types - we need better data visualizations - because when answers will inevitably occur, we want the best tools imaginable for navigating the system to track them down.
Rendering context...