Two guys come up with a good idea for a camera strap and start selling it. Competitor applies for a patent on a similar concept. Despite the fact that plenty of prior art exists that should prevent such a patent from being granted, it’s issued on November 1. On November 9, the small company announces that it’s discontinuing its products rather than risk a legal battle over the patent. Once again the real damage of the patent office failing to discharge its duty effectively is illustrated.
Before he created the awesome bookmark site Pinboard, Maciej Ceglowski was known primarily as a writer of incredibly good essays. For example, he recently wrote about the Arabic language, and in 2005, famously wrote the definitive essay criticizing the space shuttle program.
Yesterday, he wrote a post on the Pinboard Blog criticizing the concept of the social graph. This paragraph really nails the inadequacies of computerized models of our human relationships:
This obsession with modeling has led us into a social version of the Uncanny Valley, that weird phenomenon from computer graphics where the more faithfully you try to represent something human, the creepier it becomes. As the model becomes more expressive, we really start to notice the places where it fails.
I love this bit on the awkwardness of actually constructing our personal social graph as well:
There’s no way to take a time-out from our social life and describe it to a computer without social consequences. At the very least, the fact that I have an exquisitely maintained and categorized contact list telegraphs the fact that I’m the kind of schlub who would spend hours gardening a contact list, instead of going out and being an awesome guy. The social graph wants to turn us back into third graders, laboriously spelling out just who is our fifth-best-friend. But there’s a reason we stopped doing that kind of thing in third grade!
There’s a reason everybody is talking about this essay. It’s profound and important.
On a closely related note, check out the blog post from last week everyone was talking about — Zach Holman’s Don’t Give Your Users Shit Work.
Matthew Yglesias has a different take on the question of personal responsibility that I wrote about the other day. Here’s his argument:
But if I look at America today, what I see undermining any meaningful notion of work ethic is a kind of run-amok ethic of moneymaking. The old Calvinist idea about money, as I understood it, was that hard work, discipline, and prudence were moral virtues. They were also things that are more likely than not to lead to personal prosperity. So prosperity shouldn’t be stigmatized as ignoble, it should be rather seen as something likely to flow from virtuous behavior. But this equation assumes that morally speaking what matters is the hard work, the discipline, and the prudence. Cutting corners, lying, cheating, or stealing to make a quick buck doesn’t fit the bill.
Lots of thoughtful posts are cropping up about the new restrictions Apple plans to implement for OS X applications that will be distributed through the App Store. The occasion is, I suppose, the news that Apple is pushing back the deadline for all applications distributed through the App Store to be Sandbox-compliant from the middle of this month to March 2012.
For a basic rundown of the new rules and what they mean, check out this post from Pauli Olavi Ojala.
For an argument that Apple could take a more realistic, less restrictive approach to securing applications, see Will Shipley. In it, he explains why entitlements and code auditing may be useful in theory, but certificates are a more straightforward solution:
But, in the real world, security exploits get discovered by users or researchers outside of Apple, and what’s important is having a fast response to security holes as they are discovered. Certificates give Apple this.
His proposed solution makes a lot of sense, I’d love to see Apple adopt it.
Ars Technica’s Infinite Loop blog has a useful post on the sandbox features in OS X Lion as well.
Today’s must-read blog post is by Will Wilkinson, musing on the differences between liberals and conservatives in terms of how they view personal responsibility. Here’s how he describes his own view, coming from a libertarian background:
I find all of this especially interesting because my own drift from right-leaning libertarian to libertarian-leaning liberal has a lot to do with issues around the conditions for robust agency and the role of broad socio-economic forces in establishing those conditions, or not. I’ve come to accept, for example, that diffuse cultural forces, such as racism or sexism or nationalism or intergenerational poverty, can deprive an individual of her rightful liberty without any single person doing anything to violate her basic rights. This takes me a long way toward standard liberalism. But I find that my gut nevertheless leans right on issues of personal responsibility.
I agree that many people are in dire straits and suffering for absolutely no fault of their own, and that policies ought to be in place to provide meaningful material assistance. Still, I find I want an ethos of effort and individual responsibility to prevail, and I continue to think people who chose their way into trouble need to be told exactly what Welch seems to be telling the OWS folk: we’re not going to feel too sorry for you if you made some bad decisions about taking out mortgages and/or student loans, even if everybody you knew was making them too.
And here’s where he breaks ranks with progressives:
Progressives are sincerely inclined to impersonal, socio-cultural explanations of success and failure, but I think they’re also generally of the opinion that an ethos of initiative, hard work, and individual responsibility will impede the political will to offer assistance to those who ought to get it. I’m not sure that they’re wrong. After all, those who tend to oppose progressive transfers tend to do so partly on the basis of their disbelief in the faultlessness of the needy.
Here’s what I think most conservatives and libertarians fail to understand about liberals. On one hand, we have political philosophy and on the other we have personal philosophy, and they are not the same. I’ve been saying since 2004 that liberals are values voters just like conservatives, it’s just that our values are different.
The sentiments he ascribes to progressives do capture our political philosophy quite well, but not our personal philosophy. I see myself as an agent who has great influence over his own fate, and hold myself responsible for the poor decisions I have made. And when it comes to friends and family members I feel the same way. It would be nice if nobody I knew were without health insurance, but my advice to those who are is to find a way to get a job that provides health insurance. Or to save money they spend on other things and buy individual health insurance instead. My advice to people who can’t afford to pay their bills is to look harder for a job, to acquire new skills, and to cut expenses. At the individual level, the ethos of personal responsibility is the only one that makes sense.
Regardless of what I (or progressives) think the government should do, the truth is that waiting for someone else to bail you out is obviously a non-starter as a personal strategy. As a voter and an activist, my goal is to see the government do more to help people who are victims of the current downturn and of long term economic trends. But at the personal level, my goal is to encourage people to do more to take care of themselves.
Among the people I know, differences in political philosophy do not translate to large differences in personal behavior. Liberals tend to be just as frugal, industrious, and responsible as the conservatives. They also tend to hold themselves to the same moral standards. The idea that a progressive political philosophy translates to a hedonistic personal philosophy is simply incorrect, and I think that most anyone who knows any actual liberals would agree.
Former Google Reader product manager Brian Shih runs down the problems with the new Google Reader. Sometimes linking to something feels like signing a petition. This is one of those times.
Via Tim Bray, an excellent essay entitled Your code should be as boring as possible by Emmett Shear of Justin.tv. Yet another example of the brilliant stuff that’s appearing on engineering blogs from tech companies.
Ars Technica asks, how much data does Siri use?
Stephen O’Grady talks about things that should concern Google about Android. Speaking as someone who isn’t an Android fan, I see it as the least common denominator. It provides an iPhone-ish experience and handset makers can use it without paying for it, so it has taken off. The only thing its success proves is that giving something of value away for free is one way to gain traction in the marketplace, especially when no viable alternatives exist.
This weekend, Tim Bray posted a link to an article at Seldo.com that argues that ORM is an anti-pattern. If you don’t know what ORM is, you probably won’t find this post very interesting, but I’ll provide a brief definition. ORM (object-relational mapping) is a layer of abstraction that stands between your database and code and allows you to treat entities in the database as native objects in whatever language you’re using. The advantage and disadvantage is that it substitutes native calls for SQL.
The linked article does a good job of going over the downsides of using ORM, but I think it ignores the upsides. His most compelling argument is that you should be using SQL appropriately in your application rather than trying to avoid it using ORM instead:
But in my experience, the best way to represent relational data in object-oriented code is still through a model layer: encapsulation of your data representation into a single area of your code is fundamentally a good idea. However, remember that the job of your model layer is not to represent objects but to answer questions. Provide an API that answers the questions your application has, as simply and efficiently as possible. Sometimes these answers will be painfully specific, in a way that seems “wrong” to even a seasoned OO developer, but with experience you will get better at finding points of commonality that allow you to refactor multiple query methods into one.
I think that he undersells the utility of ORM when it comes to simple queries and inserting and updating data. I work on a Web service that processes transactions. Each transaction involves a user logging in and the retrieval of a number of settings from different tables. When I’m done processing a transaction, I have to insert dozens of rows of data into at least half a dozen tables. All of the data that is retrieved and stored is already represented in the object model of my application. Hibernate, the ORM library we use, is remarkably good at pulling up the data when users log in using simple queries, and more importantly, saving all of that data using inserts and in some cases, updates.
Using ORM in the transaction processing context has saved me a massive amount of time over the years, and helped avoid stupid countless bugs involved with manually updating the SQL statements in the data access layer every time I update the object model. Coding that SQL by hand would offer nothing in the way of performance nor would it make the application any more understandable.
The main downside is that on the few occasions when I do have to write Hibernate code to ask questions of the database, I pretty much have to look up the proper approach every time. It would be much easier in SQL since I already know SQL very well.
The secret is, I think, to use the right tool for the job. The main manner in which we avoid the downsides of ORM is in not using it at all for the reporting part of our application. For reports, we use a data access layer that just uses SQL to access the database in a purely relational fashion. Just as writing SQL for all of the basic create/read/update/delete operations in our application would be painful, trying to write well-optimized reporting queries through the ORM layer would be as well.
Categorically rejecting a class of tools that are used productively on thousands of projects is just as silly as picking the wrong tool for the job. Either way, you give yourself more work than is necessary.