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 | wickeand000 | null | To be fair, Trojans only work with processes that you have access to, and while you can do worse, things like this might be tricky to catch. | null | 0 | 1316674491 | False | 0 | c2lplx1 | t3_kmshh | null | t1_c2lplx1 | t1_c2lmwak | null | 1427631923 | 1 | t5_2fwo | null | null | null |
True | menteth | null | I believe he means "functional" in the "no side effects" sense, but you're completely right: that usage of random introduces side-effects. Calling the same method will give different results each time. A functional implementation would take a pseudo-random generator as a parameter to the "set" method. | null | 0 | 1316675206 | False | 0 | c2lpms6 | t3_kn9gt | null | t1_c2lpms6 | t1_c2lp4vb | null | 1427631932 | 8 | t5_2fwo | null | null | null |
True | menteth | null | He also claims that other balanced tree implementations require thousands of special-cases, which is overstating things by about three orders of magnitude. It's a nice enthusiastic article on a particular data structure and deserves reading just to know about treaps, but it doesn't do any substantial comparison to other data structures (even the "expected balanced height" thing is to be used with care, since the expected value of a random distribution is almost never achieved — it's just the most likely). | null | 0 | 1316675462 | False | 0 | c2lpn3r | t3_kn9gt | null | t1_c2lpn3r | t1_c2lp24f | null | 1427631938 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | I was not aware that 32-bit moves cleared the upper bits of a 64-bit register... I'm used to 8/16 bit moves in 32-bit mode. What can I say, I'm old. Thanks for the info.
bobindashadows pointed out that there are official 2-9 byte pure NOPs on the i686 and later platforms. I'd guess Win64 uses one of those, but the concept is still the same - every unpatched function in a .dll starts with a magic number that the processor executes as a **NOP**, patched functions will have a magic number that the processor executes as **JMP *patchpoint***. | null | 0 | 1316675767 | False | 0 | c2lpnoa | t3_kmshh | null | t1_c2lpnoa | t1_c2lpl7l | null | 1427631944 | 1 | t5_2fwo | null | null | null |
True | irascible | null | Hey overall a good article. You should do a comparative code review of something like the secondlife codebase next!
| null | 0 | 1316676097 | False | 0 | c2lpoaf | t3_klrrx | null | t1_c2lpoaf | t1_c2lmtmt | null | 1428193496 | 1 | t5_2fwo | null | null | null |
True | amasad | null | Thats cool! Is it hosted online anywhere? | null | 0 | 1316676112 | False | 0 | c2lpobn | t3_klv3o | null | t1_c2lpobn | t1_c2lm5dk | null | 1428193496 | 1 | t5_2fwo | null | null | null |
True | elima | null | The hidden image for stats tracking has been fully removed :) | null | 0 | 1316676263 | False | 0 | c2lpon6 | t3_kmmgx | null | t1_c2lpon6 | t1_c2llt48 | null | 1427631967 | 4 | t5_2fwo | null | null | null |
True | FooBarWidget | null | Apples vs oranges. A hardware tester is not necessarily good at writing software test suites. | null | 0 | 1316676290 | False | 0 | c2lpop0 | t3_klypn | null | t1_c2lpop0 | t1_c2lpc10 | null | 1427631967 | 1 | t5_2fwo | null | null | null |
True | amasad | null | Were currently in the process of implementing HTML5 app cache and hopefully you wouldn't need an internet connection once you've loaded repl.it and your favorite language once. Having everything built on JS makes the application very portable, so we actually may port it to different platforms other than the browser. | null | 0 | 1316676408 | False | 0 | c2lpox2 | t3_klv3o | null | t1_c2lpox2 | t1_c2lnhyi | null | 1427631960 | 2 | t5_2fwo | null | null | null |
True | Valken | null | Excellent article. I've learned a lot from your posts and the dEngine source. | null | 0 | 1316676515 | False | 0 | c2lpp5f | t3_klrrx | null | t1_c2lpp5f | t1_c2lej2j | null | 1427631972 | 1 | t5_2fwo | null | null | null |
True | matthiasB | null | You can see it using a disassembler. | null | 0 | 1316676642 | False | 0 | c2lppeo | t3_kmshh | null | t1_c2lppeo | t1_c2lpg4o | null | 1427631967 | 2 | t5_2fwo | null | null | null |
True | larholm | null | > We call them Ruby developers /ducks
I see what you did there. | null | 0 | 1316676864 | False | 0 | c2lppud | t3_kmshh | null | t1_c2lppud | t1_c2linob | null | 1427631972 | 3 | t5_2fwo | null | null | null |
True | llogiq | null | I do not like "Negative Commenting".
The foremost reason I do not like it (besides the critique I've already given) is that the "negative" label hides the real value of the comments which is the *reason* the line has to be that way. So, Reason commenting would IMHO be a better label, and we could cut out all the "This has to be there because" stuff.
Also finding the right level of detail to comment (module/class, method, single line) is an art. And using the highest level of detail by default is in most cases wasting programmer and reader time. Also, commenting on this level will in many cases miss out on the bigger picture.
TL;DR: Bad label, needless stuff to write and read, wrong level of detail. | null | 0 | 1316676887 | False | 0 | c2lppw9 | t3_kmk56 | null | t1_c2lppw9 | t1_c2lliur | null | 1427631974 | 2 | t5_2fwo | null | null | null |
True | elyscape | null | You'll want to grab a disassembler. [Here's one that's free](http://www.hex-rays.com/idapro/idadownfreeware.htm). It won't do everything, but it'll let you peek into a fair number of executables.
**Edit**: I've another suggestion that, while more limited, might be less daunting to start with: [ILSpy](http://wiki.sharpdevelop.net/ILSpy.ashx) can only disassemble .NET applications, but it can also decompile them into C#. In case you don't know, .NET applications are compiled into a special bytecode. Long story short, they use a different assembly language, but it's a bit easier to understand. Tip: if you're curious about what an instruction means, hover the mouse over it; you'll get a tooltip explaining what it does. | null | 0 | 1316676935 | True | 0 | c2lppzw | t3_kmshh | null | t1_c2lppzw | t1_c2lpg4o | null | 1427631974 | 3 | t5_2fwo | null | null | null |
True | jyper | null | did you reach the center? | null | 0 | 1316677056 | False | 0 | c2lpq9k | t3_klhlv | null | t1_c2lpq9k | t1_c2l8hov | null | 1427631978 | 1 | t5_2fwo | null | null | null |
True | jyper | null | I think its like that in haskell too. | null | 0 | 1316677364 | False | 0 | c2lpqwc | t3_klhlv | null | t1_c2lpqwc | t1_c2ldrce | null | 1427631986 | 1 | t5_2fwo | null | null | null |
True | rwmjones | null | Better link is:
http://www.mjmwired.net/kernel/Documentation/trace/ftrace.txt#1563
Linux does this already, and has done for many years, if configured with ftrace support. | null | 0 | 1316677441 | False | 0 | c2lpr29 | t3_kmshh | null | t1_c2lpr29 | t1_c2ljv62 | null | 1427631988 | 3 | t5_2fwo | null | null | null |
True | chrisdew | null | Const/immutability in D is great just as it is. I've been through the pain of finding non-deterministic bugs in multi-threaded code, so I really appreciate D's guarantees.
I can see his point in liking the idea of a weaker logical single-threaded const. I don't see any reason why an escapable logical const shouldn't exist in D in the future, but then I don't design compilers or languages. | null | 0 | 1316677541 | False | 0 | c2lpr9y | t3_knn5p | null | t1_c2lpr9y | t3_knn5p | null | 1427631994 | 12 | t5_2fwo | null | null | null |
True | sltkr | null | No, paradoxiology had it right: it's functional programming, but not *pure* functional programming.
This is very common in LISP, which is a non-pure functional programming language (in which pure functions can still be defined, of course).
So we have functions to operate on the treap, but they are non-pure functions. | null | 0 | 1316677561 | False | 0 | c2lprbd | t3_kn9gt | null | t1_c2lprbd | t1_c2lpms6 | null | 1427631994 | 4 | t5_2fwo | null | null | null |
True | civildisobedient | null | My apologies to Pixar. | null | 0 | 1316677781 | False | 0 | c2lprs1 | t3_kmshh | null | t1_c2lprs1 | t1_c2loj4y | null | 1427631998 | 1 | t5_2fwo | null | null | null |
True | shadowflower | null | I don't get it. Elaborate, please? | null | 0 | 1316677926 | False | 0 | c2lps2w | t3_klrrx | null | t1_c2lps2w | t1_c2lhdjb | null | 1427632012 | -1 | t5_2fwo | null | null | null |
True | ice109 | null | what's that mean? what's the general approach and what's different about malan? | null | 0 | 1316677932 | False | 0 | c2lps3b | t3_kn9fk | null | t1_c2lps3b | t1_c2lpkim | null | 1427632012 | 17 | t5_2fwo | null | null | null |
True | pizza300 | null | If you like scripting in python: [Orange](http://orange.biolab.si/) is a cool data mining/machine learning open source tool - also with a DT implementation :-). | null | 0 | 1316677952 | False | 0 | c2lps4o | t3_km0c6 | null | t1_c2lps4o | t3_km0c6 | null | 1427632003 | 1 | t5_2fwo | null | null | null |
True | thepowerofone | null | Yo dawg! I heard you like GitHub ... | null | 0 | 1316677991 | False | 0 | c2lps7z | t3_knhd2 | null | t1_c2lps7z | t3_knhd2 | null | 1427632004 | -13 | t5_2fwo | null | null | null |
True | backbob | null | It's the start of a list. But for a list like this? The big players have to be there, and they aren't on this list. This needs some work before it can be considered a list.
OP: please finish this, because it could be a really useful resource for new and existing web developers. | null | 0 | 1316678663 | False | 0 | c2lptho | t3_kmpyi | null | t1_c2lptho | t1_c2lmkjo | null | 1427632027 | 1 | t5_2fwo | null | null | null |
True | Poita_ | null | AFAICS, logical const could technically exist in future versions of D, but:
- It can't exist using only the two available type qualifiers (const, immutable) without breaking their strong guarantees.
- Even if it did exist, it's intractable to enforce it.
A logical const function is one that preservers logical equality across calls, i.e.
T temp = copy(a);
a.some_logical_const_fun();
assert( a == temp ); // using the object's == operator
Physical const OTOH is:
T temp = copy(a);
a.some_physical_const_fun();
assert( memcmp(&a, &temp, T.sizeof) == 0 ); // i.e. bitwise equality
The only way you could statically enforce logical equality before and after a logical const function would be to run some sort of sophisticated static analysis over the equality function and candidate logical const function to determine that the equality is preserved. Since the equality operator could literally do anything, it is computationally intractable.
One route D could take is to use its invariant feature to run the equality comparison after on a copy. This would work, but in many cases it would be far too expensive (e.g. .empty on an array would be logical const, and is O(1), but testing array equality is O(n)).
It's a tricky situation. My current approach is to simply use no const to mean logical const, because it's the only way that scales IMO.
| null | 0 | 1316678698 | False | 0 | c2lptkn | t3_knn5p | null | t1_c2lptkn | t1_c2lpr9y | null | 1427632037 | 9 | t5_2fwo | null | null | null |
True | OopsLostPassword | null | First thing I see is the absence of my favorite server side language for web applications : go. I guess that other are missing.
But this is an interesting list and I'll probably have a look at a few things I don't know.
EDIT : I just submitted the go. | null | 0 | 1316678745 | True | 0 | c2lptnm | t3_kmpyi | null | t1_c2lptnm | t3_kmpyi | null | 1427632028 | -3 | t5_2fwo | null | null | null |
True | secretcurse | null | Which book? You're awesome at commenting, so I value your input. | null | 0 | 1316679600 | False | 0 | c2lpv69 | t3_kn9fk | null | t1_c2lpv69 | t1_c2lmu3f | null | 1427632046 | 11 | t5_2fwo | null | null | null |
True | rubygeek | null | That is a magnificently beautiful way of presenting the code commentary...
| null | 0 | 1316679688 | False | 0 | c2lpvbo | t3_knafe | null | t1_c2lpvbo | t3_knafe | null | 1427632047 | 16 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316679781 | False | 0 | c2lpvhp | t3_klypn | null | t1_c2lpvhp | t1_c2lpop0 | null | 1427632048 | 1 | t5_2fwo | null | null | null |
True | johnwaterwood | null | Because it's a cool addition? | null | 0 | 1316679837 | False | 0 | c2lpvl2 | t3_kjdt6 | null | t1_c2lpvl2 | t1_c2ky023 | null | 1427632049 | 1 | t5_2fwo | null | null | null |
True | BeforeTime | null | I like this, but I am not able to download the source from the link you provided to id. Is it me? Or is it someone else? | null | 0 | 1316679875 | False | 0 | c2lpvnl | t3_klrrx | null | t1_c2lpvnl | t1_c2lej2j | null | 1427632050 | 1 | t5_2fwo | null | null | null |
True | johnwaterwood | null | For web based projects I suggest Java EE. Really simple, small ~25 MB runtime, yet full stack and very good performance (only C and C++ are slightly faster) | null | 0 | 1316680081 | False | 0 | c2lpw2i | t3_kn8ra | null | t1_c2lpw2i | t3_kn8ra | null | 1427632054 | 1 | t5_2fwo | null | null | null |
True | AeroNotix | null | I have a lot to read at the moment, just ordered a few more Python books.
But it's definitely on my "to read" list.
Thanks for the recommendation! | null | 0 | 1316680111 | False | 0 | c2lpw54 | t3_kmref | null | t1_c2lpw54 | t1_c2lpjh1 | null | 1427632055 | 1 | t5_2fwo | null | null | null |
True | pedrocr | null | >(IIRC there are also true multibyte NOP instructions, but they aren't compatible with early x86 processors.)
According to wikipedia x86 NOPs are 1-9 bytes on >i686 (Pentium Pro). So I guess any modern Windows could very well move to those as I don't think it would ever run on a i586 (the original Pentium). | null | 0 | 1316680170 | False | 0 | c2lpw92 | t3_kmshh | null | t1_c2lpw92 | t1_c2lmvt3 | null | 1427632056 | 2 | t5_2fwo | null | null | null |
True | hakkzpets | null | One could argue that web-servers are the important number here. | null | 0 | 1316680280 | False | 0 | c2lpwfy | t3_kmshh | null | t1_c2lpwfy | t1_c2lp8tb | null | 1427632059 | 6 | t5_2fwo | null | null | null |
True | jisang-yoo | null | Reminds me of save-excursion, save-restriction and with-* functions in Emacs Lisp. | null | 0 | 1316680292 | False | 0 | c2lpwgp | t3_kljpc | null | t1_c2lpwgp | t3_kljpc | null | 1427632059 | 1 | t5_2fwo | null | null | null |
True | nikbackm | null | Seems prudent.
Because, what does "logical const" really offer that you cannot achieve with "no const" as well?
If there are "no const" methods you don't want the clients to use just disable them in some other way. Or don't offer them at all.
Immutable OTOH offers really useful guarantees and should not be compromised. | null | 0 | 1316681035 | False | 0 | c2lpxt9 | t3_knn5p | null | t1_c2lpxt9 | t1_c2lptkn | null | 1427632086 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | I don't really have a use for this site yet. I hope that they keep at it though and add more features. It could develop into a recruitment tool for example. | null | 0 | 1316681186 | False | 0 | c2lpy2w | t3_kmpyi | null | t1_c2lpy2w | t3_kmpyi | null | 1427632091 | 0 | t5_2fwo | null | null | null |
True | akoprowski | null | What would you prefer instead? When it comes to XHTML, 1.1 is the current [W3C Recommendation](http://en.wikipedia.org/wiki/XHTML#Versions_of_XHTML) | null | 0 | 1316681533 | False | 0 | c2lpyo3 | t3_kn8ra | null | t1_c2lpyo3 | t1_c2loi3l | null | 1427632092 | 0 | t5_2fwo | null | null | null |
True | obtu | null | As a git user, this is what I need to unbreak hg:
* extdiff
* pager
* color
* purge
* graphlog
* hgk
* mq
* rebase
* patchbomb
* bookmarks
* histedit | null | 0 | 1316681709 | False | 0 | c2lpyz4 | t3_k8vpn | null | t1_c2lpyz4 | t1_c2ju09i | null | 1427632094 | 1 | t5_2fwo | null | null | null |
True | akoprowski | null | The problem with Java EE is that the stack is fairly complex. You have to learn how to deal with: a web server, templating system, web framework, JSF, EJB, database... Opa (http://opalang.org) gives you all this in a single, consistent package. | null | 0 | 1316681711 | False | 0 | c2lpyza | t3_kn8ra | null | t1_c2lpyza | t1_c2lpw2i | null | 1427632094 | 0 | t5_2fwo | null | null | null |
True | brokenfrog | null | > even the "expected balanced height" thing is to be used with care, since the expected value of a random distribution is almost never achieved — it's just the most likely
No, the most likely value is called the *mode*. The *expected value* is really the value you'll get on average over many thousands of uses of the data structure. In other words, the expected runtime is (most of the time) the value you should care about. | null | 0 | 1316681846 | False | 0 | c2lpz73 | t3_kn9gt | null | t1_c2lpz73 | t1_c2lpn3r | null | 1427632100 | 6 | t5_2fwo | null | null | null |
True | king_of_blades | null | With great power comes great responsibility. And most people have no idea what they are doing. | null | 0 | 1316681846 | False | 0 | c2lpz77 | t3_kmshh | null | t1_c2lpz77 | t1_c2lp1j2 | null | 1427632100 | 2 | t5_2fwo | null | null | null |
True | kish22 | null | excellent. this would mean i don't have to shave before making that video call! | null | 0 | 1316681935 | False | 0 | c2lpzcw | t3_kmref | null | t1_c2lpzcw | t1_c2ll6ye | null | 1427632100 | 2 | t5_2fwo | null | null | null |
True | menteth | null | Yes, I was loose with my language (and the mode and mean aren't equal here), but since we're being pedantic: the expected value is not the one you'll get on average. It's the one the values will cluster around. If you toss a coin 10,000 times (go ahead; I'll wait) and repeat that experiment 100 times (still waiting), the expected number of heads is 5000. But you'll pretty much *never* get that value. Your results are expected to cluster around 5000 more likely than any other number, but I'd be amazed if you ever actually got 5000.
My point being that the error distribution actually matter in random algorithms. In this particular article's case, creating 1000 or so treaps for each of a number of depths and showing how their actual heights distributed would go a long way towards showing why the expected height value is reasonable but also fairly variable.
Again, I think my initial point stands: it's an excellent for showing a particular data structure that isn't widely known and has some interest. it falls down whenever it tries to contrast that to other tree structures. Which is fine if it's read with the right goal. | null | 0 | 1316682060 | True | 0 | c2lpzjv | t3_kn9gt | null | t1_c2lpzjv | t1_c2lpz73 | null | 1427632102 | 3 | t5_2fwo | null | null | null |
True | vtj | null | > There's actually another lesser known alternative for writing generic code in C, and it's based on a single macro that could be viewed as sort of a "downcast" macro:
> `#define container_of(ptr, container, member) \`
> `((container *)((ptr) - offsetof(container, member)))`
Don't you have to cast ptr to `char*` before you subtract the offset? Or am I missing something here?
Anyway, it appears that this approach forces you to include `struct list` into any data type that you want to store in you generic list. That seems like it could get quite inconvenient if you plan to use several different data structures for the same data. And those casts don't look very type-safe either (suppose I mistakenly pass a list of foos to a function that expects a list of bars).
> This approach has a whole slew of advantages (I can expand on that if you want), that it was copied to C++ too.
Please do expand. Was it copied before templates and the STL were available? I can't imagine why anyone in C++ would choose this approach over templates (and I am certainly no template fanboi). | null | 0 | 1316682577 | False | 0 | c2lq0cj | t3_klphp | null | t1_c2lq0cj | t1_c2ldg1v | null | 1427632110 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316682830 | False | 0 | c2lq0sn | t3_kmshh | null | t1_c2lq0sn | t3_kmshh | null | 1427632115 | -5 | t5_2fwo | null | null | null |
True | pnettle | null | Same here. Sphinx was simple and painless and just worked. | null | 0 | 1316682929 | False | 0 | c2lq0ze | t3_ha6fb | null | t1_c2lq0ze | t1_c1tv1hp | null | 1427632117 | 1 | t5_2fwo | null | null | null |
True | bonzinip | null | "mov edi,edi" is not a nop in 64-bit mode, it zero-extends 32-bit edi to 64-bit rdi (all 32-bit instructions clear the upper 32-bits of the corresponding 64-bit register, I don't recall if this happens also for 8/16-bit instructions--probably not). | null | 0 | 1316682997 | False | 0 | c2lq13e | t3_kmshh | null | t1_c2lq13e | t1_c2lkqw6 | null | 1427632119 | 7 | t5_2fwo | null | null | null |
True | [deleted] | null | > And further, it also characterizes, in general, functional languages.
No. Functional languages are often hyped as being declarative, and I see from where this idea grows, but the fact is, no functional language in existence guarantees that `[i + j for i in range(10) for j in range(10) if i % 2]` and `[i + j for i in range(10) if i % 2 for j in range(10)]` are equivalent. Because these expressions tell what to do, not what are the properties of the desired result.
In other words, '`for i in range(10) ...`' can mean "enumerate all values from 0 to 9, assigning them to variable `i`, for each do ..." or "of all possible values of all our variables we need only those where `i` is in range [0..9]". The first meaning corresponds to relational algebra, the second -- to relational calculus. While both not only look the same but also have the [same expressive power](http://en.wikipedia.org/wiki/Codd's_theorem), they have different meaning and result in vastly different implementations, and I believe that only the second kind of stuff can be rightfully called "declarative".
Only SQL and Prolog implement calculi, all functional languages (including XSLT) implement algebras. | null | 0 | 1316683010 | False | 0 | c2lq14a | t3_kmp73 | null | t1_c2lq14a | t1_c2ll8y6 | null | 1427632119 | 3 | t5_2fwo | null | null | null |
True | RizzlaPlus | null | I find your qualification of C++ as 'hideous' debatable. It's not easy to write pretty C++ though. | null | 0 | 1316683266 | False | 0 | c2lq1ja | t3_klphp | null | t1_c2lq1ja | t1_c2lfsoy | null | 1427632125 | 2 | t5_2fwo | null | null | null |
True | gospelwut | null | Our of curiosity, could you elaborate on the project you are discussing? | null | 0 | 1316683373 | False | 0 | c2lq1pg | t3_kmshh | null | t1_c2lq1pg | t1_c2lkixt | null | 1427632127 | 6 | t5_2fwo | null | null | null |
True | gospelwut | null | Not surprisingly, unpatched linux machines get owned all the time. They suffer from the same problem that Windows does: 3rd party applications (yes I'm looking at you PHP).
I'm not saying there aren't privilege escalations and all that in Windows; there are. But, a vast majority of attack vectors are because of things like XSS browser attacks, Adobe products, etc.
I mean... another 3rd party vendor (Google) went through the effort to dedicate an immense amount of processing power to give Adobe a large list of security weaknesses for Flash (IIRC) just to make the entire ecosystem safer for everybody. | null | 0 | 1316683544 | False | 0 | c2lq1yt | t3_kmshh | null | t1_c2lq1yt | t1_c2lpwfy | null | 1427632130 | 3 | t5_2fwo | null | null | null |
True | gospelwut | null | And, suddenly, thousands of dll injections were born.
While not exactly the same, this does take me back to my first programming book -- WIN32 APIs. In retrospect, I kind of wish I learned assembly when I was younger and more apt to learning, but what can you do? Sadly, I wasted that time learning how to make AOL programs in VB6. Though, admittedly, VB was pretty good with COM compared to the alternative of using C++ -- but obviously this wasn't really on my mind as a 11-year-old. | null | 0 | 1316684320 | True | 0 | c2lq356 | t3_kmshh | null | t1_c2lq356 | t1_c2lkgd1 | null | 1427632146 | 0 | t5_2fwo | null | null | null |
True | blergh- | null | If you make sure you can't do tricks like this, you will find that, surprisingly, the /need/ for them has suddenly disappeared.
As explained in the article, there is a good reason for these instructions to be there, but that reason definitely isn't to allow you to 'update' a running executable. | null | 0 | 1316684362 | False | 0 | c2lq37p | t3_kmshh | null | t1_c2lq37p | t1_c2lnk6e | null | 1427632147 | -4 | t5_2fwo | null | null | null |
True | Locomorto | null | >Yes, I was loose with my language (and the mode and mean aren't equal here), but since we're being pedantic: the expected value is not the one you'll get on average. It's the one the values will cluster around. If you toss a coin 10,000 times (go ahead; I'll wait) and repeat that experiment 100 times (still waiting), the expected number of heads is 5000. But you'll pretty much never get that value. Your results are expected to cluster around 5000 more likely than any other number, but I'd be amazed if you ever actually got 5000.
That's not strictly true. In the case of repeated, identical independant distribution RVs though, by the central limit theorem what you say is correct.
But say you had a distribution like this: http://i.imgur.com/zb0u1.png
In this case the expected value is 50, but that's the the area of lowest density! You're right to point out that the EV is not necessarily going to actually be obtained. It's a bit hard to see in the graph, but p_x|50 = 0. That is, it's impossible to ever have a result of 50.
| null | 0 | 1316684454 | False | 0 | c2lq3cb | t3_kn9gt | null | t1_c2lq3cb | t1_c2lpzjv | null | 1427632149 | 2 | t5_2fwo | null | null | null |
True | gospelwut | null | [Related, amusing read](http://blog.acrossecurity.com/2011/05/anatomy-of-com-server-based-binary.html?m=1) (albeit a somewhat contrived "attack" this can be deployed as a per-packaged container)
Also [/r/netsec](http://www.reddit.com/r/netsec) says hi to all the programmers. | null | 0 | 1316684512 | False | 0 | c2lq3fj | t3_kmshh | null | t1_c2lq3fj | t1_c2ll27v | null | 1427632150 | 2 | t5_2fwo | null | null | null |
True | Chousuke | null | You are making an unfair comparison. Chrome started from scratch, so of course they will be able to proceed more smoothly with a continuous release policy than Mozilla who have several established projects. Well-written add-ons won't break that often on Firefox either, and as the dev team sorts out the remaining kinks with add-on compatibility, you can only expect the situation to improve.
You are insinuating that every person involved with Mozilla is incompetent just because they have some issues transitioning to an entirely new development model.
I don't know why you put so much emphasis on this particular ticket. I don't care if there's a version number in the About dialog or not; my initial reply to Olap didn't even address that. | null | 0 | 1316684756 | False | 0 | c2lq3ta | t3_kghid | null | t1_c2lq3ta | t1_c2l7osp | null | 1427632155 | 1 | t5_2fwo | null | null | null |
True | fjonk | null | The delete/insert/update will be slower since after they are done the index must be up to date, otherwise the results using the index can be wrong. If there was no tradeof for indexing we could just index everything and the problem would be solved. | null | 0 | 1316684801 | False | 0 | c2lq3vp | t3_kmp73 | null | t1_c2lq3vp | t1_c2li3c9 | null | 1427632156 | 3 | t5_2fwo | null | null | null |
True | b0dhi | null | If you're a server, sure. But it's relatively easy to secure a server since you're concentrating on a relatively small code base and it operates a relatives small set of operations. Clients can have holes due to any of the millions of programs they could be running. | null | 0 | 1316685453 | False | 0 | c2lq4u6 | t3_kmshh | null | t1_c2lq4u6 | t1_c2lpwfy | null | 1427632168 | 1 | t5_2fwo | null | null | null |
True | kitd | null | I'm sure there are a few missing. AngularJS? Any others?
I like the look of wheneverJS. Haven't seen that before. I wonder how useful it is in real-world apps. | null | 0 | 1316685557 | False | 0 | c2lq4zt | t3_knrh2 | null | t1_c2lq4zt | t3_knrh2 | null | 1427632170 | 1 | t5_2fwo | null | null | null |
True | WalterBright | null | D's immutability enables multithreaded code access to immutable data without need for synchronization. This is not true of logical const - access would have to be synchronized. | null | 0 | 1316686001 | False | 0 | c2lq5mx | t3_knn5p | null | t1_c2lq5mx | t1_c2lpr9y | null | 1427632178 | 19 | t5_2fwo | null | null | null |
True | Locomorto | null | Actually funnily enough I decided to try your idea. I flipped* a coin 10,000 times, and repeated that 100 times. I then did that 10 more times. On six occasions I had exactly 5000 heads at least once in the 100 trials.
So there you go! You should be careful with things like that, because of the central limit theorem it's going to be centered very closely around 5000.
*I lied. I had a computer do it, so sue me. | null | 0 | 1316686109 | False | 0 | c2lq5sr | t3_kn9gt | null | t1_c2lq5sr | t1_c2lpzjv | null | 1427632180 | 2 | t5_2fwo | null | null | null |
True | WalterBright | null | You're right. Logical const is only a convention, since it cannot be enforced by the compiler. | null | 0 | 1316686141 | False | 0 | c2lq5up | t3_knn5p | null | t1_c2lq5up | t1_c2lptkn | null | 1427632181 | 13 | t5_2fwo | null | null | null |
True | flukus | null | Except the number of tests required scales exponentially with complexity. | null | 0 | 1316686225 | False | 0 | c2lq5yl | t3_klypn | null | t1_c2lq5yl | t1_c2lih8z | null | 1427632182 | 1 | t5_2fwo | null | null | null |
True | skulgnome | null | I'm judging the D cult based on opinions of its members from, apparently, as few as five years ago. You might have grasped this better through a more careful reading of my comment. Having only taken at most a cursory look at the language since, I'm restricted to judging it only by its cult.
I'm also surprised that you say it's only five years. My recollection is, IIRC, quite a bit older. Was there an unavoidable "surprise `char[]` that segfaults when written" as few as six years ago? That's 2005, mind.
And indeed, first impressions are everything. To compare, Java started out with cast-happy collections and retained those until they made a heavily restricted, syntax sugar oriented concession to C++-style templates in generics. Yet even today code is written for compatibility with a 10 year old JDK using those same castaway-typed, manually-boxed collections. Another example will certainly be Google's Go and its lack of parametric polymorphism: in a few years when they finally get around to adding some, there will be reams and reams of existing code that casts back and forth from `interface{}`. Start as you mean to go on, as they say -- fixing a language feature in "version 2.0" merely cements the foundation of its most immedate predecessor. | null | 0 | 1316686264 | True | 0 | c2lq60k | t3_kljc0 | null | t1_c2lq60k | t1_c2la0ns | null | 1427632184 | 0 | t5_2fwo | null | null | null |
True | lfnoise | null | Open Music is a lisp based visual programming system.
http://repmus.ircam.fr/openmusic/overview | null | 0 | 1316686777 | False | 0 | c2lq6se | t3_kmp75 | null | t1_c2lq6se | t3_kmp75 | null | 1427632193 | 1 | t5_2fwo | null | null | null |
True | hortinstein | null | dude! awesome, I am doing a euler problem a really dumb way but want to try to brute force it with a few GPUs, I'll let you know how it turns out when I get to it this weekend....my buddy and me are doing python for these challenges so I am going to have to integrate it into python, but all the heavy lifting will be done with this. | null | 0 | 1316687014 | False | 0 | c2lq74h | t3_kltgu | null | t1_c2lq74h | t1_c2lib4i | null | 1427632198 | 1 | t5_2fwo | null | null | null |
True | Poita_ | null | Logical const (a la C++) is just a very lightly enforced convention that offers no guarantees. You can easily break it without the compiler complaining, but at the same time it will complain a little if you do follow the convention, which catches many logical errors (also gives you permission to shout at people if they aren't being const correct). | null | 0 | 1316687169 | False | 0 | c2lq7co | t3_knn5p | null | t1_c2lq7co | t1_c2lpxt9 | null | 1427632201 | 9 | t5_2fwo | null | null | null |
True | thesystemx | null | Why the downvotes? Oh, of course, Python is not discussed... | null | 0 | 1316687204 | False | 0 | c2lq7ei | t3_kn6hr | null | t1_c2lq7ei | t3_kn6hr | null | 1427632203 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Just out of curiosity, why did you have Javascript disabled? | null | 0 | 1316688201 | False | 0 | c2lq8t7 | t3_kmshh | null | t1_c2lq8t7 | t1_c2lj67g | null | 1428193489 | 1 | t5_2fwo | null | null | null |
True | zootsuit | null | 1310 is the somewhat obscure VS 2002 which was sort of deprecated by MS themselves. I limited/tried to limit my strawpoll grep to 2008 and 2010 so I wouldn't need to compare gcc 3 vs VS 2005 because frankly, I am not so interested in that. Water under the bridge. And grepping like this is not very scientific in the first place.
Anyway it's always been my impression that after gcc 4, gcc has always been ahead, no question.
One thing I for sure won't bother to look at is Intel's compliance because that's EDG isn't it? | null | 0 | 1316688424 | False | 0 | c2lq95t | t3_klphp | null | t1_c2lq95t | t1_c2lpf9t | null | 1427632225 | 1 | t5_2fwo | null | null | null |
True | julesjacobs | null | It would be great to have an IDE that would let you code like that. | null | 0 | 1316688470 | False | 0 | c2lq981 | t3_knafe | null | t1_c2lq981 | t1_c2lpvbo | null | 1427632226 | 8 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316688720 | False | 0 | c2lq9l7 | t3_kmshh | null | t1_c2lq9l7 | t1_c2lq8t7 | null | 1427632231 | 2 | t5_2fwo | null | null | null |
True | cthalupa | null | Looks like Fall 2010 | null | 0 | 1316689528 | False | 0 | c2lqat8 | t3_kn9fk | null | t1_c2lqat8 | t1_c2lpgl9 | null | 1427632247 | 1 | t5_2fwo | null | null | null |
True | sfrank | null | Algebras like the Lambda *caculus*?! | null | 0 | 1316689982 | False | 0 | c2lqbj3 | t3_kmp73 | null | t1_c2lqbj3 | t1_c2lq14a | null | 1427632255 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Outstanding, since the UI layer is like a faster WPF, which is awesome. But does the security sandbox and lack of inter-process communication still apply? If not, Microsoft has a real winner here. If you've never used XAML before (in WPF or Silverlight), you'll be surprised at how productive it is.
| null | 0 | 1316690492 | False | 0 | c2lqccf | t3_kmsmr | null | t1_c2lqccf | t3_kmsmr | null | 1427632266 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Because #hash based websites don't break the web enough. | null | 0 | 1316690699 | False | 0 | c2lqco2 | t3_knsss | null | t1_c2lqco2 | t3_knsss | null | 1427632271 | 7 | t5_2fwo | null | null | null |
True | AeroNotix | null | I think this is the big takeaway from that, if you're modifying built-ins have some common fucking decency and don't completely overwrite something, especially when you're working with a huge framework. | null | 0 | 1316690781 | False | 0 | c2lqctf | t3_kmshh | null | t1_c2lqctf | t1_c2lpz77 | null | 1427632272 | 2 | t5_2fwo | null | null | null |
True | elbekko | null | *shudder* | null | 0 | 1316690806 | False | 0 | c2lqcve | t3_knsss | null | t1_c2lqcve | t3_knsss | null | 1427632273 | 7 | t5_2fwo | null | null | null |
True | AeroNotix | null | This. And it's usually because your design is completely turd. I've monkey patched some std libs with *additional* code, because it was neither in 2.7 or in futures, so I added the functionality, not edited existing code. | null | 0 | 1316690916 | False | 0 | c2lqd1r | t3_kmshh | null | t1_c2lqd1r | t1_c2ll46z | null | 1427632276 | 3 | t5_2fwo | null | null | null |
True | julesjacobs | null | In SQL and Prolog you also have expressions that are logically equivalent but result in different implementations. The distinction you're making is nonexistent. | null | 0 | 1316690977 | False | 0 | c2lqd6h | t3_kmp73 | null | t1_c2lqd6h | t1_c2lq14a | null | 1427632277 | 1 | t5_2fwo | null | null | null |
True | mikaelhg | null | Also, Ron Paul for president. | null | 0 | 1316691138 | False | 0 | c2lqdgt | t3_knsn0 | null | t1_c2lqdgt | t3_knsn0 | null | 1427632280 | 5 | t5_2fwo | null | null | null |
True | geekville | null | Good point. But I think it will depend on what country you're in. | null | 0 | 1316691168 | False | 0 | c2lqdig | t3_kmshh | null | t1_c2lqdig | t1_c2lo50g | null | 1427632281 | 1 | t5_2fwo | null | null | null |
True | Hedegaard | null | *Worst | null | 0 | 1316691264 | False | 0 | c2lqdor | t3_kmshh | null | t1_c2lqdor | t1_c2lp3za | null | 1427632283 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316691336 | False | 0 | c2lqdu5 | t3_kmpyi | null | t1_c2lqdu5 | t1_c2llp6m | null | 1427632285 | -1 | t5_2fwo | null | null | null |
True | JustPlainRude | null | Owned by what, exactly? Would you really expose your VM to the Internet without some sort of firewall in place? | null | 0 | 1316691386 | False | 0 | c2lqdxt | t3_kmshh | null | t1_c2lqdxt | t1_c2lnn0k | null | 1427632287 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | Oh god why? Make it stop. | null | 0 | 1316691471 | False | 0 | c2lqe34 | t3_knsss | null | t1_c2lqe34 | t3_knsss | null | 1427632288 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316691520 | False | 0 | c2lqe6k | t3_klypn | null | t1_c2lqe6k | t1_c2ldi3z | null | 1427632290 | 2 | t5_2fwo | null | null | null |
True | julesjacobs | null | Once you have those preferences, that sounds like an optimization problem that computers are good at, and humans are not good at. Yet currently humans are trying to solve it. I think that the preferences wouldn't be too hard to generalize so that a default works for pretty much everything. For example if the database notices that you are often running queries with joins that take 10 minutes without an index and 2 seconds with an index, you probably want that index. | null | 0 | 1316691526 | True | 0 | c2lqe72 | t3_kmp73 | null | t1_c2lqe72 | t1_c2lk7q2 | null | 1427632290 | 3 | t5_2fwo | null | null | null |
True | thelastbaron | null | I have a Bachelors degree in CS, and I still find these intro course videos on the internet extremely entertaining and captivating. I had to stop it just now, 6 minutes in, to avoid being late for work.
Edit: 12 minutes, actually. Now I'm going. | null | 0 | 1316691617 | True | 0 | c2lqed3 | t3_kn9fk | null | t1_c2lqed3 | t3_kn9fk | null | 1427632293 | 10 | t5_2fwo | null | null | null |
True | [deleted] | null | >If there is no code in your link, it probably doesn't belong here. | null | 0 | 1316691642 | False | 0 | c2lqef4 | t3_knsn0 | null | t1_c2lqef4 | t3_knsn0 | null | 1427632293 | 2 | t5_2fwo | null | null | null |
True | axilmar | null | Isn't that also a problem today if we index records? how is that handled by the current databases?
| null | 0 | 1316691857 | False | 0 | c2lqetb | t3_kmp73 | null | t1_c2lqetb | t1_c2lq3vp | null | 1427632299 | 1 | t5_2fwo | null | null | null |
True | adient | null | If you did the first 50 without any prior knowledge (and didn't look up the answers), you will probably want to redo some of them after learning more. I recall at least 1 if not more that require dynamic programming to get the optimal answer, something you would not know about without any CS education. | null | 0 | 1316691896 | False | 0 | c2lqew2 | t3_kn9fk | null | t1_c2lqew2 | t1_c2lobza | null | 1427632300 | 2 | t5_2fwo | null | null | null |
True | axilmar | null | > I've seen this aired a couple of times, never with a good substantiation.
Well, here was a real case: I was writing a GUI library, and defined Color as
struct Color {
ubyte red, green, blue, alpha;
}
I was passing Color structs by value around functions like this:
void setColor(Color c) {
c.red = c.green = c.blue = c.red + c.green + c.blue / 3;
if (c == m_backColor) return;
m_backColor = c;
redraw();
}
Then someone asked if I could make the Color struct use floats. I said, ok, let's do it:
struct Color {
float red, green, blue, alpha;
}
But then Color took 4 times more space than the original value. So I thought I would convert it to a class:
class Color {
float red, green, blue, alpha;
}
Now that change caused many functions not to work, because I reused Color structs in various places in the code.
> In C++, does one not know how to use std::vector?
What does std::vector has to do with this?
> Bitfields are not part of the language.
I liked it better when they were and I could write bits[5], for example. Way more natural than the current stuff.
> RAII is designed to work better
How? this:
scope L = new Lock(m);
Is a lot weirder than this:
Lock L(m);
This is even weirder:
scope(exit) unlock(m);
It's especially strange because in C++ this can be done with lambdas very nicely. No need for a special construct.
And then we have:
scope(failure)
Jesus Christ, you took a simple concept and blown it out of proportions.
And then you call C++ bloated?
| null | 0 | 1316692457 | False | 0 | c2lqfxz | t3_kljc0 | null | t1_c2lqfxz | t1_c2lpg73 | null | 1427632314 | 2 | t5_2fwo | null | null | null |
True | fjonk | null | I wouldn't say problem, it's more of a requirement. We need the indexes to be up-to-date, otherwise they are just a out-of-date cache.
This is also why you should be careful when adding indexes. The indexes needs to be updated when the db returns a result so you have to wait for the re-indexing when altering something that is indexed. Example(with index on t.id):
insert into t(id) values(12);
select count(id) from t where id=12; -- Returns 0 if the index hasn't been updated
| null | 0 | 1316692470 | False | 0 | c2lqfz0 | t3_kmp73 | null | t1_c2lqfz0 | t1_c2lqetb | null | 1427632315 | 2 | t5_2fwo | null | null | null |
True | YesButIThink | null | I'm thinking of a layered system where higher-level components have business logic to decide to call lower-level components with certain arguments, or not call them in some cases, and the lower-level components encapsulate the details of writing to a db, sending an email, putting a message on a queue, etc.
I agree that you should test your components by their public apis, and your tests shouldn't know about private methods, etc. But to preserve the level of sanity that a layered design provides, I usually want to mock out the lower-level components when testing the higher-level ones.
Let's say we have some business logic in a class that decides what to put into an email, and then invokes an email service to send it. I would mock the email service and verify the subject/body arguments passed to it in my unit test for the class with the business logic. How else can we verify that it's doing the right thing? | null | 0 | 1316692486 | False | 0 | c2lqg04 | t3_klypn | null | t1_c2lqg04 | t1_c2litzy | null | 1427632315 | 1 | t5_2fwo | null | null | null |
True | skulgnome | null | How about just writing comments about what the code itself doesn't tell you? It isn't as though source code were slabs of marble, written once and read only by the compiler.
And if a programmer writes code that documents its own function poorly, how will s/he write comments that document it better? | null | 0 | 1316692509 | False | 0 | c2lqg1u | t3_kmk56 | null | t1_c2lqg1u | t3_kmk56 | null | 1427632315 | 5 | t5_2fwo | null | null | null |
True | axilmar | null | Perhaps. Before me doing this heavy and time consuming stuff, could you explain why in your own few words? | null | 0 | 1316692572 | False | 0 | c2lqg5j | t3_kmp73 | null | t1_c2lqg5j | t1_c2lltua | null | 1427632317 | 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.