pmr_

72k can keep you alive on sub-standard living conditions, but it will not keep a team of 6-7 talented programmers and artists alive for very long. Not even for way below market pay and working in a garage.

And a single person just cannot turn out something close to a AAA title.

How do you know that? Have you had any practical experience with a large code base using new style (e.g. post-C++11) Concepts? People have been using Concepts in some form for a very long time and even properly documented they can still be a major hurdle to less advanced or interested users.

The Wikipedia article linked in another reply to parent confirms that. The months in which the worms were harvested were named after the worms.

I just went clicking randomly on Vimeo links and I didn't find a single auto-playing video.

You are right about YouTube and I actually think they should handle visitors that come from outside YouTube differently than visitors from inside the site. In the first case auto-play is annoying in the second it is what is wanted.

As others I had a totally different expectation given the title. I thought it would be a piece about how Wikipedia had some message or lesson that we should listen to. I think the author had no bad intentions and what he build is probably worth looking at. I was just pointing out how a mistake in web design made me completely ignore this website because I felt it violated my control over my computer.

Why should I adapt my usage patterns to accommodate the shitty behavior of a few websites? Also, are you sure you are in position to tell other people how to use the web? I certainly don't think I am.

Starting to play sound without user confirmation is a default tab-close. I wont even take the time to look at it. Bonus point for not being flash that hijacks the browser shortcut.

That much should be clear, my (unfortunately) implicit question is: how can we instruct a machine to optimize for the very intangible things everybody seems to love so much about this chalk? What about the more subtle economic things (like signals of economic climate and value of quality).

I think the statement following this is much more important and interesting to HN:

> The tendency has become more and more prevalent under electronic auction systems.

While incidents like this are often used as examples of the failures of technocracy, I think the problem is elsewhere. A decision process has been out-sourced to a machine that is not smart enough yet to make a good decision. The decision might be good in a very localized and easy to measure sense (cheap), but lacks an understanding of other economical signals.

You are not quoting the part where he shows his benchmark results, analysis of the problem, and suggested solution. I don't necessarily agree with Linus' tone or choice of words, but what you are doing is far worse. I'm not even sure if you are trying to be sarcastic, but that does not even matter: You are not contributing anything either way.

Even if your tax is paid automatically you can still recover taxes but it is hard and the laws are confusing. In Germany a special profession with a state exam (Steuerberater) as well as special associations (Lohnsteuerhilfeverein) exist or have been created to help individuals. For self-employed or people interested in recovering part of their taxes using those services is almost unavoidable.

I'm not intending to put you, your enthusiasm, or the people behind Modules down: I've been hearing that story since C++11 was still called C++0x (this might be an exaggeration) but I don't see anything happening in terms of standardization. And as long as modules are not standardized they are not going to see widespread adoption in C++ and certainly not in the open source community.

Because I like to walk down the memory lane I've looked at my HN comments regarding modules. Here is one from exactly one year ago [1], 855 days ago [2], 1100 days ago.

[1]: https://news.ycombinator.com/item?id=7491149 [2]: https://news.ycombinator.com/item?id=4836499 [3]: https://news.ycombinator.com/item?id=3613636

At first I thought "a build system which automatically figures out what to build and how to build it purely based on the source code" included figuring out library dependencies. It looks like I was wrong though and you still have to set linker and compiler flags yourself. I think actually understanding your dependencies (minimum versions, different build configurations and all) and handling them in a unified manner without too much special casing for the peculiarities. CMake already does this quite well, but there is still lots of room for improvement.

You are saying that you actually need to read and understand code you are refactoring. Hard to disagree.

I can't follow. The code I showed is already processing masterlist and decides if it should process masterlist[z].list2 for every z: 0..masterlist.length.

I fully agree that the code in my post is very bad, I took it from the article.

> My word, something can be redundant (not conceding that point) and not "just plain wrong."

I think we can agree to disagree. I'm strictly against redundancy if it doesn't serve a well-defined purpose.

> Your language hate and insistence that the programmer himself is one of the "problems" is why people don't do code reviews, and why people get overly defensive if you offer constructive criticism of code. Your criticism is not constructive.

I would phrase my criticism entirely different if the recipient was someone who asked for my commentary and not someone who felt confident enough to write a blogpost on how to start refactoring code.

> You must null check a lot of things in C, especially since there is no graceful error handling (try/catch blocks)... C certainly allows things to be null (or garbage) values.

You are correct that adding C as an example language was wrong. C++ on the other hand still stands.

> I'm not sure what you are saying here -- the very notion of pointers do not exist in Java

Java references are just C pointers without pointer arithmetic.

He then proceeds to iterate over the list using zero based indexing. The loop would not execute once if the list had length zero, making this check just plain wrong.

I know an even lower level language (C++, C) that doesn't have the problem of things which make no sense to be NULL (list elements). The problem is that Java did away completely with value types and made everything pointer only. That has been recognized by later languages (C#) and fixed.

The whole code consists of problems: the first is the language, the second is the programmer, the third is the missing for-each construct.

    if( masterList[z].list2 != NULL && masterList[z].list2.length() > 0 )
    {
        for( Integer y = 0; y < masterList[z].list2.length(); y++ )

The if-statement is a good summary of what is wrong with Java. The author doesn't even notice that the second argument of && is redundant and keeps it in the "refactored" version as well...

This has been discussed here before in 2012 and the linked version is not different from the one before.

https://news.ycombinator.com/item?id=3871463

That sounds interesting, but I'm suspicious. Do you have any examples of such macros and maybe some statistics or ideas how often they are actually seen in the wild?

I can only speak for the Emacs capabilities of readline: all commands which would usually change the line (previous/next-line, beginning/end-of-buffer) will use the history as the buffer. All of them preserve the line you are currently typing, which will be the end of the buffer.

There are already SWIG generated python bindings for CGAL: https://code.google.com/p/cgal-bindings/

Ascending single or double ropes is most often practiced in rope access, tree climbing, caving or technical climbing. Ascending a single rope will often involve a Jumar [1] and a camming device placed on your foot or chest. Ascending a doubled rope can be done with just the rope using Blake's hitch or some extra material and a Prusik knot.

[1]: http://en.wikipedia.org/wiki/Ascender_(climbing)

You can strike the intrusive. Your comment is valid for all kinds of linked lists.

So, you argue to not add a feature to the language because it would fix one of the main points of criticism? That is silly, don't you think?

You are being downvoted because the language comes with well-defined and specifically designed ways to customize allocation/deallocation. Your approach choses to ignore those facilities and even adds a runtime decision to code that absolutely has no need for it. You are reinventing the wheel and it is not even round.

It is easy to forget that this is just a report and up to this point it hasn't had any real consequences yet. If this will ever lead to anything (be it criminal charges, convictions or change in policy) is still open.

That is the kind of magic thinking of C++ programmers sometimes exhibit that drives me insane.

Yes, compilers have become excellent at optimizing code, but they aren't magical. The generated code will have some semblance to the code we write. Eliding dynamic allocations is just not possible statically. Heck, we aren't even able to emit warnings for missing deallocations reliably and have to use run-time instrumentation for it.

Even in C++ or C, even with good compilers, we still have to go the extra mile if we want fast code.

I was immediately reminded of Robinson's work a few seconds in. There is so much to discover out there and the extremes of physical state and sheer size make it so hard to imagine it all. His writing offer a window into that world and this short was a great visualization of it.