gdp

I clicked this link. The first paragraph claims there is something special about Go. I read until the end of the article, and I was still left wondering what was special about Go and what the author thought about it.

Well, the entire Green party opposed it. It was just Hughes that spoke.

The sad part is that he proposed an amendment to remove the disconnection provision, and it was voted down by Labour and National. What happened to having an opposition?

I believe that the National party in NZ believe that by implementing ACTA (that's essentially what this is) that they will curry favor in terms of a potential US free trade agreement. It's basically the US dictating intellectual property law to the world.

The reason to do it under urgency is that it's so incredibly flawed and unpopular, it probably wouldn't stand up to a normal democratic process. So by sidestepping the democratic process, it makes it much easier to get things done.

Here's the letter I wrote to my local MP. People are welcome to appropriate any bits of it to form their own indignant letters to elected representatives, if they like:

http://www.plsadventures.com/2011/04/i-dont-usually-post-non...

I'm not sure I agree with the somewhat lax use of "semantics" here. It appears to be mixing notions from formal semantics with (not formally defined) ideas from linguistics.

Also, it's a nitpick, but the frequently repeated phrase "HTML language" belongs in the same box as "ATM machine" or "RAS syndrome".

Sure, they are art, but that's not mutually exclusive with pretentious self-importance.

Allow me to quote a randomly-chosen comment from this thread:

> _why's influence isn't only in code, but in thinking. And if you look around, for example on github, you will see a lot of people hacking away for fun, trying out new stuff and just doing something they love to do. Did _why start this trend? He didn't, but he was a big advocate of it.

Yes, that's right, this person appears to be seriously suggesting that _why could have been responsible for people hacking for fun (in the "I'm not saying that...", right after saying it kinda way).

> I'd argue his unique way of thinking has also pushed the boundaries of programming as a science in the way that calculus changed people's ways of thinking about math and physics.

As influential on programming as calculus was on maths and physics? Really? _why is on equal footing with Newton and Leibniz now?

> As for his strange charisma, I would say _why is to programming as Ramanujan was to mathematics.

This one suggests that _why is to programming as a Fellow of the Royal Society was to mathematics! Awesome!

> I always thought he was one of the most creative people currently working in any medium,

Yep. That one pretty much speaks for itself.

I mean, the _title_ of the article is "A Tale Of A Post-Modern Genius".

Need I go on? I believe my use of the word "sycophantic" was justified and I stand by it. Genuine praise for someone's achievements is completely justified and should be given freely. This is not genuine praise. It appears to be a pissing contest between different people trying to find the most absurd hyperbole with which to describe the effect that _why had on them, the Ruby community, the programming world and the entire universe and all matter contained within it.

Oh, dammit, you got me!

Without knowing anything about you, on the basis of this comment, I suspect you are a much better programmer than most people who constantly talk about how difficult their programming work is.

I agree that computing as an activity has manifestations that could be understood to be art, but that doesn't make _programming_ art. Glorifying programming as an art is like glorifying spelling as salient to the quality of Shakespeare's plays. Programming is the act of expressing programs. Coming up with interesting things for those programs to do definitely follows a creative process of human inspiration, but actually writing those programs down is not an "art". It's a fairly normative process in most cases, and it can (and should!) be made more normative.

No, I really don't. I'm suggesting that self-importance is a negative trait for programmers to hold. To me, cat pictures and silly songs are actually just another form of pretentious self-importance.

I don't consider programming to be a much greater skill than the ability to install fixed wiring in a house or balance a budget. Are small business accountants "artists"?

Accordingly, programming is not _currently_ a science. However, I think that is a much better position to aspire to than self-aggrandizement and glorifying a skill that is really no different than any other skill that any suitably motivated 12 year can acquire with a couple library books and an internet connection.

With a science of programming, we can aspire to a position where programmers can at least claim to be engineers, and at least have good odds of most programming projects resulting in software of reasonable quality. Face it, there's good art and bad art, and it's subjective which is which. Programs have objective measures we can apply, depending on what the code is used for - developer time, performance, correctness... and a million others. We can argue about which measures are the right ones to use, but at least these measures exist. We can (with current technology) empirically evaluate a piece of code in many different ways. Actually starting to apply this kind of empirical evaluation is the first step towards programming being a science.

[Edit: OK, so the parent to this was heavily edited after I posted this, but I can't be bothered rewriting this accordingly, so please excuse any incongruence between this reply and the post it is replying to]

As opposed to thinking of yourself as Van Gogh or Warhol? Without any financial considerations, thinking of what you do as a scientific or engineering activity is much more conducive to the creation of good software. I'm suggesting that glorifying programming as an activity is a bad idea. I'd prefer programmers thought of their programming activities as no more important than any other kind of skilled labour (clerical/administrative, plumbing, whatever). Get your fun an enjoyment from the obviously creative parts of creating software. Or take up a real art form as a hobby.

Articles about _why on HN seem to always take on a particularly sycophantic quality. As a non-fan of Ruby, his contributions to programming outside of that community seem minimal. The ethic that people appear to ascribe to him ("programming as art") is precisely the opposite to that which I generally advocate ("programming as science"). I (and others) often suggest that the former approach is actually harmful to software quality in many cases, particularly within teams.

Fundamentally I think my objection is to elevating a slightly odd-ball programmer to messianic status based on a mildly creepy fandom that manifests primarily as people vastly over-stating the contributions of this one guy in HN comments.

It's almost impossible to over-state his contributions to computer science, particularly within programming languages, theorem proving and concurrency theory. I never met him, but I have followed and admired his work for some time, and this is a real loss to the community.

I agree that documentation is useful and important, but too much programming languages documentation really doesn't answer some fundamental questions about the semantics of a language.

All too often, this is because the programming language designers/implementors don't know what the semantics are.

greens?

A wonderful example of how to blow open silly arguments in one paragraph or less.

I'm not sure it's a particularly faithful port of ML, and particularly not SML. It doesn't really look anything like ML. It looks like a bit of a mishmash of syntaxes, if anything, so I'm really not sure what makes it "ML derived" any more than it is Python-derived or Algol-derived.

I'm not convinced that the answer is simply "functional programming". Don't get me wrong - I'm a big fan of functional programming, however I think that the bulk of evidence shows that the number of people willing to use functional languages is still relatively small.

I think we're likely to see more continuation of the trend of quasi-functional features leaking into imperative languages.

I also think that we'll see more of a shift towards features (such as type systems) that provide stronger correctness and safety guarantees.

And finally, I think the victor in any future programming language fight will be something that enables greater degrees of parallelism and concurrency (especially of a distributed nature) without significant additional effort.

So I think that will be what the masses want. As for me, none of the current crop of functional languages coming through particularly excite me. There don't appear to be any particularly "disruptive" technologies emerging into the PL mainstream, and even at the fringes there are only a few notable examples that I think could hold promise for more than the next 3 or 4 years.

If I were to believe in such a thing, it would not be because of a book. Things that are true by virtue of their truth are nonsensical.

I'm also not sure about answering this at all, because I think it's pretty far off topic for HN.

I'm with you on this one. It doesn't even seem to have even passing interest to the general HN audience as I understand it.

An internet community of musicians that I frequent collectively played with Hit Song Science during their "free trial" period.

Basically, we discovered that it doesn't do a very good job.

For example, I had a track that was 1:57 long with a very slow tempo and a minimal arrangement, however there was a slide guitar towards the end. This gave it a really high affinity with a bunch of US chart-topping country & western hits, and so it had a score of something like 8, which is just absurd.

So while I like the general principle, we discovered very quickly that its "similarity" metric is probably just too simple. There seemed to be a very weak correlation between songs that we thought sounded like hits, and the score they got on HSS.

Alternatively, "The now over-appreciated art of duct tape programming".

Seriously, if I see one more article which features "duct tape" in the title, I'm going to start extolling the virtues of the wood-glue programmer. I have no idea what this characteristics of this programmer would be, but you can bet that the label would be repeated frequently!

I inherited a giant hideous stock-management system. It did a certain amount of automated ordering without manual intervention.

Long story short: a nasty race condition meant that it was over-ordering duplicate products from the suppliers to the tune of tens of thousands of dollars per day.

On the general theme, my most frightening software experience was when I met a guy who was the star programmer for a company doing controllers for elevators. I got talking to him, and he showed me some code. It took me about 15 seconds to identify an edge case that would engage the motor while the elevator was at the top floor (thereby attempting to pull the elevator into the roof?). It took me a further hour to explain what the edge case was. The bug wasn't that scary, as I'm sure there are hardware failsafes, but the general dimness of the guy writing software to control lifts was scary.

I started taking the stairs after that.

I have enormous respect for business people who have no technical knowledge, and behave accordingly.

Conversely, if you know that you know nothing about parts of what I do, then why do you feel it's necessary to have input into it?

I think knowing your own strengths and weaknesses and allowing others to employ their own strengths is just as valuable a skill as actually learning a bunch of technical stuff.

From my own experience as a confirmed programmer with little interest in business, here's a couple of observations:

Programmers end up knowing a heck of a lot about the business just by virtue of needing to know how it operates in order to turn it into software. Use this knowledge. Include programmers in high-level discussions occasionally to get "buy-in" at an early stage of development (before anything like "requirements gathering" happens). This reduces the possibility for mismatch in expectations between "business people" and "programmers", which is a ready source of unhappiness for programmers and business people alike.

I've always been happiest and most productive in situations where the business people above me shield me from the other business people and let me get on with my job. So many others have observed how detrimental interruptions and rapidly shifting requirements (i.e. more rapid than 1 iteration) can be. Insulate programmers from the kinds of problems which are really no concern of theirs. Be the point of contact for other people who need programming things to happen (either as external or internal stakeholders). That's not to say that a programmer shouldn't be interacting with all areas of a business, rather, they should be able to do it in a structured way, not as a never ending stream of interruptions and fires to extinguish on an ad hoc basis.

I seriously hate these lists. Top 100 universities at doing what?

There's no point being in the crappiest department of the "best" university.

Well, the main thing would be to operate in a store-nothing kind of way. There has to be a fixed amount of storage required no matter what the length of the input is. You'll need to keep aggregate totals and compute over each row, as opposed to storing any data.

The parsing should be simple. Lex and/or Yacc should handle very large files. If not, you can always write something by hand, once again sticking to the store-nothing principle.

I would think about it as a fold operation (http://en.wikipedia.org/wiki/Fold_%28higher-order_function%2...) over the lines in the file, where the parser state and any aggregate calculated values are stored in the accumulator, and each new line is considered in conjunction with the current state and the previous calculated values.

I don't think I understand the question. Are you actually asking how to read from a terabyte flat file, or are you asking how to process a terabyte of sequential data? They are two (related) but distinct questions.