551 karma · joined October 11, 2014
Yeah it is getting lost, more and more lost each year - you know why? The core JS language is bad. Note how the author uses the word 'core' instead of what they really mean: 'subset'. Use a subset or a small portion of the language, because if you use the whole breadth of language features, you will litter your application with so many landmines that you will eventually scrap it and re-write due to how awful most of the 'features' in JS are. Even using a subset you have no choice to resort to syntactical verbosity to get around bad language design, like === over ==, or const & let over var.
I wonder what the ultimate point of posts like these are; it's like someone trying to light a fire during a flood; and to what end? To pointlessly champion a bygone era of when people didn't know better? Let's be clear here, JS is popular because it is the only language shipped by default in browsers, since 1996. That's it; it's not popular because it's good; we're not using it in 2024 because it won out in a contest of merit. It's design phase was rushed and even its name betrays how stupidly conceived it was; 'JavaScript' - as if superficial association with an already trendy tech during the 90's was somehow enough to paper over it's obvious flaws as a language. Just laughable.
Seriously, it's 2024, we know better now - use TypeScript. It's actually kind of amazing how Microsoft released TypeScript only in 2012 and not years earlier.
There's been centuries of legal disputes, in both civil and criminal cases, and judges have over time through their rulings have influenced what is the acceptable wording to enforce whatever it is legislators intended for a particular law. When judges render a verdict, it becomes case law, and although that itself is regarded as part of the law, where there's ambiguity, over time, legislators have been prone to abrogate laws with more exact wording.
This is reflected in the tendency for judges to fall in groups that favour one way of interpretation over another, like Intentionalism, Purposivism, Textualism etc. The fact that statutory construction is something that is almost exclusively driven by judges themselves seems also pretty important when studying the language of the law and it's kind of absurd they ignore it in this study.
Look, Swift's a great language and all, but it's become grossly sophisticated and complex to the point of being a bloated pig; I wonder if people at Apple are still using Objective-C purely because editing it in XCode is still faster than Swift with respect to autocomplete and compilation speeds.
But even then, what point are you even trying to make? Windows 10, like previous releases before it, when its support end, will mean it was supported for a solid 10 years. I mean, that's a lifetime in tech; 2015 was the iPhone 6s.
> The process required at least 60 kilograms of coal per kilogram of synthetic butter.[23] That industrial process was discontinued after WWII due to its inefficiency.
Say what you will about Microsoft, but they have consistently supported Windows for a MINIMUM of 10 years since Windows XP (2001). That's absolutely a solid record when you compare it to the computing half-life of support that other tech companies usually give. Look at Samsung, or even Google. Hell even Apple maxes out at 7.5 years for it's longest supported device.
Are you the kitchen hand washing dishes? Are you the chef or cook who makes the meals and food that the customers eat? Are you a cleaner mopping the floors after business hours? Nope - none of you get a tip, unless the restaurant has a policy of collecting all tips and redistributing them to all employees. But how often does that happen? It's really easy to just pocket the tip and keep it for yourself.
But is this constant turnover getting ridiculous in the web dev & JS ecosystem?
Yes. I simultaneously credit and blame facebook for starting it with yarn; after yarn, the trend of re-writing build tools seemed to become much more acceptable and trendy, especially since yarn (at the time) was multiple times faster than npm; you could argue it was worth it. But now we've reached a stage where the diversity of tools like npm, yarn and pnpm, now tools like ni (https://github.com/antfu-collective/ni) are emerging to manage the diversity.
I think this is getting out of hand, now there are n+1 of them.
> JSON Schema is a constraint system which is designed to validate JSON data. Such a constraint system is not great for code generation, with TypeSchema our focus is to model data to be able to generate high quality code.
Well, types themselves are another type of constraint; specifying something like the type (number) of a property (Age) is a constraint on the possible values for that property.
> For code generators it is difficult to work with JSON Schema since it is designed to validate JSON data
There's lots of features in JSON Schema, but if you're writing a code generator, you don't actually to have support all of them. Some languages like C# don't have native lang support for AllOf, but do support OneOf or AnyOf.
> JSON Schema has many keywords which contain logic like dependencies, not, if/then/else which are basically not needed for code generators and really complicates building them.
So isn't the whole point of code generators for OpenAPI/JSON Schema is that they generate code to map foreign data sources in a target programming language so that the programmer doesn't have to write all this mapping code by hand? The vast majority of all programming languages support if/then/else and even modelling dependencies like what JSON Schema supports. So why is it a bad thing if a schema language like JSON Schema supports these constraints? Wouldn't having support for this in the schema language and a code generator mean less handwritten code and more time saved?
If a schema constrained Person.Age to be an integer always greater than 0, I would actually really love for that validation code to be generated for me. Chances are, if such constraints exist in the schema, then the vendor/original author probably has good reason to include them; having it code generated automatically means I don't have to worry about writing it myself.
I mean if you want to generate the code for only defining data structures & their properties, you can still do that, and just stop there. A whole new schema language in JSON seems wholly redundant. It seems like maybe the authors should've started with writing their own better code generator for JSON Schema rather than their whole new schema language and code generator.
Finally, reading the spec https://typeschema.org/specification, I can't see support for optional values or null/nullable types. I'm hoping it's just an oversight (seeing as how the spec itself is incredibly brief), but if it isn't, then bluntly, then this isn't ready for release.
But this seems to measure the speed at which particles can become entangled in the first place, which I always assumed would've been on the scale of Planck time, but 232 attoseconds is pretty long compared to 10^-43 seconds.
* it's own project because maintaining it will take up so much of your time.
* be decoupled from the web framework because users will want to use another because your own doesn't have abc feature.
From observing the ecosystems in .NET, Java and PHP, lots of people have lots of opinions on how ORMs should work.
Imagine instead it's for criminal defense lawyers: re-word it to be advice for attorneys defending their client against a prosecution. "Once [all exculpatory evidence against your client] is identified, defending them against a guilty verdict is easy to do"
It sounds like it's written by someone who has never practiced in the real world.
Since when has anyone ever tried to pronounce 'GPS' as anything other than G-P-S? Also "ECS" = "Ecosystem"? Maybe I'm just crazy but I've never heard or read anyone abbreviate ecosystem as 'ECS'. I've come across ECS as entity component system in video game engines, but never as just 'ecosystem'. Also it's defined exactly once in chapter 5 and then never used again in the book. Why even bother to mention it then?
Oh and publish it as a PDF, but then have no actual page numbers?
There are multiple sentences in it that make me think this is all a big joke:
Like: "Languages must be homoiconic", but then you immediately show a language that is NOT homoiconic.
And also "Microprogramming works incredibly well with LLMs. It is easy to mix and match microprograms written by humans with microprograms written by LLMs.", but then show nothing to actually demonstrate that; no demo or even example code. Did you fine tune a model yet? You don't even mention a possible LLM model by name.
And finally: "If the microprogramming trend becomes as big, if not bigger, than microservices, I would not be surprised." I'm sorry but this is hilarious, especially because the vast majority of software out there is not written as a set of microservices, because it's simply the wrong model for most apps, like mobile apps for instance.
Apple is rich because they've optimized the hell out of their supply chain and through some clever marketing have convinced (rightly or wrongly) people that it's somehow reasonable to charge $200 for 64GB flash storage upgrades on their devices that only cost them ~$20. They are probably the only company in the world that have consistently run 20%+ profit margins on selling hardware ALONE. Their services revenue from streaming and arcade are puny in comparison. Even throw in the cut they take from app store sales, compared to hardware it's relatively small.
This is one of those sentences that is clearly an opinion but stated as if it were some undeniable, incontrovertibly true statement of fact.
In your opinion, you have a better program - but give the code or repository to another dev or a group of devs and I'm sure you'll hear very different things...
> Like I said, honest open source advocates won’t take issue to how I framed their position.
Yet you've failed to provide even a single point of evidence to back up your claim.
> "honest open source advocates"
You've literally just made this term up. It's meaningless.