keyist

I consider it good practice to allow users to customize where your program creates files. I don't like $HOME to be the default dumping ground for anything I run.

A standard that uses environment variables means programs don't have to provide extra options for this customization (I've seen -f,--file , -c,--config and other variants). It allows for common code (libraries that implement the spec).

If you poke around for feature requests for various open source programs, you'll find XDG basedir compliance come up occasionally (moreso for CLI utils). I wouldn't say "nobody seems to be using it"; quick scan of my folders includes Chromium, uzbl, htop. Git's next release will be compliant too.

Instead of putting a dotfile or dotdir in the user's home directory, do follow the XDG Base Directory specification: http://standards.freedesktop.org/basedir-spec/basedir-spec-l... .

It's easy to understand and requires only a marginal increase in effort/code.

"Between semicolon-free folks and JavaScript traditionalists, who gets to play the role of the expert?"

You're framing this as a disagreement between equals. It is not. There are degrees of expertise. (Total lines of production code * amount of usage) is a reasonable approximation, and those who rank highest on this scale are overwhelmingly in favor of requiring semicolons.

If Carmack and Torvalds were in agreement on a C best practice while Odesker^W^W^W^W^W^W^W Topcoder user #12571 said to do something else, I wouldn't go with the latter.

Google, responsible for a JS engine, multiple compilers that target JS, and what is likely to be the single largest JS codebase of any company: http://google-styleguide.googlecode.com/svn/trunk/javascript...

Brendan Eich: "The moral of this story: ASI is (formally speaking) a syntactic error correction procedure."

Or you can go with the Node.js guys.

You can't have a "How to Learn Haskell" post without mentioning the Typeclassopedia: http://www.haskell.org/haskellwiki/Typeclassopedia

For those going through LYAH, I highly recommend supplementing chapters 11-13 with this excellent resource.

This is a great post that gets mentioned from time to time and covers the underlying theory well. I'd supplement it with Chapter 9 of the Pro Git book: http://progit.org/book/ch9-0.html , which focuses more on the actual implementation and shows how to create commits from scratch using Git's content-addressable primitives.

RMS has the FSF and Defective By Design sites as soapboxes if he wished to gain more attention from Jobs's death. This was a post on his political notes page. He did nothing to publicize it.

He didn't post to aggregators or tweet to ask for upvotes (technically it was posted on his Identi.ca account which is linked to his political notes feed, but it got no special treatment).

If some major sites hadn't picked up on it and provided the publicity, most readers would never know. So RMS wrote a politically incorrect opinion on his personal page. Can we move on now?

I was going to say something similar but you've done it much better, with a story to boot. So I'll just chip in with one point I had that you didn't cover directly.

A lot of the posts here are generally of the form "you can't speak ill of the newly dead". (Why? Because that's what regular people do, that's why). But adhering to social norms takes away from freedom. Indifference to what society prescribes is consistent with RMS's beliefs.

Call him what you want, but the man is consistent.

I'm guessing a lot of the angry responders here will have similar "I'm glad he's gone" feelings on RMS's death. Would not publishing those feelings give you the moral high ground over those who do?

Tarsnap gives deduplication, compression, and encryption. Some technical background on how it does this here: http://www.tarsnap.com/efficiency.html

There is a detailed breakdown provided as well. Sample output:

                                         Total size  Compressed size
  All archives                               697 MB           323 MB
    (unique data)                            215 MB           100 MB
  This archive                               148 MB            67 MB
  New data                                    17 MB           5.2 MB

If you're not using Bundler and have a simple dependency chain, you can get further improvement from symlinking your gems into a single directory (see https://gist.github.com/975509 ).

This patch certainly improved my load time tremendously, but the core of the problem still lies with the way rubygems and bundler dump all directories of gems in the load path. The promise of $LOAD_PATH is that all the directories in it will be tried -- the most bang-for-buck optimization is thus minimizing its size.

"My goal in not showing points on comments was to prevent the sort of contentious exchanges where people (in this case literally) try to score points off one another."

I think a suitable compromise would be to hide for X days until most voting activity is over (reusing the threshold where downvotes are no longer available but upvotes still are might work). This would still meet your goal without the cost of information loss.

EDIT: I'd hate to give up lists like http://top.searchyc.com/comments_by_points and http://top.searchyc.com/users_by_average_points_per_comment .

You want them to think "is this interesting and on-topic for HN?"

My earlier proposal (http://news.ycombinator.com/item?id=2242453 ): deduct karma from submitter and _anyone who upvoted_ on submissions that were successfully flagged. That should get people to think the way you mention not only when submitting, but when upvoting as well.

Improve the submissions and comments will naturally improve -- submissions that are one-sided/gossipy/demagogic tend to attract similar comments. Whereas submissions full of technical content are often rich with links to further reading, contrasting viewpoints with cited evidence, etc. (Disclaimer: observations in this paragraph may be subject to fundamental attribution error).

For the love of Kernighan & Ritchie, please do not promote this as "a convenience library aimed towards non-expert users." The only way beginners are going to learn is experimenting with the command line, not having their hands held with a tiny subset of what's available.

And the positioning -- what's agile about knowing your public ip or uploading images to imgur? Is this a belated April Fool's day joke I'm not getting?

Ok, now that I'm done venting, here's the *nix equivalents for all but the pair command (will edit in. EDIT: added. also did s/python2/python):

    # base64 is already a command, supports -d

    function imgur_up() {
      curl -F key=yourkeyhere -F "image=@$1" http://api.imgur.com/2/upload
    }   
        
    function public_ip() {
      curl -sL myip.dk | egrep '[[:digit:]]{1,3}\.[[:digit:]]{1,3}\.[[:digit:]]{1,3}\.[[:digit:]]{1,3}'
    }   

    function sloc() {
      sed '/^$/d' $1 | wc -l
    }

    # no args clears users
    # with args, assigns usernames
    function gpair() {
      if [ -z "$1" ]; then
        echo "Resetting to default user"
        git config --unset-all user.name
      else
        git config user.name "$(echo $@)"
      fi
      echo "User is now: $(git config user.name)"
    }

    function tab_to_space() {
      sed 's/\t/  /g' $1
    }   

    function space_to_tab() {
      sed 's/  /\t/g' $1
    }   

    function url_decode() {
      echo "$1" | python -c 'import sys,urllib;print urllib.unquote(sys.stdin.read().strip())' 
    }   

    function url_encode() {
      echo "$1" | python -c 'import sys,urllib;print urllib.quote(sys.stdin.read().strip())'
    }   

    function web_serve() {
      python -m SimpleHTTPServer
    }

"Ability to type quickly and accurately maximizes the effectiveness of time spent in the flow of programming. Hunting and pecking means you only capture a fraction of what could have been done."

I submit that typing speed matters, but only as a component of what I'll be unoriginal and call actions per minute (significant APM, to be precise). More important components of SAPM would be pushing blobs of text around (editor knowledge) and manipulating/filtering blobs of text efficiently (Unix toolchain).

A 60wpm developer who uses rectangle commands and pipes a portion of buffer to shell to transform it may have higher SAPM than a 150wpm developer ignorant of the various shortcuts available.

To further flog the RTS analogy: typing speed and keyboard shortcuts that operate on one line are micro. Regex replace, sed/awk-fu, multiple buffer usage, etc are macro. To be an efficient dev both are necessary but not sufficient -- all the micro and macro in the world can't save you from brain-dead decisions.

Another good resource is the Japan Subculture Research Center by Jake Adelstein (American journalist who spent 12 years in Japan on the crime beat for the Yomiuri Shinbun).

Sample post: the yakuza's role in relief efforts -- http://www.japansubculture.com/2011/03/the-worst-of-times-ca...

PS. Off-topic, but calling Stross a "pop-sci-fi author" is an injustice! Kevin Anderson and Orson Scott Card are pop-sci-fi authors. Stross writes hard science fiction.

Thanks jacquesm for showing us that it is possible to be content without being complacent, to persuade without proselytizing, to educate without ego obstructions.

My praise would probably be over the top were OP a standalone post, but I reckon it deserves that recognition given the contrast in tone with the posts it references. Hopefully OP inspires more rationality (http://lesswrong.com/lw/31/what_do_we_mean_by_rationality/) and balanced writing in submissions/comments.

I like the poll option of making the flag button more powerful, but it wouldn't do enough on its own. In addition to that, I'd like to dock karma when a submission gets flagged: -1 karma for each user who upvoted, -10 karma for the submitter.

There are no repercussions for upvoting or submitting questionable content at the moment. While my proposal is only a small penalty, hopefully it gets people to at least think before actions that potentially increase noise.

Edit: I meant "when a submission gets successfully* flagged", ie killed. Thanks davidw for pointing out the ambiguity.

Great advice. The most important part of #3, "stress how much more you’d like to do going forwards" isn't highlighted enough, however. That is, you have to establish clearly what you're looking for. The template is:

  In X months I want to be making Y.  What needs to happen for me to get there?

Then, you need to occasionally ping your manager to see how you're tracking towards your goal. This gives you an indication of progress, and uses human bias towards consistency (as described in Cialdini's "Influence") to your advantage. If your manager has been telling you that you're on course for the 150k you asked for over the course of 6 months, it'll be difficult to suddenly reverse when decision time comes.

"But our system at least makes these things aberrations and provides dissenters a way to rectify the problems in the courts."

What a lot of people don't get when they try to tu quoque US/Canada/etc on particular events is that their protection of essential liberties is defense in depth.

If a book was banned:

- due process means that this incident can be taken to court

- freedom of press means the mass media can inform others of what has happened

- freedom of speech means you can raise awareness about the banning and denounce the agencies responsible

- with freedom of assembly, those who want the ban overturned can take to the streets and protest

These freedoms are mutually supportive -- abuse of any aspect would be mitigated by the presence of the rest.

"There are maybe two(!) good books on the subject, Peopleware and Making Software."

What about Fred Brooks's works? Not being facetious -- curious to know if they slipped your mind or if you just don't rate them.

Criminally underrated comment on the topic: "Part of the problem is that the discourse on methodology is mostly conducted by people who don't themselves do the work. Imagine a bunch of managers working out a 'process' for, say, mathematicians. They'd be laughed out of the room." (gruseom, http://news.ycombinator.com/item?id=406051)

Along that vein, while we're talking scientists -- are there studies on scientist productivity? Even for computer scientists, I'm pretty sure no one's going around debating whether an academic paper is better if it's written by two researchers versus one. The one obvious parallel I can think of is peer review vis-a-vis code review. But that is a process for after the initial work is produced, not one that dictates how someone should conduct the thinking process for their job.

"As an aside, the creator of pinboard, is the anti-PG, (or at least the anti-PG of 2005)"

That is an unfair and extremely misleading label to apply to the author:

- your selective quote is immediately followed by "Hee hee", which most readers would interpret to mean that said paragraph (or indeed the entire post, since those are the last two words) is a somewhat good-natured poke.

- the criticism in the post is scoped only to the hackers<=>painters analogy

- elsewhere in the post he says "Graham is an excellent author when he sticks to topics that he knows well"

Hardly anti-PG. He's just not a fan of the analogy PG used in some essays. Don't drum up conflict where there is none.

It's particularly amusing to see someone spout off on HN of all places, with the sheer number of CEOs, CTOs, and successful founders (http://samsnyder.com/2010/11/19/successful-people-on-hacker-... ). Not to forget successful authors (cstross) and someone like cperciva whose accomplishments would require pagination.

None of whom feel the need to reference their position or achievements unless providing clarification, context, or disclaimers.

Switching back to my regular voice, because there are points to make that I can't shoehorn into the fisking format.

"Berners-Lee and W3C get way too much credit for the web". Putting 'Web Founder' in airquotes. This blatant disrespect is what angered me the most and influenced my decision to fisk instead of a polite rebuttal.

Tim Berners-Lee:

- was the first to execute on the idea of combining hypertext with TCP/IP and DNS

- wrote the first browser and HTTP server

- gave it away instead of encumbering it with patents or royalties

- has the humility to downplay his accomplishment and share the credit where it is due: http://www.w3.org/People/Berners-Lee/Kids (under "Did you invent the Internet?")

- continues to work on the web to make sure it remains open and transparent instead of resting on his laurels assured of his place in history. The Scientific American essay is but the most recent example

I'm not sure what more he would need to do to be considered the founder of the web.

> I think that Berners-Lee and W3C get way too much credit for the web. And this is an incredibly arrogant statement by Mr. Berners-Lee.

I also think that green is a totally awesome color, and that we can breed birds with horses to produce pegasii. For more attacks on the W3C at best tangential to Mr. Berners-Lee's actual essay, read on.

> Facebook has in-fact done some serious web innovation the last years and W3C has completely dropped the ball. Facebook and Twitter have been catalyzing internet adoption and the general spread of information.

I'll conveniently ignore companies like Flickr, who innovate without compromising data portability: http://laughingmeme.org/2010/05/18/minimal-competence-data-a...

> Mr. Berners-Lee's obsession about content-silos shows that there is a serious disconnect between the current state of the web and W3C. The web was about content and documents fifteen years ago, now it's about the flow of data.

Those URI thingamabobs that send you to content or documents? The web isn't about that anymore. It's about a golden shower of data, flowing down the firehose. You see, when people look up stuff on Wikipedia, they don't care about the page they're on, but the activity data on who's flowing in and out of it.

> I know Berners-Lee is a big Linked Data advocate, but the approach that's being taken by the W3C is painfully slow and doesn't take into account the fluidity of information.

See I took "flow of data" from my previous paragraph, applied my nifty FaceTwit thesaurus to it, and turned up "fluidity of information". More of my fluids to come.

> This is one of the reasons why developers (and even semantic web developers) have resorted to non-W3C technologies more and more: JSON, Javascript-wrappers, Webkit, client-side routing, non-REST HTTP requests, IOSockets/Coment, streaming apis, etc.

Look at me! I'm namedropping web technologies more than hip-hop artists namedrop the Notorious B.I.G or Tupac. I can do this all day: XML Servlet configotrons. Buffered packet gumballs. NoSQL big data Hadoopian piglets mashed up with tagsoup gravy. Activity ICMP hosepipe of RSS-killa sauce.

Pay special attention to my mention of non-REST HTTP requests. You see, REST HTTP requests are a W3C technology. But non-REST HTTP requests? That's not W3C, that's those innovative guys down the hall, second room to the right.

> The web is emergent and out of control. Deal with it. Technologies and tools compete for attention and adoption. You snooze, you lose.

Now I switch from my awesome web developer hat to my social media evangelist hat. This paragraph is not only a segue, it also panders to those of you playing buzzword bingo!

> As for the 'content silos': Are you fucking kidding me? 'Content' being stuck in Facebook is not going to happen, in fact, the content is going to flow more and more. If you mark something as 'only my friends can see this', it will leak. Don't want to be tagged in a picture? Well, you have no choice. Face recognition will get you soon.

I mentioned flow of data previously. But now it's the content that's flowing. The ultra-innovative internet catalyzer Facebook won't be able to keep your data private. Why? Because I say so, that's why.

> The internet, thanks to social web, is a giant copy machine. There's a huge shitstream of content and your attention and the activity around it is the thing that matters. Who cares about the damn content.

Want to know the internet's secret? No one watches Youtube videos. No one shares links to content on Twitter and Facebook. They just look at the activity around it. In fact, if my pal Tim BL didn't write this _content_, I'd still have some activity to do! Furious activity in fact, in the privacy of my room while penning my next ode to Facebook and Twitter.

Btw if you haven't been keeping up on my use of liquids, we've gone from flow to fluidity to shitstream. Which mirrors the general coherence of this comment.

> So maybe it's time for the 'Web Founder' and the W3 Web Museum to roll up their sleeves and do something, instead of bitch about the companies that actually advance the web.

Apple, Google, Microsoft, and the other _companies_ that are members of the World Wide Web _Consortium_ better start rolling up their sleeves. They aren't doing anything to advance the internet.

> So instead of bitching about the companies and people that actually advance the web and change the world, maybe it's time for the 'Web Founder' and the Web Museum to roll up their sleeves and do something...

That last paragraph was so good, I'ma say it twice while flipping the order of my sentence. That's activity, you see. With activity, you can copypasta content, because no one cares about content anymore. And now that I have proven my point, my point is proven.

GP is trolling. No need to counter-troll while feeding. The flamebait on committing to Ruby does not invalidate his point on stdlib maintenance though.

We can sit here and ping each other with examples of cruft all day. I think it can be shown objectively that Python's standard library is better maintained. I'll attempt to below.

I'm not saying this has a great significance in picking one language over the other in and of itself. Just that if you want to talk specifically about stdlibs, the differences are pretty clear-cut imo.

== In terms of quantity of updates ==

- Mar 13 2007: Ruby 1.8.6 launched

- May 18 2008: Ruby 1.8.7 launched

- Distance: ~14 months

- Sep 19 2006 Python 2.5 launched

- Oct 18 2008 Python 2.6 launched

- Distance: ~23 months

So discount the amount of 2.5->2.6 changes accordingly to account for the extra time.

Then compare stdlib changes:

- Ruby: http://svn.ruby-lang.org/repos/ruby/tags/v1_8_7/NEWS

- Python: http://docs.python.org/whatsnew/2.6.html#new-and-improved-mo... or http://www.python.org/download/releases/2.6.1/NEWS.txt

== In terms of quality of documentation ==

Compare

http://www.rubydoc.info/docs/ruby-stdlib to http://docs.python.org/library/

You'd need to compare across actual libraries (unittest vs Test/Unit etc). I didn't provide specific examples in links to avoid inevitable accusations of cherry-picking.

== In terms of process ==

Compare http://www.python.org/dev/peps/pep-3108/ to... closest equivalent I could find was http://redmine.ruby-lang.org/projects/roadmap/ruby-19 . Anyone with a better link?

I hate to dump on someone's effort to motivate others, but this post is a dangerous extrapolation that combines Outliers [1] and the author's personal experience.

It promotes the idea of a magic number, and that hard work and time leads to returns (not true for the majority of startups). It encourages thinking like "Man I'm at the 950 hour mark, I'm almost there!", or even worse, planning one's product milestones around time spent.

One of the main attractions of the 10k hour rule is that there are few external stimuli that can negatively affect your learning/training.

If I decided to invest time in taking up the trumpet, I don't have to worry about competition with other budding trumpeters or whether BrassCrunch or Spitter News have effusive posts on my latest performances. I won't have to determine which percentage of the public 'gets' trumpets and plan how my playing should appeal to them.

With proper practice one hardly ever goes backward -- ability increases monotonically give or take a few plateaus. With startups you often go backward as you try to figure out your product-market fit and so on. Userbase size or revenue would not increase over time the way ability does when it comes to personal improvement.

1. I haven't actually read Outliers but I'm familiar with its thesis. If it's anything like Gladwell's other books, I recommend The Talent Code for better treatment of the subject matter. Norvig's http://norvig.com/21-days.html is also great reading.

Great post, summarizes the options well.

For completeness, here are a class of Free Trade Agreement visas that are similar to the H1B:

- The E-3 visa for Australians http://en.wikipedia.org/wiki/E-3_visa

- The H1B1 visa for those from Chile or Singapore: http://en.wikipedia.org/wiki/H1B_visa (search for 'Chile')

If you are from one of those countries and looking for employment, be sure to bring up those options. These visas are much more attractive to employers because they involve less paperwork/requirements and have priority over the regular H1B cap.

One issue with software methodology assessment is the difficulty in getting consensus on ways to determine code quality. One potential experiment I've been thinking of to work around this is by seeing if 3rd parties can tell if a methodology was used. To abuse OP's analogy of debug statements, this is essentially a "assert this practice makes a visible difference".

Have Alice and Bob sporadically use practice X on a group of changesets and track the time spent on each. Eve and other coworkers then go through the resulting list and try to determine which changesets used practice X.

There will need to be practice-specific variations of course. For example if experimenting for TDD, the changesets obviously need to include tests and code in the same commit (without indicating which came first). If experimenting for pairing, should probably report the time elapsed as the pair worked on it, instead of summing the time spent by both developers.

Just thought I'd throw this idea out here where it's somewhat on-topic and see what y'all think about its feasibility. If anyone tries this out I'd love to hear the results!

You'll enjoy the posts below then. Matt Taibbi takes skewering Friedman and raises it to the level of an art form:

- http://www.nypress.com/article-11419-flathead.html

- http://www.smirkingchimp.com/thread/5950

- http://www.nypress.com/article-19271-flat-n-all-that.html

- http://trueslant.com/matttaibbi/2009/04/23/tom-friedman-stri...

More interesting albeit difficult to quantify would be PG's writing style.

If you've read a PG essay and found yourself agreeing because you're gradually taken towards a conclusion yourself instead of having it preached to you, you'll know what I'm referring to.

Turns out there is a style for that.

I am no writing expert, but I feel PG's style is (intentional or otherwise) most akin to Classic Style as outlined in the book "Clear and Simple as the Truth" (overview from Robin Hanson of Overcoming Bias here: http://www.overcomingbias.com/2009/03/deceptive-writing-styl.... ).

Most telling excerpt: "Classic style is in its own view clear and simple as the truth. It adopts the stance that its purpose is presentation; its motive is disinterested truth. Successful presentation consists of aligning language with truth, and the test of this alignment is clarity and simplicity."

CaSatT homepage: http://www.classicprose.com/

"Instead we reward people for being smart -- for learning more and more details about trivial libraries that will be deprecated in ten years' time."

I get what the author is trying to convey in this post, but I feel he is unintentionally attacking a strawman.

I don't think many developers set out to memorize small details of libraries -- it's just something they pick up naturally over time with more usage.

My take is: on the surface, knowledge based on experience often seems like memorization. That's because when say Alice brings up a better way/library/tool, she's acting as a layer of abstraction.

You don't immediately get to see the internal processing Alice is doing to decide which library to use and why it is the best choice for your specific task. All you see is her output: "here's what you use in this situation". This isn't about knowing trivial details of libraries. It isn't about rote learning. It is the practical application of knowledge borne out of experience.

That experience is what is being rewarded, not the memorization. How to tell the difference? The best developers come with introspection tools: they are able and very willing to explain the reasoning behind their recommendations in detail.