386 karma · joined April 29, 2014
You know, I wouldn't pile those who are "not too" or have "expressed skepticism" with those who are completely opposed to the idea of evolution & the currently accepted age of Earth.
I mean, sure, evolution manifests itself in everything around ourselves, but that aside for a brief moment.
If your measure of "dumbness" is "anyone who doesn't unreservedly believe in evolution and the bing bang" then you're turning science into just another brand of religion.
I'd much prefer to interact with people who aren't too sure about either religion or about the current scientific viewpoint, rather than zealots on either side.
You see, the currently accepted scientific point tends to change over time (one of the benefits of science over religion I suppose). It was not long ago when black holes were described as having infinite density and zero volume. Few discoveries and math formulas later, turns out they far more likely stop collapsing at the size of their Schwarzschild radius.
So who is dumb now. The one who "believed" in zero volume black holes, the one who "believed" in no black holes, or the one who had the courage to doubt and seek answers?
Talking about zealots:
"Has the most powerful nation on Earth lost its mind?"
Emphasis mine. Give me a fucking break. The author may need a bit of smarting up on their own, it seems.
Employees who have an unclear idea of what they're doing or why they're doing it, also don't have their focus on improving their company and the lives of their customers. Hence they'd often make arbitrary decisions regarding how to prioritize their limited resources (time, money, which features go into the next milestone etc.). And in this way they may end up dragging the company down.
An employee asking themselves "am I worth it" can be a sign of a dysfunctional company culture, or the problem may lie with the employee, but wherever the blame lies, people who don't know their worth are in the long run not worth that much to their company, fad and cargo cult caused disbalances notwithstanding.
The system should be able to assess the scope of a task, and ask you to confirm 10 times if it has to, in blinking red dialogs, to make sure you really want to do what you are doing.
Of course, it's crucial that "clicking 10 times" is not the default behavior for any trivial action. Or boredom and the subsequently formed mechanical 10-click habit of the operator will kill the effectiveness of this approach...
That is a real principle in interface design - if something would be really, really bad to activate unintentionally, make it really, really hard to activate.
If you design a nuclear missile facility, you don't put the "launch nukes" button right next to "check email" and "open facebook".
Same way it shouldn't be easy for users to delete or corrupt their data by accident due to some omnipotent action innocently shoved right in between other trivial actions.
I wouldn't blame the person who triggered this re-imaging process. I'd blame those who designed the re-imaging interface, to allow it to happen so easily by accident.
Ascribing intelligence and self-awareness only to those species that share specific superficial traits with us is the kind of thinking that allowed us to think one sex is inferior than the other, or that one race is inferior than the other.
But while all intellects start from the same place (nothing), they are not all necessarily going in the same direction. A monkey is not a less evolved human and a cat is not a less evolved mammal.
Many animals have abilities, including intellectual, that we can't match (and some we can only crudely replicate with tools). Species have the traits they needed in nature to survive and be efficient. So those that didn't need the circuitry for dealing with mirrors, simply didn't evolve that ability.
You can't prove self awareness or disprove it. Even science has limits. Hell, I can't even prove anyone except me is self-aware. But I don't have the arrogance to claim everyone but me will be presumed not self-aware until proven otherwise.
So as a species, it'd be best for humans not to cast the animal kingdom as not self-aware "until they prove otherwise" (in silly arbitrary tests).
But making libraries better is not exactly an unsolved problem, the only problem is the solution made libraries themselves mostly obsolete. E-book stores and online publications make libraries "S" - Superseded, and library books "E" - Elsewhere.
Throwing money at a problem and forgetting about it almost never works. It just breeds corruption. Case in point.
Well, in a way the money wasn't wasted. Mark really needed the positive PR back then what with The Social Network movie and all the privacy vulnerabilities and abuses of Facebook. He got his PR. Facebook surviving was worth $100 million to him, so good job. Facebook survived. So he stopped donating.
The reason is... it's full of JavaScript kids out there, and because they're so many, they're all replaceable, and cheap. Like the commodity hardware servers they're programming.
It's neat to cast this as "easy to attract and retain talent", but "rapid innovation" and "developer happiness" (especially considering the lack of strict typing, lack of basic primitives, single threaded-ness and callback hell of Node.JS) are just B.S. reasons of the kind a Node.JS consulting company would add so it doesn't all look so cynical.
http://www.youtube.com/watch?v=yTu9omph9U8&feature=youtu.be
That patent is a bit sad, even if I consider the "hate the game not the players" principle.
A "scaling SQL" article that suggests adding Redis is like a "make more beer" article that suggests adding water.
There are performant algorithms for durable operations (as seen in frameworks like LMAX's Disruptor) which are simply not explored by Redis. The Disruptor is not canonical ACID, but it is durable.
They stumbled upon scalable durability because they had no other choice. As a trading platform, they were required to be durable by law, and required to scale by their clients.
A blanket all-or-nothing statement like "it will never scale" stops you before you even try to research the space of possible solutions.
Redis will enter into conflicts (where in this article's example, those locks won't "lock" the thing you're locking), and it'll lose minutes of committed operations on unexpected stops.
Does that make Redis useless? Hell no. Can it help scale your app if carefully considered, with regards to its properties? Sure. Does it "scale SQL"? No.
As for HTTP, if HTTP itself isn't truly RESTful, the only protocol I've ever seen REST implemented on, I'll have to resign from this debate, because it becomes completely abstract.
I hope the right protocol comes along to show us what REST might really be.
I'm spotting a bit of a pattern in REST supporters, where if some understanding of REST is found to have faults, it's called "not truly RESTful". Reminds me of how Agile failures tended to be explained as "not truly Agile"... but that's another story.
I judge a system by the implementations, not by the theory. If REST is this beautiful unattainable ideal that almost no one can truly implement, I tend to think the fault doesn't lie with the implementers.
It's quite likely REST simply has very few applications itself, but the applications have the potential to become all-encompassing (like the web itself). But in this case the issue remains REST is not suitable for 99% of the services people expose on-line, as each of those services has a specific scope and application, where REST's "network effects" of uniform resource interface and so on don't apply.
However the idea of exposing SQL databases publicly as an approach never took hold for many reasons we're today aware of. And the idea of public write access is ridiculous right from its premise.
The anti-API rant of this author shows us that those who don't know their history are doomed to repeat it.
Don't get me wrong, this can be great for "hypermedia applications" as Fielding's paper argues. But "hypermedia applications" just doesn't fit what many distributed services do these days.
Services are naturally centered arounds verbs (commands and queries) and not nouns (resources), so like with any other CRUD system, at some point a REST API that shoehorns everything into the four standard verbs HTTP commonly gives us, no longer adequately describes the business requirements of your app. You can definitely force things to be RESTful, but it's typically not the natural way to build an API. Feels akin to the ORM kind of impedance mismatch in some ways.
What a horrible idea.
Exposing implementations is bad because implementations change.
Exposing implementations is bad because as you expose the intricacies of your data model to your client (which he claims is a benefit) you in turn obscure and hide the intricacies of your business domain, which will surely not allow you to patch a service's distributed data tree in an arbitrary fashion.
It's in essence like having SQL as your underlying data model, and replacing your API with an open read/write/delete access to your SQL server to the entire world, and hoping everyone will run the right queries and all will be all right.
It won't be all right.
APIs will become more asynchronous and eventually all APIs will be seen as protocols, that don't necessarily follow a simple request/response pattern.
But they'll remain in the form of abstract commands and queries modeled after the business domain of the application, and not the underlying data model of it.
Each one of us struggles to add something to the stream of human thought, and it's hard every time, and it's worth praise every time, but it's interesting to see it all as a part of a bigger picture, in that computers are just systems like any. They have certain properties emphasized, and certain other properties de-emphasized right now, but that's it.
I actually didn't go far enough in my error detection and correction examples, I only went few thousand years back. There's an even more ancient example, going back millions of years... the process of DNA replication itself:
http://en.wikipedia.org/wiki/Proofreading_(Biology)
One shouldn't be surprised to discover that some cellular process might have stumbled onto heap sorting, either.
System design is bigger and older than any of us. To think otherwise is just a sign our culture is just too young yet to appreciate where we fit in the world. In some ways, it seems we still think we're at the center of the Universe.
We're not inventing algorithms, just rediscovering them. This doesn't make any of the achievements of our inventors any lesser, but it's good to keep in mind the big picture. It helps us, among other things, to look in more places for inspiration and knowledge, and in turn, create better systems.
Open isn't always good when it comes to your PR.
When you have one exit and it's blocked due to many people attempting to fit at once, the entire queue is congested.
That barrier turns one exit into two exits (even if it's backed by only one real exit). If one is congested, people can still flow through the other one, and vice versa.
This explains why the evacuation rate is roughly twice faster.
If the barrier is designed to even more virtual exits, it'll be even faster.
And there's an even faster way, that requires no architectural changes, but people will have to be trained in it so well, that they'd follow it even in panic.
And this would be some heuristic which orders people in an unambiguous way, so only one person is attempting to exit at a given moment.
I don't know, left to right order, split in rows, people holding hands... Some creative solution is required to decide what that heuristic would be.
Queues have no congestion, so they'll represent the fastest possible rate of evacuation through a single exit.
People have used a simple form of error detection checksum when copying books manually (like the Bible) thousands of years ago.
Retransmission requests based on error detection like the above have been use over various pre-electronic communication channels, like telegraphs, which is a form of error correction scheme.
Of course anything that requires a modern CPU to compute wouldn't be feasible, but the basics of it, the seed, was.
Transaction protocols can be observed before computers especially in military protocols where "distributed coordination" and consistency of command are crucial for carrying out a military mission. Their channels of communications were slow and unreliable.
I suppose I don't have to also point out same military protocols often required a log where every formal exchange is written down in order, for later review if needed. Here are your modern day database transaction logs.
I can also cite famous examples of encryption schemes going back to the Roman empire, before computers existed, but we all know those.
We assign names to various inventions and we tend to think no one before had any idea like that, but truth is good ideas keep getting "reinvented" over and over, and the only difference is the level of sophistication that computers afford us in combining such concepts and building upon them into more complex schemes.
By the way in ancient Egypt, every person would be registered and written down in a set of books, books would be split and sorted by a hash of their name for easy look up.
Yup. Ancient Egypt had a hash-based index for their database of people (and books are the hashmap buckets).
DELETE ALL COMMENTS AND CHANGE SYNTAX HIGHLIGHTING!
The reason why comments are pale compared to code is because a comment always belongs to a given piece/block of code.
A comment doesn't exists for itself, it exists to clarify the next lines of code.
You scan code, and when the code doesn't say enough, you read the comment. So code is the primary thing, comments are important, but hierarchically they're subservient to code not the other way around.
Also, why on earth would doc comments be "redundant" and have to be removed? Why would green/red be bad for insertions/deletions? Give me break...
Not about programming itself.
We were designing systems for millennia before computers existed. All the basic algorithms we use in programming today were invented before computers.
Computers just happen to make systems a lot more reliable, performant and scalable (if designed right), since computers have evolved to complement us (i.e. we're bad at what computers are good at and vice versa).
I don't think programming is the new literacy, I think understanding the common principles that tie system behavior together has always been the highest form of skill for any human to possess.
As for turning a system design into code, if you know how to design the system on a higher level, you can always delegate the "boring" act of coding itself.
I'm a programmer, but I understand that the act of programming by itself, even though I find it enjoyable, isn't that interesting on its own. It's only interesting in terms of how the program I'm writing connects to a system where the real world and real people are involved. All programs, with no exception, either interface directly with people, or interface with other programs that do interface with people.
Currently we conflate programming with the act of designing systems (algorithms, design patterns etc.), but I expect sooner or later system design and programming will split into separate "trades". Would it be a resurgence of cybernetics, or a brand new branch of science, I don't know.
But it'll happen. And it'll be good, because many programmers use computers as their golden hammer of system design, and it's hardly the only component of a good system.
This is pure gold, I love the analytical thinking in it, especially as someone designing systems that commonly interface computers with human operators.
I've saved it, it's a great checklist of unintended effects of design decisions I can go through while working on my projects.
If it's leaking out of Beats, then they're already demonstrating how poor of a cultural fit for Apple they are. From... literally not day 1, but day -N.
This would be like a person who is unable to lead internal dialog, and everything they think, they say out loud.