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 | smackmybishop | null | You are right. Those downvoting you are wrong. Need a better subreddit. | null | 0 | 1316657701 | False | 0 | c2lnp8g | t3_kmevq | null | t1_c2lnp8g | t1_c2lh2pe | null | 1427631030 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316657880 | False | 0 | c2lnq6i | t3_kmp75 | null | t1_c2lnq6i | t1_c2ln15g | null | 1427631041 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I learned a crapload about Windows internals when I made a poker bot that played on Pokerstars. Doesn't work anymore since Pokerstars now uses an entirely custom UI and I never bothered relearning it, but it was a fun project and a great way to learn nitty gritty details. | null | 0 | 1316658207 | False | 0 | c2lns1l | t3_kmshh | null | t1_c2lns1l | t1_c2lkgd1 | null | 1427631062 | 1 | t5_2fwo | null | null | null |
True | mhd420 | null | I remember there was outrage over Windows 2000 installation disks being able to access the command prompt of Windows XP machines without a password because the SAM databases were a different format. I guess it's easier to blame Microsoft for all of your security problems because they are a good scapegoat. | null | 0 | 1316658534 | False | 0 | c2lntuh | t3_kmshh | null | t1_c2lntuh | t1_c2lm2a0 | null | 1427631083 | 1 | t5_2fwo | null | null | null |
True | bobindashadows | null | I'm not talking about mov di, di, I'm taking about actual NOPs. Read the x86 manual. | null | 0 | 1316658706 | False | 0 | c2lnurg | t3_kmshh | null | t1_c2lnurg | t1_c2ln024 | null | 1427631094 | 0 | t5_2fwo | null | null | null |
True | jrcapa | null | This is a nice experiment to find out how much aware you have to be about code, that is all. | null | 0 | 1316658806 | False | 0 | c2lnv9u | t3_kmk56 | null | t1_c2lnv9u | t3_kmk56 | null | 1427631101 | 5 | t5_2fwo | null | null | null |
True | stoph | null | > Because having the ability to automatically index means no one will ever be able to add a manual index again, right?
Sometimes adding an index will slow down your table for hours or the greater part of an entire day. Do you really want the database to do that automatically?
You only have so much computing at your disposal, why waste it on unnecessary tasks with lots of overhead? | null | 0 | 1316658876 | False | 0 | c2lnvnn | t3_kmp73 | null | t1_c2lnvnn | t1_c2lhsst | null | 1427631106 | 2 | t5_2fwo | null | null | null |
True | Already__Taken | null | Any chance of an example? /not arguing | null | 0 | 1316659151 | False | 0 | c2lnx5c | t3_kmshh | null | t1_c2lnx5c | t1_c2llyzy | null | 1427631126 | 5 | t5_2fwo | null | null | null |
True | mvanier | null | I read this book ages ago and I think it's one of the reasons I fell in love with programming languages. The conciseness of Forth, coupled with the ability to change the language from within the language, left a huge impression on me. Even though I don't use Forth anymore (I'm mostly a Haskeller), I still fondly remember this book. The author's sense of humor and the cartoons made the book fun reading, too. Leo, wherever you are: thanks. | null | 0 | 1316659208 | True | 0 | c2lnxgk | t3_kkegr | null | t1_c2lnxgk | t3_kkegr | null | 1427631130 | 2 | t5_2fwo | null | null | null |
True | mvanier | null | Although Postscript is a stack language, the authors of Postscript (or at least, the authors of the Postscript book I read that was from Adobe) claimed that it was not derived from Forth. Perhaps there was some inspiration, but the languages have very different feature sets. | null | 0 | 1316659336 | False | 0 | c2lny5f | t3_kkegr | null | t1_c2lny5f | t1_c2l321w | null | 1427631140 | 1 | t5_2fwo | null | null | null |
True | Diamond145 | null | Old! :p But thanks for sharing :) | null | 0 | 1316659336 | False | 0 | c2lny5m | t3_kmlu2 | null | t1_c2lny5m | t3_kmlu2 | null | 1427631140 | 0 | t5_2fwo | null | null | null |
True | FearlessFreep | null | Hmm...I mostly program python and while monkeypatching is not really the first go-to technique, I've used it when no other option was available and I didn't really think it was frowned upon *when needed* | null | 0 | 1316659479 | False | 0 | c2lnyuq | t3_kmshh | null | t1_c2lnyuq | t1_c2ln10d | null | 1427631149 | 1 | t5_2fwo | null | null | null |
True | ricky_clarkson | null | Yeah.. I'd much prefer descriptive commit messages. | null | 0 | 1316659616 | False | 0 | c2lnzim | t3_kmk56 | null | t1_c2lnzim | t3_kmk56 | null | 1427631156 | 1 | t5_2fwo | null | null | null |
True | Svenstaro | null | USE GDB AND UNFAULT IT | null | 0 | 1316659679 | False | 0 | c2lnzuq | t3_knghm | null | t1_c2lnzuq | t3_knghm | null | 1427631162 | -3 | t5_2fwo | null | null | null |
True | honcas | null | What did I say that was violent? | null | 0 | 1316659691 | False | 0 | c2lnzww | t3_kl7h0 | null | t1_c2lnzww | t1_c2lnkqa | null | 1427631162 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | You can't just check those strings, because a lot of the work arounds are of the form BOOST_MSVC > 1400 or 1300 or some other older version. You also need to check against BOOST_DINKUMWARE since they're the provider of Microsoft's standard library.
I remember reading a comparison of standard compliance which did more than just use boost, if I find the link I'll post it but basically gcc 4 and above has overall the best standards compliance up there with Intel and clang is catching up. Visual Studio wasn't the absolute worst, but of all 'prominent' C++ compilers it was the lowest. I mean you have some pretty obscure compilers from companies who I don't even know if they're in business anymore that ranked lower and then you have the MS compiler thrown in there. | null | 0 | 1316659870 | True | 0 | c2lo0uh | t3_klphp | null | t1_c2lo0uh | t1_c2li0tu | null | 1427631174 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | What's an "actual NOP?" Even the original one-byte x86 NOP instruction, 0x90, is actually **xchg (e)ax,(e)ax**. Thanks for the downvote, though, and feel free to re-read that x86 manual. | null | 0 | 1316659876 | False | 0 | c2lo0vt | t3_kmshh | null | t1_c2lo0vt | t1_c2lnurg | null | 1427631174 | 5 | t5_2fwo | null | null | null |
True | tontoto | null | SEGMENTATION FAULT?
NOT MY FAULT | null | 0 | 1316660129 | False | 0 | c2lo24m | t3_knghm | null | t1_c2lo24m | t3_knghm | null | 1427631191 | -4 | t5_2fwo | null | null | null |
True | ethraax | null | Actually, from my attempts to get a virus on a Windows 98 and a Windows 95 virtual machine, I must say that there isn't a whole lot going around that infects them anymore. I assume that most viruses are targeted at more common systems, like XP and onwards (although I managed to get Windows 2000 killed by something off Megaupload).
Edit: I even downloaded and ran a 2 MB executable that was labeled "2 GB OF PORN", and the executable just crashed - I guess it tried exploiting a feature that wasn't even in Windows 95... | null | 0 | 1316660191 | False | 0 | c2lo2fr | t3_kmshh | null | t1_c2lo2fr | t1_c2lnn0k | null | 1427631195 | 17 | t5_2fwo | null | null | null |
True | Tossrock | null | From the sidebar: "Some seem to think this reddit is for "links that programmers might find interesting or funny". No. It's for programming links. Programming. *Programming*. **Programming.**" | null | 0 | 1316660535 | False | 0 | c2lo475 | t3_knghm | null | t1_c2lo475 | t3_knghm | null | 1427631218 | 1 | t5_2fwo | null | null | null |
True | civildisobedient | null | 1994 was not "late 90s' or 200x's".
[Fucking kids.](http://www.youtube.com/watch?v=Dyx4v1QFzhQ) | null | 0 | 1316660547 | False | 0 | c2lo49f | t3_kmshh | null | t1_c2lo49f | t1_c2lmzcq | null | 1427631219 | 13 | t5_2fwo | null | null | null |
True | flukus | null | With a mocking library you create defaults in your setup method and the specifics in your individual tests. If you use concrete classes instead you probably need a different concrete class for each individual test.
You also need a lot more boilerplate code if you want verifications on the parameters passed out.
Lets say I have a math class with a int PlusOne(int number) method. The class has a ResultListener dependency that needs to be notified of every result. This is completely contrived example, obviously.
With Moq (c#) in our setup method we would setup the default:
MockListener.Setup(x => x.AddResult(It.IsAny<int>()));
Because this is a generic setup we don't care what number is passed to AddResult because we are not running any verifications on it, we just want it to not crash. This is also called a stub. Note the use of It.IsAny<int>().
In one test we just want to make sure the correct result is returned from the function:
int result = MathObject.PlusOne(5);
Assert.AreEqual(6, result);
In another test we want to verify that the correct result is passed to the result listener, so we override the mock method:
MockListener.Setup(x => x.AddResult(It.Is<int>(9))).Verifyable();
int result = MathObject.PlusOne(8);
MockListener.Verify();
With the concrete method you would have to write code that stores the value passed to the AddResult method and use that in an assertion, which would be more code, even for this simple example.
And what if an expected result of AddOne is to swallow exceptions returned by the ResultListener? If you were using a concrete classes you would you would have to create another implimentation with a method that throws and exception, with a mock the entire test looks like:
MockListener.Setup(x => x.AddResult(It.IsAny<int>())).Thows(new SomeException());
int result = MathObject.PlusOne(5);
Assert.AreEqual(6, result); //we get here because the exception is swallowed
So even on a simple example with one dependency with one method mocking comes out being a lot less code, not to mention more readable. | null | 0 | 1316660578 | False | 0 | c2lo4ey | t3_klypn | null | t1_c2lo4ey | t1_c2lidwb | null | 1427631221 | 1 | t5_2fwo | null | null | null |
True | civildisobedient | null | What in the hell is that? Some fucking Pixar bullshit? Ten years and everyone forgets everything. Reel 2 Real, ftw. | null | 0 | 1316660595 | False | 0 | c2lo4il | t3_kmshh | null | t1_c2lo4il | t1_c2ln1j4 | null | 1427631222 | 0 | t5_2fwo | null | null | null |
True | NitWit005 | null | What's more questionable than the difficulty issue is the availability of alternatives to Stack Overflow. When I searched for help with Apple's libraries, I hit a lot of blog posts. Similar search terms hit Stack Overflow and official documentation for Android queries. | null | 0 | 1316660611 | False | 0 | c2lo4lk | t3_kkp4z | null | t1_c2lo4lk | t1_c2l0zsh | null | 1427631223 | 1 | t5_2fwo | null | null | null |
True | hydrogen18 | null | Wouldn't viewing the disassembly violate the EULA you agreed to? | null | 0 | 1316660695 | False | 0 | c2lo50g | t3_kmshh | null | t1_c2lo50g | t3_kmshh | null | 1427631229 | 1 | t5_2fwo | null | null | null |
True | hydrogen18 | null | I guess the real outrage is all those Ubuntu Live CDs that can just edit the passwords of Window machines. | null | 0 | 1316661025 | False | 0 | c2lo6lc | t3_kmshh | null | t1_c2lo6lc | t1_c2lntuh | null | 1427631249 | 7 | t5_2fwo | null | null | null |
True | bobindashadows | null | I didn't downvote you, but thanks for implying otherwise. While you are right about 0x90, consider the 2-9-byte instructions:
I recommend Intel's [instruction set manual](http://www.intel.com/content/dam/doc/manual/64-ia-32-architectures-software-developer-vol-2a-2b-instruction-set-a-z-manual.pdf) which if you go to page X notes how you can insert a 1-cycle, 1-pipe instructions from 1-9 bytes:
* 2 bytes: `0x66 0x90`
* 3 bytes: `0x0F 0x1F 0x00`
* 4 bytes: `0x0F 0x1F 0x40 0x00`
* 5 bytes: `0x0F 0x1F 0x40 0x00 0x00`
* 6 bytes: `0x66 0x0F 0x1F 0x40 0x00 0x00`
* 7 bytes: `0x0F 0x1F 0x80 0x00 0x00 0x00 0x00`
* 8 bytes: `0x0F 0x1F 0x84 0x00 0x00 0x00 0x00 0x00`
* 9 bytes: `0x66 0x0F 0x1F 0x84 0x00 0x00 0x00 0x00 0x00` | null | 0 | 1316661106 | False | 0 | c2lo6yg | t3_kmshh | null | t1_c2lo6yg | t1_c2lo0vt | null | 1427631255 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | wow, i nearly made it a whole ten hours without seeing a new ur-lisp implementation | null | 0 | 1316661637 | False | 0 | c2lo9ig | t3_knafe | null | t1_c2lo9ig | t3_knafe | null | 1427631287 | 16 | t5_2fwo | null | null | null |
True | mvanier | null | It seems to me that they came up with a good solution by dividing the language into "small" Scheme (with the benefits you mention) and "large" Scheme (suitable for large-scale application development). Anyway, now PLT Scheme (which is from Felleisen's group and groups associated with him) is now Racket, which I think is a very positive step. Racket has lots of interesting innovations that would be hard to fold back into a Scheme standard IMO (if only because it would be hard to get everyone to agree to them). | null | 0 | 1316661683 | False | 0 | c2lo9q0 | t3_kk1hp | null | t1_c2lo9q0 | t1_c2kxpdk | null | 1427631291 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Oh jesus, don't violate the EULA! | null | 0 | 1316661773 | False | 0 | c2loa4q | t3_kmshh | null | t1_c2loa4q | t1_c2lo50g | null | 1427631296 | 18 | t5_2fwo | null | null | null |
True | [deleted] | null | must.read.the.book. | null | 0 | 1316661862 | False | 0 | c2loaib | t3_kmref | null | t1_c2loaib | t1_c2lk9w5 | null | 1427631301 | 2 | t5_2fwo | null | null | null |
True | disidentadvisor | null | I have loved doing the Euler Problems this summer (I completed about 50 with no prior programming experience) but I am starting to hit difficulties in them so I have been exploring new languages and trying to learn new algorithms.
I look forward to using this set of classes to supplement my learning. Plus, the guy is extremely positive which is valuable for staying motivated. | null | 0 | 1316662199 | False | 0 | c2lobza | t3_kn9fk | null | t1_c2lobza | t3_kn9fk | null | 1427631320 | 5 | t5_2fwo | null | null | null |
True | lighthill | null | Does that let you replace only some of the functions in the regular system DLL? I was under the impression that you had to replace the whole DLL, or none of it. (Yes, I know you can have your DLL implement every function that you _don't_ want to replace with a stub that calls the function in the regular DLL. There's gotta be a better way, right?) | null | 0 | 1316662373 | False | 0 | c2loctz | t3_kmshh | null | t1_c2loctz | t1_c2lnbgq | null | 1427631331 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | I didn't say you couldn't do that. I said multi-byte NOPs go all the way back to the 8086 and provided examples, which you suggested were not real NOPs and told me to "read the manual", which is a pretty dickish response, you could have just clarified and pointed out that the i686 introduced an official set of multi-byte NOP sequences. | null | 0 | 1316662433 | True | 0 | c2lod3u | t3_kmshh | null | t1_c2lod3u | t1_c2lo6yg | null | 1427631333 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | Am I supposed to be impressed by that?
Nothing in there justifies your hatred of the GPL or RMS. | null | 0 | 1316662519 | False | 0 | c2lodi5 | t3_kl7h0 | null | t1_c2lodi5 | t1_c2lh4s7 | null | 1427631340 | 0 | t5_2fwo | null | null | null |
True | tjdziuba | null | Not nearly as neat as the early Unix C compiler shenanigans. | null | 0 | 1316662551 | False | 0 | c2lodn1 | t3_knhd2 | null | t1_c2lodn1 | t3_knhd2 | null | 1427631340 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | Borderline violent.
Do you want to ask me about the vitriol part? | null | 0 | 1316662563 | False | 0 | c2lodot | t3_kl7h0 | null | t1_c2lodot | t1_c2lnzww | null | 1427631341 | 1 | t5_2fwo | null | null | null |
True | flamingspinach_ | null | Pocoo developer spotted! This guy no doubt knows what he's talking about. | null | 0 | 1316663068 | False | 0 | c2log1x | t3_kmshh | null | t1_c2log1x | t1_c2lkzek | null | 1427631373 | 1 | t5_2fwo | null | null | null |
True | thantik | null | Same is true for things that span an average of 10 words across.......with sometimes as little as 8 words.
Also, zooming in doesn't change the layout. Zooming in...zooms in. | null | 0 | 1316663296 | False | 0 | c2loh3y | t3_kldfr | null | t1_c2loh3y | t1_c2l8yer | null | 1427631386 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316663338 | False | 0 | c2loh9a | t3_kn6hr | null | t1_c2loh9a | t3_kn6hr | null | 1427631388 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | That does happen in the Sandy Bridge processors: you can run up to 4 NOPs/XOR reg,same per cycle, decoder being the bottleneck. In previous ones, they're still assigned ports, even though they're reading/writing nowhere. | null | 0 | 1316663444 | False | 0 | c2loht4 | t3_kmshh | null | t1_c2loht4 | t1_c2lljas | null | 1427631395 | 3 | t5_2fwo | null | null | null |
True | stesch | null | I still can't cope with the fact that Opa forces you to produce XHTML **1.1**. | null | 0 | 1316663506 | False | 0 | c2loi3l | t3_kn8ra | null | t1_c2loi3l | t1_c2lmfw5 | null | 1427631400 | 2 | t5_2fwo | null | null | null |
True | xiongchiamiov | null | Um, Pixar makes *good* movies, not Madagascar. | null | 0 | 1316663733 | False | 0 | c2loj4y | t3_kmshh | null | t1_c2loj4y | t1_c2lo4il | null | 1427631414 | 15 | t5_2fwo | null | null | null |
True | ooooo5 | null | Why not just make an AVL tree? | null | 0 | 1316663753 | False | 0 | c2loj7x | t3_kn9gt | null | t1_c2loj7x | t3_kn9gt | null | 1427631415 | 4 | t5_2fwo | null | null | null |
True | a_redditor | null | Please do not post stupid memes to /r/programming. | null | 0 | 1316663793 | False | 0 | c2lojeu | t3_knghm | null | t1_c2lojeu | t3_knghm | null | 1427631417 | 5 | t5_2fwo | null | null | null |
True | munificent | null | > Next you trace the ray back to some other wall
But that's only a single ray, which would render a wall with a mirror-like perfectly reflective finish (which ray tracing is great for). Most surfaces reflect light in all directions. That means that light coming in from any angle to a point on the surface will illuminate it, and that illumunation in turn will bounce off in all directions.
Radiosity simulates that, which is why each iteration has to render an entire scene (the hemisphere) from the surface's perspective: light coming in from any of those directions can illuminate the surface. | null | 0 | 1316664143 | False | 0 | c2lokyi | t3_kmlu2 | null | t1_c2lokyi | t1_c2lieq1 | null | 1427631437 | 2 | t5_2fwo | null | null | null |
True | TinyEarl | null | Well, they *did* make Cars 2... | null | 0 | 1316664174 | False | 0 | c2lol3l | t3_kmshh | null | t1_c2lol3l | t1_c2loj4y | null | 1427631439 | 14 | t5_2fwo | null | null | null |
True | acm | null | jesus, that dude needs to take a breath every once in a while. | null | 0 | 1316664200 | False | 0 | c2lol7m | t3_kn9fk | null | t1_c2lol7m | t3_kn9fk | null | 1427631440 | 20 | t5_2fwo | null | null | null |
True | grauenwolf | null | > Lets say I have a math class with a int PlusOne(int number) method. The class has a ResultListener dependency that needs to be notified of every result. This is completely contrived example, obviously.
Yes, it is quite obvious your example is contrived. Given this scenario I would construct the API of MathObject as such:
class MathObject
int PlusOne(int)
event ResultCalculated
Then without any need for mocks, stubs, or other foolishness I would verify that PlusOne raised the ResultCalculated event.
If you design your APIs according to the guidelines of your language then it is almost a given that they are going to be testable. | null | 0 | 1316664210 | False | 0 | c2lol9g | t3_klypn | null | t1_c2lol9g | t1_c2lo4ey | null | 1427631441 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I don't get it. | null | 0 | 1316664496 | False | 0 | c2lomiz | t3_kmp73 | null | t1_c2lomiz | t1_c2lneri | null | 1427631458 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316665325 | False | 0 | c2loq3n | t3_kl7h0 | null | t1_c2loq3n | t1_c2lodot | null | 1427631504 | 1 | t5_2fwo | null | null | null |
True | myztry | null | Virtualisation does provide an extra level of software to overcome flaws in the host OS by means of virtual devices.
Say if someone if trying to leverage something like a SCSI DMA writeback which the virtualised OS doesn't prevent, the proper OS still has the opportunity to prevent such things. Other things would be possible like catching shader based DOS and denying them.
It would be fairly limited though. If the OS is borked than there is little that can be done. | null | 0 | 1316665500 | False | 0 | c2loqwu | t3_kmshh | null | t1_c2loqwu | t1_c2lnn0k | null | 1427631514 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | "NoSQL" is all the rage | null | 0 | 1316665815 | False | 0 | c2los9g | t3_kmp73 | null | t1_c2los9g | t1_c2lomiz | null | 1427631532 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Value5 = 5
So if one day value of 5 would change itself, our ENTERPISE solution would be ready | null | 0 | 1316665849 | False | 0 | c2loseo | t3_klhlv | null | t1_c2loseo | t3_klhlv | null | 1427631534 | 1 | t5_2fwo | null | null | null |
True | besvr | null | Request for Change Estimate:
* 10 hours programming
* 5 hours updating comments | null | 0 | 1316666124 | False | 0 | c2lothi | t3_kmk56 | null | t1_c2lothi | t1_c2lh40v | null | 1427631549 | 4 | t5_2fwo | null | null | null |
True | cybermind | null | Sure. If the calling module obtains DLL function addresses at runtime (with GetProcAddress), you can patch your own DLL's export table with the real DLL's exports at load time (nice example project [here](http://metamod-p.sourceforge.net/)), or you can hook GetProcAddress (using something like Detours, or with the method below, but then you don't need to really hook GetProcAddress to begin with) and then for GetProcAddress calls for your module handle, direct it to the real DLL's module handle.
Alternatively, you can have your DLL patch the desired module's IAT pointers for the desired functions and point them to functions in your DLL. This has the added bonus of only actually hooking functions when called by specific modules, since each module has its own IAT which points to functions in other modules. So you could have the main .exe's IAT patched so that calls to ws2_32.dll!connect() redirect to your hook function, but when that function is called from any other module, it would call the original one.
Neither of these are particularly good ideas, though. | null | 0 | 1316666183 | False | 0 | c2lotpu | t3_kmshh | null | t1_c2lotpu | t1_c2loctz | null | 1427631553 | 3 | t5_2fwo | null | null | null |
True | kamatsu | null | Or a Red-Black tree? Or a Splay Tree? Or any other balanced tree? There are different tradeoffs for each one. | null | 0 | 1316666406 | False | 0 | c2loulj | t3_kn9gt | null | t1_c2loulj | t1_c2loj7x | null | 1427631563 | 4 | t5_2fwo | null | null | null |
True | Mr_Incognito | null | It requires SBT to build, points you to a page for the wrong version of SBT, does not instruct you on how to build the project with SBT, and the Google group does not have much content and offers no help. This doesn't really promote an atmosphere friendly to newcomers. | null | 0 | 1316666633 | False | 0 | c2lovit | t3_kmygn | null | t1_c2lovit | t3_kmygn | null | 1427631575 | 4 | t5_2fwo | null | null | null |
True | wal9000 | null | [AGI32](http://www.agi32.com) is radiosity based, and I think more widely used in lighting engineering than Radiance | null | 0 | 1316666765 | False | 0 | c2low1u | t3_kmlu2 | null | t1_c2low1u | t1_c2li2v9 | null | 1427631583 | 2 | t5_2fwo | null | null | null |
True | ooooo5 | null | Yes, that's what I'm asking. How exactly is this different than all of the above? It'd be nice to have that kind of analysis, rather than just, "WOOOOOOOO, I MADE A BALANCED TREE!!!" | null | 0 | 1316667349 | False | 0 | c2loydf | t3_kn9gt | null | t1_c2loydf | t1_c2loulj | null | 1427631619 | 3 | t5_2fwo | null | null | null |
True | Sniffnoy | null | So do any of these expand to some other no-op like 0x90 does? (I realize they're treated atomically and not actually expanded to anything else, I just mean would they expand to some other no-op if they didn't have this special meaning.) | null | 0 | 1316667773 | False | 0 | c2lp00r | t3_kmshh | null | t1_c2lp00r | t1_c2lo6yg | null | 1427631634 | 2 | t5_2fwo | null | null | null |
True | mariuz | null | I have read last night your q2 source review , it's amazing how much work was done at that time and i have still some parts that i don't understand but it will help me with the q2 pascal port cleanup
Now related to q3 you can inspire on the maps format from Brandon's technical talks : Rendering Quake 3 maps with WebGL http://blog.tojicode.com/2010/08/rendering-quake-3-maps-with-webgl-tech.html
and the github repository with code https://github.com/toji/webgl-quake3 | null | 0 | 1316667867 | False | 0 | c2lp0cy | t3_klrrx | null | t1_c2lp0cy | t1_c2lej2j | null | 1427631639 | 2 | t5_2fwo | null | null | null |
True | crusoe | null | Tell me about it. I found a bug at work, due to a Rails class we had wrote called "Rack" that conflicted with the rails "Rack" utility.
No other runtime errors, or anything, just random bugs here and there.
It would sometimes choke.
Ruby is a ghetto.
Lets pollute the global namespace.
Lets allow monkeypatching of arbitrary objects, in arbitrary places!
Scala Implicits are nice. | null | 0 | 1316668157 | False | 0 | c2lp1j2 | t3_kmshh | null | t1_c2lp1j2 | t1_c2lmprl | null | 1427631654 | 6 | t5_2fwo | null | null | null |
True | mariuz | null | Related to modified Quake 1 engines , i love the Xonotic game that was just released it shows that q1 still got something to show
http://www.xonotic.org/2011/09/xonotic-0-5-release/
And with big textures and new effects it looks great and the quake1 feeling is somehow better than q3 one (maybe is about the dark places and how rendering is done) | null | 0 | 1316668184 | False | 0 | c2lp1mn | t3_klrrx | null | t1_c2lp1mn | t1_c2ldaic | null | 1427631655 | 1 | t5_2fwo | null | null | null |
True | kdoto | null | From the first sentence of the article:
> [...] but is also easy to code, requiring none of the special-case bashing that characterizes red-black trees.
The biggest benefit I see so far is that this balanced tree is very easy to implement compared to AVL or red-black trees.
However it is random, so some analysis of how much better treaps behave compared to other random balanced trees. It's very easy to create a balanced tree based on random insertion -- so I can't say how special these treaps are, or how often a simpler implementation is really worth anything. We usually have a library with a AVL or Red Black tree or similar available to us, don't we? | null | 0 | 1316668318 | True | 0 | c2lp24f | t3_kn9gt | null | t1_c2lp24f | t1_c2loydf | null | 1427631662 | 3 | t5_2fwo | null | null | null |
True | Pxtl | null | Ahh, rdbmses. A beautiful kernel of set theory trapped inside a gigantic mud-boulder of ugly hacks you have to do to keep it performant. | null | 0 | 1316668764 | False | 0 | c2lp3sl | t3_kmp73 | null | t1_c2lp3sl | t3_kmp73 | null | 1427631684 | 2 | t5_2fwo | null | null | null |
True | Zaziel | null | Worse example ever, I would sacrifice small children to get Microsoft Bob back! | null | 0 | 1316668814 | False | 0 | c2lp3za | t3_kmshh | null | t1_c2lp3za | t1_c2llqie | null | 1427631686 | 4 | t5_2fwo | null | null | null |
True | paradoxiology | null | > By making some use of randomness, ... we'll code up a complete treap implementation in Lisp (particularly, pylisp) that is also fully functional.
How can the code be functional(as in pure functional programming) if the algorithm uses randomness.
Maybe I don't understand the syntax, but the function `set` doesn't seem to be pure at all due to the use of `(random.randint 0 1000000000)`?
Or does he mean functional as usable/working? | null | 0 | 1316669059 | False | 0 | c2lp4vb | t3_kn9gt | null | t1_c2lp4vb | t3_kn9gt | null | 1427631698 | 1 | t5_2fwo | null | null | null |
True | j_lyf | null | I have a question - how does one get to program at this level of complexity. | null | 0 | 1316669350 | False | 0 | c2lp5xv | t3_klrrx | null | t1_c2lp5xv | t3_klrrx | null | 1427631714 | 4 | t5_2fwo | null | null | null |
True | igotthepancakes | null | Going through this class last Fall, and eventually finishing up by the end of Christmas break, helped me get an internship last summer. The skills I took away from that one course cover about two courses worth at my university. I recommend CS50 to any beginner. It will be challenging, but worth it in the end. | null | 0 | 1316669365 | False | 0 | c2lp5zw | t3_kn9fk | null | t1_c2lp5zw | t3_kn9fk | null | 1428193502 | 2 | t5_2fwo | null | null | null |
True | mfukar | null | I see. I'm trying to promote a similar system here. Glad to know it works, even though I can't know what for. :-P | null | 0 | 1316669682 | False | 0 | c2lp748 | t3_klypn | null | t1_c2lp748 | t1_c2lm0x2 | null | 1427631729 | 2 | t5_2fwo | null | null | null |
True | Rikkochet | null | It appears semantically identical to:
list1.Update(list2);
UpdateableList<Person> updated = list1;
I assume the API was designed that way to support method chaining, but I think it's unintuitive and could burn future developers. I'm used to seeing that kind of behavior for immutable classes (like DateTime.AddDays()). | null | 0 | 1316669756 | False | 0 | c2lp7cz | t3_kn9oj | null | t1_c2lp7cz | t1_c2lmg6t | null | 1427631743 | 1 | t5_2fwo | null | null | null |
True | darjus | null | Both agree and disagree here :)
My biggest worry with the comments that say "oh and this is needed because of function x somewhere else" is that you also need to say in function x that you are initializing value a somewhere else, because if you change the function x to either not use the value or not care about the initialization and don't change initialize, the comment immediately becomes obsolete/useless/confusing, etc. On the other hand if you don't put the comment, i would do a Ctrl + s for the file for "entries" and let's hope there's no monkey patching or external side effects. Also, i like to read the unit tests as they should describe the use cases, so in many cases it is quite descriptive of *expected* usage of the class.
From one side it's a good idea to comment on side effects, but this particular case it's useless (IMO) because I'm initializing attributes of an object *during* initialization. Quite self explanatory to me. | null | 0 | 1316669939 | False | 0 | c2lp80b | t3_kmk56 | null | t1_c2lp80b | t1_c2lgtqk | null | 1427631745 | 1 | t5_2fwo | null | null | null |
True | Vaste | null | I think the idea was that small_expr would be a small expression (probably containing x). | null | 0 | 1316670028 | False | 0 | c2lp8by | t3_klphp | null | t1_c2lp8by | t1_c2lgouh | null | 1427631747 | 1 | t5_2fwo | null | null | null |
True | darjus | null | If you have more than one person working on this and you don't use 100% proof static analysis (which is impossible with a language like Ruby), you're always guessing. People don't keep comments up to date 100% of the time. | null | 0 | 1316670078 | False | 0 | c2lp8ia | t3_kmk56 | null | t1_c2lp8ia | t1_c2llvjt | null | 1427631748 | 3 | t5_2fwo | null | null | null |
True | djimbob | null | Its not April Fools day. Requiring a comment per line is a complete waste, and couldn't be used in any real project. Write code with appropriate names for variables, functions, classes, in a straightforward manner (unless profiling shows the need for a less readable optimization); comments are usually a sign showing you should refactor your code (except the appropriate comments, specifying the contract/specification/use of functions/classes). Commenting on a per-line basis is only useful in teaching absolute beginners; and still most programming books will only comment on the lines with new stuff. | null | 0 | 1316670139 | False | 0 | c2lp8pm | t3_kmk56 | null | t1_c2lp8pm | t3_kmk56 | null | 1427631750 | 5 | t5_2fwo | null | null | null |
True | b0dhi | null | Your statement is interesting in light of this: according to http://en.wikipedia.org/wiki/Usage_share_of_operating_systems#Web_clients , the share of machines on the Internet running Windows versions 2000 and earlier is ~4.9%. That's higher than Linux's ~1% (not counting web-servers). | null | 0 | 1316670167 | False | 0 | c2lp8tb | t3_kmshh | null | t1_c2lp8tb | t1_c2lo2fr | null | 1427631756 | 3 | t5_2fwo | null | null | null |
True | markusro | null | Exactly, but here is only ONE column, and that makes it not nice to read. IMHO. (And this column is too narrow) | null | 0 | 1316670197 | False | 0 | c2lp8wq | t3_kldfr | null | t1_c2lp8wq | t1_c2l84fb | null | 1427631755 | 1 | t5_2fwo | null | null | null |
True | flukus | null | So you would use events for all interactions between a class and it's dependencies? | null | 0 | 1316670277 | False | 0 | c2lp95h | t3_klypn | null | t1_c2lp95h | t1_c2lol9g | null | 1427631757 | 1 | t5_2fwo | null | null | null |
True | djimbob | null | The problem with comments is that comments can lie. The code can change or the programmer made a mistake. Programmers should learn to read and write code in their languages, and there *never* should be a comment that just documents basic language feature (you import a module so I can use its namespace, or you instantiate a variable so you can use it). Comments are useful; but only really for documenting the specifications for classes/functions and semantic meaning for code that's difficult to see otherwise. | null | 0 | 1316670848 | False | 0 | c2lpb46 | t3_kmk56 | null | t1_c2lpb46 | t1_c2lgu73 | null | 1427631779 | 2 | t5_2fwo | null | null | null |
True | kmmeerts | null | [Sure, under heavy construction](https://github.com/kmmeerts/kosmos). I have only been working on it for two weeks, so the there's little it does apart from render a 8 teapots orbiting the teapot sun. | null | 0 | 1316670921 | False | 0 | c2lpbdu | t3_klrrx | null | t1_c2lpbdu | t1_c2lms16 | null | 1427631784 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316671119 | False | 0 | c2lpc10 | t3_klypn | null | t1_c2lpc10 | t3_klypn | null | 1427631792 | 1 | t5_2fwo | null | null | null |
True | sebzim4500 | null | Where do we go for links that programmers might find interesting or funny? | null | 0 | 1316671344 | False | 0 | c2lpcr7 | t3_kmevq | null | t1_c2lpcr7 | t1_c2lh2pe | null | 1427631801 | 5 | t5_2fwo | null | null | null |
True | dyydvujbxs | null | It depends what you mean by "component" and "project". GPL "derived works" critetia does not cross process boundaries, only API boundaries within a process. LGPL does not even cross API boundaries. Projects that deliver output (as opposed to projects that deliver code) are also not constrained by GPL.
For example, Amazon.com can use GPL MySQL to power its website.
Affero is more broad in scope, but that is only one member of the GPL family. | null | 0 | 1316671508 | False | 0 | c2lpdag | t3_kl7h0 | null | t1_c2lpdag | t1_c2lioxr | null | 1427631807 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | What dependency?
Based on the description and unit tests you gave me for MathObject, it really doesn't care whether or not there is a ResultListener attached to it. | null | 0 | 1316671520 | False | 0 | c2lpdbq | t3_klypn | null | t1_c2lpdbq | t1_c2lp95h | null | 1427631809 | 1 | t5_2fwo | null | null | null |
True | dyydvujbxs | null | Right, but it is fashionable in some circles to dislike his views. | null | 0 | 1316671611 | False | 0 | c2lpdm1 | t3_kl7h0 | null | t1_c2lpdm1 | t1_c2lhvwb | null | 1427631813 | 1 | t5_2fwo | null | null | null |
True | tryx | null | Then you failed their test. For a serious researcher, writing a 20 second email to save tens of hours of work is nothing. | null | 0 | 1316671756 | False | 0 | c2lpe21 | t3_klzm8 | null | t1_c2lpe21 | t1_c2li2cp | null | 1427631818 | 0 | t5_2fwo | null | null | null |
True | fullouterjoin | null | Couldn't this have been like 10x lines shorter? | null | 0 | 1316671809 | False | 0 | c2lpe84 | t3_knafe | null | t1_c2lpe84 | t3_knafe | null | 1427631821 | 1 | t5_2fwo | null | null | null |
True | s73v3r | null | Did you know that anarcho-capitalism is fucking retarded? And anyone that thinks that's the way to go even more so? It's true. Mainly because they think they'll be the ones on top, but then fail to realize all the help they'd need to get there, and that they'd be subjugated by the rich. | null | 0 | 1316671849 | False | 0 | c2lpeck | t3_klqte | null | t1_c2lpeck | t1_c2ln29h | null | 1427631824 | 2 | t5_2fwo | null | null | null |
True | Gotebe | null | Yes, but I claimed that it's been OK since 2003 (1310, I think). That still gives a lot. I still do think that MS does reasonably well WRT standards-compliance, but I have since yesterday changed my mind about *how* well.
Also, take a look e.g. at number of hits for Intel or recent GCC. | null | 0 | 1316672148 | False | 0 | c2lpf9t | t3_klphp | null | t1_c2lpf9t | t1_c2li0tu | null | 1427631836 | 1 | t5_2fwo | null | null | null |
True | dyydvujbxs | null | There is no guarantee of assistance or non-compete, though.
Suppose you make a database engine to power a great CMS product. You figure you can BSD the database and get some help from someone in the ecommerce industry who are not your competition but who also need a database engine.
First off, the ecommerce firms don't have to bother contributing back their fixes, unless the cost of maintaining a downstream branch exceeds the cost of contributing back. Second, nothing stops another CMS vendor from leapfrogging your CMS product by saving all that database dev cost.
BSD does not offer any competitive protection to the original author. That is likely related to its origin as a poduct of a public university that wasn't concerned about economic competition and was arguably obligated to make its work nearly public domain. | null | 0 | 1316672148 | False | 0 | c2lpf9u | t3_kl7h0 | null | t1_c2lpf9u | t1_c2lir1p | null | 1427631836 | 1 | t5_2fwo | null | null | null |
True | flukus | null | As I said, it's a contrived example, Reddit isn't suitable for posting large code samples.
Once again you seem to be disparaging things you don't understand (ie, our branching/merging conversation). | null | 0 | 1316672359 | False | 0 | c2lpfz0 | t3_klypn | null | t1_c2lpfz0 | t1_c2lpdbq | null | 1427631846 | 1 | t5_2fwo | null | null | null |
True | marshmallowsOnFire | null | Can someone tell me where exactly one can 'see' this assembly code? Where in my system should I go to see this stuff? I have always been keen on seeing the real assembly code that makes my OS and my laptop and everything work. | null | 0 | 1316672410 | False | 0 | c2lpg4o | t3_kmshh | null | t1_c2lpg4o | t3_kmshh | null | 1427631848 | 1 | t5_2fwo | null | null | null |
True | andralex | null | >the struct vs class dichotomy requires upfront knowledge of how a type will be used.
I've seen this aired a couple of times, never with a good substantiation. In C++, does one not know how to use std::vector?
>many things in D are awkwardly designed: bitfields, RAII, bit-blits of structs, etc.
Bitfields are not part of the language. RAII is designed to work better and is guaranteed to be more efficient than C++'s without complicating the language with the likes of rvalue references. That said, a good argument would be a good argument. Let's hear it. | null | 0 | 1316672430 | False | 0 | c2lpg73 | t3_kljc0 | null | t1_c2lpg73 | t1_c2lhwei | null | 1427631848 | 3 | t5_2fwo | null | null | null |
True | Iggyhopper | null | When was this recorded? | null | 0 | 1316672573 | True | 0 | c2lpgl9 | t3_kn9fk | null | t1_c2lpgl9 | t3_kn9fk | null | 1427631856 | 1 | t5_2fwo | null | null | null |
True | johnlocke90 | null | What about people intentionally trying to harm his computer? | null | 0 | 1316673488 | False | 0 | c2lpj8i | t3_kmshh | null | t1_c2lpj8i | t1_c2lo2fr | null | 1427631885 | 2 | t5_2fwo | null | null | null |
True | wickeand000 | null | I agree. | null | 0 | 1316673581 | False | 0 | c2lpjh1 | t3_kmref | null | t1_c2lpjh1 | t1_c2loaib | null | 1427631890 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316673932 | False | 0 | c2lpkfp | t3_kmevq | null | t1_c2lpkfp | t1_c2lpcr7 | null | 1427631903 | 7 | t5_2fwo | null | null | null |
True | myblake | null | Yea it's pretty solid, David Malan is an amazing teacher (it's kind of shocking that Harvard has such a guy given the general approach there). | null | 0 | 1316673962 | False | 0 | c2lpkim | t3_kn9fk | null | t1_c2lpkim | t1_c2lnmsz | null | 1427631903 | 0 | t5_2fwo | null | null | null |
True | MaybeReconsider | null | * mov edi, edi zeroes the upper 32 bits of rdi, which is a nonvolatile register. So that would be bad.
* mov rdi, rdi would be safe, but would require a REX prefix and so be three bytes long instead of two. | null | 0 | 1316674224 | False | 0 | c2lpl7l | t3_kmshh | null | t1_c2lpl7l | t1_c2lmxpk | null | 1427631912 | 7 | 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.