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 | grauenwolf | null | I see. But then you could have multiple incoming service calls executing concurrently. | null | 0 | 1318981948 | False | 0 | c2skriv | t3_lf1px | null | t1_c2skriv | t1_c2skdcm | null | 1427750572 | 1 | t5_2fwo | null | null | null |
True | ElencherMind | null | Interesting, I learned something new, thanks. | null | 0 | 1318981986 | False | 0 | c2skrot | t3_lfblq | null | t1_c2skrot | t1_c2sjtdn | null | 1427750574 | 1 | t5_2fwo | null | null | null |
True | leonardo_m | null | Bug fixed, more small improvements, plus some suggestions: http://codepad.org/DHAew9Zf | null | 0 | 1318982018 | False | 0 | c2skruz | t3_lew0f | null | t1_c2skruz | t1_c2sekbk | null | 1427750576 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | A string is no exception. In .NET String is just a wrapper around an array of Char. In fact, when you call StringBuilder.ToString you are actually getting a wrapper around the same char array you were just mutating. | null | 0 | 1318982085 | False | 0 | c2sks7x | t3_lf1px | null | t1_c2sks7x | t1_c2skc26 | null | 1427750581 | 1 | t5_2fwo | null | null | null |
True | ewiethoff | null | It's more likely the site sucks. Try comparing what [the site](http://www.reddit.com/r/programming/comments/lg6ms/great_descriptions_of_design_patterns/c2skosi) and IMDB say about the original "The Blob" movie.
| null | 0 | 1318982097 | False | 0 | c2sks9o | t3_lg6ms | null | t1_c2sks9o | t1_c2sjowy | null | 1427750581 | 2 | t5_2fwo | null | null | null |
True | crinos666 | null | I'll be honest. I've been hacking around with C for literally about 2 weeks. What would the rationale be behind storing negative integers in an unsigned int in the first place? To try and store numbers between -(UINT_MAX) and -0, and increase the available negative integers?
To my relative layman's mind, "unsigned" a... | null | 0 | 1318982338 | False | 0 | c2sktdq | t3_lg59j | null | t1_c2sktdq | t1_c2sfcd9 | null | 1427750596 | 1 | t5_2fwo | null | null | null |
True | elder_george | null | Using `volatile` for cross-thread communication requires several assumptions to be made:
1) that memory access to the variable is atomic, which is not guaranteed for most types;
2) operations are executed in order by CPU.
Which is often simply not true. See e.g. [this article](http://software.intel.com/en-us/blogs/2... | null | 0 | 1318982403 | False | 0 | c2sktoh | t3_lgjhl | null | t1_c2sktoh | t1_c2skpa1 | null | 1427750599 | 9 | t5_2fwo | null | null | null |
True | [deleted] | null | Multiple short statements on a single line. | null | 0 | 1318982416 | False | 0 | c2sktr2 | t3_lfm1k | null | t1_c2sktr2 | t1_c2si28m | null | 1427750600 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Actually it was. It was very perlish. ">>=", ">>", "<$>", "++" what's with all the hieroglyphics man? Everywhere else the trend seems to be to dial down this kind of symbol based syntax. | null | 0 | 1318982583 | False | 0 | c2skuha | t3_lfm1k | null | t1_c2skuha | t1_c2sfi71 | null | 1427750610 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318982656 | False | 0 | c2skusr | t3_lgjhl | null | t1_c2skusr | t1_c2si1dq | null | 1427750614 | -1 | t5_2fwo | null | null | null |
True | uriel | null | `volatile` might not be ignored by most compilers, but [it is at best useless and at worst evil](http://lwn.net/Articles/233482/). | null | 0 | 1318982759 | False | 0 | c2skva0 | t3_lgjhl | null | t1_c2skva0 | t1_c2sjeto | null | 1427750624 | -4 | t5_2fwo | null | null | null |
True | lordlicorice | null | As a student, UML fills my chest with clutching horror. I want to live in the world of lambdas and of thread safety and of signed integer wrapping standards. I would weep at my desk if I had to make sense of [this kind of sputum](http://sourcemaking.com/files/sm/images/uml/img_4.jpg ) on a daily basis.
Seriously, a de... | null | 0 | 1318982812 | False | 0 | c2skvih | t3_lg6ms | null | t1_c2skvih | t3_lg6ms | null | 1427750624 | 3 | t5_2fwo | null | null | null |
True | joehillen | null | except you forgot the last 0 | null | 0 | 1318982835 | False | 0 | c2skvmg | t3_lgfp0 | null | t1_c2skvmg | t1_c2skjx0 | null | 1427750625 | 5 | t5_2fwo | null | null | null |
True | psygnisfive | null | And yet the diagram makes no quantitative judgements, it simply says that the set of programs in Haskell that works is much smaller than the total set of programs that work. But this is necessarily true, because everything outside of the "code written in Haskell" circle is written in some other programming language. Th... | null | 0 | 1318982932 | False | 0 | c2skw4b | t3_lfm1k | null | t1_c2skw4b | t1_c2sk50x | null | 1427750632 | 1 | t5_2fwo | null | null | null |
True | SyKoHPaTh | null | I grab em as they come out. | null | 0 | 1318982948 | False | 0 | c2skw6b | t3_lg6zg | null | t1_c2skw6b | t1_c2sjxxv | null | 1427750633 | 1 | t5_2fwo | null | null | null |
True | MarshallBanana | null | `volatile` is absolutely mandatory for writing correct programs in various situations. Linus himself outlines some of them in that very post.
So, it is at best required for correctness and at worst evil. Like most programming language features. | null | 0 | 1318982957 | False | 0 | c2skw85 | t3_lgjhl | null | t1_c2skw85 | t1_c2skva0 | null | 1427750633 | 11 | t5_2fwo | null | null | null |
True | fmihaly | null | Putting "new" into a link to a 20 year old (1990) paper is misleading. | null | 0 | 1318982968 | False | 0 | c2skwa5 | t3_lgjhl | null | t1_c2skwa5 | t3_lgjhl | null | 1427750634 | 26 | t5_2fwo | null | null | null |
True | naasking | null | I have yet to run into a situation where inheritance is more flexible than parameterization. It's sometimes more concise, but only because the language penalizes parameterization. | null | 0 | 1318982979 | False | 0 | c2skwc5 | t3_lg1xx | null | t1_c2skwc5 | t1_c2sk4wm | null | 1427750635 | 2 | t5_2fwo | null | null | null |
True | ewiethoff | null | Why did you assume that the statistic applied to land line calls in the first place? Maybe your personal experience with cell calls doesn't match the 1:7 stat, so you assumed the stat applies to land line calls?
| null | 0 | 1318983010 | False | 0 | c2skwh1 | t3_lg6ms | null | t1_c2skwh1 | t1_c2sjbu2 | null | 1427750636 | 1 | t5_2fwo | null | null | null |
True | generalT | null | indeed. we haven't "designed" the WCF instancing yet on our service (we're still implementing the components that consume remote services), or implemented the service itself, but when we do, we'll have to account for the multi-threaded environment.
looking forward to using the TPL for the first time. | null | 0 | 1318983036 | True | 0 | c2skwl0 | t3_lf1px | null | t1_c2skwl0 | t1_c2skriv | null | 1427750638 | 1 | t5_2fwo | null | null | null |
True | uriel | null | Not really as Linus explains in the post I linked.
Also, it obviously it is not mandatory in any way given that the whole Plan 9 OS is written without it. | null | 0 | 1318983129 | False | 0 | c2skwzy | t3_lgjhl | null | t1_c2skwzy | t1_c2skw85 | null | 1427750642 | 2 | t5_2fwo | null | null | null |
True | MarshallBanana | null | I probably edited my post after you replied, so re-read it. | null | 0 | 1318983170 | False | 0 | c2skx6q | t3_lgjhl | null | t1_c2skx6q | t1_c2skwzy | null | 1428192049 | 1 | t5_2fwo | null | null | null |
True | generic_0 | null | I remember coding a file system in school on my Linux laptop. It's gcc, so what could go wrong, right? Well I found out (luckily) that the TA tested them on the Solaris box with a hopelessly outdated version of gcc. This meant that all of my file system assumptions like block size went out the window and the result ... | null | 0 | 1318983238 | False | 0 | c2skxi7 | t3_lgfp0 | null | t1_c2skxi7 | t1_c2shygc | null | 1427750662 | 3 | t5_2fwo | null | null | null |
True | akdas | null | Whoops, missed that the first time around. [billsnow explains why both I and the article are wrong about text objects not being available in vi.](http://www.reddit.com/r/programming/comments/lfblq/vim_text_objects_the_definitive_guide/c2sd6si) | null | 0 | 1318983239 | False | 0 | c2skxie | t3_lfblq | null | t1_c2skxie | t1_c2sgcvi | null | 1427750662 | 1 | t5_2fwo | null | null | null |
True | NruJaC | null | How is that different than any abstraction mechanism ever? | null | 0 | 1318983248 | False | 0 | c2skxk3 | t3_lfm1k | null | t1_c2skxk3 | t1_c2sj7wu | null | 1427750654 | 3 | t5_2fwo | null | null | null |
True | generalT | null | hmm, interesting. i don't know too much about the details of the string implementation- i'm just ape-ing what i've read from other sources.
>[Strings are immutable](http://msdn.microsoft.com/en-us/library/362314fe.aspx)--the contents of a string object cannot be changed after the object is created, although the sy... | null | 0 | 1318983273 | True | 0 | c2skxnl | t3_lf1px | null | t1_c2skxnl | t1_c2sks7x | null | 1427750665 | 1 | t5_2fwo | null | null | null |
True | sltkr | null | That's about compilers, though. newgre was talking about most *systems*.
I suppose those numbers depend on two things: how many desktops run 64-bit Windows these days? How do the number of desktops compare to the number of servers? I'm assume that the biggest internet companies, like Google and Amazon, all run 64-bit ... | null | 0 | 1318983289 | True | 0 | c2skxq7 | t3_lgfp0 | null | t1_c2skxq7 | t1_c2sknso | null | 1427750656 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | I'm at a loss to understand what part of "volatile is rarely sufficient but occasionally necessary" has been refuted by *anything* that you've posted.
Your many arguments about why the keyword is rarely sufficient may well agree with everything I've been saying - but you've failed to prove that it is never necessary.
... | null | 0 | 1318983289 | False | 0 | c2skxq8 | t3_lgjhl | null | t1_c2skxq8 | t1_c2sktoh | null | 1427750656 | -5 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318983338 | False | 0 | c2skxxs | t3_lfm1k | null | t1_c2skxxs | t1_c2sd43j | null | 1427750660 | 1 | t5_2fwo | null | null | null |
True | uriel | null | Go might be many things, 'insane' is not one of them. | null | 0 | 1318983393 | False | 0 | c2sky5b | t3_ld12r | null | t1_c2sky5b | t1_c2s7i0c | null | 1427750662 | 1 | t5_2fwo | null | null | null |
True | Spec_Laconic | null | ahh 6.828, the memories. Also, I hear it's multicore this year, I'm jealous! | null | 0 | 1318983396 | False | 0 | c2sky5o | t3_lgfp0 | null | t1_c2sky5o | t3_lgfp0 | null | 1427750662 | 4 | t5_2fwo | null | null | null |
True | fmihaly | null | A title stating simply "You should avoid using unsigned data types to store negative values" would have been much more helpful. | null | 0 | 1318983441 | False | 0 | c2skyev | t3_lg59j | null | t1_c2skyev | t3_lg59j | null | 1427750670 | 0 | t5_2fwo | null | null | null |
True | flukshun | null | question 3 recently nipped me in the ass. I'm working on live migration for virtual machines, and much of that involves serializing data structures and sending them to a process waiting on the destination machine for all the data it needs to re-instantiate the virtual machine. The framework for doing the serialization ... | null | 0 | 1318983530 | True | 0 | c2skyvw | t3_lgfp0 | null | t1_c2skyvw | t1_c2sjn6o | null | 1427750678 | 10 | t5_2fwo | null | null | null |
True | uriel | null | You are still misrepresenting Linus' position, he gives two cases where `volatile` is *potentially* useful, not in any way *mandatory*.
Note that one of those two cases is: *"jiffies", for stupid legacy reasons*.
Then there is inline asm, which nobody sane should be using anyway, and is certainly not mandatory in any... | null | 0 | 1318983540 | False | 0 | c2skyxh | t3_lgjhl | null | t1_c2skyxh | t1_c2skx6q | null | 1427750678 | -1 | t5_2fwo | null | null | null |
True | zhivago | null | Arrays in C are also simple.
Start by getting rid of gibberish like 'decay'.
You can think of it as "the value of an array is a pointer to its first element".
char a[3];
printf("%d, %d\n", sizeof a == 3, sizeof (a + 0) == sizeof (char *));
sizeof and & operate on objects rather than values, and everythi... | null | 0 | 1318983556 | True | 0 | c2skz03 | t3_lgfp0 | null | t1_c2skz03 | t1_c2sh57h | null | 1427750673 | 22 | t5_2fwo | null | null | null |
True | rghd | null | >its objective was to stump know-it-all undergrads
sounds like its objective was to mislead them with the aim of discouraging their enthusiasm.
real nice, man. | null | 0 | 1318983594 | False | 0 | c2skz6n | t3_lgfp0 | null | t1_c2skz6n | t1_c2shfrc | null | 1427750683 | 3 | t5_2fwo | null | null | null |
True | ewiethoff | null | Python doesn't have an `iterable` (or whatever you want to call it) class. Rather, an iterable object is any object that has an `__iter__` method. Think duck typing.
| null | 0 | 1318983709 | False | 0 | c2skzp9 | t3_lg940 | null | t1_c2skzp9 | t1_c2shk3c | null | 1427750685 | 1 | t5_2fwo | null | null | null |
True | zhivago | null | It's depressing that they got their questions wrong:
#include <stdio.h>
int main() {
int x[5];
printf("%p\n", x); /* undefined behavior */
printf("%p\n", x+1); /* undefined behavior */
printf("%p\n", &x); /* undefined behavior */
printf("%p\n", &x+1); /* undefined be... | null | 0 | 1318983743 | False | 0 | c2skzum | t3_lgfp0 | null | t1_c2skzum | t3_lgfp0 | null | 1428192047 | 0 | t5_2fwo | null | null | null |
True | psygnisfive | null | The points about programming languages as a tool for thought are entirely valid, but APL is the worst language to express these thoughts in. For one, the horrendous character set makes it impossible to port any existing knowledge. For instance, this equivalence is given:
+/5⍴6 = 6×5
If you don't understand that, ... | null | 0 | 1318983756 | True | 0 | c2skzx1 | t3_lg5ri | null | t1_c2skzx1 | t3_lg5ri | null | 1427750687 | 8 | t5_2fwo | null | null | null |
True | sltkr | null | It depends. It's very important to completely understand the semantics of C before you can do a proper code review, because errors don't always show up at runtime.
For example, you need to thoroughly understand how arrays and pointers work in C to catch errors like this:
int func(int a[10])
{
memset(a... | null | 0 | 1318983842 | False | 0 | c2sl0bc | t3_lgfp0 | null | t1_c2sl0bc | t1_c2sjn6o | null | 1427750693 | 3 | t5_2fwo | null | null | null |
True | MarshallBanana | null | > You are still misrepresenting Linus' position, he gives two cases where volatile is potentially useful, not in any way mandatory.
Sorry, no, you are.
He gives three situations where it is mandatory:
* in _code_, i.e., for things like the definition of "readb()" etc, where we use it to force a particular access.... | null | 0 | 1318983860 | False | 0 | c2sl0e9 | t3_lgjhl | null | t1_c2sl0e9 | t1_c2skyxh | null | 1427750695 | 5 | t5_2fwo | null | null | null |
True | thatusernameisal | null | Too bad no TTS voice available for Chrome comes even close to the default voice in Windows7, I was hoping to finally see some progress in the world of TTS. | null | 0 | 1318983902 | False | 0 | c2sl0lm | t3_lgk5y | null | t1_c2sl0lm | t3_lgk5y | null | 1427750696 | 1 | t5_2fwo | null | null | null |
True | norkakn | null | How can you apply a role to an instance in Python? (Or is that outside the scope of the default object system? I don't really do any new OO without Moose these days) | null | 0 | 1318983915 | False | 0 | c2sl0nn | t3_lg940 | null | t1_c2sl0nn | t1_c2si8pd | null | 1427750698 | 1 | t5_2fwo | null | null | null |
True | ncr100 | null | I've used Idea 10 for Android dev for a month. I'm comfortable with Eclipse and Idea.
I feel Idea is 3x better than Eclipse - stability, speed, and advanced refactoring / code searching features. Well worth a license for the productivity improvement. | null | 0 | 1318984013 | False | 0 | c2sl142 | t3_lgebd | null | t1_c2sl142 | t1_c2sjvs0 | null | 1427750702 | 2 | t5_2fwo | null | null | null |
True | artsrc | null | > DI injects (= creates) dependencies. That's the problem, not the solution. Modular design separates concerns and thereby minimizes dependencies.
The organization of the software involves dependencies. Minimizing is good but they can never go away. I see no evidence that DI promotes designs with tighter coupling... | null | 0 | 1318984061 | False | 0 | c2sl1c5 | t3_lf1px | null | t1_c2sl1c5 | t1_c2shbcf | null | 1427750715 | 1 | t5_2fwo | null | null | null |
True | elder_george | null | I think we violently agree on the fact that removal of `volatile` doesn't make code better. That's nice because I never made such a statement.
We also agree that using `volatile` for cross-thread interaction in absence of other tools is rarely sufficient. That's nice as well.
I can agree as well that there're scenari... | null | 0 | 1318984071 | False | 0 | c2sl1e6 | t3_lgjhl | null | t1_c2sl1e6 | t1_c2skxq8 | null | 1427750715 | 13 | t5_2fwo | null | null | null |
True | uriel | null | There is nothing that is impossible without inline asm.
As for accessing memory-mapped devices, as Linus points out, `volatile` does not really solve this, only part of it, and there is nothing wrong with using (assembly or otherwise) stubs to do it, that is basically what Linux does too. | null | 0 | 1318984187 | False | 0 | c2sl1xp | t3_lgjhl | null | t1_c2sl1xp | t1_c2sl0e9 | null | 1427750717 | -5 | t5_2fwo | null | null | null |
True | caviar | null | Also guilty here. I researched this and found a good discussion about the sizes of various data types on 64 bit systems here:
http://stackoverflow.com/questions/384502/what-is-the-bit-size-of-long-on-64-bit-windows/384672#384672 | null | 0 | 1318984201 | False | 0 | c2sl206 | t3_lgfp0 | null | t1_c2sl206 | t1_c2skpjd | null | 1428192045 | 2 | t5_2fwo | null | null | null |
True | nexes300 | null | Who cares? Correct is CHAR_BITS * sizeof and everything else is wrong. | null | 0 | 1318984208 | False | 0 | c2sl21l | t3_lgfp0 | null | t1_c2sl21l | t1_c2skldn | null | 1427750718 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | But sizeof() is *not* bit length. An int32_t is guaranteed to be 32 bits, but that says very little about sizeof(int32_t). If CHAR_BIT == 32 then:
int32_t x[5]; // x == 0x7fffdfbf7f00
printf("%p\n",x+1); // prints 0x7fffdfbf7f01
sizeof(int) must be given to get this question correct, or some very ... | null | 0 | 1318984337 | False | 0 | c2sl2o9 | t3_lgfp0 | null | t1_c2sl2o9 | t1_c2sjsv3 | null | 1427750727 | 5 | t5_2fwo | null | null | null |
True | _georgesim_ | null | Something tells me that UML is not your only problem. | null | 0 | 1318984373 | False | 0 | c2sl2u8 | t3_lg6ms | null | t1_c2sl2u8 | t1_c2skvih | null | 1427750730 | -1 | t5_2fwo | null | null | null |
True | artsrc | null | I tried to articulate a trivial DI design here:
http://www.reddit.com/r/programming/comments/lf1px/are_there_any_benefits_in_dependency_injection/c2sasya
I think you need at least 5 classes before you should use DI. And many more (15?) before you benefit from a framework.
The key point is when you want access to a ... | null | 0 | 1318984416 | False | 0 | c2sl316 | t3_lf1px | null | t1_c2sl316 | t1_c2sg712 | null | 1427750733 | 2 | t5_2fwo | null | null | null |
True | MarshallBanana | null | > There is nothing that is impossible without inline asm.
Writing code that efficiently uses extended processor instructions. Stubs incur function call overhead, which may not be acceptable.
> As for accessing memory-mapped devices, as Linus points out, volatile does not really solve this, only part of it,
I ... | null | 0 | 1318984450 | False | 0 | c2sl37b | t3_lgjhl | null | t1_c2sl37b | t1_c2sl1xp | null | 1427750744 | 5 | t5_2fwo | null | null | null |
True | ewiethoff | null | I think many, many people are confused about why `x` (say) has a `__len__` method, not a `len` method. The length method has a crazy double underbar name because it's a "special" or "magic" method. Why are special methods special? Because they are routinely invoked by special syntax, seldom by `x.methodname()` syntax. ... | null | 0 | 1318984465 | False | 0 | c2sl39v | t3_lg940 | null | t1_c2sl39v | t1_c2sk14i | null | 1427750735 | 1 | t5_2fwo | null | null | null |
True | mcguire | null | Yeah, the details of x86 assembly are out of date, but there is a lot of interesting things to learn. And Abrash is a *good* writer. | null | 0 | 1318984497 | False | 0 | c2sl3g9 | t3_lgwpf | null | t1_c2sl3g9 | t3_lgwpf | null | 1427750738 | 7 | t5_2fwo | null | null | null |
True | artsrc | null | You already indent your code.
Indented code without the fluff ({,}, etc.) simply works in the languages with significant whitespace.
| null | 0 | 1318984647 | False | 0 | c2sl47l | t3_lfm1k | null | t1_c2sl47l | t1_c2seig1 | null | 1427750750 | 1 | t5_2fwo | null | null | null |
True | X-Istence | null | typedef char* (*ptFunc2)()
typedef int* (*ptFunc1)(ptFunc2 my_function)
ptFunc1[10];
ptFunc1 (*ptrToArray)[10] = &ptFunc1;
Is this what you were looking for?
| null | 0 | 1318984655 | False | 0 | c2sl48n | t3_lgfp0 | null | t1_c2sl48n | t1_c2sj6pi | null | 1427750750 | 4 | t5_2fwo | null | null | null |
True | _georgesim_ | null | People, the fact that it's presented in an article-like fashion doesn't mean it's progit worthy...
It's seems like nowadays everyone and their sisters are writing programming oriented articles while actually having no merits on what they're talking about. | null | 0 | 1318984691 | False | 0 | c2sl4er | t3_lg59j | null | t1_c2sl4er | t3_lg59j | null | 1427750755 | 0 | t5_2fwo | null | null | null |
True | mcguire | null | > "something other than the code can change the value of this variable, so the optimizer can't assume that it will be constant even if the code doesn't modify it"
Which explains why it's regarded as useless: as far as I can tell, the Plan 9 compilers didn't optimize, so the issue doesn't come up.
[Dang it, I can d... | null | 0 | 1318984724 | False | 0 | c2sl4kh | t3_lgjhl | null | t1_c2sl4kh | t1_c2sj9vh | null | 1427750757 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318984769 | False | 0 | c2sl4sd | t3_lg940 | null | t1_c2sl4sd | t1_c2sl39v | null | 1427750757 | 2 | t5_2fwo | null | null | null |
True | Smallpaul | null | Yes, if you want to read the article as if the writer's goal was to say nothing at all, then you are certainly free to read it that way.
Conversely, if you wish to apply your common sense you can assume that there is some relationship between the title of the piece, and various sentences like:
"writing Haskell code i... | null | 0 | 1318984837 | False | 0 | c2sl54z | t3_lfm1k | null | t1_c2sl54z | t1_c2skw4b | null | 1427750761 | 1 | t5_2fwo | null | null | null |
True | sltkr | null | Very nice case, but I think the proper question to ask is whether the code invokes undefined behaviour rather than whether it segfaults (although this code does neither).
There are plenty of cases of undefined behaviour which, depending on the compiler and the level of optimizations applied, may segfault or not.
For ... | null | 0 | 1318984867 | True | 0 | c2sl5af | t3_lgfp0 | null | t1_c2sl5af | t1_c2sk7oz | null | 1427750762 | 1 | t5_2fwo | null | null | null |
True | Noink | null | Wait, sizeof(int) == 4 on a 64-bit system, and not 8? | null | 0 | 1318985064 | False | 0 | c2sl6ar | t3_lgfp0 | null | t1_c2sl6ar | t3_lgfp0 | null | 1427750774 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318985178 | False | 0 | c2sl6v6 | t3_lfm1k | null | t1_c2sl6v6 | t1_c2sd41m | null | 1427750778 | 1 | t5_2fwo | null | null | null |
True | mcguire | null | > See e.g. this article for some of problems.
[That](http://software.intel.com/en-us/blogs/2007/11/30/volatile-almost-useless-for-multi-threaded-programming/) is a very good article. Thanks. | null | 0 | 1318985226 | False | 0 | c2sl730 | t3_lgjhl | null | t1_c2sl730 | t1_c2sktoh | null | 1427750781 | 6 | t5_2fwo | null | null | null |
True | sheenobu | null | Great. awesome. fantastic. Now where's the implementation? It's just like code bubbles, you hear about it and then never see the working software. Anything like this or code bubbles as an eclipse plugin or the like? | null | 0 | 1318985255 | False | 0 | c2sl78s | t3_lgecn | null | t1_c2sl78s | t3_lgecn | null | 1427750783 | 1 | t5_2fwo | null | null | null |
True | jldugger | null | Well, any decent C programmer would specify int32_t instead of leaving it to chance. | null | 0 | 1318985580 | True | 0 | c2sl8ui | t3_lgfp0 | null | t1_c2sl8ui | t1_c2sitfg | null | 1427750798 | 1 | t5_2fwo | null | null | null |
True | psygnisfive | null | I know exactly what the authors goals were. My point was that he didn't make that point very well, because he said things that have nothing specific to do with Haskell. His argument for that point was simply flawed by his own lack of understanding. And your argument is flawed by the exact same lack of understanding, as... | null | 0 | 1318985614 | False | 0 | c2sl90m | t3_lfm1k | null | t1_c2sl90m | t1_c2sl54z | null | 1427750800 | 1 | t5_2fwo | null | null | null |
True | ewiethoff | null | Calling `len(x)` is weird if you come from Java or Ruby. :-) Java even makes you memorize when to use `x.length`, `x.length()`, or `x.size()`. As if these are easier to learn? Ruby tries to "simplify" your life by providing both `x.length` and `x.size` to perform the same operation. Um, yeah, don't forget to override t... | null | 0 | 1318985775 | False | 0 | c2sl9sa | t3_lg940 | null | t1_c2sl9sa | t1_c2sl4sd | null | 1427750810 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | That's a fairly pedantic distinction between compilers and systems. Further, "most systems" could refer to the breadth of available systems, and not simply the overall installed base. Even further, discussing how many installed systems use LP vs. ILP seems like it's missing the point that the grandparent post was ... | null | 0 | 1318985820 | False | 0 | c2sl9yf | t3_lgfp0 | null | t1_c2sl9yf | t1_c2skxq7 | null | 1427750813 | 1 | t5_2fwo | null | null | null |
True | djrubbie | null | What about making a feature branch that is private such that you don't share far and wide so if it really doesn't work, you can pretend it never happened? | null | 0 | 1318985845 | False | 0 | c2sla3u | t3_lgoan | null | t1_c2sla3u | t3_lgoan | null | 1427750815 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Old Honeywells, PDP-6/10, IBM 70x/70xx, many UNIVACs with 9 bit char.
CDC machines, DEC-20, PDP-8, IM6100 with 12 bit char.
TI C54x, C62xx, C64xx DSPs with 16 bit char. Cutting edge OMAP2 chips here.
There are some 32bit and 36 bit char machines out there also. The above systems range from very old to very new.
... | null | 0 | 1318985854 | False | 0 | c2sla5v | t3_lgfp0 | null | t1_c2sla5v | t1_c2sjs2x | null | 1427750818 | 7 | t5_2fwo | null | null | null |
True | mcguire | null | Well, it is the title of the paper. | null | 0 | 1318986009 | False | 0 | c2slax6 | t3_lgjhl | null | t1_c2slax6 | t1_c2skwa5 | null | 1427750835 | 7 | t5_2fwo | null | null | null |
True | grauenwolf | null | Flexibility isn't the only reason to use something. | null | 0 | 1318986014 | False | 0 | c2slay0 | t3_lg1xx | null | t1_c2slay0 | t1_c2skwc5 | null | 1427750835 | 2 | t5_2fwo | null | null | null |
True | ashultz | null | In 15 years I have never done an inch of actual UML, and I've read only a tiny bit. The people I know who actually use it tend to use one or another UML (actually usually UML-like because they don't bother to remember all the symbols) on some sticky part of a project, like a sequence diagram which is a useful thing al... | null | 0 | 1318986135 | False | 0 | c2slbl4 | t3_lg6ms | null | t1_c2slbl4 | t1_c2skvih | null | 1427750843 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | TPL is fun, but what I'm really looking forward to is the Async stuff built on top of it. I'm doing mostly Silverlight development these days and that stuff would solve countless problems for me. | null | 0 | 1318986222 | False | 0 | c2slc1f | t3_lf1px | null | t1_c2slc1f | t1_c2skwl0 | null | 1427750846 | 1 | t5_2fwo | null | null | null |
True | cavercody | null | No of course it doesn't need to be perfect when done on a whiteboard. Minor syntax errors, bugs, handling of nullptrs, etc. could all be ignored. It's important to see if they can communicate a solution to you and how they can explain their own code. If they make a bug, you could ask them to step through their code to ... | null | 0 | 1318986346 | False | 0 | c2slcmj | t3_lf038 | null | t1_c2slcmj | t1_c2sjyn3 | null | 1427750851 | 1 | t5_2fwo | null | null | null |
True | agottem | null | > Even if integers are not atomic, when another thread modifies the flag, it simply does not matter if there is a read of '0' when you might have expected a non-zero - the loop will execute one extra time, but there is nothing in this code suggesting that this is a problem. If it was a problem, you'd use a more soph... | null | 0 | 1318986354 | False | 0 | c2slco0 | t3_lgjhl | null | t1_c2slco0 | t1_c2skxq8 | null | 1427750851 | 6 | t5_2fwo | null | null | null |
True | grauenwolf | null | Basically it is an optimization. When you call StringBuilder.ToString it sets a flag and gives you a cheap string.
If you decide to make further changes to the StringBuilder and that flag is set then it needs to make a new character array to store a copy of the data. Same cost as before, but 95% of the time you aren't... | null | 0 | 1318986363 | False | 0 | c2slcq4 | t3_lf1px | null | t1_c2slcq4 | t1_c2skxnl | null | 1427750851 | 1 | t5_2fwo | null | null | null |
True | potifar | null | Too bad the bet is formulated so it's unwinnable for you ;) | null | 0 | 1318986376 | False | 0 | c2slcs8 | t3_lgfp0 | null | t1_c2slcs8 | t1_c2skcwd | null | 1427750852 | 1 | t5_2fwo | null | null | null |
True | SirClueless | null | The number of bits in int32_t is not the issue. The issue is that on some bizarre systems, a char is 32 bits as well. Therefore sizeof(int32_t) == sizeof(char), and the standard says that sizeof(char) == 1, so sizeof(int32_t) == 1. | null | 0 | 1318986423 | True | 0 | c2sld0z | t3_lgfp0 | null | t1_c2sld0z | t1_c2sjs2x | null | 1427750861 | 3 | t5_2fwo | null | null | null |
True | AgentME | null | [On most compilers, right.](https://secure.wikimedia.org/wikipedia/en/wiki/64-bit#64-bit_data_models) | null | 0 | 1318986480 | False | 0 | c2sldb9 | t3_lgfp0 | null | t1_c2sldb9 | t1_c2sl6ar | null | 1427750858 | 1 | t5_2fwo | null | null | null |
True | FeepingCreature | null | Well fuck that shit. People seem to forget that "char" is short for "character". Unless these chips are so cutting edge they have UTF32 in the metal .. | null | 0 | 1318986616 | False | 0 | c2sle12 | t3_lgfp0 | null | t1_c2sle12 | t1_c2sla5v | null | 1427750874 | -4 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318986853 | False | 0 | c2slf7t | t3_lg940 | null | t1_c2slf7t | t1_c2sl9sa | null | 1427750885 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | "Character" is not defined to be 8-bit. ASCII is a 7 bit character standard. 8 bits are used on the 32bit systems to store ASCII because 32 isn't divisible by 7. So the char data type does not match the "character" size the system was originally designed for. UTF-8 characters are relative newcomers optimized for thes... | null | 0 | 1318986967 | False | 0 | c2slfsh | t3_lgfp0 | null | t1_c2slfsh | t1_c2sle12 | null | 1427750890 | 8 | t5_2fwo | null | null | null |
True | lordlicorice | null | Oh, buh. I'm not even going to try to claim that was a typo; I typed everything but the last digit and thought "huh, now all I need to do is append the sizeof(int) as the last hex digit. let's use a plus sign." WTF? | null | 0 | 1318987112 | False | 0 | c2slgku | t3_lgfp0 | null | t1_c2slgku | t1_c2skvmg | null | 1427750900 | 8 | t5_2fwo | null | null | null |
True | eluusive | null | It's not even arrays in general which have special arcane behavior. It's specifically static arrays. They're optimized in funny ways that aren't even consistent across compilers. | null | 0 | 1318987189 | False | 0 | c2slgy7 | t3_lgfp0 | null | t1_c2slgy7 | t1_c2sh57h | null | 1427750912 | 1 | t5_2fwo | null | null | null |
True | ropers | null | Oracle has taken over Ksplice?
Well, [fuck](http://en.wikipedia.org/wiki/Ksplice):
> It was developed by Ksplice, Inc. until 21 July 2011, when Oracle acquired Ksplice, started offering support for Oracle Linux, and dropped support for Red Hat Enterprise Linux among other distributions. | null | 0 | 1318987381 | False | 0 | c2sli0k | t3_lgfp0 | null | t1_c2sli0k | t3_lgfp0 | null | 1427750925 | 3 | t5_2fwo | null | null | null |
True | uzimonkey | null | Right, but that's like saying OpenGL is a 3D context for a framebuffer, and the OP is saying he can't wait to see what else the framebuffer can do. The demo is not really about the framebuffer, it's about the 3D interface. | null | 0 | 1318987507 | False | 0 | c2slioj | t3_lg6zg | null | t1_c2slioj | t1_c2sk36p | null | 1427750926 | 9 | t5_2fwo | null | null | null |
True | roboduck | null | Could you back up your claim that these statements result in undefined behavior with references to the C standard? | null | 0 | 1318987583 | False | 0 | c2slj2k | t3_lgfp0 | null | t1_c2slj2k | t1_c2skzum | null | 1427750937 | 1 | t5_2fwo | null | null | null |
True | squidgy | null | Yup, they bought them then promptly took down the blog and redirected it to a placeholder on oracle.com. For like 3 months. Glad to see it's back. | null | 0 | 1318987628 | False | 0 | c2sljam | t3_lgfp0 | null | t1_c2sljam | t1_c2sli0k | null | 1427750934 | 4 | t5_2fwo | null | null | null |
True | ewiethoff | null | Cough. Python wisely takes after
* Fortran: `SIZE(name)`
* Lisp: `(length name)`
* Pascal: `Length(x)`
* Perl: `scalar(@name)`
| null | 0 | 1318987720 | False | 0 | c2sljri | t3_lg940 | null | t1_c2sljri | t1_c2slf7t | null | 1427750941 | 1 | t5_2fwo | null | null | null |
True | roboduck | null | "64-bit system" just means that pointers are 64 bits. It doesn't define anything about other types (which is why technically the questions given are not specified fully). Most compilers you're going to run into today have 4-byte ints, however, even on 64-bit systems. | null | 0 | 1318987750 | False | 0 | c2sljx8 | t3_lgfp0 | null | t1_c2sljx8 | t1_c2sl6ar | null | 1427750944 | 6 | t5_2fwo | null | null | null |
True | ashultz | null | Your EE investment in the past, and the past is gone. If EE is not going to make you happy in the future and CS is, switch. | null | 0 | 1318987789 | False | 0 | c2slk43 | t3_lf038 | null | t1_c2slk43 | t1_c2sboa0 | null | 1427750945 | 1 | t5_2fwo | null | null | null |
True | zhivago | null | Q: What type does %p require of its associated argument?
A: void *
Q: What conversion for pointers occurs in the absence of type information?
A: None.
Q: What happens when you make a function call, providing a value of the wrong type?
A: Undefined behavior.
Which is also why printf("%p\n", NU... | null | 0 | 1318987872 | False | 0 | c2slkih | t3_lgfp0 | null | t1_c2slkih | t1_c2slj2k | null | 1427750952 | 4 | t5_2fwo | null | null | null |
True | sltkr | null | I agree that counting this fairly is difficult (especially because of server systems which typically don't run Windows, and may serve many different users from a single machine) but I think that newgre has a good point, by remarking that Windows is still a huge player in the OS market, and thus if Microsoft chooses to ... | null | 0 | 1318987903 | True | 0 | c2slkob | t3_lgfp0 | null | t1_c2slkob | t1_c2sl9yf | null | 1427750953 | 5 | t5_2fwo | null | null | null |
True | ashultz | null | Actually it's one ride on a half bus half train half plane. | null | 0 | 1318987920 | False | 0 | c2slkrq | t3_lf038 | null | t1_c2slkrq | t1_c2s8ldc | null | 1427750954 | 1 | t5_2fwo | null | null | null |
True | bluGill | null | The c99 committee took the other choice: ints are 32 bits on almost all 64 bit systems.
Their choice was eliminate the old (K&R) rule the short <= int <= long (or change short and long to be something other than 16 and 32 bits), or introduce a new type for 64 bits.
When I use int I mean "hey compiler, I d... | null | 0 | 1318988182 | False | 0 | c2slm2b | t3_lgfp0 | null | t1_c2slm2b | t1_c2sh69m | null | 1427750971 | 2 | t5_2fwo | null | null | null |
True | cavercody | null | Sure. I'm not sure you want treatment at the level of TAOCP for EE though anymore than someone would want it for an introduction to CS.
Signal Processing First by McClellan, Schafer, and Yoder (TAOCP equivalent is Discrete Time Signal Processing by Oppenheim and Schafer)
Introduction to Electric Circuits by Dorf and ... | null | 0 | 1318988205 | False | 0 | c2slm6r | t3_lf038 | null | t1_c2slm6r | t1_c2sej78 | null | 1427750973 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318988250 | False | 0 | c2slmh2 | t3_lgfp0 | null | t1_c2slmh2 | t1_c2sigbr | null | 1427750977 | 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.