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 | lolomfgkthxbai | null | Thank you for reminding me of Monday.
*shivers in horror* | null | 0 | 1316298578 | False | 0 | c2kmjlg | t3_ki83r | null | t1_c2kmjlg | t1_c2kkqec | null | 1427613183 | 3 | t5_2fwo | null | null | null |
True | _asterisk | null | Accents aren't necessarily Unicode though, they are represented in extended ASCII. | null | 0 | 1316298643 | True | 0 | c2kmjty | t3_kicbo | null | t1_c2kmjty | t1_c2kjnaq | null | 1427613186 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316298663 | False | 0 | c2kmjwk | t3_kg2sg | null | t1_c2kmjwk | t1_c2kid09 | null | 1427613186 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Thank you for your lengthy answer. That was very clear.
Not sure if I'm sold on the idea of structural typing though. If you need to add methods to your interface, but all those classes work fine without being updated to implement them, then maybe what you shouldn't be changing the original interface but creating a new one that extends it. Anyway, I have to admit I'm quite biased being used to haskell and its classes system. | null | 0 | 1316298780 | True | 0 | c2kmkbc | t3_kikut | null | t1_c2kmkbc | t1_c2kmgcr | null | 1427613193 | 3 | t5_2fwo | null | null | null |
True | seydar | null | One day you will understand.
| null | 0 | 1316298811 | False | 0 | c2kmkfz | t3_kh9sr | null | t1_c2kmkfz | t1_c2k8mgl | null | 1427613194 | 5 | t5_2fwo | null | null | null |
True | DontCallMeSurely | null | It's free and community produced. Stop complaining. | null | 0 | 1316298881 | False | 0 | c2kmkpw | t3_kgfhb | null | t1_c2kmkpw | t1_c2kangj | null | 1427613198 | 0 | t5_2fwo | null | null | null |
True | incrediblemojo | null | you couldn't be more wrong when you call musicality a mechanical ability. only a crude approximation can be taught or trained. emotion and musical expressiveness must be felt from within. mechanical ability is what enables the artist to express what is inside them, nothing more. | null | 0 | 1316299110 | False | 0 | c2kmljr | t3_khf6j | null | t1_c2kmljr | t1_c2kmjjj | null | 1427613209 | 2 | t5_2fwo | null | null | null |
True | simonask | null | Your question rests on the assumption that the parser needs to be aware what is a template argument and what is a function argument. It doesn't. Again, I don't know what the internal AST of any D compiler looks like, but `foo(...)(...)` is quite trivial to parse. | null | 0 | 1316299174 | False | 0 | c2kmltp | t3_kikut | null | t1_c2kmltp | t1_c2kmht8 | null | 1427613212 | 2 | t5_2fwo | null | null | null |
True | jyper | null | >Bram Moolenaar of the Vim Text Editor
FTFY | null | 0 | 1316299226 | False | 0 | c2kmm1a | t3_kgln6 | null | t1_c2kmm1a | t1_c2k9xti | null | 1427613215 | 2 | t5_2fwo | null | null | null |
True | simonask | null | What about them? They didn't make it into C++11. The reason they didn't is that it's questionable whether or not they were a worthwhile addition in their current form. | null | 0 | 1316299250 | False | 0 | c2kmm51 | t3_kikut | null | t1_c2kmm51 | t1_c2km9ny | null | 1427613216 | 3 | t5_2fwo | null | null | null |
True | CafeNero | null | I have to say this is tipping me over to Python, a poor video but some cool stuff. | null | 0 | 1316299327 | False | 0 | c2kmmgl | t3_khx5g | null | t1_c2kmmgl | t3_khx5g | null | 1427613220 | 5 | t5_2fwo | null | null | null |
True | Tordek | null | > > This leads naturally to another problem of ORM: inefficiency. When you fetch an object, which of its properties (columns in the table) do you need? ORM can't know, so it gets all of them
> Nope. SQLalchemy and even Hibernate fetches properties in a lazy way if you don't force it.
Uh, but... if it fetches lazily, it's "inefficient" when you ask for all of its properties. You end up doing a query per property, instead of a single join. | null | 0 | 1316299338 | False | 0 | c2kmmi9 | t3_ki83r | null | t1_c2kmmi9 | t1_c2kj17b | null | 1428193784 | 8 | t5_2fwo | null | null | null |
True | Steve132 | null | > Says who? There's more than enough information in there for the compiler to bind the default comparator at compile-time.
You are right, but if the compiler interpreted it that way it would crowd out the actual meaning of a default argument. C++ has a specific syntax for "runtime binding of a default argument". You can choose to say "When used it in a template, that syntax is not runtime but compile-time bound" which is fine but inconsistent and harder for compiler writers to implement correctly. Or, you could leave things consistent with the non-template version and it would be slower
>No. I realize that the names are currently mangled differently, but it's perfectly implementable to have specializations like so:
Nope, what you did there is valid C++, but it is an overloaded function not a specialization. Overloading and Specialization are two very different things, and need to have different syntax to allow the programmer to specify which one he wants Just like the first case, if you wanted you could say "Overloading == Specialization when foo is a template" but that would reduce consistency and require compiler writers to try to guess what was intended.
> A compiler could easily assume that it's a typename in the absence of other tokens. Consider:
void foo<T, int N>();
I actually agree with you there, but that wasn't the typename I was referring to. I was referring to
std::less<typename C::value_type>
becoming
std::less<C::value_type>
Pop quiz, without knowing anything about C, does the expression C::value_type refer to a member function, an inner class, an inner typedef, or a member function pointer or a static constant integer? Answer: You don't know, because it is impossible to know. | null | 0 | 1316299460 | False | 0 | c2kmn09 | t3_kikut | null | t1_c2kmn09 | t1_c2kkp0c | null | 1427613227 | -1 | t5_2fwo | null | null | null |
True | ekimt27 | null | You're not looking far enough to the future. People wont have a tablet and a laptop, they will have one that serves both functions; initially through docking stations, etc and eventually as just the hardware. Win 8 just seems like it'll help us blend the two. | null | 0 | 1316299461 | False | 0 | c2kmn0k | t3_kejwo | null | t1_c2kmn0k | t1_c2km9g3 | null | 1427613228 | 1 | t5_2fwo | null | null | null |
True | abreev8 | null | foo(...)(...) could mean either two function applications or one function application with template parameters in your syntax. How do you decide which it is?
I understand that this is usually decided in the parsing stage of a compiler. Please correct me if I'm wrong. | null | 0 | 1316299544 | False | 0 | c2kmncn | t3_kikut | null | t1_c2kmncn | t1_c2kmltp | null | 1427613232 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Because no one wants to download a 300mb (or whatever) video file. People want one-click in-browser streaming without having to delete some file after having watched the video.
Pretty darn obvious, but whatever. | null | 0 | 1316299609 | False | 0 | c2kmnlx | t3_kii9z | null | t1_c2kmnlx | t1_c2kkovc | null | 1427613236 | -6 | t5_2fwo | null | null | null |
True | [deleted] | null | Really stellar thinking there. This is why IT projects fail; "throw more hardware / expensive/fancy software at problem". Typical apathetic 9-to-5 .Net CRUD'in code monkeys who couldn't write an even remotely non-trivial library of their own if their lives depended on it; but it never does for these guys *anyway* of course, so no worries! | null | 0 | 1316299794 | True | 0 | c2kmodd | t3_kii9z | null | t1_c2kmodd | t1_c2kjd0e | null | 1427613247 | 0 | t5_2fwo | null | null | null |
True | kikaerter | null | The Constitution gives Congress the _power_ to establish patents, not the duty. | null | 0 | 1316299942 | False | 0 | c2kmoyb | t3_khvyw | null | t1_c2kmoyb | t1_c2khkeh | null | 1427613254 | 2 | t5_2fwo | null | null | null |
True | wtfisthat | null | That's.... awesome. | null | 0 | 1316299944 | False | 0 | c2kmoyo | t3_ki4ib | null | t1_c2kmoyo | t3_ki4ib | null | 1427613254 | 2 | t5_2fwo | null | null | null |
True | danharaj | null | So if I skimmed the post correctly, the author is finding elements of the symmetric group on n numbers that square to identity? | null | 0 | 1316300127 | True | 0 | c2kmppa | t3_kj03o | null | t1_c2kmppa | t3_kj03o | null | 1427613262 | 17 | t5_2fwo | null | null | null |
True | greyfade | null | If that were actually in the bill, those would be improvements, yes. But as I understand, only the joinder reform survived. | null | 0 | 1316300140 | False | 0 | c2kmpr7 | t3_khvyw | null | t1_c2kmpr7 | t1_c2klq6f | null | 1427613264 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Poor people of course, because all the "rich" people are non-fools.
</sarcasm> | null | 0 | 1316300183 | False | 0 | c2kmpxt | t3_kii9z | null | t1_c2kmpxt | t1_c2klydu | null | 1427613265 | 1 | t5_2fwo | null | null | null |
True | eramos | null | higher risk/higher rewards, but EV might still be the same | null | 0 | 1316300228 | False | 0 | c2kmq3y | t3_khx0u | null | t1_c2kmq3y | t1_c2kmhck | null | 1427613269 | 1 | t5_2fwo | null | null | null |
True | audaxxx | null | Yes, but you usually tell your database what you want and of course you need to tell it your ORM. Without that info your ORM can only guess and what it guesses depends on your lib and config. | null | 0 | 1316300287 | False | 0 | c2kmqca | t3_ki83r | null | t1_c2kmqca | t1_c2kmmi9 | null | 1427613271 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | It is. Fucking lying dipshits on this site. People can fuck off; Reddit in particular.
(..downloading is *not* an option in 2011; people want single-click streaming with no files left around on their computers afterwards..) | null | 0 | 1316300330 | False | 0 | c2kmqin | t3_kii9z | null | t1_c2kmqin | t1_c2kj7up | null | 1427613274 | -3 | t5_2fwo | null | null | null |
True | [deleted] | null | I was messing around with this idea recently, as to how compatible subtyping and genericity are. If you have a (compile-time) function that takes classes as arguments and outputs a class or function, isn't that generics?
I think the main incompatibility is that type inference is difficult with OOP. | null | 0 | 1316300346 | False | 0 | c2kmqkl | t3_kikut | null | t1_c2kmqkl | t1_c2kkxdc | null | 1427613275 | 1 | t5_2fwo | null | null | null |
True | Bamafan | null | > Uh, but... if it fetches lazily, it's "inefficient" when you ask for all of its properties. You end up doing a query per property, instead of a single join.
Great point and this brings up probably the single biggest issue with ORMs - newish/inexperienced devs who have zero idea what they don't know like the poster you quoted. | null | 0 | 1316300411 | False | 0 | c2kmqu7 | t3_ki83r | null | t1_c2kmqu7 | t1_c2kmmi9 | null | 1428193781 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | You're right. It is streaming; day_cq is an idiot. | null | 0 | 1316300432 | False | 0 | c2kmqx0 | t3_kii9z | null | t1_c2kmqx0 | t1_c2kktdw | null | 1427613288 | 2 | t5_2fwo | null | null | null |
True | Bamafan | null | Your response x 1000. Excellent, excellent points all the way through. | null | 0 | 1316300534 | False | 0 | c2kmrbn | t3_ki83r | null | t1_c2kmrbn | t1_c2kjf06 | null | 1427613287 | 2 | t5_2fwo | null | null | null |
True | danharaj | null | No. | null | 0 | 1316300554 | False | 0 | c2kmre4 | t3_kj10o | null | t1_c2kmre4 | t3_kj10o | null | 1427613288 | 2 | t5_2fwo | null | null | null |
True | seanbaxter | null | The NV cores aren't any more complex. The difference is that the VLIW4/5 components on ATI must all be utilized in a single instruction to get high utilization. This is possible when you're doing vec-4 register-register operations, but becomes difficult when you need to use shared memory for inter-thread communication, as on those cycles, most of the ALU hardware of the ATI's CU will go unutilized.
But this is all history, as the next-gen Southern Islands architecture abandons VLIW and uses a scalar architecture like NV. You'll see a reduction in theoretical arithmetic throughput (compared to what it VLIW4 could have done at 28nm) but an increase in utilization. | null | 0 | 1316300679 | False | 0 | c2kmrwg | t3_khryi | null | t1_c2kmrwg | t1_c2kk7gw | null | 1427613294 | 2 | t5_2fwo | null | null | null |
True | rosetta_stoned | null | > What evidence would you accept? A DivDev employee "I love Mono" tatoo on their forehead?
How about a quote, in writing, from a named official of Microsoft declaring that they intended .NET to be cross-platform?
> Clearly the amount of open source libraries Microsoft created and Mono now ships isn't enough evidence for you
How do these supposed libraries answer the question of whether MS intended .NET to be cross-platform?
> And you certainly don't care that the System.IO classes were specifically designed to be file system agnostic.
No, I don't care, because being file-system agnostic isn't the same thing as being cross-platform.
> If I told you that the Moonligh guys were given a copy of the Silverlight unit tests would you believe me? Or would you demand to see a press release?
Again, how does this answer the question of whether MS intended .NET to be cross-platform? They only gave the unit tests to the Moonlight developers after the MS-Novell GPL subversion pact was signed. It was sometime in 2008, I believe.
> Let's turn this around. How many people in DivDev have you talked to?
DivDev? Are you getting your cutesey widdle names all mixed-up? Perhaps MS, and you, should stop naming things as though you were writing for a children's book. I have, to my certain knowledge, never spoken to anyone at MS, and I see no reason to suppose that that will change, nor can I imagine any reason why I would want it to.
> Where is your evidence that Microsoft hates Mono?
The public utterances of named officials of Microsoft:
> “There is a substantive effort in open source to bring such an implementation of .Net to market, known as Mono and being driven by Novell, and one of the attributes of the agreement we made with Novell is that the *intellectual property associated with that is available to Novell customers*.” – Bob Muglia, Microsoft President
*Emphasis* is mine. Here no less a person than the president of the company warns people that Novell, and *only* Novell, through the agreement they signed, has the patent rights necessary to use and distribute Mono. Those are not the words of a minor flunky, and they are not the words of a man who intended that .NET should be cross-platform. At least, not without signing an agreement with MS and paying money.
It is clear that MS never intended that dot net would run on a non-Windows environment. When Mono came about, MS saw an opportunity to divide and conquer, and to subvert the intent of the GPL. Although Mono and Moonlight were released under free licenses, the patent protection did not extend unless one obtained the software from Novell, or one was "unpaid" for one's work. Worse, Moonlight's codecs were all proprietary, and because of their patents, one could only obtain them from MS and not distribute them. All of these are direct attacks upon everything that Free Software advocates hold dear. You can try to whitewash them all you want, but the truth is already on the web for all to see.
| null | 0 | 1316300770 | False | 0 | c2kms97 | t3_kgl4f | null | t1_c2kms97 | t1_c2kk75s | null | 1427613310 | 0 | t5_2fwo | null | null | null |
True | Bamafan | null | I mean an *object* association where the object is an enum rather than a class. Specifically in Hibernate (the ORM I'm most familiar with).
And yes, I agree it's pretty lame. I think most projects using Hibernate would be better off without it (long term). | null | 0 | 1316300797 | False | 0 | c2kmscy | t3_ki83r | null | t1_c2kmscy | t1_c2kj9ou | null | 1427613311 | 1 | t5_2fwo | null | null | null |
True | skew | null | The downvoted post was wondering about was the one where you included the line
> Haskell has null pointers, it just happens to express them via the Option monad.
then axmilar replied quoting that part and saying
> I wonder why you got downvoted. You spoke the truth.
to which you replied
> Because the fanboys don't actually understand their own language. They see the Option type as something magicial, not just a somewhat safer way to represent nulls. | null | 0 | 1316300831 | False | 0 | c2kmshj | t3_kfvm7 | null | t1_c2kmshj | t1_c2kk5y9 | null | 1427613305 | 1 | t5_2fwo | null | null | null |
True | AgentME | null | Nice try, Notch. | null | 0 | 1316300834 | False | 0 | c2kmshx | t3_kgq62 | null | t1_c2kmshx | t1_c2ka38z | null | 1428193779 | 1 | t5_2fwo | null | null | null |
True | Sc4Freak | null | It also defaults to HTML5 if you don't have Silverlight installed... | null | 0 | 1316300862 | False | 0 | c2kmslu | t3_kii9z | null | t1_c2kmslu | t1_c2kkovc | null | 1427613314 | 8 | t5_2fwo | null | null | null |
True | AlyoshaV | null | If I'm reading your post correctly, I have no idea what the author is doing. | null | 0 | 1316300897 | False | 0 | c2kmsqv | t3_kj03o | null | t1_c2kmsqv | t1_c2kmppa | null | 1427613313 | 28 | t5_2fwo | null | null | null |
True | [deleted] | null | First time installing VS? | null | 0 | 1316300924 | False | 0 | c2kmsus | t3_khtuh | null | t1_c2kmsus | t1_c2kkd8o | null | 1427613315 | 2 | t5_2fwo | null | null | null |
True | Bamafan | null | If you know the corner cases *from the beginning*, it wouldn't be an issue. But typically, you only know *after* the fact.
In a non-trivial app (say 70+ tables, with many bidirectional assocations of collections of objects) that's maintained over several years, the ORM typically *costs* you more time than saved in my experience. | null | 0 | 1316300987 | False | 0 | c2kmt3p | t3_ki83r | null | t1_c2kmt3p | t1_c2kj5lo | null | 1427613316 | 0 | t5_2fwo | null | null | null |
True | danharaj | null | You can think of a permutation as a *function* on a list of numbers (no repeats, no skips). So a permutation is not only such a list of numbers, but a function.
[1,2,3,4] is the same as the identity on a permutation of the numbers 1 to 4. [2,3,4,1] would be the one that sends 1st to 2nd, 2nd to 3rd, 3rd to 4th, and 4th to 1st in the list, making a new list.
A group is a set of objects with a binary operation that has an identity, is associative, and such that every element has an inverse. The set of permutation functions has these properties, so it's a group, called the symmetric group. The binary operation is function composition.
Some permutations when composed with themselves give you the identity. Seems like the blog post is trying to count them with code. | null | 0 | 1316301132 | False | 0 | c2kmtoy | t3_kj03o | null | t1_c2kmtoy | t1_c2kmsqv | null | 1427613320 | 14 | t5_2fwo | null | null | null |
True | angsty_geek | null | Yes, true, but most developers don't realize this. I see the same garbage code every day. Execute a query. Loop through a result set. Copy a row into an object. Etc.
You complain about it, and you get "I don't want to use an ORM. ORMs are bad." without any reasoning.
Or, you get someone who's idea of an ORM is Hibernate and 1000 XML files.
There is a middle ground.
| null | 0 | 1316301134 | False | 0 | c2kmtp9 | t3_ki83r | null | t1_c2kmtp9 | t1_c2klrhc | null | 1427613320 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316301226 | 1426106102 | 0 | c2kmu27 | t3_kitgf | null | t1_c2kmu27 | t3_kitgf | null | 1427613322 | 1 | t5_2fwo | null | null | null |
True | MathPuzzle | null | Yep, it's easy to check that the example the author gives is a product of transpositions: (15)(28)(37)(46). | null | 0 | 1316301546 | False | 0 | c2kmvcc | t3_kj03o | null | t1_c2kmvcc | t1_c2kmppa | null | 1427613335 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | Oh my god you're fucking crazy &#3232;\_&#3232;
| null | 0 | 1316301648 | False | 0 | c2kmvrl | t3_kicbo | null | t1_c2kmvrl | t1_c2kjpx8 | null | 1427613341 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | What is a "real" programming language?
Javascript is a code that is ran which informs the computer to execute a sequence of operations, no? | null | 0 | 1316301747 | False | 0 | c2kmw4t | t3_kicbo | null | t1_c2kmw4t | t1_c2kjd4l | null | 1427613346 | 0 | t5_2fwo | null | null | null |
True | Wolfspaw | null | Hm, you're right! With Symbola I can see them. | null | 0 | 1316301813 | False | 0 | c2kmwe3 | t3_kicbo | null | t1_c2kmwe3 | t1_c2klrn7 | null | 1427613349 | 1 | t5_2fwo | null | null | null |
True | bastawhiz | null | I think this is great. The biggest barrier for me to start with Arduino is that I have no background with electronics, even though I'm a strong programmer. I'd love something like this, but with support for loading up custom code on it. | null | 0 | 1316301877 | False | 0 | c2kmwmm | t3_kj1na | null | t1_c2kmwmm | t3_kj1na | null | 1427613352 | 8 | t5_2fwo | null | null | null |
True | anti_crastinator | null | I called it devstudio because that's how old I am. I've been using microsoft tools since before they called it visual c. We (EA) are currently using 2008 on a mix of machines. We're about to switch to 2010 - something I'm dreading as I've heard from other teams already switched that it's comparitively less stable!
It's got NOTHING to do with machines or configuration. Visual Studio is an unstable and bad development environment. I suspect that all the people disagreeing are doing so because they don't know how much better it is if you get used to good tools.
The compile/link/test cycle in visual studio, if it doesn't hang, on the game I'm currently working on is about 10 minutes. For the snsytems or gcc configs it's about 45 seconds. Microsofts ability to provide decent dependency calculation and non buggy incremental linking is pathetic. Couple that with the abomination which is intellisense (oh the irony) leaves it completely without doubt that it's a pile of steaming shit. | null | 0 | 1316301896 | True | 0 | c2kmwpd | t3_hudvd | null | t1_c2kmwpd | t1_c2klcmj | null | 1427613353 | 2 | t5_2fwo | null | null | null |
True | cyancynic | null | I'm more questioning his decision to take a massive chunk of JSON and turn it into Core Data objects. Pretty inefficient processing strategy and the parser is the least of his worries in that scenario. | null | 0 | 1316301954 | False | 0 | c2kmwxz | t3_kfirl | null | t1_c2kmwxz | t1_c2kjkui | null | 1427613356 | 1 | t5_2fwo | null | null | null |
True | yggdrasiliv | null | True, however most people who don't know what they are doing base it on length. | null | 0 | 1316302163 | False | 0 | c2kmxsx | t3_khf6j | null | t1_c2kmxsx | t1_c2kgmaq | null | 1427613367 | 1 | t5_2fwo | null | null | null |
True | sirin3 | null | keepassx | null | 0 | 1316302235 | False | 0 | c2kmy3l | t3_khtwb | null | t1_c2kmy3l | t1_c2kduqw | null | 1427613371 | 1 | t5_2fwo | null | null | null |
True | sausagemix | null | It didn't seem like they had HTML5 version of this one | null | 0 | 1316302401 | False | 0 | c2kmyrt | t3_kii9z | null | t1_c2kmyrt | t1_c2kmslu | null | 1427613381 | 1 | t5_2fwo | null | null | null |
True | evinrows | null | Like high school teachers? :) | null | 0 | 1316302423 | False | 0 | c2kmyv1 | t3_khf6j | null | t1_c2kmyv1 | t1_c2kmxsx | null | 1427613381 | 1 | t5_2fwo | null | null | null |
True | eruonna | null | Yup, they discovered inversion of permutations, then went looking for fixed points. | null | 0 | 1316302807 | False | 0 | c2kn0df | t3_kj03o | null | t1_c2kn0df | t1_c2kmppa | null | 1427613403 | 7 | t5_2fwo | null | null | null |
True | millstone | null | Looks like any major x86 platform. | null | 0 | 1316302962 | False | 0 | c2kn10m | t3_kitgf | null | t1_c2kn10m | t1_c2kmu27 | null | 1427613418 | 2 | t5_2fwo | null | null | null |
True | mistralol | null |
I know exactly what you mean. Code like. Open a database connection. Create an sql statements. Escape / AddParms for the sql statement. Execute the sql statement. Loop over the result set. Close the database connections. Repeat that for almost all data that is displayed. It a nice way for people to copy paste bugs across a system. Make it hard to log failing / slow sql statements.
I was spending a lot of time in c# / .net. In the interface code I think we wrote a maximum of 2 lines of code before data appeared on the web page :)
Something that a lot of people don't seem to pick up on is how to separate an application into manageable chunks and layers. Without a basic structure it just ends up as a bag of mess. Becomes hard to test. Hard to flush out bugs. Hard to understand and impossible to work on in an efficiently way
| null | 0 | 1316303236 | False | 0 | c2kn236 | t3_ki83r | null | t1_c2kn236 | t1_c2kmtp9 | null | 1427613425 | 1 | t5_2fwo | null | null | null |
True | TheSuperficial | null | Her own words: blah blah blah "without them having to write any code"
WTF does this have to do with programming? I develop firmware all day long, I get that there's firmware in the little modules, but my HDTV has a shitload more firmware in it - should I post HDTV links here too?
I'm not the guy to always say "computers != programming", quote "Some seem to think...", etc. but c'mon, this is just blatant promotion IMO.
This group deserves better. | null | 0 | 1316303634 | False | 0 | c2kn3oa | t3_kj1na | null | t1_c2kn3oa | t3_kj1na | null | 1427613444 | -3 | t5_2fwo | null | null | null |
True | zzing | null | I have met a guy that is implementing a functional programming language using C++ templates and is almost done. The joys of PhD work... | null | 0 | 1316303898 | False | 0 | c2kn4r7 | t3_kikut | null | t1_c2kn4r7 | t1_c2kjzyw | null | 1427613459 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316304084 | False | 0 | c2kn5j9 | t3_khkyd | null | t1_c2kn5j9 | t1_c2kd2t6 | null | 1427613471 | 1 | t5_2fwo | null | null | null |
True | Asians_and_cats | null | I think it is a good idea, but it is almost too simple to be expandable. I recently got an [arduino inventor kit](http://www.sparkfun.com/products/10173) and have found it to be very useful/cool. Last time I had something like this, it was a pic32 board and programming it in C was not anywhere close how easy it is to program these arduino boards. | null | 0 | 1316304261 | False | 0 | c2kn678 | t3_kj1na | null | t1_c2kn678 | t3_kj1na | null | 1427613488 | 5 | t5_2fwo | null | null | null |
True | 0xABADC0DA | null | You didn't answer any question so I guess you missed the point. If the programmer has to have the foresight to declare something an interface, then there's not much reason to have structural typing at all. | null | 0 | 1316304491 | False | 0 | c2kn758 | t3_kikut | null | t1_c2kn758 | t1_c2kmhmt | null | 1427613491 | 1 | t5_2fwo | null | null | null |
True | gfxlonghorn | null | It is a cool idea, but I feel like Lego implemented this much better with Mindstorms. | null | 0 | 1316304533 | False | 0 | c2kn7al | t3_kj1na | null | t1_c2kn7al | t3_kj1na | null | 1427613492 | 19 | t5_2fwo | null | null | null |
True | sketerpot | null | You can write the parts that need to be fast in C. JS is not always fast enough.
You can write in languages other than JavaScript. That's kind of a big deal for me.
You're not at the mercy of all the different JS engines when it comes to the speed of your programs. You know what instructions are going to be executed, and you don't have to worry about so many weird pathological cases.
You'll be able to use existing libraries for things. There's a lot of code out there that would be nice to be able to use in web apps, but you can't, because it's not in JavaScript. | null | 0 | 1316304657 | False | 0 | c2kn7rw | t3_kitgf | null | t1_c2kn7rw | t1_c2kmf7r | null | 1427613499 | 4 | t5_2fwo | null | null | null |
True | sketerpot | null | They also have an ARM version, and they're working on a portable version where the "binaries" are distributed in LLVM bytecode, and JIT compiled to native code. | null | 0 | 1316304732 | False | 0 | c2kn82e | t3_kitgf | null | t1_c2kn82e | t1_c2kn10m | null | 1427613503 | 4 | t5_2fwo | null | null | null |
True | Hyperian | null | I'd like to play with her little bits | null | 0 | 1316304856 | False | 0 | c2kn8kb | t3_kj1na | null | t1_c2kn8kb | t3_kj1na | null | 1427613509 | -12 | t5_2fwo | null | null | null |
True | andralex | null | A very nice piece indeed, and very eloquently put. Unfortunately, as it gets dangerously close to generic programming and Go's lack thereof, it painfully illustrates Go's insufficiencies as much as its fitness for the task at hand.
First off, one thing that may be non-obvious is that the description given is straight interface-based programming, in the grand tradition of Java. A Java programmer may as well implement the sort.Interface interface, or may write trivial boilerplate code that retrofits some class to implement it a la:
class Adaptor implements sort.Interface {
private MyCollection data_;
int Len() { return data_.length; }
bool Less(int i, int j) { return data_.at(i) < data_.at(j); }
void Swap(int i, int j) { data_.swapAt(i, j); }
}
Then MyCollection is effectively usable with sort() as described. To its credit, Go saves the programmer from writing such boilerplate code as long as the signatures match.
But the underlying problem is considerably deeper and far-reaching. The Heap example given with its use of interface{} is a good canary. sort() narrowly gets away with the interface as described at the price of conflating two distinct notions: that the collection being sorted offers random access, and that its elements are comparable for ordering. This works with sort and e.g. certain (but not all) flavors of partition because they're peculiar that way, but it will never scale to the multitude of algorithms, collections, and comparison functions out there.
Consider for example an algorithm as simple as functional map. The correct signature for map is generic - it takes a range of generic T and a function mapping generic T to generic U, and returns a range of generic U. Given a function and a range, Go is unable to express "I want to map this function to this range obtaining a different range". At best it could do so by using dynamic interfaces and casts, but that is awkward at the very best, not to mention utterly inefficient.
The list goes on and on. Go has severe difficulties in expressing swap, fold, filter, min, max, linear search with predicate (well pretty much anything with a predicate and most interesting higher-order functions), even lexicographical compare. Actually, the fact that Go works with sort and dijkstra without many contortions is more of the exception than the rule.
| null | 0 | 1316305427 | False | 0 | c2knaqk | t3_kikut | null | t1_c2knaqk | t1_c2kj75k | null | 1427613538 | 15 | t5_2fwo | null | null | null |
True | 74HC595 | null | It's a real shame the [starter kit is $130](http://www.sparkfun.com/products/10627). | null | 0 | 1316305454 | False | 0 | c2knaum | t3_kj1na | null | t1_c2knaum | t3_kj1na | null | 1427613539 | 4 | t5_2fwo | null | null | null |
True | bunny182 | null | Her eyebrows : / | null | 0 | 1316305476 | False | 0 | c2knaye | t3_kj1na | null | t1_c2knaye | t3_kj1na | null | 1427613541 | -13 | t5_2fwo | null | null | null |
True | jschuh | null | NaCl avoids the two biggest flaws of ActiveX. First, ActiveX binaries run unmodified native code with no restrictions, which is why ActiveX eventually became synonymous with security vulnerabilities. In contrast, NaCl binaries are compiled to a limited, safe instruction set (which the client reverifies) and run inside an origin isolated sandbox--meaning NaCl is native code that uses the same security model as JavaScript.
The second big difference is that ActiveX is not portable--it's just an interface layer for native Windows code. Whereas NaCl ships with a portable API (Pepper). It's also a completely open source codebase that can be ported to any platform or browser other than Chrome. Right now it is limited to the x86 instruction set, but the NaCl team has an Arm port underway, and is working on a portable NaCl that is delivered as LLVM bytecode. | null | 0 | 1316305516 | False | 0 | c2knb4i | t3_kitgf | null | t1_c2knb4i | t1_c2klv3t | null | 1427613543 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316305519 | False | 0 | c2knb4x | t3_kj1na | null | t1_c2knb4x | t3_kj1na | null | 1427613543 | -1 | t5_2fwo | null | null | null |
True | skew | null | Ah, so you are following Wadler.
Do you believe the students using the dynamically typed language finished their parsers more quickly? | null | 0 | 1316305549 | False | 0 | c2knb8x | t3_k7o9e | null | t1_c2knb8x | t1_c2kj893 | null | 1427613545 | 1 | t5_2fwo | null | null | null |
True | Lerc | null | If they get portable nativeclient going on a light footprint I think the platform has a lot of potential. I'm not sure how much weight LLVM adds to the equasion.
A lack of processor portability is the biggest issue with NativeClient.
| null | 0 | 1316305621 | False | 0 | c2knbi9 | t3_kitgf | null | t1_c2knbi9 | t1_c2kn82e | null | 1427613548 | 2 | t5_2fwo | null | null | null |
True | placidppl | null | http://littlebits.cc/ | null | 0 | 1316305723 | False | 0 | c2knbwn | t3_kj1na | null | t1_c2knbwn | t3_kj1na | null | 1427613553 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | If I'm going to read this whole thing why the hell do they put it in a tiny box? | null | 0 | 1316305744 | False | 0 | c2knbzb | t3_kewkd | null | t1_c2knbzb | t1_c2jtwv7 | null | 1427613554 | 2 | t5_2fwo | null | null | null |
True | placidppl | null | Their site store allows you to [preorder for $99](http://littlebits.cc/pre-order). | null | 0 | 1316305786 | False | 0 | c2knc5a | t3_kj1na | null | t1_c2knc5a | t1_c2knaum | null | 1427613556 | 3 | t5_2fwo | null | null | null |
True | ezekiel | null | Yes, thank you. I too have seen essentially a 100% failure rate for ORMs across three separate companies and three different ORMs. The ORM cannot possibly know what is needed to be saved or retrieved. It may be able to do it right sometimes, but that is not good enough. Also, across all the usages I have seen, never was the ORM really adding any benefit despite the substantial effort and learning needed to make it work.
TLDR: Either use SQL directly or use a non-SQL datastore. ORMs have had their fad time and they have failed us. | null | 0 | 1316305994 | False | 0 | c2knd0a | t3_ki83r | null | t1_c2knd0a | t1_c2kljiv | null | 1427613566 | 3 | t5_2fwo | null | null | null |
True | sketerpot | null | If you compile x86 and ARM versions, then don't you have >99% of people covered? The main barrier there is developer tools, to make it easy to compile and test with both processors. | null | 0 | 1316306076 | True | 0 | c2kndbe | t3_kitgf | null | t1_c2kndbe | t1_c2knbi9 | null | 1427613571 | 4 | t5_2fwo | null | null | null |
True | ezekiel | null | > ORM does not abstract a database.
What does that mean? ORMs stand between the application and the database. They present an API to the app, an API different from the database's own API. Sounds like the Facade Pattern to me. Maybe a little Adapter Pattern mixed in. | null | 0 | 1316306156 | False | 0 | c2kndmr | t3_ki83r | null | t1_c2kndmr | t1_c2kiwwi | null | 1427613575 | -1 | t5_2fwo | null | null | null |
True | stoicaurelius | null | Really? You watched the whole video, and the only thing you could do is make a stupid comment about her eyebrows? | null | 0 | 1316306195 | False | 0 | c2kndrt | t3_kj1na | null | t1_c2kndrt | t1_c2knaye | null | 1427613577 | 9 | t5_2fwo | null | null | null |
True | freespace | null | Amazingly clear explanation. | null | 0 | 1316306202 | False | 0 | c2kndsp | t3_kj03o | null | t1_c2kndsp | t1_c2kmtoy | null | 1427613578 | 1 | t5_2fwo | null | null | null |
True | djkrugger | null | Not even a [breadboard](http://files.hwkitchen.com/200000505-8ada68bd41/arduino-protoshield-kit-with-mini-breadboard.jpg)? You just plug the wires, no soldering needed. | null | 0 | 1316306255 | False | 0 | c2kne0a | t3_kj1na | null | t1_c2kne0a | t1_c2kmwmm | null | 1427613581 | 10 | t5_2fwo | null | null | null |
True | ezekiel | null | *All* developers I have met who promote the use of ORMs describe "avoiding SQL" as the main benefit. (And, *I* don't see that as a benefit.) | null | 0 | 1316306314 | False | 0 | c2kne7v | t3_ki83r | null | t1_c2kne7v | t1_c2kii6n | null | 1427613584 | 0 | t5_2fwo | null | null | null |
True | unquietwiki | null | Good question | null | 0 | 1316306511 | False | 0 | c2kneyo | t3_kewkd | null | t1_c2kneyo | t1_c2knbzb | null | 1427613594 | 1 | t5_2fwo | null | null | null |
True | ironiridis | null | That's fair. I can't disagree with anything you've written. | null | 0 | 1316306537 | False | 0 | c2knf24 | t3_kgqdd | null | t1_c2knf24 | t1_c2khd3p | null | 1427613595 | 2 | t5_2fwo | null | null | null |
True | jschuh | null | There are fundamental parts of JavaScript that limit its performance (things like dispatch overhead and typing). Other JIT compiled languages don't necessarily suffer this as badly as JavaScript, but they all do incur penalties of some form. Since a nexe is just a straight ia32 binary, it avoids most of the overhead associated with those other languages/VMs (accepting the overhead incurred for NaCl's own sandboxing). You also have the advantage that the NaCl compiler is built on the GCC toolchain, so it takes advantage of decades of optimization work that have already been invested. | null | 0 | 1316306563 | False | 0 | c2knf62 | t3_kitgf | null | t1_c2knf62 | t1_c2kmf7r | null | 1427613595 | 2 | t5_2fwo | null | null | null |
True | gwern | null | > Do you believe the students using the dynamically typed language finished their parsers more quickly?
I seem to recall thinking something along those lines.
> Subjects using the dynamically-typed language completed the scanner in an average of 5.2 hours, statically-typed in an average of 7.7 hours; the difference is statistically significant at level p=0.04. | null | 0 | 1316306738 | False | 0 | c2knfuy | t3_k7o9e | null | t1_c2knfuy | t1_c2knb8x | null | 1427613605 | 1 | t5_2fwo | null | null | null |
True | shoeOnHeadPls | null | Stock options are a great way for employees to share in the success of the startup if the startup is a success. The thing is if the startup fails the options are worthless and the employee is unemployed.
Now, a person who is already part of the startup scene might know the founders and be able to make an informed decision about how likely it is the people and technology will succeed. But if you're trying to hire people who don't already know you, they might not value the stock options as highly as you do. | null | 0 | 1316306763 | False | 0 | c2knfyh | t3_khx0u | null | t1_c2knfyh | t1_c2kjmm6 | null | 1427613607 | 2 | t5_2fwo | null | null | null |
True | ezekiel | null | Same here.
LINQ-to-SQL was rough and required lots of complex helper objects.
NHibernate is currently consuming probably 60% of our time too, fixing bugs caused by the "edge cases" (of which there are many). The other 40% of time is being similarly consumed by WPF mysteries.
ADO DataReader works just fine and has for years. Funnel all your data accesses through a simple datalayer, use SQL queries and DB views, and use stored procedures for strangely complicated situations. But, as people have complained in these comments: don't copy-paste bad code all over nor create gigantic stored procedures filled with cursors just because you don't know SQL.
Learn SQL and use it. It is simple. It works just fine. | null | 0 | 1316306815 | False | 0 | c2kng6c | t3_ki83r | null | t1_c2kng6c | t1_c2kjem6 | null | 1427613609 | 7 | t5_2fwo | null | null | null |
True | Sc4Freak | null | There is an HTML5 version, and it works fine.
Although I just realised it won't work if you're using Firefox or Chrome, because they don't support H.264. Try it in IE9 or Safari, and HTML5 works fine and dandy. | null | 0 | 1316306945 | False | 0 | c2kngp2 | t3_kii9z | null | t1_c2kngp2 | t1_c2kmyrt | null | 1427613616 | 6 | t5_2fwo | null | null | null |
True | ezekiel | null | I see what you are saying--there is an object-relational mismatch and the ORM advocates are trying to pretend like there isn't. You are correct.
But, focus on the actual needs we have: to store specific data and later query to get it back. In that perspective, SQL already works perfectly. Nothing needs to be added. | null | 0 | 1316307046 | False | 0 | c2knh2x | t3_ki83r | null | t1_c2knh2x | t1_c2kkr8y | null | 1427613621 | 1 | t5_2fwo | null | null | null |
True | caust1c | null |
## | null | 0 | 1316307117 | True | 0 | c2knhdl | t3_kj1na | null | t1_c2knhdl | t1_c2kn3oa | null | 1427613625 | -4 | t5_2fwo | null | null | null |
True | danharaj | null | Everything mathematical is clearer when you pass from thinking about objects to thinking about functions. | null | 0 | 1316307575 | False | 0 | c2knj4o | t3_kj03o | null | t1_c2knj4o | t1_c2kndsp | null | 1427613649 | 2 | t5_2fwo | null | null | null |
True | Phr0ztByte | null | What is wrong with you? Seriously. I felt violently ill after reading your comments from the last week or so. My god. | null | 0 | 1316308282 | False | 0 | c2knlvv | t3_kii9z | null | t1_c2knlvv | t1_c2kiz5a | null | 1427613685 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316308358 | False | 0 | c2knm71 | t3_kj1na | null | t1_c2knm71 | t3_kj1na | null | 1427613686 | -1 | t5_2fwo | null | null | null |
True | imaginaryredditor | null | If portability is a goal, they really should only be supporting the LLVM version. If the other versions are there, people are gonna use 'em. | null | 0 | 1316308437 | False | 0 | c2knmh4 | t3_kitgf | null | t1_c2knmh4 | t1_c2knb4i | null | 1427613690 | 6 | t5_2fwo | null | null | null |
True | noumuon | null | it's still a mechanical ability. the emotion is portrayed in the slight changes in tempo and dynamic. this is entirely reproducible and is a reproduction of the mechanics of playing. a very, very large majority of musicians do exactly this. all you have to do is see how the popular interpretations of various pieces have changed since they were written, and each change is the general population mimicking similar tempo and dynamic changes. many pieces modern players completely disregard what the original composer wrote (see: a very large portion of middle movements in sonatas and the blatant disregard for the tempo indications). | null | 0 | 1316308595 | False | 0 | c2knn3o | t3_khf6j | null | t1_c2knn3o | t1_c2kmljr | null | 1427613699 | 1 | t5_2fwo | null | null | null |
True | xon_xoff | null | I like the idea behind Google NaCl, but on Windows it actually manages to be **less** portable than native code. The programmers used x86 segmentation as part of the 32-bit sandboxing algorithm, and in order to set it up they used an undocumented OS call (NtSetLdtEntries). LDT support was removed with x64 versions of Windows, so the result is that while you can run Win32 programs on 64-bit Windows, you cannot run 32-bit NaCl programs.
For x64 code, NaCl uses a different sandboxing algorithm that doesn't require segmentation or otherwise undocumented OS calls. However, it places some severe restrictions on memory access (no direct pointers) which hamper it compared to native code or even a VM.
PNaCl solves the portability problem, but appears to still have the SFI overhead. I am interested in how this turns out, since it will be harder to leverage CPU-specific operations in this model, blunting one of NaCl's strengths.
| null | 0 | 1316308666 | False | 0 | c2knndr | t3_kitgf | null | t1_c2knndr | t3_kitgf | null | 1427613704 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | Kannada nagana? | null | 0 | 1316308738 | False | 0 | c2knno3 | t3_kicbo | null | t1_c2knno3 | t1_c2khozj | null | 1427613708 | 1 | t5_2fwo | null | null | null |
True | Ralgor | null | It is not "quite trivial to parse". It makes the grammar context sensitive and ambiguous. It is this exact same thing that makes C++ so hard to parse. You can't just "parse" C++, you also have to do full semantic analysis. Adding the "!" makes things MUCH cleaner.
Now, there's an argument that a programming language should be designed for programmers, and not compilers. But the difficulty of parsing C++ has meant that open source tools for efficiently editing C++ code have been pretty hard to find. It's really only been pretty recently (the last few years) that a few C++ parsers have made it to the stage where they give effective information for code completion. | null | 0 | 1316308767 | False | 0 | c2knnsk | t3_kikut | null | t1_c2knnsk | t1_c2kmltp | null | 1427613709 | 3 | t5_2fwo | null | null | null |
True | catcradle5 | null | I assume you prefer functional programming to OOP then? | null | 0 | 1316308796 | False | 0 | c2knnwu | t3_kj03o | null | t1_c2knnwu | t1_c2knj4o | null | 1427613711 | 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.