2,674 karma · joined September 22, 2009
Usually, the same way that ecosystems stratify around languages, opinions in questions of tech advocacy tends to stratify based on developer background. Most of the progression in web standards that the author is against has been bolstered by the attitude from people that hail from his background. (Roughly, that camp's attitude tends to resemble something like, just give the developer the ability he or she needs in order to do what he or she wants.) It's the exact attitude that gave rise to developer-first QOL improvements like WebAssembly and many other things that have popped up in the nearly 1.5 decades after this was written.
This is notable because that camp's overriding perspective is the exact opposite of the author's own grumble about "your experience interacting with the web could be vastly better, but browser authors are instead caught up in enhancing the abilities of content creators". I.e., the author prioritizes a user-first perspective, recognizing that the developer-first mindset has almost always been in conflict with his ideal vision for the Web, despite his own background.
There's also the really great breakdown of Web content as type #1 vs #2 vs #3, which predates similar descriptions that I'd only seen start to become independently written about in the last several years—probably after 2011 or so.
In my opinion, this essay is as on-the-nose, as brutal, and as important as Maciej Ceglowski's similar and often referenced takes ("Legends of the Ancient Web", and "The Website Obesity Crisis").
1. http://nothings.org/gamedev/how_i_found_myself_in_the_game_i...
I wrote about something similar to this (called "type-named objects") in a post last year[1]. The idea is that for small utility methods, you shouldn't have to interrupt your main flow of thought to come up with names for your formal parameters; in fact, you shouldn't even have to name your locals. If you're working in a language with a (perhaps already verbose) static type system, you can just leverage that.
So, for example, instead of this:
appendNode(node: Node): void {
this.tail.next = node;
this.tail = node;
}
... you can do: appendNode(Node): void {
this.tail.next = the Node;
this.tail = the Node;
}
This does introduce some precedence/binding gotchas that I go more into. But that hints towards further improvements. From the aforementioned post, you could end up with a language that allows: the ControlMessage's id := defocus
Or, if you add support for "passive voice" to your language: id from the ControlMessage := defocus
Completely unrelated, but related to the use of "the", Carmack wrote a tweet[2] that I've got embedded in the comments of a project of mine.> I have moved to naming global singletons with a The* prefix -- ThePacketServer, TheMasterServer, TheVoip, etc. Feels pretty good.
Since then, I stopped creating "proper" singletons altogether. Instead, it'd be a quasi-singleton, where I write a `MasterServer` class, and then bless an instance as `TheMasterServer`. Application code will always import, refer to, and otherwise operate on the latter, but tests are free to instantiate their own. This is especially useful if you have implemented some sort of developer switch in the UI that allows you to launch an embedded test harness within a live, running instance of the app. In that case, you don't exactly want your tests to be fiddling with your "real" singleton.
1. https://www.colbyrussell.com/2017/02/16/novel-ideas-for-prog...
2. https://twitter.com/ID_AA_Carmack/status/575788622554628096
It seems likelier that a P2P web based on Dat (or something like it) will gain adoption in the large before getting embedded devices manufacturers (a) to willingly take on the role required here, and (b) to get it right, which are each big asks on their own. There's also the hidden third problem (c): getting the masses to actually go out and upgrade a piece of hardware that would actually support this kind of thing. It's a lot easier to just download a new browser (or an update for their current browser) and sign up for a service that will act as an always-on peer on your behalf—for exactly the same reason that the centralization of the Web happened in the first place.
Apple's is not the only ecosystem that settled on carriage return. Who do you think was around for them to deliberately break compatibility with in 1977? Kildall?
Go on, finish the thought, and make your conclusion explicit. Because by any reasonable reading, you're suggesting that the Supreme Court would not have granted Oracle's petition if Google prevailed in the Ninth Circuit. And yet you start by saying that this isn't your argument. Be explicit.
Second: That's a stretch. To argue that the case would have stopped at the Ninth Circuit is to argue that because the Supreme Court denied Google's petition to reverse the Federal Circuit, then they would have denied Oracle's petition to reverse the Ninth Circuit. That's a junk argument.
Not true. Android has been exactly that since 2016. Harmony is dead (killed at the ASF, even), and Android is now using OpenJDK.
Since then, this suit has been about (a) deciding whether Google is guilty of wrongdoing in the past, and (b) what the extent of the damages should be for that historical wrongdoing should be, if any.
The outcome here doesn't really have any impact on the future of Android (except if Google wanted to factor the suit into their decisionmaking for their own reasons).
The point is, nuance matters. If you're physically attacked and defend yourself in a way where you end up killing the guy, you claim that your actions were justified. You don't go to court claiming that killing people is just not a problem.
Here's how this case should go:
0. Oracle sues Google for copyright infringement.
1. Courts find that the design of APIs is an expression resulting from substantial creative decisions far above the low bar we already have for precedent, and therefore they're copyrightable.
2. Google defends themselves on the claim that, creativity notwithstanding, merely implementing a public API should not subject an implementor to the consequences of copyright infringement, and that there are no damages owed here.
And by every indication, we're right on track.
https://news.ycombinator.com/item?id=10949839
And it looks like you're moving the goalposts and shitting out two-second replies, anyway, so I'm done commenting further here.
When the Supreme Court was considering Google's petition to hear the case, the court asked the White House to voice an opinion—where by "White House administration", you mean the Solicitor General.
That's not "weird"; that's a normal part of the job.
https://en.wikipedia.org/wiki/Solicitor_General_of_the_Unite...
- Xamarin did offer a commercial license to Unity; Unity would not accept it
- MS began to release their own .NET implementation under the kinds of license terms that Unity wanted years ago, but Unity didn't budge
- In the meantime, MS then relicensed Mono itself—the .NET implementation that Unity actually wanted—under the kinds of terms that Unity wanted, but still Unity didn't show signs of moving until very recently
The whole it's Mono's fault that Unity sucks was essentially a successful PR attempt for Unity to disclaim responsibility for their shortcomings, with the (maybe not unintentional) side effect of directing public ire towards Mono for not doing enough free work (to benefit what was already one of the industry's most successful companies!)
- Common Voice does have a TOS. It's here:
https://voice.mozilla.org/en/terms
- You're equivocating on the word "may". You're reading it as declaration of intent—i.e., as a synonym for the word "might" and def 5 as listed on Wiktionary[1]. In reality, it's being used in line with the most common tendency for things like TOS, RFCs, etc, which is as a synonym for the word "can", i.e., to acknowledge what one is allowed to do (in this case Google), as in def 2.
For anyone looking on and thinking of following this advice, please don't treat Bugzilla like GitHub, where advocacy and general discussion is the norm. Bugzilla is for code reviews and for people who are otherwise working together so they can coordinate and get things done. It's not an open solicitation for people to jump in and voice their opinions about general project directions, etc. If you do try to use Bugzilla the wrong way, you'll likely be warned about generating too much noise and possibly banned.
Please do continue using social platforms like blogs, comment sites like this one, etc. for posting opinion pieces and weighing in. That's where general commentary belongs, and it'll be much more effective to boot, if you're interested in getting people's attention or changing minds.
This is how the keybase sigchain works. (And I do mean "works"—as in, it's available now and real people have been using it.)
PS: Your HN profile doesn't contain any contact info.
It's true that there are some types of web apps that exist on the traditional (HTTP) web but that cannot be made as a Dat app, but it's also true that there are a class of apps that could be built with Dat but that cannot be built on the traditional web.
1. dat://fritter.hashbase.io
I can't say much about IPFS, but this is not quite true of Dat. The Beaker team is working on a complementary set of APIs to read and write to Dat archives, so you could have, say, a TiddlyWiki-like site that can update itself.
It's always been a big problem that the security of file:// URIs is unstandardized. I can publish a repo, for example, that includes some tests/runner.html. You could open it Firefox to run the automated tests, but Chrome will choke on it because Chrome doesn't allow XHR for file:// URIs. The only way around this is to either put it online or run a local webserver (e.g., `python -m SimpleHTTPServer`) and access it through localhost. This is perverse. Dat is solving this in a way that's very similar to what would happen if file:// got first-class attention from the browser makers. If it's in a Dat, it doesn't actually matter if it's on your computer or hosted somewhere. All that matters is that you have the content.
This might not be exciting to HN types who are comfortable and willing to go rent some DigitalOcean instance and put up with administering it, but this will have a huge impact on the long tail of businesses—both small and large—that are quietly chugging along on little more than Excel and email (maybe the odd SharePoint installation).
On the other hand, developers should be excited about this, too, because it means they can start building apps that are _actually_ serverless (compared to Amazon and Google's definition). We're back to where we were in the 90s: you can go write some neat client software and share it with me, without having to think about the headache of needing to run a server in perpetuity just so that it can continue being useful.