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 | wnoise | null | Even if you use arithmetic coding (which extracts the maximum amount of information from the random bits), that won't be guaranteed. If you're choosing between three things, 01010101... will never decide. | null | 0 | 1318959617 | True | 0 | c2shed5 | t3_lfsfk | null | t1_c2shed5 | t1_c2sen2t | null | 1427748935 | 2 | t5_2fwo | null | null | null |
True | sindisil | null | The second question was a crap shoot, since they didn't specify sizeof(int) for that system.
That aside, pretty elementary C questions, really.
| null | 0 | 1318959659 | False | 0 | c2shemp | t3_lgfp0 | null | t1_c2shemp | t3_lgfp0 | null | 1427748938 | 5 | t5_2fwo | null | null | null |
True | reventlov | null | Well, true. (This is what happens when I type up a rebuttal in 5 minutes.) With a more typical RAND_MAX of 2147483647, *assuming a completely unbiased rand()*, you get a 33.333333364% chance of 0, and a 33.333333318% chance of 1 or 2 when you take rand() % 3. | null | 0 | 1318959715 | False | 0 | c2shey8 | t3_lfsfk | null | t1_c2shey8 | t1_c2sf492 | null | 1427748940 | 6 | t5_2fwo | null | null | null |
True | sindisil | null | No, it's not.
sizeof(int) might well have been 8.
The author wrote a poor quiz. | null | 0 | 1318959727 | False | 0 | c2shf09 | t3_lgfp0 | null | t1_c2shf09 | t1_c2sh9v1 | null | 1427748941 | 11 | t5_2fwo | null | null | null |
True | insertAlias | null | >EDIT: Not sure about the 9 downvotes. Sometimes I wonder if there are people here whose life is so empty and sad they keep a half dozen accounts just for downvoting and censoring the uncomfortable truths they disagree with. Or is it supposed to be a secret that C#'s basics are inspired by Java?
Wow, conceited much... | null | 0 | 1318959739 | False | 0 | c2shf2x | t3_lg1xx | null | t1_c2shf2x | t1_c2seplf | null | 1427748941 | 3 | t5_2fwo | null | null | null |
True | dranek | null | Or: taking a negative of an unsigned is bad. | null | 0 | 1318959745 | False | 0 | c2shf45 | t3_lg59j | null | t1_c2shf45 | t1_c2semto | null | 1427748941 | 1 | t5_2fwo | null | null | null |
True | mrossi | null | I like the SIMD-oriented Fast Mersenne Twister from [here](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/). It is supposed to be fast, too.
It passes Marsaglias DieHard tests.
The GNU Scientific Library also offers several random number generators: [Documentation](http://www.gnu.org/software/gsl/manual/html_nod... | null | 0 | 1318959827 | True | 0 | c2shfky | t3_lfsfk | null | t1_c2shfky | t1_c2sepj6 | null | 1427748945 | 2 | t5_2fwo | null | null | null |
True | w_daher | null | Yeah, I was torn on this -- on the one hand, yes, it's under-specified. On the other hand, explicitly stating it reminds you more than I'd like about how pointer arithmetic works, and gives you a clue to #2.
Hard to say. When this was designed, its objective was to stump know-it-all undergrads :). (In its initial inca... | null | 0 | 1318959860 | False | 0 | c2shfrc | t3_lgfp0 | null | t1_c2shfrc | t1_c2shcd2 | null | 1427748947 | 14 | t5_2fwo | null | null | null |
True | codekiller | null | Even if it sounds funny nowadays, that's what you could have said about Java when it was first released... | null | 0 | 1318959892 | False | 0 | c2shfy0 | t3_lfm1k | null | t1_c2shfy0 | t1_c2sconi | null | 1427748951 | 0 | t5_2fwo | null | null | null |
True | NruJaC | null | Absolutely, and yet, they share some fundamental similarities, that's why they are both termed monads. The monadic abstraction tells us fundamental things about what we can expect from their respective bind functions. We may not know exactly how they operate, but we can say quite a bit about how they behave. And that's... | null | 0 | 1318959942 | False | 0 | c2shg8z | t3_lfm1k | null | t1_c2shg8z | t1_c2shdkd | null | 1427748954 | 5 | t5_2fwo | null | null | null |
True | elder_george | null | Sometimes method-call syntax is shorter than LINQ, sometimes it is not, sometimes it's hard to express at all.
E.g. simple query or aggregate call is much simpler with method calls. Queries to multiple tables and groupings are usually simpler in LINQ syntax. `let` bindings are very clunky with method calls but piece o... | null | 0 | 1318960014 | False | 0 | c2shgo3 | t3_lg1xx | null | t1_c2shgo3 | t1_c2sf45y | null | 1427748959 | 4 | t5_2fwo | null | null | null |
True | reventlov | null | Yeah, I made a mistake in that explanation. It should actually be M = (RAND_MAX + 1) / N, but RAND_MAX is often the same as INT_MAX, in which case overflow bites you hard. You can use M = RAND_MAX / N, you'll just end up throwing out slightly more results from rand(), and you have to handle N = RAND_MAX + 1 as a spec... | null | 0 | 1318960046 | False | 0 | c2shgtw | t3_lfsfk | null | t1_c2shgtw | t1_c2sfxug | null | 1427748960 | 2 | t5_2fwo | null | null | null |
True | mitsuhiko | null | Yes, but it's a linux centric blog and it said 64bit, so it could have been guessable. | null | 0 | 1318960048 | False | 0 | c2shguv | t3_lgfp0 | null | t1_c2shguv | t1_c2shf09 | null | 1427748961 | 5 | t5_2fwo | null | null | null |
True | dranek | null | ... because unsigned zero extends and not sign extends. | null | 0 | 1318960077 | False | 0 | c2shh13 | t3_lg59j | null | t1_c2shh13 | t3_lg59j | null | 1427748963 | 3 | t5_2fwo | null | null | null |
True | wnoise | null | I'm a fan of [the Mersenne twister](http://en.wikipedia.org/wiki/Mersenne_twister), but in general you need to know what properties it needs to pass.
[elperroborrachotoo's answer](http://www.reddit.com/r/programming/comments/lfsfk/how_to_really_use_rand/c2seb8v) gives some very good criteria. Autocorrelation can be a... | null | 0 | 1318960133 | True | 0 | c2shhd2 | t3_lfsfk | null | t1_c2shhd2 | t1_c2se7zz | null | 1427748965 | 1 | t5_2fwo | null | null | null |
True | FoolishClownfish | null | Good point. I probably have introduced some new bugs with the new rewrite. However, the change in architecture is much better for scalability and a bunch of other issues we were going to run into. | null | 0 | 1318960134 | False | 0 | c2shhdd | t3_ldgye | null | t1_c2shhdd | t1_c2sevfc | null | 1427748965 | 2 | t5_2fwo | null | null | null |
True | Unmitigated_Smut | null | They weren't comparing the scalability of synchronous vs. asynchronous; they were comparing a homemade queue of cron+database vs. activemq, i.e. two different asynchronous solutions. Nowhere in the article did they propose message queueing as a solution for web application scalability.
I think the whole concept of Tw... | null | 0 | 1318960156 | False | 0 | c2shhi9 | t3_lff3n | null | t1_c2shhi9 | t1_c2sedag | null | 1427748970 | 2 | t5_2fwo | null | null | null |
True | Nebu | null | Much less cruel, because it's more likely to produce an effect noticeable during development. | null | 0 | 1318960337 | False | 0 | c2shimy | t3_lfsfk | null | t1_c2shimy | t1_c2se74v | null | 1427748981 | 1 | t5_2fwo | null | null | null |
True | mtVessel | null | Ok. Obviously, I wasn't reacting to your knowledge, but to your impertinence. ;) | null | 0 | 1318960398 | False | 0 | c2shiyo | t3_lg1xx | null | t1_c2shiyo | t1_c2shbbw | null | 1427748984 | 2 | t5_2fwo | null | null | null |
True | prakashk | null | Just set up [local::lib](https://metacpan.org/module/local::lib) which let's you install CPAN modules to a non-root directory. Then you shouldn't have to install as root anything you want to experiment. | null | 0 | 1318960430 | False | 0 | c2shj4r | t3_lfcd0 | null | t1_c2shj4r | t1_c2s8iph | null | 1427748984 | 1 | t5_2fwo | null | null | null |
True | mwynholds | null | I like this! The last feature of RubyMine (or IDEA) that I kept coming back to was cmd-N (and it's variants). Maybe this will replace that and then I can think about going Vim full time. | null | 0 | 1318960521 | False | 0 | c2shjnv | t3_lghyk | null | t1_c2shjnv | t3_lghyk | null | 1427748988 | 1 | t5_2fwo | null | null | null |
True | rjsen | null | Then why isn't it a class method on iterable? | null | 0 | 1318960595 | False | 0 | c2shk3c | t3_lg940 | null | t1_c2shk3c | t1_c2sgpl3 | null | 1427748992 | 4 | t5_2fwo | null | null | null |
True | riffito | null | In BeOS, if you pressed 'M' at boot, you got to see a colorcycling mandelbrot fractal. | null | 0 | 1318960740 | False | 0 | c2shkuq | t3_lfqqr | null | t1_c2shkuq | t3_lfqqr | null | 1427749000 | 1 | t5_2fwo | null | null | null |
True | sporkexec | null | I'm not sure what you mean, but a single process touching the database means you can take exactly one request at a time and block the rest of the world. You're going to add multiple processes on multiple machines either way.
They don't. Load balancing is one of the ways to scale by having more workers on the front end... | null | 0 | 1318960776 | False | 0 | c2shl20 | t3_lff3n | null | t1_c2shl20 | t1_c2segi8 | null | 1427749005 | 1 | t5_2fwo | null | null | null |
True | i8beef | null | Either you are completely mistaken, or you do not understand what is meant by dependency.
class ThingWithDependency {
void SomeMethod() {
var repository = new Repository();
var someThing = repository.GetThing();
...
}
}
In the above code, Repository is a d... | null | 0 | 1318960780 | False | 0 | c2shl2y | t3_lf1px | null | t1_c2shl2y | t1_c2shdsj | null | 1427749005 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318960895 | False | 0 | c2shlr5 | t3_lfm1k | null | t1_c2shlr5 | t1_c2sgpjh | null | 1427749017 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318960965 | False | 0 | c2shm3z | t3_lfm1k | null | t1_c2shm3z | t1_c2sgpjh | null | 1427749019 | 1 | t5_2fwo | null | null | null |
True | fkaginstrom | null | Nice article. His two main ideas for integrating are:
1. Help separate out the NumPy C library from the Python interface, and then hook straight to the C library (this makes NumPy available in lots of other environments too, like IronPython, ruby, etc.)
2. Build better integration with [Cython](http://cython.org/), a... | null | 0 | 1318961102 | False | 0 | c2shmug | t3_lez71 | null | t1_c2shmug | t3_lez71 | null | 1427749028 | 3 | t5_2fwo | null | null | null |
True | solarpanzer | null | *Can't... resist...*
Why not Zoidberg? | null | 0 | 1318961131 | False | 0 | c2shn02 | t3_lfm1k | null | t1_c2shn02 | t3_lfm1k | null | 1427749030 | 2 | t5_2fwo | null | null | null |
True | tootie | null | > there is a huge learning curve for DI frameworks
I don't know. I figured out how Spring works in maybe a week or two. All you need to know is that any class that will be injected via DI needs to be thread-safe. I feel like 80% of the benefit of using something like Spring is more about the number of canned mo... | null | 0 | 1318961390 | False | 0 | c2shoed | t3_lf1px | null | t1_c2shoed | t1_c2sfjl7 | null | 1427749047 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | that's my lack of familiarity in c showing (i have not used it in a couple years). should be *x++, or (*x)++ if that doesn't work.
edit: apparently reddit is eating my dereferences. | null | 0 | 1318961396 | False | 0 | c2shofd | t3_lfm1k | null | t1_c2shofd | t1_c2sggub | null | 1427749048 | 1 | t5_2fwo | null | null | null |
True | ziom666 | null | SelectMany is the only time I'm using linq syntax | null | 0 | 1318961404 | False | 0 | c2shoh5 | t3_lg1xx | null | t1_c2shoh5 | t1_c2sgzvu | null | 1427749048 | 6 | t5_2fwo | null | null | null |
True | Contero | null | > If we search back in the depths of our memory, we remember that x[i] can be rewritten as *(x+i). For that to work, x must be the memory location of the start of the array.
~~Well I didn't expect to come into a "pointer challenge" and know more about arrays and pointers than the challenger.~~ Disregard that, I'm k... | null | 0 | 1318961505 | True | 0 | c2shp1q | t3_lgfp0 | null | t1_c2shp1q | t3_lgfp0 | null | 1427749056 | -1 | t5_2fwo | null | null | null |
True | eek04 | null | My *guessed* traps - I was proficient Perl and Ruby programmer before I learned Python:
- Automatic conversion between different types. Strings and integers are the same type, arrays automatically become scalars in scalar context, etc.
- Autovification, or "make up empty hashes or arrays when you think it would be c... | null | 0 | 1318961591 | False | 0 | c2shpim | t3_lg940 | null | t1_c2shpim | t3_lg940 | null | 1427749063 | 6 | t5_2fwo | null | null | null |
True | doomchild | null | No harm, no foul. My impertinence often eclipses my knowledge. | null | 0 | 1318961621 | False | 0 | c2shpn3 | t3_lg1xx | null | t1_c2shpn3 | t1_c2shiyo | null | 1427749064 | 2 | t5_2fwo | null | null | null |
True | sidneyc | null | > [...] there are two indications that rand() isn't supposed to be a high-quality random number generator.
The standard allows for low-quality as well as high-quality PRNGs. There is no "supposed to be".
> This is a simple linear-congruential generator with 32 bits of state.
Not necessarily 32 bits. | null | 0 | 1318961667 | False | 0 | c2shpx7 | t3_lfsfk | null | t1_c2shpx7 | t1_c2sfdck | null | 1427749068 | 1 | t5_2fwo | null | null | null |
True | i8beef | null | Yeah, someone else pointed that out to me in another thread. I have never had to use SelectMany, as I haven't had any collections that required flattening in anything I've worked on yet... But I agree, that the LINQ syntax is more readable in that case. | null | 0 | 1318961695 | False | 0 | c2shq4b | t3_lg1xx | null | t1_c2shq4b | t1_c2shoh5 | null | 1427749077 | 1 | t5_2fwo | null | null | null |
True | sporkexec | null | See the first line in my first post? That's a quote, it means you can go back to the article and find those words again. While the focus was indeed replacing his nastier method, scalability was mentioned.
And for the record, how in the fuck does a queue help you schedule an event for "a future time specified by the us... | null | 0 | 1318961926 | False | 0 | c2shrf4 | t3_lff3n | null | t1_c2shrf4 | t1_c2shhi9 | null | 1427749086 | -4 | t5_2fwo | null | null | null |
True | w_daher | null | Yes, the fact that arrays are not pointers is, in fact, the whole point of this challenge.
I chose a more Socratic writing style where we "think out loud and solve it together," rather than blandly just asserting the rule up front. I make your exact same point in the answer to #3. So yes, we're on the same page :) | null | 0 | 1318961993 | False | 0 | c2shrtq | t3_lgfp0 | null | t1_c2shrtq | t1_c2shp1q | null | 1427749101 | 3 | t5_2fwo | null | null | null |
True | Zak | null | A problem I see with this site, and perhaps a cultural problem with the patterns movement in general is that it's strongly focused on a certain style of object orientation (more or less the one Java uses) as the One True Way. It seems to imply that this style is *always* better than procedural and to ignore functional ... | null | 0 | 1318962047 | False | 0 | c2shs50 | t3_lg6ms | null | t1_c2shs50 | t3_lg6ms | null | 1427749098 | 4 | t5_2fwo | null | null | null |
True | realityglitch | null | Came here to say this. (But it should be while r > MAX ;) | null | 0 | 1318962099 | False | 0 | c2shsfh | t3_lfsfk | null | t1_c2shsfh | t1_c2seml1 | null | 1427749102 | 1 | t5_2fwo | null | null | null |
True | StrangeWill | null | >Use C++ with .NET. Microsoft supply a .NET C++ compiler that produces IL rather than machine code. (To make full use of the .NET environment (e.g. garbage collection), a set of extensions are required to standard C++, called C++/CLI.)
I thought writing C++/CLR code produced a hybrid of both, hence why you can't b... | null | 0 | 1318962102 | False | 0 | c2shsga | t3_lg1xx | null | t1_c2shsga | t3_lg1xx | null | 1427749102 | 1 | t5_2fwo | null | null | null |
True | Contero | null | C++ lacks none of these things.
And I downvoted him for being dismissive of other programming languages or programmers. | null | 0 | 1318962124 | False | 0 | c2shskv | t3_lg1xx | null | t1_c2shskv | t1_c2sf3di | null | 1427749103 | 1 | t5_2fwo | null | null | null |
True | honcas | null | I'm normally a big fan of consistency. In this case, I'm not sure the tradeoff is worth it. | null | 0 | 1318962262 | False | 0 | c2shtca | t3_lg940 | null | t1_c2shtca | t1_c2sgpl3 | null | 1427749114 | 2 | t5_2fwo | null | null | null |
True | mcguire | null | From the paper:
**3.1. Register, volatile, const**
The keywords register, volatile, and const, are recognised syntactically but are semantically ignored. Volatile seems to have no meaning, so it is hard to tell if ignoring it is a departure from the standard. Const only confuses library interfaces with the hope of ca... | null | 0 | 1318962395 | False | 0 | c2shu4b | t3_lgjhl | null | t1_c2shu4b | t3_lgjhl | null | 1427749130 | 18 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | class ThingWithoutDependency {
// no dependencies whatsoever
void SomeMethod( P1 p2, P2 p2, P3 p3 ) {
...
}
}
> All my ThingWithDependency REALLY needs is an instance of an object that implements a GetThing() method that returns an object that is th... | null | 0 | 1318962400 | False | 0 | c2shu5j | t3_lf1px | null | t1_c2shu5j | t1_c2shl2y | null | 1427749132 | 1 | t5_2fwo | null | null | null |
True | MarshallBanana | null | I don't like the Mersenne Twister much. It is not a bad generator, obviously, but it is totally overkill for almost every purpose, its runtime is uneven, and it uses a lot more code and storage than the Tausworthe generator linked above (which is a handful of lines of code, and 12 bytes of storage).
Mainly, I prefer t... | null | 0 | 1318962411 | False | 0 | c2shu8a | t3_lfsfk | null | t1_c2shu8a | t1_c2shfky | null | 1427749132 | 1 | t5_2fwo | null | null | null |
True | elder_george | null | Because then implementor of any iterable will have to implement string concatenation (or to inherit from some base class), no matter if he needs it or not. | null | 0 | 1318962451 | False | 0 | c2shugf | t3_lg940 | null | t1_c2shugf | t1_c2shk3c | null | 1427749134 | 2 | t5_2fwo | null | null | null |
True | 00kyle00 | null | > int *ip = malloc(10);
> return ip[5];
Damn man, you just accessed illegal memory and then leaked it :(
>I'm sure someone can step in and correct me on the details, but I think it's important to know that arrays aren't just pointers.
This is important in one place in C++, because you can have arrays... | null | 0 | 1318962570 | False | 0 | c2shv4w | t3_lgfp0 | null | t1_c2shv4w | t1_c2shp1q | null | 1427749140 | 5 | t5_2fwo | null | null | null |
True | filipf | null | You can compile with /clr:pure and it will generate pure CIL
But what's the point? Just use c# :) | null | 0 | 1318962656 | False | 0 | c2shvlq | t3_lg1xx | null | t1_c2shvlq | t1_c2shsga | null | 1427749154 | 3 | t5_2fwo | null | null | null |
True | i8beef | null | This is still DI, you are just injecting your dependencies into the method instead of the class.
**Edit:** which is fine if you are thinking in terms of making everything static, but when you are dealing with Objects which have state, or share resources between methods, etc., is not acceptable, as you are going to be ... | null | 0 | 1318962692 | True | 0 | c2shvt6 | t3_lf1px | null | t1_c2shvt6 | t1_c2shu5j | null | 1427749150 | 1 | t5_2fwo | null | null | null |
True | paracelsus | null | Comparisons of Qi/Shen with Agda, Coq etc. are misleading. Despite the hype these are not practical programming vehicles. Try writing integer square root in Martin-Lof type theory - you need a Ph.D. All these system are pumped up proof assistants. Their main purpose is to generate papers.
A clue to the experimenta... | null | 0 | 1318962778 | False | 0 | c2shwch | t3_le3tg | null | t1_c2shwch | t1_c2s5827 | null | 1427749158 | 2 | t5_2fwo | null | null | null |
True | Contero | null | Ahh shit. I'm getting to comfortable in C++, I was thinking new int[10]. | null | 0 | 1318962837 | False | 0 | c2shwnn | t3_lgfp0 | null | t1_c2shwnn | t1_c2shv4w | null | 1427749162 | 0 | t5_2fwo | null | null | null |
True | Contero | null | Ahh, sorry then. I started to skip when I got all the answers right. I see you do go into it a bit. I still think it's important to point out that x[5] means different things when x is an array or a pointer though. | null | 0 | 1318962854 | False | 0 | c2shwt8 | t3_lgfp0 | null | t1_c2shwt8 | t1_c2shrtq | null | 1427749164 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318962864 | True | 0 | c2shwvx | t3_lfm1k | null | t1_c2shwvx | t1_c2seiqd | null | 1427749165 | 2 | t5_2fwo | null | null | null |
True | TehHat | null | There is another city in the Atlantic Ocean as well. Possibly Las Vegas? It wouldn't pop up the name for me when I moused over. Rivera, Uruguay is in the middle of the Indian/Pacific Ocean too. | null | 0 | 1318963000 | False | 0 | c2shxnc | t3_lfcpb | null | t1_c2shxnc | t1_c2saak0 | null | 1427749175 | 1 | t5_2fwo | null | null | null |
True | MarshallBanana | null | I guess you could consider that part of the test, too. You're supposed to know that pretty much nobody uses 64-bit ints. | null | 0 | 1318963012 | False | 0 | c2shxqd | t3_lgfp0 | null | t1_c2shxqd | t1_c2sh7if | null | 1427749176 | 4 | t5_2fwo | null | null | null |
True | drysart | null | The correct description is that the ref keyword creates a pass *of* a reference by reference. There's no double "by reference", because ref is only adding one layer of indirection, and the raw parameter without ref is passed by value (yes, that value is a reference, but it's not *by* reference).
But it is similar to... | null | 0 | 1318963067 | False | 0 | c2shy21 | t3_lg1xx | null | t1_c2shy21 | t1_c2sgx3a | null | 1427749179 | 2 | t5_2fwo | null | null | null |
True | MarshallBanana | null | Almost no systems in existence have 64-bit ints. In practice, sizeof(int) is always 4. | null | 0 | 1318963067 | False | 0 | c2shy2e | t3_lgfp0 | null | t1_c2shy2e | t1_c2shf09 | null | 1427749180 | 8 | t5_2fwo | null | null | null |
True | MarshallBanana | null | I think it's OK this way. If you really know C, you also know sizeof(int) is 4 on pretty much every system. | null | 0 | 1318963131 | False | 0 | c2shygc | t3_lgfp0 | null | t1_c2shygc | t1_c2shfrc | null | 1427749182 | -2 | t5_2fwo | null | null | null |
True | MarshallBanana | null | In today's world, there is only one sizeof(int) you will ever encounter, and that is 4. | null | 0 | 1318963155 | False | 0 | c2shyl6 | t3_lgfp0 | null | t1_c2shyl6 | t1_c2shemp | null | 1427749183 | -4 | t5_2fwo | null | null | null |
True | split_electron | null | enough ! If I see one more article on "how to use rand()" I'll burn something soon. | null | 0 | 1318963204 | False | 0 | c2shyvy | t3_lfsfk | null | t1_c2shyvy | t3_lfsfk | null | 1427749185 | 1 | t5_2fwo | null | null | null |
True | 00kyle00 | null | >How to really use rand()
Dont. | null | 0 | 1318963210 | False | 0 | c2shyx7 | t3_lfsfk | null | t1_c2shyx7 | t3_lfsfk | null | 1427749187 | 1 | t5_2fwo | null | null | null |
True | Flarelocke | null | > why would seq have a big impact on the memory usage?
Space leaks are sometimes the result of laziness. When a computation is deferred, a data structure called a thunk is built containing pointers to the function and its arguments. Huge towers of thunks can be built, which eat up memory. Arrays are normally as... | null | 0 | 1318963243 | False | 0 | c2shz4n | t3_lfm1k | null | t1_c2shz4n | t1_c2sg0vs | null | 1427749193 | 2 | t5_2fwo | null | null | null |
True | paracelsus | null | This notation has been standard for over 50 years | null | 0 | 1318963267 | False | 0 | c2shza1 | t3_le3tg | null | t1_c2shza1 | t1_c2s44im | null | 1427749190 | 2 | t5_2fwo | null | null | null |
True | vintermann | null | Someone ought to write a book about _real world_ Haskell ;)
Actually, I think the examples of that book, and what's being done with web development in Haskell, is very, very interesting. Happily Haskell has long since passed the theoretical curiosity stage. | null | 0 | 1318963320 | False | 0 | c2shzks | t3_lfm1k | null | t1_c2shzks | t1_c2segjl | null | 1427749195 | 6 | t5_2fwo | null | null | null |
True | CynicalTyler | null | http://sourcemaking.com/design_patterns/prototype/java/1
interface Xyz {
Xyz cloan();
}
ಠ\_ಠ
| null | 0 | 1318963434 | False | 0 | c2si091 | t3_lg6ms | null | t1_c2si091 | t3_lg6ms | null | 1428192097 | 8 | t5_2fwo | null | null | null |
True | cybercobra | null | You don't realize they were coined by *critics* of The Right Way? | null | 0 | 1318963441 | False | 0 | c2si0ac | t3_lfm1k | null | t1_c2si0ac | t1_c2sgpjh | null | 1428192097 | 4 | t5_2fwo | null | null | null |
True | elder_george | null | Hmm... ['New' is probably 1990 in this case](http://doc.cat-v.org/plan_9/4th_edition/papers/compiler).
From what I know, `volatile` is heavily used in embedded code. `register` is used as well, but not so much (it always was recommendation for compiler, not directive).
[Here](http://kerneltrap.org/Linux/C_Semantics_C... | null | 0 | 1318963624 | False | 0 | c2si1dq | t3_lgjhl | null | t1_c2si1dq | t1_c2shu4b | null | 1427749231 | 29 | t5_2fwo | null | null | null |
True | reddit_clone | null | Very well said. I also found the hyperbolic claims like 'if it compiles, it will run flawlessly' a bit unjustified. They don't say that you have to do that much amount of work with the type system.
One way or other the piper needs to be paid.
> errors due to failing to consider corner cases
Yep. If the disk were ... | null | 0 | 1318963640 | False | 0 | c2si1h5 | t3_lfm1k | null | t1_c2si1h5 | t1_c2se7zn | null | 1427749243 | 0 | t5_2fwo | null | null | null |
True | w_daher | null | Agreed :) | null | 0 | 1318963715 | False | 0 | c2si1y9 | t3_lgfp0 | null | t1_c2si1y9 | t1_c2shwt8 | null | 1427749243 | 2 | t5_2fwo | null | null | null |
True | 00kyle00 | null | So why the heck didn't they go ahead and just killed them? Having language correct the source code for you is silly. | null | 0 | 1318963760 | False | 0 | c2si28m | t3_lfm1k | null | t1_c2si28m | t1_c2sf7jc | null | 1427749248 | 2 | t5_2fwo | null | null | null |
True | cybercobra | null | Nomenclature varies. Cf. Python's functools.partial | null | 0 | 1318963858 | False | 0 | c2si2ua | t3_lfm1k | null | t1_c2si2ua | t1_c2sei91 | null | 1427749256 | -2 | t5_2fwo | null | null | null |
True | algo_trader | null | Definitely. I would be a little nervous if I was a business that was trying to be next-gen and decided to use google as my office suite. I doubt anyone is doing that, but still, the google giveth, and the google taketh away... it dissuades developers like myself from developing their platform. | null | 0 | 1318963860 | False | 0 | c2si2uu | t3_lca6k | null | t1_c2si2uu | t1_c2rtfmn | null | 1427749256 | 1 | t5_2fwo | null | null | null |
True | psygnisfive | null | Yes, I did. Did you read my comment? | null | 0 | 1318964065 | False | 0 | c2si40u | t3_lfm1k | null | t1_c2si40u | t1_c2sdplh | null | 1427749266 | 1 | t5_2fwo | null | null | null |
True | eaturbrainz | null | "Better than C++" is not a good standard. | null | 0 | 1318964106 | False | 0 | c2si49n | t3_lfm1k | null | t1_c2si49n | t1_c2shg8z | null | 1427749271 | 0 | t5_2fwo | null | null | null |
True | Excedrin | null | Ah, I was thinking you meant that it was free/automatic/etc.
In Haskell you can do:
let memo = map f [1 .. 10000]
Then values in memo get calculated as needed, which is pretty simple for the case when you want to cache some values. Laziness is nice for this.
It should probably use an array instead of a list, bu... | null | 0 | 1318964219 | False | 0 | c2si4w7 | t3_lfm1k | null | t1_c2si4w7 | t1_c2sg2o1 | null | 1427749275 | 1 | t5_2fwo | null | null | null |
True | bobstevens | null | Ah, so the "ignore language features I don't understand or don't like" approach to compiler development, then?
volatile and register certainly have problems, but it's hard to see how ignoring their existence entirely is a step forward.
I don't understand why people dislike const, but a few of the older guys where I w... | null | 0 | 1318964274 | False | 0 | c2si573 | t3_lgjhl | null | t1_c2si573 | t1_c2shu4b | null | 1427749283 | 9 | t5_2fwo | null | null | null |
True | algo_trader | null | depending on your net provider, a nas box may work for you. I have had "the cloud" since 2007.
synology and qnap make little shoe box sized nas's that are essentially arm-based servers. It works for personal usage, though there are some limits on what you can do. | null | 0 | 1318964302 | False | 0 | c2si5ch | t3_lca6k | null | t1_c2si5ch | t1_c2rk7jn | null | 1427749278 | 1 | t5_2fwo | null | null | null |
True | norkakn | null | Maybe someone who usually uses python needs to talk to a lot of complicated SOAP services that use a lot of strange Unicode things. Python sucks rather horribly at both of those. | null | 0 | 1318964321 | False | 0 | c2si5fy | t3_lg940 | null | t1_c2si5fy | t1_c2sg2af | null | 1427749279 | 2 | t5_2fwo | null | null | null |
True | Negitivefrags | null | If you negate an unsigned variable in MSVC you get something like "Negating an unsigned variable x, result is still unsigned".
It is perfectly valid to assign a negative constant to an unsigned value though. | null | 0 | 1318964379 | False | 0 | c2si5ru | t3_lg59j | null | t1_c2si5ru | t1_c2sgbio | null | 1427749281 | 4 | t5_2fwo | null | null | null |
True | vividboarder | null | Yea, I didn't make the website, but I was looking for the same thing! It looks like they are pulling commit logs from Github, they should have commit links. | null | 0 | 1318964395 | False | 0 | c2si5v4 | t3_lf898 | null | t1_c2si5v4 | t1_c2savct | null | 1427749282 | 1 | t5_2fwo | null | null | null |
True | redbo | null | Yeah, this is why I almost always use stdint types like int32_t anymore. | null | 0 | 1318964457 | False | 0 | c2si68s | t3_lgfp0 | null | t1_c2si68s | t1_c2sh69m | null | 1427749286 | 1 | t5_2fwo | null | null | null |
True | sotonohito | null | The quick answer is practice.
I don't know how long you've been at it with matlab, but I'll bet it's not as long as you'd need to. How many hours have you spent solving toy problems, coding for grins, and otherwise goofing around with matlab programming?
Also, breaking problems down in real life is a different sort ... | null | 0 | 1318964526 | False | 0 | c2si6mm | t3_lf038 | null | t1_c2si6mm | t1_c2sgxpd | null | 1427749289 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | What you posted is almost literally the source code to [uglymemo](http://hackage.haskell.org/packages/archive/uglymemo/0.1.0.1/doc/html/src/Data-MemoUgly.html).
I'd argue you're not really 'fighting the language' by doing this. uglymemo is called 'uglymemo' because the implementation is considered ugly: there are othe... | null | 0 | 1318964742 | False | 0 | c2si7tq | t3_lfm1k | null | t1_c2si7tq | t1_c2sg2o1 | null | 1427749302 | 3 | t5_2fwo | null | null | null |
True | anttirt | null | > "Either don't use a broken compiler (casting a const pointer to a non-const is definitely not a bug), or cast to 'unsigned long' (if it still complains, now the compiler is not just stupid, it's broken). The whole point of memory management is that we know how pointers work, and understand that they have a *bit* r... | null | 0 | 1318964818 | False | 0 | c2si88n | t3_lgjhl | null | t1_c2si88n | t1_c2si1dq | null | 1427749307 | 7 | t5_2fwo | null | null | null |
True | jimbokun | null | But isn't only harder because you already have a lot of experience writing fast programs in C? Maybe if the experience level for each language is equalized, it takes less time to write a correct, fast program in Haskell than it does in C. | null | 0 | 1318964831 | False | 0 | c2si8be | t3_lfm1k | null | t1_c2si8be | t1_c2sfxy3 | null | 1427749308 | 3 | t5_2fwo | null | null | null |
True | daveime | null | Ah, the innocence of youth.
It's quite obvious that this CS major has learned everything he knows about programming from a book, and thinks he needs to install multiple new modules in the language-du-jour just to do a simple page scrape, when in fact he's probably got Perl installed on his system by default and could ... | null | 0 | 1318964902 | True | 0 | c2si8p7 | t3_lfrt9 | null | t1_c2si8p7 | t3_lfrt9 | null | 1427749313 | -1 | t5_2fwo | null | null | null |
True | mr_chromatic | null | > Classes is complicated; bless isn't really exactly a class
What? Python and Perl have the same object system. Look past the syntax. Everything that's broken about Perl 5's default object system is broken about Python's object system. | null | 0 | 1318964903 | False | 0 | c2si8pd | t3_lg940 | null | t1_c2si8pd | t1_c2shpim | null | 1427749313 | 6 | t5_2fwo | null | null | null |
True | mr_chromatic | null | > WHAT FOR AND WHY?
Libraries. Stability. A huge ecosystem. Working lexical scopes. Performance. Ubiquity. | null | 0 | 1318964956 | False | 0 | c2si8zl | t3_lg940 | null | t1_c2si8zl | t1_c2sg2af | null | 1427749317 | 7 | t5_2fwo | null | null | null |
True | thatpaulbloke | null | What? You know which method you're overriding by the name and arguments of the method. How can you possibly have any confusion over which method to override? | null | 0 | 1318965039 | False | 0 | c2si9gz | t3_lg1xx | null | t1_c2si9gz | t1_c2sfzwd | null | 1427749327 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318965055 | False | 0 | c2si9jr | t3_lgfp0 | null | t1_c2si9jr | t1_c2shygc | null | 1427749327 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Not very difficult... What's hard is reverse engineering obfuscated functions from game clients and rewriting them completely (in C) without using any assembly... and and then using code injection to call those routines. | null | 0 | 1318965080 | False | 0 | c2si9ox | t3_lgfp0 | null | t1_c2si9ox | t3_lgfp0 | null | 1427749330 | -19 | t5_2fwo | null | null | null |
True | omnilynx | null | I wish array languages and the concepts they represent were more prevalent. If you've gone into any of the higher maths or sciences, you know that array/matrix notation is a powerful tool for analyzing arbitrarily complex systems. Being able to reference a whole *system* of operations in a single statement seems tailor... | null | 0 | 1318965133 | False | 0 | c2si9wu | t3_lg5ri | null | t1_c2si9wu | t3_lg5ri | null | 1427749332 | 3 | t5_2fwo | null | null | null |
True | curien | null | >In the second one, we know the address of ia[5] at compile-time and can load from it directly. In the first we need to load the value of ip, add 5*sizeof(int) to it, and load again.
That's an optimization detail which may or may not be true (for either operation). The abstract machine described by the C standard t... | null | 0 | 1318965332 | False | 0 | c2sib4z | t3_lgfp0 | null | t1_c2sib4z | t1_c2shp1q | null | 1427749347 | 1 | t5_2fwo | null | null | null |
True | maep | null | ... and this is where the bugs sneak in. Especially with Unix you newer know where your code might end up running. | null | 0 | 1318965362 | False | 0 | c2sibbx | t3_lgfp0 | null | t1_c2sibbx | t1_c2shygc | null | 1427749350 | 25 | t5_2fwo | null | null | null |
True | Urik88 | null | Decided to read it for my Software Design exam and found it so much easier to understand than the GOF. The GOF may be a great book and have a very precious historical value, but I think that people should stop recommending it for inexperienced programmers and students. | null | 0 | 1318965423 | False | 0 | c2sibp2 | t3_lg6ms | null | t1_c2sibp2 | t1_c2sh6iq | null | 1427749354 | 2 | t5_2fwo | null | null | null |
True | anttirt | null | > Volatile seems to have no meaning, so it is hard to tell if ignoring it is a departure from the standard.
It has a very significant meaning. In fact, the entire execution of the language is defined at the very lowest level *in terms of* `volatile`.
This is from the C++ standard (I don't have the C standard at ha... | null | 0 | 1318965463 | False | 0 | c2sibxr | t3_lgjhl | null | t1_c2sibxr | t1_c2shu4b | null | 1427749356 | 15 | t5_2fwo | null | null | null |
True | smcameron | null | And here's a bit from the linux kernel Documentation directory about volatile:
[volatile-considered-harmful.txt](http://lwn.net/Articles/234017/) | null | 0 | 1318965549 | False | 0 | c2sicfj | t3_lgjhl | null | t1_c2sicfj | t1_c2si1dq | null | 1427749362 | 2 | t5_2fwo | null | null | null |
True | cybercobra | null | Yes, just the ones not involving medicine or finance. :-P | null | 0 | 1318965737 | False | 0 | c2sidjt | t3_lfm1k | null | t1_c2sidjt | t1_c2sdkpi | null | 1427749376 | 2 | 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.