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 | axilmar | null | This.
| null | 0 | 1316692620 | False | 0 | c2lqg8q | t3_kmp73 | null | t1_c2lqg8q | t1_c2lqe72 | null | 1427632317 | -1 | t5_2fwo | null | null | null |
True | ece_guy | null | Right, with prime numbers for example. The simplest solution is easy, however it is also extremely slow. It is fun optimizing your code and seeing how much faster it finds the solution. | null | 0 | 1316692663 | False | 0 | c2lqgbn | t3_kn9fk | null | t1_c2lqgbn | t1_c2lqew2 | null | 1427632329 | 2 | t5_2fwo | null | null | null |
True | axilmar | null | Perhaps you are not aware of the effort required to update a compiler for a language like C++. It's perhaps 50 times more work to update the compiler rather than to simply write a set of wrapper classes.
| null | 0 | 1316692729 | False | 0 | c2lqggd | t3_kl1qp | null | t1_c2lqggd | t1_c2ljfpa | null | 1428193488 | 0 | t5_2fwo | null | null | null |
True | axilmar | null | But this consequence of indexing is also valid in current databases. So, I see no problem.
| null | 0 | 1316692964 | False | 0 | c2lqgy2 | t3_kmp73 | null | t1_c2lqgy2 | t1_c2lidbd | null | 1427632328 | 0 | t5_2fwo | null | null | null |
True | thesystemx | null | yes | null | 0 | 1316693047 | False | 0 | c2lqh4b | t3_kjwil | null | t1_c2lqh4b | t1_c2ldwhx | null | 1427632335 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | For example?
A proper RDBMS must treat equivalent SQL expressions as equivalent. Oracle and PostgreSQL are pretty close to proper RDBMS. | null | 0 | 1316693108 | False | 0 | c2lqh8b | t3_kmp73 | null | t1_c2lqh8b | t1_c2lqd6h | null | 1427632332 | 1 | t5_2fwo | null | null | null |
True | MarshallBanana | null | > Honestly nothing impressive in there.
Oh, so [FSF high-priority projects](http://www.fsf.org/blogs/licensing/free-rarv3-extraction) are "nothing impressive" to you.
I guess the FSF just has no clue about what is important, huh. | null | 0 | 1316693239 | False | 0 | c2lqhir | t3_kl7h0 | null | t1_c2lqhir | t1_c2lnn80 | null | 1427632335 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Lambda calculus becomes a calculus the moment you prove that your reductions always result in a unique normal form (if it exists) and then forget about reductions altogether. Which would make an equivalent to the [Codd's theorem](http://en.wikipedia.org/wiki/Codd's_theorem).
Anyway, I don't know, maybe these terms don't have universal meaning, but at least relational algebra and relational calculus are formally defined, with the exact distinction that I'm talking about. What's your problem with that? | null | 0 | 1316693389 | False | 0 | c2lqhu4 | t3_kmp73 | null | t1_c2lqhu4 | t1_c2lqbj3 | null | 1427632339 | 2 | t5_2fwo | null | null | null |
True | kiddikiddi | null | The delete/insert/update operations will slow down. They will slow down because of the indexing.
Think of it this way, every time there's an insert/update/delete operation on a table/row/column that affects an index there are essentially two (or more, even more if triggers are involved) operations being performed before the actual operation is marked as complete.
1. The adding/removal/modification of actual data.
2. Updating the indexes involved.
The latter operation is especially valid if you've got something more than just a simple b-tree index, e.g. range index or a function based index etc.
It may not look like much per individual operation, but just like in Superman III, those fractions add up! | null | 0 | 1316693746 | False | 0 | c2lqimc | t3_kmp73 | null | t1_c2lqimc | t1_c2lqgy2 | null | 1427632349 | 3 | t5_2fwo | null | null | null |
True | rubygeek | null | Meanwhile there's apparently [Docco](http://jashkenas.github.com/docco/) and associated ports/re-implementations. The article was apparently prepared using Pycco (the Python port) | null | 0 | 1316693778 | False | 0 | c2lqiov | t3_knafe | null | t1_c2lqiov | t1_c2lq981 | null | 1427632350 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | One question I've had about immutability and const in D is whether there's any way to make use of mutability while assembiling a data structure and then "freeze" it when you're done putting it together. The simplest example would be when you want to construct the classic functional data structure, the immutable singly-linked list, but while you're constructing it you mutate tail pointers. The alternative is to construct the list and then reverse it, which means traversing the list twice and doing twice as much consing. | null | 0 | 1316693778 | False | 0 | c2lqiow | t3_knn5p | null | t1_c2lqiow | t3_knn5p | null | 1427632350 | 4 | t5_2fwo | null | null | null |
True | grokfail | null | Seems like premature optimisation. If your querystrings are too long, POST data to the server. The maximum real world URL length is ~2083 characters, a whopping 2KB.
If you are serving pages under 100KB then perhaps 2KB might start to matter, I'll bet that a decent amount of JS alone will top that even when using small libraries, not to mention images, CSS, and the HTML itself, which is loaded on every request.
It is a lossy representation, it mangles this valid JSON.
a = URLON.stringify([ {}, {}, {} ]);
>> "@;@;@"
URLON.parse(a);
>> "Unexpected char ;"
It can't handle this simple case;
x = URLON.stringify({"foo":[]});
>> "_foo"
URLON.parse(x);
>> "Unexpected char undefined"
At (@) is a reserved character in URLs, as are colon (:) and semi-colon (;)
http://www.blooberry.com/indexdot/html/topics/urlencoding.htm#whatwhy | null | 0 | 1316693850 | False | 0 | c2lqius | t3_knsss | null | t1_c2lqius | t3_knsss | null | 1427632352 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | I aint impressed and certainly you have not been able to convince me not to use the GPL or not to use GPLed products.
In fact your extreme hostility towards a massive segment of the open source community is a disgusting thing to witness.
| null | 0 | 1316694000 | False | 0 | c2lqj6a | t3_kl7h0 | null | t1_c2lqj6a | t1_c2lqhir | null | 1427632356 | 0 | t5_2fwo | null | null | null |
True | simonask | null | Huh? I guess constants can be initialized with non-constants, can't they? | null | 0 | 1316694167 | False | 0 | c2lqjkg | t3_knn5p | null | t1_c2lqjkg | t1_c2lqiow | null | 1427632362 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | Was fortunate to hear the talk live. I have half-mind to try provoking my company to implement some of his ideas for the next project - the organizational side of things seemed to be neeeeeat.
Also, the dude is a great presenter. The slides alone are not worth even a quarter of the live performance. | null | 0 | 1316694168 | False | 0 | c2lqjkh | t3_knhd2 | null | t1_c2lqjkh | t3_knhd2 | null | 1427632362 | 3 | t5_2fwo | null | null | null |
True | julesjacobs | null | It depends on the particular RDBMS. What they do is take a query and translate it to relational algebra, and then they apply a query optimizer that tries to find the best way to execute it. An example could be:
(SELECT COUNT(*) FROM ...) > 0
-vs-
EXISTS (SELECT * FROM ...)
Of course this depends on the optimizer. Perhaps a particular optimizer will recognize the pattern and optimize the first form to the second form, but that is not an intrinsic property of SQL. And no query optimizer will recognize all such instances, because that is an undecidable problem.
And in Prolog you can do:
foo(...), bar(...)
-vs-
bar(...), foo(...)
These two logically have the same meaning, but they can result in vastly different implementation and performance just like your list comprehension example. | null | 0 | 1316694182 | False | 0 | c2lqjlo | t3_kmp73 | null | t1_c2lqjlo | t1_c2lqh8b | null | 1427632364 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Yeah I'm sure Win95 is a web server for app front-end... if that was true it would deserve to get destroyed. | null | 0 | 1316694239 | False | 0 | c2lqjpx | t3_kmshh | null | t1_c2lqjpx | t1_c2lqdxt | null | 1427632372 | 1 | t5_2fwo | null | null | null |
True | Timmmmbob | null | I use ii, jj, etc. in matlab because i is the imaginary unit. | null | 0 | 1316694290 | False | 0 | c2lqjuh | t3_klhlv | null | t1_c2lqjuh | t1_c2l938z | null | 1427632368 | 1 | t5_2fwo | null | null | null |
True | i_ate_god | null | hehe, GPL is anti freedom. | null | 0 | 1316694324 | False | 0 | c2lqjxb | t3_klphp | null | t1_c2lqjxb | t1_c2lifz7 | null | 1427632368 | 1 | t5_2fwo | null | null | null |
True | Objectivetruth1 | null | I took this course before actually taking Intro to CompSci at my current University and it was great. really wish I had David Malan as my prof here.
I also love the "hacker edition" concept he has for the course. More profs should emulate this | null | 0 | 1316694417 | False | 0 | c2lqk65 | t3_kn9fk | null | t1_c2lqk65 | t1_c2lnmsz | null | 1427632371 | 4 | t5_2fwo | null | null | null |
True | GTChessplayer | null | No, see, 1) There's Nobel Prize winning research to support this. 2) What's the difference if we're "subjugated" by the rich or subjugated by bureaucrats who want to pass laws such as the Patriot Act and FISA bills?
At least with businesses, we can just not buy their product. With government, there's nothing we can do.
It's funny how pseudo-intellectuals like you will castigate fundies for not believing in evolution and instead are brainwashed to follow religion, but you are brainwashed into believing the government will save you, despite their gross distortions at every corner. Oh yeah, and you're ignoring all the evidence that supports it. | null | 0 | 1316694610 | False | 0 | c2lqkmp | t3_klqte | null | t1_c2lqkmp | t1_c2lpeck | null | 1427632376 | 0 | t5_2fwo | null | null | null |
True | AxiomShell | null | If you are referring to the name *Lithp* ,yes, it is mildly amusing.
Don't know why the downvotes. | null | 0 | 1316694876 | False | 0 | c2lql9m | t3_knafe | null | t1_c2lql9m | t1_c2lmmoo | null | 1427632384 | 4 | t5_2fwo | null | null | null |
True | MarshallBanana | null | "Massive hostility"?
Man, you're kind of nuts, you know that? | null | 0 | 1316695067 | False | 0 | c2lqlqq | t3_kl7h0 | null | t1_c2lqlqq | t1_c2lqj6a | null | 1427632390 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | >"Massive hostility"?
Yes massive hostility. | null | 0 | 1316695251 | False | 0 | c2lqm7i | t3_kl7h0 | null | t1_c2lqm7i | t1_c2lqlqq | null | 1427632397 | 0 | t5_2fwo | null | null | null |
True | axilmar | null | Sure, I understand that. But this delay already exists as databases are now. So I do not see how automatic indexing will create a different problem than today.
| null | 0 | 1316695419 | False | 0 | c2lqmmc | t3_kmp73 | null | t1_c2lqmmc | t1_c2lqimc | null | 1427632402 | 1 | t5_2fwo | null | null | null |
True | khafra | null | If you want to be somebody else
If you're tired of fighting battles with yourself
If you want to be somebody else
Download this software | null | 0 | 1316695500 | False | 0 | c2lqmt6 | t3_kmref | null | t1_c2lqmt6 | t3_kmref | null | 1427632403 | 1 | t5_2fwo | null | null | null |
True | pbewig | null | I [wrote an implementation of treaps](http://programmingpraxis.com/2009/06/26/treaps/) at my blog. | null | 0 | 1316695565 | False | 0 | c2lqmyx | t3_kn9gt | null | t1_c2lqmyx | t3_kn9gt | null | 1427632406 | 5 | t5_2fwo | null | null | null |
True | axilmar | null | I think that indexing can be automated to a large degree, based on runtime time and space statistics. It could be optionally turned off, if problems are observed. But for the majority of cases, it would work.
| null | 0 | 1316695582 | False | 0 | c2lqn0a | t3_kmp73 | null | t1_c2lqn0a | t1_c2lqfz0 | null | 1427632407 | 1 | t5_2fwo | null | null | null |
True | ethraax | null | I highly suspect that most of that 4.9% is running Windows 2000, which as I said earlier is still vulnerable. Remember that Windows underwent significant changes under the hood between Windows 98 and Windows 2000. | null | 0 | 1316695803 | False | 0 | c2lqnl2 | t3_kmshh | null | t1_c2lqnl2 | t1_c2lp8tb | null | 1427632414 | 2 | t5_2fwo | null | null | null |
True | Peaker | null | > Don't you have to cast ptr to char* before you subtract the offset? Or am I missing something here?
Oops, thanks, corrected. (Macro was written off top of my head).
> 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.
Yes, it has some disadvantages. But it also has significant advantages. It can be in multiple data structures without a problem, and you have O(1) access to the "iterator" you need. For example, if it is in multiple lists, and you want to delete it from some of them, it can be done in O(1) for each list.
> 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).
True. It is possible to make it slightly safer, using a macro that defines a list anchor that is "typed" over the type of nodes in the list. You can do so by having the macro define a list node alongside an array of 0 nodes. Then you can have your list/downcast macros verify the type of the nodes is the same as the type of the array.
In any case, having practical experience using these kinds of lists and data structures for years, I've rarely encountered wrong downcasts. The few wrong casts I did encounter were casting down the list anchor (also a "struct list") to the node type (where they don't actually have a node type around them).
> 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).
Sure:
* No need for explicit allocations. Inserting the list nodes into the higher data structure means that the allocations become the "caller's problem". It doesn't actually burden the caller, because it already needs to allocate his data nodes anyway.
* No allocations -> No failure modes. It is amazing how many error-code/exception-returning functions become void functions when allocations are not needed. This saves you from needing to test a huge amount of potential errors. In C, it also saves the error-code-handling boilerplate. In C++, it saves you from most of the exceptions you might get and need to test for. Also, this means you're allowed to do more things in e.g: destructors which cannot re-throw exceptions.
* No extra indirections. A templated list can avoid an extra indirection too, if the node type is in *exactly one list*. If you want to put your node in a list, red black tree, and more structures simultaneously, then only one of the templated data structures can "own" the data. The others have to point at it. This indirection will cause each node to hit 2 cache lines rather than one, which can be a noticeable runtime penalty. It also adds the cost of a pointer (4 or 8 bytes) for each node. In the software I currently work with, this overhead is pretty large (we work with very large data structures).
* As I said above, when your list nodes are defined in your data structure, it effectively becomes like a valid STL iterator into the data structure, allowing O(1) access to operations on it. If your node is in multiple templated data structures, you're going to need to point back at each of the "nodes" of the various data structures. That incurs a significant storage and cache penalty on your node type.
| null | 0 | 1316695925 | False | 0 | c2lqnws | t3_klphp | null | t1_c2lqnws | t1_c2lq0cj | null | 1427632419 | 2 | t5_2fwo | null | null | null |
True | stusmith | null | Half of these could be caught in a static language with:
-Wall -Wextra
Perhaps the choice of language isn't mixing so well with the desire for checking everything statically? | null | 0 | 1316696011 | False | 0 | c2lqo52 | t3_kmk56 | null | t1_c2lqo52 | t3_kmk56 | null | 1427632422 | 5 | t5_2fwo | null | null | null |
True | grokfail | null | But without a type prefix, how do you know that it is an integer?
int m_i_cnt_ds = 0;
| null | 0 | 1316696187 | False | 0 | c2lqoni | t3_kmk56 | null | t1_c2lqoni | t1_c2lnglo | null | 1427632428 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | > Don't **tar** us all with the same brush.
Can we **grep** you if we ask politely? Or will you tell us to **git** out of here? | null | 0 | 1316696202 | False | 0 | c2lqooz | t3_kmshh | null | t1_c2lqooz | t1_c2lkydr | null | 1427632429 | -3 | t5_2fwo | null | null | null |
True | pedrocr | null | Isn't C a functional language by that definition? | null | 0 | 1316696315 | False | 0 | c2lqp0v | t3_kn9gt | null | t1_c2lqp0v | t1_c2lprbd | null | 1427632434 | 3 | t5_2fwo | null | null | null |
True | curien | null | Because today, there *wouldn't be an index* in this case because the DBA wouldn't have created it. With automatic indexing, the DBA will have to figure out that the automatically-created index is slowing down the state-changing queries and manually disable it.
That said, kiddikiddi's complaint only applies to a pretty naive or overly-aggressive index-auto-creation strategy. | null | 0 | 1316696577 | False | 0 | c2lqprr | t3_kmp73 | null | t1_c2lqprr | t1_c2lqmmc | null | 1428193481 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316696601 | False | 0 | c2lqpty | t3_knhd2 | null | t1_c2lqpty | t1_c2lps7z | null | 1428193481 | -6 | t5_2fwo | null | null | null |
True | Poita_ | null | They can, but I think what he means is some kind of object that needs to be constructed over time, but then is immutable afterwards.
D doesn't directly support this (I think Clojure does with its trasients), but you can safely cast it to an immutable(T) once you know it will be immutable. Of course, you need to *ensure* that it never changes after that point. | null | 0 | 1316696602 | False | 0 | c2lqpu5 | t3_knn5p | null | t1_c2lqpu5 | t1_c2lqjkg | null | 1427632444 | 5 | t5_2fwo | null | null | null |
True | behrangsa | null | It says the preferred way to build is to use Maven. | null | 0 | 1316696658 | False | 0 | c2lqq09 | t3_kmygn | null | t1_c2lqq09 | t1_c2lovit | null | 1427632447 | 0 | t5_2fwo | null | null | null |
True | axilmar | null | > With automatic indexing, the DBA will have to figure out that the automatically-created index is slowing down the state-changing queries and manually disable it.
The computer could easily do that. By keeping statistics of operations, the computer would optimize operations and indexing.
| null | 0 | 1316696953 | False | 0 | c2lqqwz | t3_kmp73 | null | t1_c2lqqwz | t1_c2lqprr | null | 1427632459 | 1 | t5_2fwo | null | null | null |
True | disidentadvisor | null | Most I was able to get down to a swift run time but I remember one notorious problem that would require dynamic programming to significantly improve it. I believe it asked for ways to make change for a few English pound.
I totally agree with your advice and have saved all the original answers with the intent to return and optimize them. | null | 0 | 1316697220 | False | 0 | c2lqrrj | t3_kn9fk | null | t1_c2lqrrj | t1_c2lqew2 | null | 1427632469 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | > And no query optimizer will recognize all such instances, because that is an undecidable problem.
I'm not sure that this is correct.
There are two problems:
1) For any query construct some kind of a normal form, thus partitioning queries into equivalence classes. Which have a property that for every two equivalence classes there exists a dataset on which they produce different results.
2) For a query in a normal form construct an optimal execution plan (for a particular dataset).
I wouldn't bet my head on it, but I'm pretty sure that if you limit yourself to pure relational algebra, (1) is not only decidable, but relatively straightforward. (2), on the other hand, is very hard, especially in impure systems (for example, with stored procedures), so real RDBMSs don't go all the way in (1), to allow the person who made a query to affect results by reformulating it. But they still go much, much farther than any existing functional language implementations. | null | 0 | 1316697242 | False | 0 | c2lqrtq | t3_kmp73 | null | t1_c2lqrtq | t1_c2lqjlo | null | 1427632469 | 1 | t5_2fwo | null | null | null |
True | disidentadvisor | null | Oh, and as a side note, just used scratch for the first time and love the idea. It seems like a great way to introduce kids to programming without initially overwhelming them. Obviously, they will want to learn a real language when they are able if they enjoy the first taste with scratch. | null | 0 | 1316697300 | False | 0 | c2lqrzw | t3_kn9fk | null | t1_c2lqrzw | t1_c2lqrrj | null | 1427632472 | 3 | t5_2fwo | null | null | null |
True | metl_lord | null | [Give it time.](http://www.cin.ufpe.br/~haskell/haskelldotnet/) | null | 0 | 1316697413 | False | 0 | c2lqsbo | t3_khtuh | null | t1_c2lqsbo | t1_c2l9zj1 | null | 1427632476 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | The title is sensational and misleading. | null | 0 | 1316697440 | False | 0 | c2lqseh | t3_knv14 | null | t1_c2lqseh | t3_knv14 | null | 1427632477 | 6 | t5_2fwo | null | null | null |
True | RoboMind | null | I think it is very similar to [skip lists](http://en.wikipedia.org/wiki/Skip_list) | null | 0 | 1316697507 | False | 0 | c2lqslf | t3_kn9gt | null | t1_c2lqslf | t3_kn9gt | null | 1427632480 | 2 | t5_2fwo | null | null | null |
True | pnpbios | null | > It's been several years since Oracle (previously Sun) stopped providing support for the open source Java3D projects. It was decided that keeping binaries signed with old Sun signing certificates represented a potential security risk, and because of this, we have removed the old Sun signing certificates for the binaries on download.java.net. | null | 0 | 1316697814 | False | 0 | c2lqtkc | t3_knv14 | null | t1_c2lqtkc | t3_knv14 | null | 1427632494 | 6 | t5_2fwo | null | null | null |
True | curien | null | The DBMS has no way to determine the relative time-criticality of the various queries. If adding an index speeds up query A dramatically but slows down query B a little bit, no amount of statistics gathered by the DBMS can tell it that no one cares how fast query A runs, but we care greatly how fast query B runs. Sure, we could add a mechanism to tell it, but that adds even more complexity to an already complex system and takes more work than just creating the index manually in the first place. | null | 0 | 1316698075 | False | 0 | c2lquct | t3_kmp73 | null | t1_c2lquct | t1_c2lqqwz | null | 1427632514 | 2 | t5_2fwo | null | null | null |
True | grokfail | null | Rather than writing a comment for a non-obvious piece of code, how about refactoring it so that the intent of the code is clear. Moving conditions and tests into methods and giving them meaningful names seems a better choice. | null | 0 | 1316698142 | False | 0 | c2lquk3 | t3_kmk56 | null | t1_c2lquk3 | t1_c2llhbf | null | 1427632509 | 3 | t5_2fwo | null | null | null |
True | julesjacobs | null | Problem (1) is not decidable for SQL (which is what your claim was about). Solving Diophantine equations is undecidable. You can easily encode them into SQL, so equivalence of SQL expressions is undecidable. Whether the problem is decidable for pure relational algebra perhaps depends on what you want to include in it. Most problems of the form "is expression X equivalent to expression Y" are undecidable for most languages. So your claim that it is decidable for relational algebra is surprising and definitely needs proof. Do you have a reference to a paper that proves this claim?
In any case the problem is trivially undecidable for Prolog because it is Turing complete. Note that a language doesn't have to be very expressive for equivalence to be undecidable. For example equivalence for context free grammars is already undecidable. | null | 0 | 1316698291 | False | 0 | c2lqv2j | t3_kmp73 | null | t1_c2lqv2j | t1_c2lqrtq | null | 1427632515 | 2 | t5_2fwo | null | null | null |
True | archiminos | null | Just makes me think of [this](http://xkcd.com/927/) | null | 0 | 1316698552 | False | 0 | c2lqvxs | t3_knsss | null | t1_c2lqvxs | t3_knsss | null | 1427632525 | 1 | t5_2fwo | null | null | null |
True | lessthan_i | null | Yea ok. I've never worked much with the LAMP stack as a professional. It's all been enterpricy stuff based on Microsoft and Java stuff | null | 0 | 1316698883 | False | 0 | c2lqx1h | t3_kmpyi | null | t1_c2lqx1h | t1_c2lm8fb | null | 1427632538 | 5 | t5_2fwo | null | null | null |
True | simonask | null | Won't a const pointer initialized to a non-const value still point to the same object, which can then still be modified by holders of the non-const version of the pointer? (I ask because I don't know, I'm not familiar with D.) | null | 0 | 1316698949 | False | 0 | c2lqxas | t3_knn5p | null | t1_c2lqxas | t1_c2lqpu5 | null | 1427632541 | 5 | t5_2fwo | null | null | null |
True | terrapinbear | null | I upvoted you. | null | 0 | 1316699324 | False | 0 | c2lqynw | t3_kmp75 | null | t1_c2lqynw | t1_c2ln15g | null | 1427632559 | 0 | t5_2fwo | null | null | null |
True | mikaelhg | null | With an agenda. | null | 0 | 1316699361 | False | 0 | c2lqyss | t3_kmpyi | null | t1_c2lqyss | t1_c2lmkjo | null | 1427632561 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | > generas
*Really?* I think you mean **genres**. | null | 0 | 1316699474 | False | 0 | c2lqz8a | t3_knoub | null | t1_c2lqz8a | t3_knoub | null | 1427632566 | 4 | t5_2fwo | null | null | null |
True | terrapinbear | null | Blender 3D has a visual game programming system. | null | 0 | 1316699480 | False | 0 | c2lqz9a | t3_kmp75 | null | t1_c2lqz9a | t3_kmp75 | null | 1427632572 | 1 | t5_2fwo | null | null | null |
True | Saivo | null | i do not fully disagree with what you state, i am probably a bit traumatized with java. I got very annoyed when coding android, but enjoy doing quite java-like c#. Still, cant really cook up an exact argument as for my java-hatred, and am not willing to spend any more time introspecting for the purpose of this thread.
As for my programming skills, i will let my peers decide. I've been programming since i was 8, and for the past 10 years somebody has even bothered to pay me quite nicely, so my code is probably more precisely "tolerable" rather than "poor". | null | 0 | 1316699789 | False | 0 | c2lr0dh | t3_kgq62 | null | t1_c2lr0dh | t1_c2kqnfc | null | 1427632582 | 0 | t5_2fwo | null | null | null |
True | julesjacobs | null | That doesn't give you the same power as Ruby's monkey patching because the implicit conversion for .quadruple is looked up statically instead of dynamically. With Ruby's monkey patching you can add dynamically dispatched methods. For example say you have a Foo class with subclasses Bar and Baz. Now you can add a method that behaves differently for Bar and Baz:
class Bar
def quadruple; return 3; end
end
class Baz
def quadruple; return 4; end
end
arr = [Bar.new, Baz.new].map{|x| x.quadruple}
I.e. Ruby's monkey patched methods are real methods, Scala's methods added via implicit conversions act different than normal methods in complicated and confusing ways. | null | 0 | 1316699799 | False | 0 | c2lr0fl | t3_kmshh | null | t1_c2lr0fl | t1_c2llmu7 | null | 1427632582 | 0 | t5_2fwo | null | null | null |
True | nodemo | null | FixTheBackgroundGradientInFuckingShitIE()
Does some magic removals and appendchilds to some dom-elements get consistent behavior with other browsers. Nobody knows why or how it works or why it's required at all but it is. | null | 0 | 1316700302 | False | 0 | c2lr2a2 | t3_klhlv | null | t1_c2lr2a2 | t3_klhlv | null | 1427632607 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316700375 | False | 0 | c2lr2jv | t3_knvv4 | null | t1_c2lr2jv | t3_knvv4 | null | 1427632621 | 0 | t5_2fwo | null | null | null |
True | 8-bit_d-boy | null | there was another project that ported some library, whose name had something to do with pie, to ruby, so they called the project "Red Carpet". | null | 0 | 1316700517 | False | 0 | c2lr33b | t3_knafe | null | t1_c2lr33b | t1_c2lql9m | null | 1427632630 | 1 | t5_2fwo | null | null | null |
True | tragomaskhalos | null | Microsoft / .NET is not even *mentioned* here. So much for objectivity.
| null | 0 | 1316700656 | False | 0 | c2lr3mq | t3_kn8ra | null | t1_c2lr3mq | t3_kn8ra | null | 1428193477 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | Ooops, you are right, it turns out that we are not allowed to use set difference if we want decidability (if I understood it correctly). Interesting. | null | 0 | 1316700766 | False | 0 | c2lr41t | t3_kmp73 | null | t1_c2lr41t | t1_c2lqv2j | null | 1427632639 | 1 | t5_2fwo | null | null | null |
True | CallMemaJiC | null | Thank you very much. I wanted to start venturing into programming, and since all I know is some web programming this seems the perfect start. Again, thank you! | null | 0 | 1316700914 | False | 0 | c2lr4nc | t3_kn9fk | null | t1_c2lr4nc | t3_kn9fk | null | 1427632645 | 1 | t5_2fwo | null | null | null |
True | frymaster | null | >So that's what Windows people do instead of LD_PRELOAD! I had been wondering.
as mentioned in the comments for the article, this is an OS internal feature, not something users, sysadmins, application writers, or driver writers should ever be using. | null | 0 | 1316701143 | False | 0 | c2lr5jv | t3_kmshh | null | t1_c2lr5jv | t1_c2ln353 | null | 1427632650 | 2 | t5_2fwo | null | null | null |
True | fla-guy | null | outstanding paper some of the stuff I have wondered about the rest I had not even considered | null | 0 | 1316701226 | False | 0 | c2lr5vs | t3_knua7 | null | t1_c2lr5vs | t3_knua7 | null | 1427632654 | 5 | t5_2fwo | null | null | null |
True | ChaosMotor | null | Hey smart ass -
>Venture capitalists and angels all have an internal switch that can flip in a meeting with an entrepreneur. Something gets said that marks the entrepreneur as simply too green to invest in. ***Maybe the entrepreneur asks the VC to sign a non-disclosure agreement***, or they introduce the CFO, who also happens to be their grandma. ***Call it the amateur alarm.***
http://www.boston.com/business/technology/innoeco/2011/09/what_can_an_entrepreneur_say_i.html
God, you know *so much* about seeking investment! | null | 0 | 1316701355 | False | 0 | c2lr6ff | t3_klqte | null | t1_c2lr6ff | t1_c2lj8nv | null | 1427632660 | 0 | t5_2fwo | null | null | null |
True | mhd420 | null | This is a pretty neat article, but fucking hell that graph API syntax is atrocious. | null | 0 | 1316701382 | False | 0 | c2lr6jd | t3_knoub | null | t1_c2lr6jd | t3_knoub | null | 1427632661 | 2 | t5_2fwo | null | null | null |
True | ysangkok | null | That awkward dude at the end reminds me of myself. :P | null | 0 | 1316701494 | False | 0 | c2lr70e | t3_kn9fk | null | t1_c2lr70e | t3_kn9fk | null | 1427632668 | 1 | t5_2fwo | null | null | null |
True | fruitloop | null | Honestly I wasn't a fan of the lecture.....pretty cool though. I think this sort of thing is going to be come a trend, just like how stanford offered AI to everyone this fall. | null | 0 | 1316701805 | False | 0 | c2lr8ao | t3_kn9fk | null | t1_c2lr8ao | t3_kn9fk | null | 1427632694 | 1 | t5_2fwo | null | null | null |
True | woonie | null | "I saw you walking around at the CS50 Fair with a nametag saying you were in the class.
You are smart and adorable and all this time I thought you were dumb and adorable.
You just became so much hotter."
what. | null | 0 | 1316702074 | False | 0 | c2lr9hd | t3_kn9fk | null | t1_c2lr9hd | t3_kn9fk | null | 1427632700 | 1 | t5_2fwo | null | null | null |
True | Justananomaly | null | sudo git install godeeper | null | 0 | 1316702079 | False | 0 | c2lr9i0 | t3_knhd2 | null | t1_c2lr9i0 | t1_c2lqpty | null | 1427632700 | -3 | t5_2fwo | null | null | null |
True | KingEllis | null | I think you are hanging out with the wrong crowd... | null | 0 | 1316702091 | False | 0 | c2lr9k2 | t3_knafe | null | t1_c2lr9k2 | t1_c2lo9ig | null | 1427632701 | 6 | t5_2fwo | null | null | null |
True | stonefarfalle | null | >How is the database ever going to be able to determine what the most common cases are.
Yeah, however will the database determine what queries you run on your database? Vacum on postgres already updates statistics that directly impact query plans. I don't see why it couldn't also suggest indexes or implement them itself. | null | 0 | 1316702193 | False | 0 | c2lra07 | t3_kmp73 | null | t1_c2lra07 | t1_c2lhx10 | null | 1427632707 | 1 | t5_2fwo | null | null | null |
True | methical | null | >Error
>Something is wrong.
>
>Please be patient while things are resolved.
Is this supposed to be a joke or something like that? :) | null | 0 | 1316702458 | False | 0 | c2lrb3n | t3_knua7 | null | t1_c2lrb3n | t3_knua7 | null | 1427632721 | 3 | t5_2fwo | null | null | null |
True | jsully | null | The application he's running might need to expose some functionality to the Internet so users can access it, or so it can process data. If it's a webapp, he may be stuck running IIS 1.0, and in that instance you can't really firewall it. | null | 0 | 1316702508 | False | 0 | c2lrbbb | t3_kmshh | null | t1_c2lrbbb | t1_c2lqdxt | null | 1427632725 | 1 | t5_2fwo | null | null | null |
True | badassumption | null | > However it is random, so some analysis of how much better treaps behave compared to other random balanced trees. It's very easy to create a balanced tree based on random insertion.
As far as I can tell, this should create a tree with properties identical to what you would get by just doing random insertion with no rebalancing. | null | 0 | 1316702520 | False | 0 | c2lrbd2 | t3_kn9gt | null | t1_c2lrbd2 | t1_c2lp24f | null | 1427632726 | 1 | t5_2fwo | null | null | null |
True | PstScrpt | null | You only need indexes to go with foreign keys if you're going to be deleting rows or updating primary key values in the referenced table. Those should both be very rare actions. | null | 0 | 1316702555 | False | 0 | c2lrbih | t3_kmp73 | null | t1_c2lrbih | t1_c2libjs | null | 1427632727 | 1 | t5_2fwo | null | null | null |
True | axilmar | null | But in most cases, there is no need to manage speeds of queries like that.
Even if we really wanted to make query B faster than A, adding a priority to B is easier than adding one or more indexes to it.
| null | 0 | 1316702925 | False | 0 | c2lrd5z | t3_kmp73 | null | t1_c2lrd5z | t1_c2lquct | null | 1427632749 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | lol javascript. toy scripting language. | null | 0 | 1316703048 | False | 0 | c2lrdpp | t3_knrh2 | null | t1_c2lrdpp | t3_knrh2 | null | 1427632756 | -3 | t5_2fwo | null | null | null |
True | [deleted] | null | With full speed to idiocracy. Nowadays the knowledge to read HTTP headers is enough to warrant a technical job.
also: not programming. | null | 0 | 1316703277 | False | 0 | c2lresd | t3_kmevq | null | t1_c2lresd | t3_kmevq | null | 1427632771 | -5 | t5_2fwo | null | null | null |
True | safe_work_for_naught | null | upButt.pop()->pinkSock(); | null | 0 | 1316703390 | False | 0 | c2lrfal | t3_klhlv | null | t1_c2lrfal | t1_c2l8724 | null | 1427632776 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Because the world is app stores and shiny UIs ... | null | 0 | 1316703414 | False | 0 | c2lrfec | t3_klgme | null | t1_c2lrfec | t1_c2lcr4t | null | 1427632778 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Yes. Here's the sort of thing I'm thinking of. Pardon my lousy D; I only ever sort of knew the language, and it's been a while.
abstract class List(T) {
abstract virtual bool isEmpty () const;
abstract virtual T head () const;
abstract virtual List!T tail () const;
private final class Nil: List!T {
override bool isEmpty() const { return true; }
override T head () const { throw /* a relevant exception*/ }
override List!T tail () const { throw /* that same exception */ }
private final class Cons: List!T {
immutable T head_;
List!T tail_; // not immutable here for a reason
this(T h, List!T t) { head_ = h; tail_ = t; }
override bool isEmpty() const { return false; }
override T head () const { return head_ }
override List!T tail () const { return tail_ }
}
static immutable Nil nil = new Nil();
static List!T makeFromArray(T[] array) {
if (array.length == 0) { return nil; }
List!T result = new Cons(array[0], nil);
List!T end = result;
for (int i = 1; i < array.length; ++i) {
end.tail_ = new Cons(array[i], nil);
end = end.tail_;
}
return result;
}
}
Now, due to the fact that all the mutability in `Cons` is private, I'd like to be able to return a `List!T` as something immutable, but as I understand it, this means I need a cast, and I'm not sure what the implications of that cast are (in terms of whether I can mark things safe, or even whether the behavior is defined according to the spec). | null | 0 | 1316703484 | False | 0 | c2lrfpm | t3_knn5p | null | t1_c2lrfpm | t1_c2lqpu5 | null | 1427632782 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | > The question is, why?
Because there are applications where you can't have some VM sitting between you and the hardware. Try anything that needs to process a fuckload of data in near realtime.
C# is nice for database front ends but that's pretty much about it. | null | 0 | 1316703533 | False | 0 | c2lrfxn | t3_klgme | null | t1_c2lrfxn | t1_c2lmwl0 | null | 1427632785 | 0 | t5_2fwo | null | null | null |
True | elima | null | The certificate has been upgraded. It should be now trusted by Firefox.
Thanks a lot for reporting it! | null | 0 | 1316703580 | False | 0 | c2lrg6f | t3_kmmgx | null | t1_c2lrg6f | t1_c2lklou | null | 1427632789 | 5 | t5_2fwo | null | null | null |
True | julesjacobs | null | HTML5? | null | 0 | 1316703625 | False | 0 | c2lrgdx | t3_kn8ra | null | t1_c2lrgdx | t1_c2lpyo3 | null | 1427632792 | 9 | t5_2fwo | null | null | null |
True | rizla7 | null | rofl. some people oughta have their head checked. go watch the BUILD developer conference if you're actually a dev. if not, stfu already. | null | 0 | 1316703840 | False | 0 | c2lrhdi | t3_kmh5r | null | t1_c2lrhdi | t3_kmh5r | null | 1427632804 | 1 | t5_2fwo | null | null | null |
True | gonemad16 | null | i love movies based on graphs | null | 0 | 1316703897 | False | 0 | c2lrhmw | t3_knoub | null | t1_c2lrhmw | t3_knoub | null | 1427632808 | 10 | t5_2fwo | null | null | null |
True | stacks85 | null | http://www.amazon.com/Windows%C2%AE-Internals-Including-Windows-Developer/dp/0735625301
any book from this series, it doesn't have to be the latest. | null | 0 | 1316703971 | False | 0 | c2lrhzq | t3_kmshh | null | t1_c2lrhzq | t1_c2lkp13 | null | 1427632812 | 1 | t5_2fwo | null | null | null |
True | fjonk | null | > Yeah, however will the database determine what queries you run on your database?
It knows what queries I run, but not how important it is for them to be fast.
Of course the database can suggest indexes, but that has to be AFTER you put your product in production, so why not just use a separate tool to analyze a query log instead? I'm not saying you can't have a tool that suggests indexes, I'm saying that the database shouldn't/couldn't start adding/removing them itself, and definitely not in production.
Having the database analyze the queries in production has a number of disadvantages.
* The suggestions must still be accepted by a developer.
* The same indexes must be used in development.
* You have no reliable data about speed to use when you talk to the client because you don't know how fast queries will be until the product is in production.
Anyways, I don't see the big deal with manually adding indexes. You can use tools to find indexes you forgot, you can use tools to profile queries etc, but what is the advantage of having the database do it for you? | null | 0 | 1316704273 | False | 0 | c2lrjfj | t3_kmp73 | null | t1_c2lrjfj | t1_c2lra07 | null | 1427632831 | 3 | t5_2fwo | null | null | null |
True | imphasing | null | Yet again, zero content. You must just be trolling.
Welcome to software development, where we mix components together to form the system that's required of us. Lots of things can go wrong in any dev environment, Mono doesn't increase that risk in the slightest.
Seriously, it's like using pypy vs Python 2.6. It's just another runtime and environment. Is your development world really so fragile that you can't cope with having components from multiple vendors in your systems?
All it takes is a little bit of knowledge, it's not like Mono is some black magic. It's just another CIL runtime that happens to have an apache module, do you even know what most .NET DLLs have inside them? It's almost never native code, I'll tell you that. There's no problem running .NET assemblies cross-platform, there's no platform specific code that goes into my assemblies, and if there is, then your shit's not going to be cross-platform like in any other language.
If you understand on even a basic level what the .NET environment is like, it's not hard to see the benefit of Mono and get started using it. It's a very mature and full-featured .NET runtime that also interfaces with the best web servers in the world. All you need to do is learn a little, which I guess is asking too much from some people. Don't be terrified of something just because you're ignorant of it, that's just stupid.
> It's just risky behavior for no gain.
Oh, because saving thousands of dollars per month on servers isn't a gain. Damn, good thing you told me bro. | null | 0 | 1316704287 | False | 0 | c2lrjie | t3_kgl4f | null | t1_c2lrjie | t1_c2lnl8n | null | 1427632832 | 3 | t5_2fwo | null | null | null |
True | gregK | null | I always say use the best language. | null | 0 | 1316705037 | False | 0 | c2lrn7l | t3_kn8ra | null | t1_c2lrn7l | t3_kn8ra | null | 1427632880 | 3 | t5_2fwo | null | null | null |
True | jaybee | null | That's in the source, not a header. | null | 0 | 1316705333 | False | 0 | c2lrope | t3_kmevq | null | t1_c2lrope | t1_c2ll8t9 | null | 1427632900 | 3 | t5_2fwo | null | null | null |
True | dsquid | null | We use Easyhook (http://easyhook.codeplex.com/) extensively in production. There are a number of excellent articles and discussions of hooking in the documentation pages on that site. | null | 0 | 1316705722 | False | 0 | c2lrqkt | t3_kmshh | null | t1_c2lrqkt | t1_c2lkp13 | null | 1427632926 | 2 | t5_2fwo | null | null | null |
True | nascent | null | > disabling the gc also disables the standard libraries and array facilities.
No it doesn't, it disables the GC collection cycle. Which means if you allocate on the GC it won't get collected until it is enabled.
The standard library does assume a working GC, but not all of it relies on such. There is talk/interest in a compiler switch to prevent use of the GC, which would be better then the current situation of allowing its use.
Also you are no worse off then any other C program. You'd loose many of the advantages D provides, but it is still a better than C if that is the route you wish to go.
> many things in D are awkwardly designed: bitfields, RAII, bit-blits of structs, etc.
There is still much work needed to be done to easily use D's advantages over C in a non-GC enviroment, such as RAII. I don't know what issue there is with bitfields though, or why you consider post-blitz awkward (I haven't used it and don't fully understand the problem it solves). | null | 0 | 1316705898 | False | 0 | c2lrri0 | t3_kljc0 | null | t1_c2lrri0 | t1_c2lhwei | null | 1427632938 | 2 | t5_2fwo | null | null | null |
True | dsquid | null | We hook other people's software to monitor its behavior and to layer functionality on top. Our target market is a large, established install base of a number of applications developed by other ISVs in the early 90's (!!) which are still in wide use today in industry.
We carefully study them and then do things like, for example, hooking TextOutA to observe what they're writing to the screen...combined with some relative positioning code it's pretty straightforward to know that "Oh, he's in state X because the app's hand-drawn status bar says Y"
It's definitely not the "best" way to approach this (wouldn't it be nice if everyone re-wrote their legacy apps with APIs?!) but if you want to add value to existing installations which are going nowhere fast (these setups typically cost $20-$30K each), hooking is the way.
Another canonical example is a pokerbot - see http://www.codingthewheel.com/archives/how-i-built-a-working-online-poker-bot-7 | null | 0 | 1316705922 | False | 0 | c2lrrlr | t3_kmshh | null | t1_c2lrrlr | t3_kmshh | null | 1427632940 | 1 | t5_2fwo | null | null | null |
True | LeftCorner | null | American Pie Chart still makes me laugh | null | 0 | 1316706306 | False | 0 | c2lrtjb | t3_knoub | null | t1_c2lrtjb | t1_c2lrhmw | null | 1427632964 | 15 | t5_2fwo | null | null | null |
True | s73v3r | null | Blah blah blah blah, I think that anarcho-capitalism won't end up with an underclass that will be fucked over by the rich, and that companies won't just decide to do whatever the fuck they want, polluting the fuck out of our environment and eliminating what little worker's rights we have now.
>Oh yeah, and you're ignoring all the evidence that supports it.
Says the guy who believes in some magic system that has absolutely no evidence of ever working. | null | 0 | 1316706411 | False | 0 | c2lru2m | t3_klqte | null | t1_c2lru2m | t1_c2lqkmp | null | 1427632971 | 1 | t5_2fwo | null | null | null |
True | axilmar | null | > No it doesn't, it disables the GC collection cycle. Which means if you allocate using on the GC it won't get collected until it is enabled.
According to [this](http://www.digitalmars.com/d/2.0/garbage.html), operations that involve the GC are:
* NewExpression
* Array appending
* Array concatenation
* Array literals (except when used to initialize static data)
* Associative array literals
* Any insertion, removal, or lookups in an associative array
* Extracting keys or values from an associative array
* Taking the address of (i.e. making a delegate) a nested function that accesses variables in an outer scope
* A function literal that access variables in an outer scope
* An AssertExpression that fails its condition
So all the above cannot be used when the GC is disabled.
So, if you don't want GC in your program, you are out of luck.
> Also you are no worse off then any other C program. You'd loose many of the advantages D provides, but it is still a better than C if that is the route you wish to go.
Yeah, better than C, worse than C++.
> don't know what issue there is with bitfields though
D 2.0 doesn't have bitfields. They can be done with macros, but they are ugly. It is also surprising, considering other things that can be done with libraries are part of the language specification.
> or why you consider post-blitz awkward (I haven't used it and don't fully understand the problem it solves).
It's awkward because it is one of the many things that are not orthogonal to the rest of the language.
In C++, we have a copy or move operation. In D, we have a copy operation, or a blit, depending on which kind of entity you use (class or struct). The concept is the same though; it just has different treatment in each case. Go figure.
| null | 0 | 1316706470 | False | 0 | c2lrue1 | t3_kljc0 | null | t1_c2lrue1 | t1_c2lrri0 | null | 1427632976 | 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.