archived stringclasses 2
values | author stringlengths 3 20 | author_fullname stringlengths 4 12 ⌀ | body stringlengths 0 22.5k | comment_type stringclasses 1
value | controversiality stringclasses 2
values | created_utc stringlengths 10 10 | edited stringlengths 4 12 | gilded stringclasses 7
values | id stringlengths 1 7 | link_id stringlengths 7 10 | locked stringclasses 2
values | name stringlengths 4 10 ⌀ | parent_id stringlengths 5 10 | permalink stringlengths 41 91 ⌀ | retrieved_on stringlengths 10 10 ⌀ | score stringlengths 1 4 | subreddit_id stringclasses 1
value | subreddit_name_prefixed stringclasses 1
value | subreddit_type stringclasses 1
value | total_awards_received stringclasses 19
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
True | bonch | null | > No seriously, he understands business and technology trends.
How can you say this after the market failure that was id Tech 4 and the rise of the Unreal engine? Dark, confined rooms were the exact opposite direction the rest of the industry was going at the time. | null | 0 | 1316589752 | False | 0 | c2lg9nn | t3_klrrx | null | t1_c2lg9nn | t1_c2lausb | null | 1427627452 | 0 | t5_2fwo | null | null | null |
True | repsilat | null | The simple answer is "the people who need software". If an industry needs a piece of software, and that piece of software isn't available, that industry will be willing to write that software, or willing to pay to have it written. | null | 0 | 1316589915 | False | 0 | c2lg9yw | t3_kl7h0 | null | t1_c2lg9yw | t1_c2le0sy | null | 1427627456 | 5 | t5_2fwo | null | null | null |
True | n2dasun | null | Thanks. | null | 0 | 1316589997 | False | 0 | c2lga5k | t3_klrrx | null | t1_c2lga5k | t1_c2lan3n | null | 1427627460 | 2 | t5_2fwo | null | null | null |
True | jyper | null | > If you disagree, I challenge you to use any language with a good lambda syntax.
FTFY
see haskell,scala,c#,ect. | null | 0 | 1316590405 | False | 0 | c2lgb05 | t3_klphp | null | t1_c2lgb05 | t1_c2lawby | null | 1427627471 | 2 | t5_2fwo | null | null | null |
True | jib | null | The same people who pay for the vast majority of software written today: the businesses who need it to be written so they can use it. | null | 0 | 1316590411 | False | 0 | c2lgb0n | t3_kl7h0 | null | t1_c2lgb0n | t1_c2le0sy | null | 1427627471 | 6 | t5_2fwo | null | null | null |
True | jyper | null | he said viable alternative | null | 0 | 1316590486 | False | 0 | c2lgb6i | t3_klphp | null | t1_c2lgb6i | t1_c2lb32w | null | 1427627473 | 2 | t5_2fwo | null | null | null |
True | nkteam | null | I don't always test my code... but when I do... I do it in production | null | 0 | 1316590489 | False | 0 | c2lgb6q | t3_kljc0 | null | t1_c2lgb6q | t1_c2la3bd | null | 1427627473 | 4 | t5_2fwo | null | null | null |
True | uriel | null | Once more: Vector is deprecated in Go, use slices instead. | null | 0 | 1316590668 | False | 0 | c2lgbjq | t3_kikut | null | t1_c2lgbjq | t1_c2kydmh | null | 1427627477 | 0 | t5_2fwo | null | null | null |
True | alanzeino | null | You'd think the company bankrolling the development of LLVM and HTML5 is *pro* programmer... | null | 0 | 1316590915 | False | 0 | c2lgc1v | t3_kgqnz | null | t1_c2lgc1v | t1_c2k8lu5 | null | 1427627483 | 1 | t5_2fwo | null | null | null |
True | grigri | null | I need to email someone to download it? | null | 0 | 1316591051 | False | 0 | c2lgcau | t3_klzm8 | null | t1_c2lgcau | t1_c2lcr6k | null | 1427627488 | 3 | t5_2fwo | null | null | null |
True | jazimov | null | You're completely right; it amounts to little more than racketeering. | null | 0 | 1316591219 | False | 0 | c2lgcmm | t3_klqte | null | t1_c2lgcmm | t1_c2ladit | null | 1427627492 | 3 | t5_2fwo | null | null | null |
True | farnz | null | No, because in the US legal system, even with first-to-invent, the poor are fucked hard. You *must* have money to win a patent case; that's how the US legal system works.
Indeed, there's an argument that first-to-file works slightly in favour of the poorer inventor (defined here as someone who can scrape together $1,000 to patent their invention, but not much more than that):
In first-to-invent, the inventor files for a patent, paying the $190 "small entity" fee. He expects to go back once he's got funding and amend the patent into proper legal language, and goes to $bigco with his patent-pending invention. $bigco likes it, and decides to try and patent it themselves; they tie the inventor up in legal knots trying to prove that they were the first to invent - this will cost tens of thousands of dollars minimum if the inventor tries to fight on, or $bigco gets the patent on the small guy's invention.
In first-to-file the inventor pays his $190. He shows the patent-pending invention to $bigco - and now $bigco cannot even attempt steal his patent, as the inventor filed first. At most, $bigco can hunt for prior art to invalidate the patent for everyone - but that costs $bigco, and will benefit both $bigco and $bigco's competitors in this space. | null | 0 | 1316591301 | False | 0 | c2lgcs5 | t3_klqte | null | t1_c2lgcs5 | t1_c2les1r | null | 1427627494 | 6 | t5_2fwo | null | null | null |
True | acmecorps | null | I love the personal notes. I love the details. I love the simple explanations. I LOVE THIS! Thank you! :) | null | 0 | 1316591389 | False | 0 | c2lgcya | t3_klrrx | null | t1_c2lgcya | t1_c2lej2j | null | 1427627495 | 15 | t5_2fwo | null | null | null |
True | hellotanjent | null | CSectionOfSingleMaterialDrawableObjectBuilder.
It was a factory class that did nothing, written (in C++) by a programmer who would rather have been writing Lisp. | null | 0 | 1316591580 | False | 0 | c2lgdao | t3_klhlv | null | t1_c2lgdao | t3_klhlv | null | 1427627502 | 1 | t5_2fwo | null | null | null |
True | jeff_hanson | null | > Right so the GPL is good for business.
Are you retarded? They made money because businesses (who idiotically wanted to use MySQL at all) wanted to get away from the GPL. What you said is like saying that robberies are good for business because businesses will pay for security to prevent robberies. | null | 0 | 1316591643 | False | 0 | c2lgdf4 | t3_kl7h0 | null | t1_c2lgdf4 | t1_c2lfnyk | null | 1427627502 | 2 | t5_2fwo | null | null | null |
True | Quazatron | null | I'm not arguing they don't. We all know that Windows carries legacy compatibility layers for way too long, to satisfy Microsoft's corporate partners.
What I'm saying is that they pitch new technologies to developers as the "one true way forward" and then sideline them a few years ahead for something else.
In a way, it can't be helped, they have to adjust to the market conditions, but I feel sorry for the people who have to learn yet another new API. | null | 0 | 1316591665 | False | 0 | c2lgdh3 | t3_kl1qp | null | t1_c2lgdh3 | t1_c2ldihp | null | 1427627504 | 1 | t5_2fwo | null | null | null |
True | alexeyr | null | No, a "trit". | null | 0 | 1316591914 | False | 0 | c2lgdws | t3_klhlv | null | t1_c2lgdws | t1_c2lbytz | null | 1427627508 | 3 | t5_2fwo | null | null | null |
True | simonask | null | I can't from the top of my head think of a language that has downright horrible lambda/closure syntax, though. I personally enjoy Ruby's very terse syntax, that makes chaining almost pleasant:
foos.map {|it| it.something }.each {|it| puts it }
I like C# and Scala as well. | null | 0 | 1316591921 | False | 0 | c2lgdxe | t3_klphp | null | t1_c2lgdxe | t1_c2lgb05 | null | 1427627509 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316591922 | False | 0 | c2lgdxh | t3_kmh5r | null | t1_c2lgdxh | t3_kmh5r | null | 1427627509 | -6 | t5_2fwo | null | null | null |
True | Sc4Freak | null | And this might be a good time to point out that Microsoft *already* provides such a wrapper. Plain old COM and Win32 had the ATL, and WinRT has the WRL, which is a plain standard C++ library which wraps over and abstracts away some of the details of COM management of WinRT. | null | 0 | 1316592074 | False | 0 | c2lge6s | t3_kl1qp | null | t1_c2lge6s | t1_c2ldcj4 | null | 1427627512 | 2 | t5_2fwo | null | null | null |
True | farnz | null | Reading the study, patent trolls as they exist are an enormously inefficient way to divert money from users of inventions to inventors.
Of the $500 billion trolls have cost users, the study authors can only trace $7.6 billion going back in the direction of inventors and their legal advisors. Therefore, at an optimistic estimate, $490 billion of that cost (or 98%) is deadweight, simply funding the trolling and not encouraging other inventors.
Given that the goal of the system is to encourage inventors, a 98% parasitic loss suggests that the system is not working as intended; while you expect some parasitic loss (compensating for the risk a patent purchaser takes), 98% implies that either 90% or so of patents are worthless, or that the system is strongly biased in favour of trolls. | null | 0 | 1316592230 | False | 0 | c2lgehj | t3_klqte | null | t1_c2lgehj | t1_c2lbqq7 | null | 1427627519 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Well come on mate. Just imagine they said 'might as well be called legal extortion'. You know what they mean anyway, don't be annoying. | null | 0 | 1316592804 | False | 0 | c2lgfip | t3_klqte | null | t1_c2lgfip | t1_c2lfmu3 | null | 1427627532 | 5 | t5_2fwo | null | null | null |
True | jasonthe | null | Are you a developer on VS? And yeah, my team has been using a simple foreach macro similar to [this](http://gamedevstudent.com/journal/2011/09/c-foreach-in-msvc-2010/), since we're using custom containers (with ranges!) anyway. | null | 0 | 1316592924 | False | 0 | c2lgfqq | t3_kg44k | null | t1_c2lgfqq | t1_c2ld5m8 | null | 1427627537 | 1 | t5_2fwo | null | null | null |
True | Danthekilla | null | How so?
If you don't like it then just turn it off, in the developer preview it cannot be turned off because it is a preview of the metro UI first and foremost not a OS preview to be tested as a full OS. | null | 0 | 1316592973 | False | 0 | c2lgftk | t3_kl7h0 | null | t1_c2lgftk | t1_c2l7g0z | null | 1427627538 | 1 | t5_2fwo | null | null | null |
True | bonch | null | > It helps that Carmack hates using malloc(), which helps programmers like me who don't use C very much.
Huh? The article says "the engine relied massively on malloc and free for memory management." | null | 0 | 1316593199 | False | 0 | c2lgg71 | t3_klrrx | null | t1_c2lgg71 | t1_c2lcl6m | null | 1427627541 | 2 | t5_2fwo | null | null | null |
True | MrSkruff | null | I'm talking about VFX. I'm also pretty certain that I sat through a session with Marcos Fajardo where he was pretty frank about the increased need for scene efficiency with Arnold. It's not like swapping gbs of data in and out of memory is free. | null | 0 | 1316593274 | False | 0 | c2lggbb | t3_kldfr | null | t1_c2lggbb | t1_c2lfv02 | null | 1427627541 | 1 | t5_2fwo | null | null | null |
True | akoprowski | null | I hope the first article on the blog (http://blog.opalang.org/2011/06/hello-opa-what-is-opa-to-quote-manual.html) should answer that question. | null | 0 | 1316593490 | False | 0 | c2lggom | t3_klnf3 | null | t1_c2lggom | t1_c2lavcx | null | 1427627544 | 1 | t5_2fwo | null | null | null |
True | mfukar | null | Is your time really worth less than $100M? | null | 0 | 1316593714 | False | 0 | c2lgh2j | t3_kljc0 | null | t1_c2lgh2j | t1_c2l8hfb | null | 1427627549 | -1 | t5_2fwo | null | null | null |
True | G_Morgan | null | Less code does not necessarily make things easier to read. For instance with dynamic languages I'm always left looking for where a function is called from to work out which types are being passed it. With a static language I just look at the signature.
The way to make things easier to read is to reduce the amount of context needed to understand something. Redundancy does a good job of this. | null | 0 | 1316593729 | False | 0 | c2lgh3h | t3_klphp | null | t1_c2lgh3h | t1_c2lb183 | null | 1427627550 | 0 | t5_2fwo | null | null | null |
True | stusmith | null | Lambdas? Bah!
mapM_ print $ map something foos | null | 0 | 1316593733 | False | 0 | c2lgh3o | t3_klphp | null | t1_c2lgh3o | t1_c2lgdxe | null | 1427627550 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316593847 | False | 0 | c2lghaj | t3_klqte | null | t1_c2lghaj | t1_c2lcyyr | null | 1427627552 | 1 | t5_2fwo | null | null | null |
True | EnderMB | null | I CHOOSE YOU, HASKELL! | null | 0 | 1316593866 | False | 0 | c2lghbq | t3_kljc0 | null | t1_c2lghbq | t3_kljc0 | null | 1427627552 | 1 | t5_2fwo | null | null | null |
True | Deusdies | null | Haha, I was coding a Python app a couple days ago and was parsing headers from wordpress.com, and saw the same thing :) | null | 0 | 1316594065 | False | 0 | c2lghnp | t3_kmevq | null | t1_c2lghnp | t3_kmevq | null | 1427627557 | 2 | t5_2fwo | null | null | null |
True | voxfrege | null | How about Haskell? | null | 0 | 1316594229 | False | 0 | c2lghwf | t3_klv3o | null | t1_c2lghwf | t3_klv3o | null | 1427627560 | 5 | t5_2fwo | null | null | null |
True | Boojum | null | Now to balance out my earlier arguments in favor of rasterization I'll argue for ray tracing. :-)
Depending on the acceleration structure that you use, a ray tracer actually can be made to cope with vertex deformation without fully rebuilding the acceleration structure. In particular if you use an object-subdivision data structure like a BVH or an SKD-tree, it's very quick work (and easily parallelized) to refit the nodes from the bottom up around the geometry as it moves. While this obviously won't work for topology changes or really extreme deformations like a destruction or fluid sim produces it can work surprisingly well for character animation; you can usually expect that the fingers on a hand will stay together even as the arm moves around.
Eventually things will degrade to the point where you want to rebuild from scratch but you can often get away without doing it for each frame. And there's been a decent amount of research on fighting the degradation to reduce how often you have to rebuild. | null | 0 | 1316594362 | False | 0 | c2lgi3e | t3_kldfr | null | t1_c2lgi3e | t1_c2lab1e | null | 1427627563 | 1 | t5_2fwo | null | null | null |
True | A_for_Anonymous | null | You make some good points (though you seem to treat conventions like a dogma; you shouldn't). However, I'll raise one more point. Why treat dotfiles specially? Why not hyphenfiles too? Why treat any files specially at all? You are trying to use part of the file name as metadata. File extensions are bad enough already; a Good system design shouldn't rely on hacks such as "if part of the name says... then it's...".
> To address your whole previous "biting" argument, pick any critical system file on a Unix box and try to delete it.
It says "Permission denied". But I know what you're trying to argue. UNIX deletes files when I tell it to, just like my phone will call my mother-in-law at 4 AM if I dial her number by that time, and my knife will cut my finger if I force it to.
> Now do the same on Windows. Guess which one saves you from shooting yourself in the foot?
Privileges aside (as in the UNIX case), Windows has a flawed system files restorer that is both annoying and not very effective, and a severe defect: the stupid thing can't delete, move or rename any hard link of currently open data. It's so stupid, so annoying, and so Microsoftly to botch the filesystem like this. Go ahead, try this: use a non-Windows utility (because Windows is as lame as to not come with any) to create hardlinks and hardlink an important file from System32 (e.g. winlogon* or some of that shit) into some unsuspecting user's desktop directory, calling it "FUCK_YOU_FAGGOT_LOL". Once created, not even you as an adminsitrator can delete or even rename this file! You have to use some stupid hack to delete it on next boot, and the standard Windows procedure for problem fixing - reboot. | null | 0 | 1316594384 | False | 0 | c2lgi4l | t3_klhlv | null | t1_c2lgi4l | t1_c2leioc | null | 1427627563 | 1 | t5_2fwo | null | null | null |
True | ibisum | null | int c;
That one. | null | 0 | 1316594591 | False | 0 | c2lgiga | t3_klhlv | null | t1_c2lgiga | t3_klhlv | null | 1427627567 | 1 | t5_2fwo | null | null | null |
True | Tasgall | null | Actually, you already can use it as a web browser, which can effectively be used as a music player :P | null | 0 | 1316594893 | False | 0 | c2lgiy7 | t3_kg44k | null | t1_c2lgiy7 | t1_c2k40jx | null | 1427627575 | 1 | t5_2fwo | null | null | null |
True | antrn11 | null | That's just stupid. | null | 0 | 1316594939 | False | 0 | c2lgj0t | t3_kmh5r | null | t1_c2lgj0t | t3_kmh5r | null | 1427627576 | 0 | t5_2fwo | null | null | null |
True | Maristic | null | Actually, you *can* call blocks from STL code, including `for_each`. (Tested with current clang and libc++). | null | 0 | 1316595004 | False | 0 | c2lgj4j | t3_klphp | null | t1_c2lgj4j | t1_c2lanh8 | null | 1427627577 | 8 | t5_2fwo | null | null | null |
True | mfukar | null | A few days of test runtime isn't holding you back? What's your commit strategy? What are you developing? | null | 0 | 1316595140 | True | 0 | c2lgjc9 | t3_klypn | null | t1_c2lgjc9 | t1_c2ldi3z | null | 1427627581 | 3 | t5_2fwo | null | null | null |
True | Maristic | null | Even before move semantics, there was the RVO (return value optimization). | null | 0 | 1316595156 | False | 0 | c2lgjdd | t3_klphp | null | t1_c2lgjdd | t1_c2lf2xj | null | 1427627581 | 1 | t5_2fwo | null | null | null |
True | Tasgall | null | nope. | null | 0 | 1316595161 | False | 0 | c2lgjdn | t3_kg44k | null | t1_c2lgjdn | t1_c2k5fwn | null | 1427627581 | 1 | t5_2fwo | null | null | null |
True | jyper | null | mapM_ print $ map (\x -> small_expr) foos | null | 0 | 1316595569 | False | 0 | c2lgk0o | t3_klphp | null | t1_c2lgk0o | t1_c2lgh3o | null | 1427627592 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Nah, you can't do really complex app with the metro-stuff. It's for dumbed down one task apps like a rss feed widget or a twitter client.
If you want more complexity you will have to go win32 desktop. | null | 0 | 1316595891 | False | 0 | c2lgkhh | t3_kl7h0 | null | t1_c2lgkhh | t1_c2l7856 | null | 1427627597 | 1 | t5_2fwo | null | null | null |
True | wcoenen | null | Elsewhere in this thread I already pointed out [how nouveaudriver was created](http://www.pledgebank.com/nouveaudriver). | null | 0 | 1316595937 | False | 0 | c2lgkjl | t3_kl7h0 | null | t1_c2lgkjl | t1_c2le0sy | null | 1427627597 | 1 | t5_2fwo | null | null | null |
True | rwallace | null | Well, he said _if run sequentially_ they would take a few days. Hardware is dirt cheap compared to people - you can buy literally hundreds of computers for the cost of hiring a single developer - and running test suites is an embarrassingly parallel job. There's no reason people should be spending large amounts of time sitting around waiting for test results. | null | 0 | 1316595969 | False | 0 | c2lgkl8 | t3_klypn | null | t1_c2lgkl8 | t1_c2lgjc9 | null | 1427627598 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | Wait. I have to test that now. If this works now it would be pretty much awesome.
/edit: Wow, it works now. Thank you for mentioning that! | null | 0 | 1316596109 | True | 0 | c2lgksw | t3_klphp | null | t1_c2lgksw | t1_c2lgj4j | null | 1427627600 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | Oh, but the MS dude said they had such awesome abstractions that you can use metro apps 100% with mouse/keyboard. | null | 0 | 1316596450 | False | 0 | c2lglaw | t3_kl1qp | null | t1_c2lglaw | t1_c2lddkq | null | 1427627605 | 2 | t5_2fwo | null | null | null |
True | amnezia | null | yeah they should write it in python or ruby because dynamic languages are great for real time event processing | null | 0 | 1316596468 | False | 0 | c2lglbw | t3_kks00 | null | t1_c2lglbw | t1_c2lalt2 | null | 1427627606 | 3 | t5_2fwo | null | null | null |
True | jyper | null | My comment was more about the fact that static languages can also have nice lambda syntax's and simple passing of lambdas as parameters to popular higher order functions(each/map/filter/fold/all/any/ect)(plus hey type safety).
There are some problems with some languages lambda/closure syntax.
Examples:
I guess this isn't so much syntax but I wish that ruby's {} and do/end made an actual function object.
I think c++0x syntax can end up a bit ugly but I think that because of flexibility & manual memory management.
Python is restricted to one expression or having to make a named function. | null | 0 | 1316596651 | False | 0 | c2lglkc | t3_klphp | null | t1_c2lglkc | t1_c2lgdxe | null | 1427627608 | 1 | t5_2fwo | null | null | null |
True | ZMeson | null | C and C++ are excellent languages that excel at their job. Their job responsibilities has just shrunk ... err... perhaps not expanded as much with the rest of computing. If you want high-performance, cross-platform code, C and C++ excel at this. | null | 0 | 1316597086 | False | 0 | c2lgm8v | t3_klgme | null | t1_c2lgm8v | t1_c2ld1pe | null | 1427627617 | 1 | t5_2fwo | null | null | null |
True | smallfried | null | Solution: Become a lawyer yourself. | null | 0 | 1316597315 | False | 0 | c2lgmjt | t3_klqte | null | t1_c2lgmjt | t1_c2lazyp | null | 1427627621 | 1 | t5_2fwo | null | null | null |
True | simonask | null | > Less code does not necessarily make things easier to read.
No, but that's not the assertion. Less *boilerplate* makes things easier to read, because there is less cruft you have to sift through. The higher percentage of your code is devoted to the *purpose* of the program, the easier the code is to follow.
> Redundancy does a good job of this.
Wow. I *sincerely* hope I will never have to use an API designed by you. | null | 0 | 1316597375 | False | 0 | c2lgmn1 | t3_klphp | null | t1_c2lgmn1 | t1_c2lgh3h | null | 1427627632 | 3 | t5_2fwo | null | null | null |
True | G_Morgan | null | The point is having the object type specified in the signature as in static languages improves readability. It is redundant because you can find that information at the call site. Still better to have it there. | null | 0 | 1316597579 | False | 0 | c2lgmyb | t3_klphp | null | t1_c2lgmyb | t1_c2lgmn1 | null | 1427627628 | 1 | t5_2fwo | null | null | null |
True | kawa | null | > People have been stating this for years
True. But this time around, it will really happen.
The reason is that computers have enough power today, so that manufacturers can afford to lose computing power in favour of energy efficiency. Sure, you pay much more in $/gflops terms, but most people don't care about gflops, they care about "can I do the stuff I want with the thing". And today even the better smartphones have enough computing power for most people in this regard.
| null | 0 | 1316597651 | False | 0 | c2lgn21 | t3_kl1qp | null | t1_c2lgn21 | t1_c2lb1tp | null | 1427627635 | 0 | t5_2fwo | null | null | null |
True | Jigsus | null | For a moment there I thought you were Nonsensicalanalogy | null | 0 | 1316597746 | False | 0 | c2lgn62 | t3_klqte | null | t1_c2lgn62 | t1_c2lc3le | null | 1427627630 | 2 | t5_2fwo | null | null | null |
True | llogiq | null | The only Extreme in here is waste. The "if (this or that) wasn't here, (reason for this being here)" could be shortened to "(reason)". Also most of the comments are too specific or too general. For example the sample-rakefile contains the following:
> #N If we don't require 'based', we can't use Based:: module
This is just tautology. If you really need to explain your imports, just state the function it uses. I don't know Ruby, but most programming languages allow to specify which parts of modules to import (as in Perl's "use XY qw(a b c);" or pythons "from xy import a, b, c", heck, even Java nowadays allows for "static import my.package.ClassName.staticFunction;".
Also the strict interspersal of comments and code does the whole no good. Better to have a big comment on top to explain the reasoning behind the module (maybe even with a few examples on how to use it) than this - e.g. doctest).
Also the author has obviously never heard of [Literate Programming](http://en.wikipedia.org/wiki/Literate_programming). Too bad, it makes for a much better documentation.
EDIT: formatting | null | 0 | 1316597921 | False | 0 | c2lgnex | t3_kmk56 | null | t1_c2lgnex | t3_kmk56 | null | 1427627639 | 30 | t5_2fwo | null | null | null |
True | [deleted] | null | Yeah, but the idea of having two entirely distinct UI concepts within the same OS makes it seem fragmented, as if it were two different OSes in one. (I haven't personally used it, this is just the vibe I've been getting from beta testers and demo videos.) | null | 0 | 1316598064 | False | 0 | c2lgnl4 | t3_kl7h0 | null | t1_c2lgnl4 | t1_c2l7vzp | null | 1427627635 | 2 | t5_2fwo | null | null | null |
True | amnezia | null | why would you want to convert an IP address to an integer anyway? | null | 0 | 1316598283 | False | 0 | c2lgnw8 | t3_klhlv | null | t1_c2lgnw8 | t1_c2ldsvc | null | 1427627640 | 0 | t5_2fwo | null | null | null |
True | mydyingdreams | null | WTF:
[0012] The inventor and the assignee of this patent have no intention of applying the techniques described herein offensively but instead intend to use the patent defensively to discourage patent trolls and the like from extortionist practices. | null | 0 | 1316598318 | False | 0 | c2lgnxy | t3_klqte | null | t1_c2lgnxy | t1_c2lddr9 | null | 1427627640 | 1 | t5_2fwo | null | null | null |
True | shizzy0 | null | Really cool. Nice looking REPL. | null | 0 | 1316598531 | False | 0 | c2lgo7w | t3_klv3o | null | t1_c2lgo7w | t3_klv3o | null | 1427627644 | 1 | t5_2fwo | null | null | null |
True | xlevus | null | Didn't patent law originally require a working implementation of your patent to be submitted along with your application?
Sounds like brining back this requirement would prevent this sort of thing. | null | 0 | 1316598698 | False | 0 | c2lgofo | t3_klqte | null | t1_c2lgofo | t1_c2lbsl5 | null | 1427627649 | 2 | t5_2fwo | null | null | null |
True | IRQBreaker | null | This is like one of those things that might look good on paper but it's impossible to do in the Real World(tm).
It would probably be possible to do this on a hobby project at home, but on a professional level no way. There's simpy not enough time for something like this. | null | 0 | 1316598875 | False | 0 | c2lgony | t3_kmk56 | null | t1_c2lgony | t3_kmk56 | null | 1427627653 | 0 | t5_2fwo | null | null | null |
True | stusmith | null | I see your lambda and raise you a const:
mapM_ print $ map (const small_expr) foos
(Although it's a bit weird to simultaneously map over something, and ignore it, at the same time. | null | 0 | 1316599010 | False | 0 | c2lgouh | t3_klphp | null | t1_c2lgouh | t1_c2lgk0o | null | 1427627656 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | The thing is, with that approach you never ends up the remaining 90M. | null | 0 | 1316599215 | False | 0 | c2lgp3p | t3_kljc0 | null | t1_c2lgp3p | t1_c2l8vsy | null | 1427627659 | 2 | t5_2fwo | null | null | null |
True | boomerangotan | null | I love that eclipse inherently recognizes variables, so it has the ability to intelligently rename them automatically (rather than by search/replace). | null | 0 | 1316599216 | False | 0 | c2lgp3q | t3_klhlv | null | t1_c2lgp3q | t1_c2l9at4 | null | 1427627659 | 2 | t5_2fwo | null | null | null |
True | H4Z3Y | null | [source](http://www.reddit.com/r/geek/comments/km31u/start_new_job_track_down_missing_server_find_this/c2led3c) | null | 0 | 1316599435 | False | 0 | c2lgpe6 | t3_kmlb9 | null | t1_c2lgpe6 | t3_kmlb9 | null | 1427627664 | 2 | t5_2fwo | null | null | null |
True | EdiX | null | # initialise with un-initialised entries
#N Without initialize, @entries required for getEntries won't be initialised
def initialize
#N If we don't pre-set @entries to nil, we won't know that we haven't yet initialised that value
@entries = nil
end
This is why this method of commenting is a huge waste of time. The problem with reading code is not understanding the single lines but the big picture. | null | 0 | 1316599446 | False | 0 | c2lgper | t3_kmk56 | null | t1_c2lgper | t3_kmk56 | null | 1427627664 | 42 | t5_2fwo | null | null | null |
True | [deleted] | null | >They made money because businesses (who idiotically wanted to use MySQL at all) wanted to get away from the GPL.
Right. If they had a different license they would not have made the money.
The GPL is very good for making money.
>What you said is like saying that robberies are good for business because businesses will pay for security to prevent robberies.
Except of course that it's not robbery. | null | 0 | 1316599685 | False | 0 | c2lgpqt | t3_kl7h0 | null | t1_c2lgpqt | t1_c2lgdf4 | null | 1427627666 | 2 | t5_2fwo | null | null | null |
True | Bamafan | null | "There's simpy not enough time for something like this."
I've always thought that if you don't even have time to write out what your program is doing in plain English, you probably don't have time to write the program...though for a long time, a project can fool itself into thinking they are "on time".
That is to say, typing in comments should *never* be the deciding factor on the timeliness of a project, no matter how "extreme". | null | 0 | 1316599688 | True | 0 | c2lgpqz | t3_kmk56 | null | t1_c2lgpqz | t1_c2lgony | null | 1427627666 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | >Nope, he wanted to give to others without forcing them to give it as well.
No he just wants to take. If he liked giving he would enjoy the GPL which ensures more giving. | null | 0 | 1316599722 | False | 0 | c2lgpsi | t3_kl7h0 | null | t1_c2lgpsi | t1_c2lfvax | null | 1427627666 | 1 | t5_2fwo | null | null | null |
True | boomerangotan | null | > I still had to occasionally do Coldfusion stuff
You've earned the right to those any many more shenanigans.
In fact, if you ever get in legal trouble and wind up in front of a tech-savvy judge, just be sure to mention that. | null | 0 | 1316599782 | False | 0 | c2lgpvn | t3_klhlv | null | t1_c2lgpvn | t1_c2l88ae | null | 1427627666 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | >Nope, his position that developer should always give. But since he can't force that, he tried to make GPL code spread so that developer will take, therefor must give.
There is no force involved with the GPL. It's a voluntary exchange.
>In RMSs ideal world he will want GPL code so wide spread and part of everything so that it's practically impossible to do anywork without touching GPL code at all.
Yes that would be ideal. That means that most developers in the world chose to use his license.
| null | 0 | 1316599817 | False | 0 | c2lgpxl | t3_kl7h0 | null | t1_c2lgpxl | t1_c2lft72 | null | 1427627667 | 4 | t5_2fwo | null | null | null |
True | Gotebe | null | Aren't you equaling OS with it's GUI shell a bit too much? ;-)
AFAICanSee, Metro apps will still run inside the same shell. You'll just scroll from one Metro to another, and you'll still have your old Explorer-based shell (in a desktop system, at least). | null | 0 | 1316599837 | False | 0 | c2lgpyj | t3_kl7h0 | null | t1_c2lgpyj | t1_c2lgnl4 | null | 1427627668 | 1 | t5_2fwo | null | null | null |
True | Bamafan | null | I like the way this guy thinks and I think this kind of approach should be encouraged. Why? Because his approach gives *context* to whatever line of code you're looking at. That way it's way, way, way easier for someone else to jump into your code and be productive fast...or 6 months down the road, it'll help you to remember why the hell you did what you without having to reload the entire program into program into your head, along with the sequence of events that lead you to write the code that you did. | null | 0 | 1316599878 | False | 0 | c2lgq0q | t3_kmk56 | null | t1_c2lgq0q | t3_kmk56 | null | 1427627668 | -2 | t5_2fwo | null | null | null |
True | [deleted] | null | >I must say that I could not possibly care less.
If you don't care about being precise and accurate in your statements there is no sense in having a conversation with you.
>Now why would a proponent of open source claim this?
Because it's true. It's the absolute best for the developer.
>Do you honestly think this is true?
Yes.
>That releasing source code is bad for the developer, and they should to be forced to do so for your benefit?
The GPL has no force. It's a voluntary exchange.
Releasing the code is a sacrifice for the developer who chooses to carry out an act of generosity towards those who may be using his code.
>That would make the GPL extremely anti-developer, yes?
Yes it's very anti developer. Every developer who chooses the GPL chooses it as an act of generosity and kindness.
| null | 0 | 1316600089 | False | 0 | c2lgqbi | t3_kl7h0 | null | t1_c2lgqbi | t1_c2lfq9i | null | 1427627670 | 0 | t5_2fwo | null | null | null |
True | shenglong | null | Thank you for posting this very informative piece. | null | 0 | 1316600123 | False | 0 | c2lgqcw | t3_klrrx | null | t1_c2lgqcw | t1_c2lej2j | null | 1427627671 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | Your posts are borderline violent and filled with irrational and misinformed vitriol. | null | 0 | 1316600126 | False | 0 | c2lgqd1 | t3_kl7h0 | null | t1_c2lgqd1 | t1_c2lfppq | null | 1427627671 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | >You were saying?
I was saying how I hate 404 pages. | null | 0 | 1316600178 | False | 0 | c2lgqfu | t3_kl7h0 | null | t1_c2lgqfu | t1_c2lfodl | null | 1427627672 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316600646 | False | 0 | c2lgr4m | t3_klhlv | null | t1_c2lgr4m | t1_c2le46b | null | 1427627682 | 1 | t5_2fwo | null | null | null |
True | IRQBreaker | null | > I've always thought that if you don't even have time to write out what your program is doing in plain English, you probably don't have time to write the program
I can only speak for myself and my team. But we *are* coding as readable as possible. I.e. absolutely no cryptic variable or function names, use clean interfaces and small functions and so on. The code must be as *readable* as possible.
This together with doxygen tagging of the functions can create quite a good documentation of the code.
Like I said, this level of commenting might work in a pure academical context or in a hobby project. But in the real world, there are tight deadlines to match. Unfortunately. | null | 0 | 1316600674 | False | 0 | c2lgr6b | t3_kmk56 | null | t1_c2lgr6b | t1_c2lgpqz | null | 1427627682 | 2 | t5_2fwo | null | null | null |
True | berkut | null | It's the same geometry assets they'd be using with PRMan anyway... | null | 0 | 1316601456 | False | 0 | c2lgsbd | t3_kldfr | null | t1_c2lgsbd | t1_c2lggbb | null | 1427627697 | 1 | t5_2fwo | null | null | null |
True | Diamond145 | null | 4GB is not a limit of VirtualBox, sorry. 4GB is the limit of an (32bit) unsigned int, so either of RAM (x86), or of the filesystem (FAT32). | null | 0 | 1316601662 | False | 0 | c2lgsm8 | t3_kjtsp | null | t1_c2lgsm8 | t3_kjtsp | null | 1427627701 | 1 | t5_2fwo | null | null | null |
True | WWWEH | null | That's unfair, as, for exmaple, IBM is pretty active in RFID research and I imagining licencing/selling those technologies would generate quite a bit of revenue. | null | 0 | 1316601818 | False | 0 | c2lgsuk | t3_klqte | null | t1_c2lgsuk | t1_c2leyl7 | null | 1427627712 | 6 | t5_2fwo | null | null | null |
True | killerstorm | null | Let corporations to announce patent value themselves, but them make them stick to it.
For example, through a cap on yearly revenue.
Say, company XYZ announces that its patent on audio codec should bring no more thatn $10M per year. Then company ABC will pay no more than $10M to use it in its audio devices. Or if it is going to sue company DEF for patent infringement, they can demand only $10M per year in compensations. But they pay some %% of $10M each year even if they have no revenue.
This would balance desire to get as much as possible in revenue with a risk to pay taxes while getting no revenue.
The only problem is to that revenue calculated on a yearly basis, while patent use might be not. One way to resolve this is to arrange multi-year contracts, e.g. if media player useful life time is 3 years then ABC will pay to XYZ each year for three years. | null | 0 | 1316602049 | False | 0 | c2lgt74 | t3_klqte | null | t1_c2lgt74 | t1_c2ld2c2 | null | 1427627709 | 7 | t5_2fwo | null | null | null |
True | Bamafan | null | While it's not giving you the entire picture, these comments give you significant *insight* into the "big picture". I don't know ruby or this program, but from reading these comments, I know:
a) The purpose of this method is to initialize entries to the specific value of nil because...
b) There's *another* method called "getEntries" that depends upon this collection of entries and it needs to know the state of the collection, presumably to decide how to act on it.
Now does that tell me the *entire* picture? Of course not! But this is a *huge* amount of information being conveyed that would otherwise require someone unfamiliar with the program to spend a much larger amount of time figuring out...or more often than not, the person reading the code *thinks* they know what's going on while having no clue.
I'd say comments are even *more* important in dynamic languages like ruby since you can't lean on your IDE to navigate your code as much as you can with statically typed languages (C#, Java, etc). | null | 0 | 1316602414 | True | 0 | c2lgtqk | t3_kmk56 | null | t1_c2lgtqk | t1_c2lgper | null | 1427627715 | 4 | t5_2fwo | null | null | null |
True | MrSkruff | null | Not sure what you mean. I should say I'm certainly not a rendering expert, but I was of the understanding that the random access nature of a ray casting based renderer means there's a large cost to not being able to keep all your render data in memory at once. This will also be a problem with prman if you need to ray trace but less so since it's opt-in. So I'd be surprised if the render time of a complex scene in Arnold isn't significantly slower than prman, for a high quality result.
Obviously adding all these layers of complexity to fake things in prman isn't without it's own problems but that's a different issue. | null | 0 | 1316602489 | False | 0 | c2lgtus | t3_kldfr | null | t1_c2lgtus | t1_c2lgsbd | null | 1427627717 | 1 | t5_2fwo | null | null | null |
True | kitd | null | > I suppose these kinds of layers will be okay for effortlessly optimizing embarrassingly parallel algos. But that's only the tip of the GPGPU iceberg.
At the moment, yes. But the aim of the chip makers is to expand the range of applicable solutions. I know that in the financial services industry where many of the problems involve a MapReduce process on a large number of records, GPGPUs are being looked at very closely. And that's a big industry with a lot of clout.
So projects like this create buzz and keep the ideas flowing. | null | 0 | 1316602516 | False | 0 | c2lgtw9 | t3_kltgu | null | t1_c2lgtw9 | t1_c2leohp | null | 1427627718 | 1 | t5_2fwo | null | null | null |
True | shit | null | > army of developers
Wrong approach. | null | 0 | 1316602538 | False | 0 | c2lgtx9 | t3_kljc0 | null | t1_c2lgtx9 | t1_c2ld4bq | null | 1427627718 | 6 | t5_2fwo | null | null | null |
True | OlDer | null | So, no unit tests in the codebase? | null | 0 | 1316602571 | False | 0 | c2lgtyu | t3_klrrx | null | t1_c2lgtyu | t3_klrrx | null | 1427627718 | 0 | t5_2fwo | null | null | null |
True | Bamafan | null | What you're doing is great and absolutely necessary. Readable code, non-cryptic variable naming, etc are immensely important. But it's not quite enough. From the blog entry:
>...for any developer reading any code, there will be situations where the developer thinks they know what something is, but they're not quite sure. Or the developer is just starting to read some code, and they have almost no prior context to help them understand what anything in the code actually does or what it means.
This is the key point. For a new guy reading your code (or *you* reading your code 8 months down the road), merely having reasonably named variables and clean interfaces isn't going to provide you the aforementioned context. Only English can do that.
| null | 0 | 1316602746 | True | 0 | c2lgu73 | t3_kmk56 | null | t1_c2lgu73 | t1_c2lgr6b | null | 1427627721 | 0 | t5_2fwo | null | null | null |
True | want_to_want | null | If I invented the computer mouse, I would publicize the idea but not patent it, because that would make mankind better off than if I'd patented it. I'd like other inventors to do the same. | null | 0 | 1316602991 | True | 0 | c2lguk5 | t3_klqte | null | t1_c2lguk5 | t1_c2lbqq7 | null | 1427627725 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316603406 | False | 0 | c2lgv7t | t3_klqte | null | t1_c2lgv7t | t3_klqte | null | 1427627734 | 0 | t5_2fwo | null | null | null |
True | frm | null | It's not my intention to judge the usefulness of the Javascript Garden layout. My only target was to reproduce that funcionality with my own code, for the pleasure to do it. | null | 0 | 1316603412 | False | 0 | c2lgv88 | t3_kliaa | null | t1_c2lgv88 | t1_c2ldmtw | null | 1427627734 | 2 | t5_2fwo | null | null | null |
True | Fabien4 | null | >This is why this method of commenting is a huge waste of time.
If you do it by hand, yes. Such comments should be created automatically, without any human intervention. | null | 0 | 1316603788 | False | 0 | c2lgvtl | t3_kmk56 | null | t1_c2lgvtl | t1_c2lgper | null | 1427627742 | -8 | t5_2fwo | null | null | null |
True | __j_random_hacker | null | Whenever you look at a line of code, you can see the external things that line of code depends on (or at least figure them out in principle -- overloading, namespaces etc. can make them hard to "see" in C++!). From looking at the code samples, I think the essence of the idea here is that in addition to this *what-things-do-I-depend-on* information, which often doesn't need a comment because it's implicit in the code itself, it would be useful to have knowledge of *what-things-depend-on-me*. That latter information is what you would write in a "negative comment" at the site of the depended-on thing. (Though I would call it a "reverse-dependency comment" -- I think the OP is mistaken in requiring that all these comments must be worded "negatively".) Of course, *people do this already* :)
The only problem I see with this is just the usual problem of having lots of comments in general: in a changing codebase, the more comments you have, the more likely they are to get out of sync with what the code actually does. If you essentially double the number of comments by adding in "negative" comments at the "other end" of every dependency, you now have 2 sets of comments describing the same thing -- so it's that much easier for 1 or both comments to get unstuck. It's the "extreme" aspect that I take issue with.
**TL;DR:** "reverse-dependency comments" are a good idea that you probably already use in moderation; excessive use becomes a maintenance burden. | null | 0 | 1316603854 | False | 0 | c2lgvxc | t3_kmk56 | null | t1_c2lgvxc | t3_kmk56 | null | 1427627743 | 7 | t5_2fwo | null | null | null |
True | want_to_want | null | Nice! The calculation seems correct to me. | null | 0 | 1316603856 | False | 0 | c2lgvxj | t3_klqte | null | t1_c2lgvxj | t1_c2lekop | null | 1427627743 | 1 | t5_2fwo | null | null | null |
True | stevedonovan | null | I like what the guy says, but don't like what he does. Line-by-line commenting misses an opportunity to write a paragraph about the _why_ of a function, not the _how_.
| null | 0 | 1316604029 | False | 0 | c2lgw85 | t3_kmk56 | null | t1_c2lgw85 | t1_c2lgony | null | 1427627747 | 1 | t5_2fwo | null | null | null |
True | shaurz | null | It's patents that are the problem, the patent trolls are just a symptom that would evaporate if patents were abolished. | null | 0 | 1316604162 | False | 0 | c2lgwf9 | t3_klqte | null | t1_c2lgwf9 | t3_klqte | null | 1427627750 | 1 | t5_2fwo | null | null | null |
Subsets and Splits
Filtered Reddit Uplifting News
The query retrieves specific news articles by their link IDs, providing a basic overview of those particular entries without deeper analysis or insights.
Recent Programming Comments
Returns a limited set of programming records from 2020 to 2023, providing basic filtering with minimal analytical value.