3,476 karma · joined April 10, 2007
I lost track of all the slimy rhetorical techniques in this article. FUD about the “cost of regulations” by talking about restaurants in SF. Saying that T-Mobile’s rise was good for competition, so I guess zero-rating is a good thing after all (without arguing that it was specifically zero-rating that led to T-Mobile’s rise). Saying the “only future we have to fear” is one where these regulations stay... really?? Just because he has a hand-wavy argument they might be bad, or at least unnecessary?
Oh, let’s not forget, the argument that regulations as written don’t eliminate all possible ways to violate the spirit of the law, so they don’t do any good at all. Law can be updated. If there was a legal loophole that let people murder each other, would we say the laws against murder are pointless?
Zero-rating is not aligned with net neutrality, even if it’s currently allowed by a loophole, and if it benefits some customer or some company in some way. Hemming and hawing about it is just kicking up smoke.
The author wants to drive a wedge between the positions of “net neutrality” and “ISPs are telecommunication carriers,” and I don’t see it. Or he wants them to be neutral carriers but not have it be legally enforced. Or first repeal the current enforcement, and then talk about enforcing it some other way. Slimy, slimy, slimy.
I personally think “functional persistent” data structures, as a language default, trade a lot of runtime performance in order to achieve some guarantees like thread-safety and functions not having side effects. Every mutation to every array or dictionary is treated like a transaction in a MVCC database, with the garbage collector in charge of cleaning up the records of every past version that wasn’t actually necessary to keep around, because no multiversion concurrency was actually necessary in that case. I encourage languages to experiment with other methods of achieving similar benefits.
I think limiting side effects and shared mutable state is very important, but at a local level, imperative code that mutates a data structure is highly readable and performant. Certain algorithms practically require it. Certain hardware practically requires it.
Functional languages let you think in terms of abstract “compound values,” but in practice these are backed by tons of little heap-allocated objects, partly so that lots of sharing can be done when the data structure is copied on every change.
Working with your arms outstretched in front of you, Minority-Report-style, has been determined to be not feasible due to fatigue, so how is working overhead reasonable? I’ve never been in a car factory or on an assembly line, but from an armchair it sounds bound to lead to a lot of strain.
Why not have workers lie on their backs on carts or something?
Microsoft did a really good job putting resources behind TypeScript, making sure tooling and IDE integrations are good, and generally getting a ton of momentum going. TypeScript is fast-moving, with bugs fixed and features added at a high rate, and the quality of discussion on the issue tracker is high. Flow, in comparison, was not evolving as fast.
Flow touts global inference, which I think means better types when you don't necessarily have annotations on module boundaries, but I mostly care about what's possible in a greenfield or well-annotated codebase.
Flow deserves a ton of credit, and Microsoft probably studied it in detail, but I think the advantages are overblown at this point. Take the soundness thing. TypeScript added null-strictness a while ago, and recently they improved function type polymorphism. The reality is that both type systems have limits and you sometimes need to type something imperfectly or use an escape valve ("any"). In most cases, however, TypeScript gives you more sophisticated tools to construct the types you want, so you actually get better types. Maybe TypeScript lacks a theoretical underpinning for soundness, but there's no reason it can't continue to get "more and more sound," with it harder and harder to find good examples of unsoundness.
I can see it now, researchers claiming that computers are actually now 1% better at warfare than humans, on the standard corpus of example scenarios. And then someone decides it would be remiss to not let the computers make the decisions.
1. They are so much more intelligent than us as to render us insignificant — because we all know that intelligence is what makes people significant and worthy.
2. They are better humans than humans, not just more intelligent in a problem-solvy way but more moral and compassionate as well; truly “better” (there has been sci-fi about this rather fanciful but easily written scenario)
3. We build “wilier” machines/software that, given the power to do so, can out-strategize us and win in battle, or outcompete us in the economy. This is quite possible. Obviously we should limit the power (physical, legal, etc) of this software. There are real legal and economic issues here — not to mention futuristic disaster movie plots that could become real — but not moral ones.
4. We build artificial life that’s way smarter than us, and it decides it doesn’t care about us because we’re such dumb simpletons. The same way we don’t care about bugs, presumably because they’re dumb, and not savvy wisecrackers like the main character in Bee Movie, voiced by Jerry Seinfeld. But why would we expect intelligent software to decide to care about us, anyway? To judge us and find we have merit? If someone told me they made a machine with a concept of what other beings are worth and it found me unworthy, based on reasons such as its being waaay more intelligent, I would not be surprised or impressed, or more than mildly insulted.
Edit: I guess people are worried about some combo of 2/3/4, where computers whose judgment we agree with basically say humans are lesser beings — like bugs — and we think about it and are like yeah, you’re right. Or computers are so human we are compelled to give them the rights of humans. I’m just not sure that actually makes sense, or at least it will take decades with many intermediate stages to talk about first.
Animals (including humans) are born with a version of 3 (and 4). Emotions are simple. Thought-level nuance is learned over time, but data learned by one android (or whatever) can be shared. Also, children are able to learn from comparatively few data points, and computers are beginning to do this too (see “one-shot” learning, learning from one occurrence, like the way kids sometimes pick things up).
If you make a child android that looks and acts like a child, people will read to it and play with it; there are movies about this! :)
1. pure problem-solving (chess, go) from
2. competency of behavior in the world (vision, navigating a maze), from
3. universal cognitive-emotional life (getting frustrated trying to accomplish a goal and trying a different approach; having competing drives that form the basis for goal-setting, like hunger, boredom, and self-preservation), from
4. more arbitrary-seeming, human-like cognitive emotions, like humor and beauty.
You can have 1 and 2 without anything directly resembling human intelligence, and 3 with animal-like intelligence, or you could make something completely alien. An appreciation of humor and beauty would be a great way to demonstrate you’ve made something like a virtual “human mind.”
There’s no reason computers couldn’t be better at all of these things, including writing better jokes. There’s a funny blog post somewhere about the idea of a computer writing superhuman-level funny jokes; I wish I remembered where!
There is a route you can go that doesn’t use contenteditable, except as a small box at the cursor position to handle IME; it’s what Google Docs does. At my most recent job (stealth start-up) we built an editor like this, painting our own selection and everything. It makes certain things easy or possible — custom text wrapping, tab stops, custom handling of cursor and selection with regard to embeds. It doesn’t get you very far on mobile web, though.
At another level, I’ll admit that most founders I’ve worked for have excelled more at promoting their ideas, raising money, and hiring talent — top talent, no small feat! — than product ownership. In this case, the lieutenants who make the gears mesh and not jam are the heroes to me.
Edit: Ok, maybe I could have predicted that lines like "HTML 5 is a plague on our industry" would ruffle some feathers. I guess I like a little snark in my criticism.
The appeal of CSS in JS to me is one less language to think in -- one less syntax to worry about and format and lint and forget semicolons in. Also, modules and defining constants. Most web developers seem to use a compile-to-CSS language and a module system these days anyway, rather than vanilla CSS.
I didn't know Plan 9 was behind UTF-8. :)
We've come a long, long way since the 90s and even the 00s. It's shocking and gratifying how well emojis work online. A great motivator for Unicode support, too. :)
One level of abstraction that works is to think of a string as a series of integers (which may be much larger than 65535) representing code points. Whether your VM uses a fixed-length or variable-length encoding to encode this series of integers should be irrelevant, aside from performance and memory consumption concerns. JavaScript's "charAt" and numeric indexing of strings violate this abstraction, making them not useful in Unicode-aware code. Of course, the "series of code points" abstraction has limits too, since what we think of as a single "character" can be composed of multiple code points, which calls into the question the whole concept of a "character," which is fuzzy in the first place.
This is all massively inefficient, of course. Most strings are representable as UTF-8, and using two bytes to represent their characters means you are using more memory than you need to, as well as paying an O(n) tax to re-encode the string any time you encounter a HTTP or filesystem boundary.
There's nothing stopping us from packing UTF-8 bytes into a UTF-16 string: to use each of the two bytes to store one UTF-8 character. We would need custom encoders and decoders, but it's possible. And it would avoid the need to re-encode the string at any system boundary.
This line of thinking does not make sense to me, and I'm not sure what scheme is being proposed. First of all, "most strings" are representable as UTF-8? All strings are representable as UTF-8. And if you are reading data from a UTF-8 source and you don't want to pay the time and memory cost of decoding it and re-encoding it in a less space-efficient code, leave it as a Buffer of bytes! Don't decode it.
Because everything else in the world is moving to UTF-8, Node is also trying to move to UTF-8.
Node does make you specify which encoding you want when converting between strings and Buffers, but it's always embraced UTF-8 as its primary encoding, as far as I'm aware.
Because Javascript was invented twenty years ago in the space of ten days, it uses an encoding that uses two bytes to store each character, which translates roughly to an encoding called UCS-2, or another one called UTF-16.
This is kind of silly. Java made the same decision and was certainly not "invented" in ten man-days!
If the file system operated in an event-sourcing model, you'd be able to listen to a stream of events from the OS and reconstruct the state of the file system from them. If it acted like a database, you'd be able to do consistent reads, or consistent writes (transactions! holy cow).
Just to rant on file systems for a sec, I learned from working on the Meteor build tool that they are slow, flaky things.
For example, there's no way on any desktop operating system to read the file tree rooted at a directory and then subscribe to changes to that tree, such that the snapshot combined with the changes gives you an accurate updated snapshot. At best, an API like FSEvents on OS X will reliably (or 99% reliably) tell you when it's time to go and re-read the tree or part of the tree, subject to inefficiency and race conditions.
"Statting" 10,000 files that you just read a second ago should be fast, right? It'll just hit disk cache in RAM. Sometimes it is. Sometimes it isn't. You might end up waiting a second or two.
And don't get me started on Windows, where simply deleting or renaming a file, synchronously and atomically, are complex topics you could spend a couple hours reading up on so that you can avoid the common pitfalls.
Current file systems will make even less sense in the future, when non-volatile RAM is cheap enough to use in consumer devices, meaning that "disk" or flash has the same performance characteristics and addressability as RAM. Then we won't be able to say that persisting data to a disk is hard, so of course we need these hairy file system things.
Putting aside how my data is physically persisted inside my computer, it's easy to think of better base layers for applications to store, share, and sync data. A service like Dropbox or BackBlaze would be trivial to implement if not for the legacy cruft of file systems. There's no reason my spreadsheets can't be stored in something like a git repo, with real-time sync, provided by the OS, designed to store structured data.