488 karma · joined January 30, 2009
Email: toby@arcticrex.com Twitter: @tow21
Sounds like a win to me.
http://en.wikipedia.org/wiki/Billion_laughs
Same is mostly true of JSON parsers as well of course.
If you let potentially hostile users feed arbitrary data into any of these, even a totally non-buggy, perfectly conformant parser is wide-open to being abused via DOS.
At the moment, both those prices are strongly dominated by the cost of processing, I would imagine. At some point, it could well be the scarcity you're paying for with copper, though.
Scarcity increases price, and two orders of magnitude is hardly inconceivable.
See, for example: http://blogs.wsj.com/informedreader/2007/05/25/a-metal-scare... which talks primarily about LCD displays (we're fast running out of Gallium/Hafnium/Indium), but points out that copper is likely to get significantly more expensive throughout this century.
That's going to increase the price/performance ratio of practically everything.
And since you've got both "git commit --amend" and "git rebase -i" to hand, it's trivial to later on fix up any mistakes you do make.
Honestly, having a clean history is an enormous win - it far outweighs the minor cost of making the odd wrong but easily-correctable-after-the-fact commit.
When all that I get in return for open source software is goodwill/karma/recognition, then there's no quid-pro-quo going on, and valuation is explicitly in non-monetary terms.
As soon as you start sending physical goods around, you're making it look like you're assigning direct value to my labour. I suspect my reaction to a company t-shirt in the post would be either
"You think so little of my work that it's worth one lousy t-shirt?"
or worse
"Not only are you profiting off the sweat of my brow, you want to me to wear this tshirt & give you free advertising?"
I don't claim this is rational - but I suspect I'd react emotionally that way.
Exactly. If you go down this road, you want big companies to be scared of potential liability. Then you offer to grant them a traditional software license for a traditional sum of money, just like they're used to, and everyone goes home happy.
Why would I want to waste brain time deciding which box to type in if Google will do the right thing either way?
(and about 1% of the time I'm constructing a URL to a test server on localhost. Then I use the address bar - for some reason, google seems to give much poorer results for localhost URLs.)
(Read Peter Ackroyd's "London: The Biography" for a good overview)
And in this context, I think that's fair enough. There are far more developers out there with more than a passing familiarity with Java & the Java toolchain, than there are for Objective-C/XCode.
By the sounds of it, it will be easier for those developers to develop for Android phones than the iPhone. Regardless of the relative technical merits of the platforms viewed in isolation, the ability to re-use your existing Java chops is going to be valuable.
(I speak as someone who has done equally small amounts of development in both environments - personally, I prefer Objective-C development)
(and I only need one coffee cup at a time. Keep your refills within arms length!)
"On the other hand, I look at the online public sphere and too often tend to find myself thinking: “Discourse at this level can’t possibly accomplish anything beyond giving people some simulation of justification for what they wanted to believe in the first place.” This is, needless to say, not a problem limited to philosophy."
ie, if you had an enormous immutable value (in Python, a tuple with lots of entries), then in a hypothetical Python implementation which did call-by-value, it might be significantly slower than call-by-reference, on account of having to copy the entire tuple.
But this falls squarely into 'implementation detail' - if you're so inclined, you could implement either CBV or CBR in hundreds of other ways. Certainly from the perspective of time-independent program behaviour you shouldn't be able to tell the difference.
Fos most of the rest of his issues, I think Zed's problem is that he thinks there's one obvious answer, but lots of other people would disagree with his one answer. Python tends to be either very opinionated, or very agnostic. Where there's One Way To Do Things, that's what you must do; except where there's obvious disagreement in which case it doesn't bless a single answer.
API doc autogeneration; I can guarantee that if anyone came up with a default tool with default output such that "doctool module html_directory" was all you needed (and indeed people have) then there would be widespread, perfectly legitimate, disagreement on any number of choices in the design of it.
(Prsonally, I think API doc autogeneration is entirely pointless, and indeed fundamentally the Wrong Thing To Do for most Python libraries. When I come across pages of JavaDoc-ish API documentation, I groan internally and just look at the source instead.)
Not that the chances are any good, and I can understand why - it would be decidedly un-Pythonic. But it's just mildly frustrating at times when I find myself writing the same coupe of lines of code twenty times within a file, because scoping rules insist they have to be there (reading from locals() is often where it hits me))
Better to have the process neither know not care about its daemonized status, which is not really core program logic, and have the process monitor manage daemonization, à la http://cr.yp.to/daemontools.html
As best I can tell, it's actually two questions merged into one, though the answers are still separated out, except the answer to the second question seems to depend on the first; but the first question isn't simply yes/no, it's yes/no(A)/no(B)/no(C), and by the time I've finished trying to parse the question and the proffered answers I've given up caring.
I can guess at what it's asking, but I'm a software developer. How is a normal end-user supposed to make an even halfway-informed choice?
If Windows is going to push these choices out in front of me, it needs to ask questions users can understand.
"you & I have cooked up an agreement to increase your salary more than those around you, and this NDA will let us avoid the social awkwardness that would otherwise result."
(and the implicit message is always "more than", whatever the facts) Meanwhile, of course, you'll always be looking at your colleagues, wondering how much more than you they might be making.
Unless you're working in an environment where negotiation is a part of the job, then I don't see why rewarding it makes any sense.
Of course, there's nothing to stop your better negotiators going and finding a better deal elsewhere - but I see no reason why "better negotiatiors" equates to "better programmers", and there's always going to be some reason why some of your employees might want to move on.
I really want something reliable where I can just pay someone to do this for me, so I don't have to worry about it.
I find that if your problem is not very domain-specific; ie if you can strip out the labels, and consider what you're doing as manipulations of relatively abstract objects; rearranging lists and graphs and so on - then up-front thinking is repaid many times over.
There tend to be lots of corner cases (what if this list is empty, what if this graph has no nodes, ...) and accidental infinite loops you can fall into. Thinking about it and specifying the algorithm up front forces you to take a coherent view on your problem domain.
If you approach this sort of thing iteratively (well, if I approach this sort of think iteratively) I tend to find that even if I can get my initial usecase working quickly, I haven't got the problem well enough established in my own mind, so I end up fixing things in an ad-hoc manner, squashing bugs in one corner case only to find 5 or 6 cropping up elsewhere because eg in half the code I assume X can never be 0 while in the other half I've been using 0 as a marker value for invalidity.
Solving that sort of problem I find is much better done by thinking hard about it before hand and working out what you're trying to do. Of course, in any case, you should surround your method with lots of testcases documenting what it's doing as well.
This is very different I think from the argument of agile development against waterfall-style development. The hard thinking in this case is at most a few hours - it fits in entirely with agility.
1) I find IRC completely unusable - I've been on the net since 1994, I've tried IRC multiple times, and it just doesn't gel with my head, sorry.
2) I don't use SO when I need an immediate answer. At the very least I'll put a query in, then wander off and google some more in the hope of finding an answer, then come back in half an hour. More usually I'll leave it overnight while i get on with something I do know how to do. It feels like the same sort of dialogue timescale as a mailing list query, but for where there isn't an appropriate mailing list.
But I may not be typical.
Writing unit tests up front forces me to write the code in a way where inputs & outputs can easily be stubbed out, which in turn makes writing messy interdependencies simply too hard!
Basically, if I write with unit tests, it becomes easier to write maintainable code, and harder to write unmaintainable code.
Also, I'm not convinced your google account sign in thing works right; I clicked on it to login to google, and then google didn't know where to redirect me to.