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 | [deleted] | null | [deleted] | null | 0 | 1316281660 | False | 0 | c2kkq8c | t3_kii9z | null | t1_c2kkq8c | t1_c2kk8z3 | null | 1427612327 | 1 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | First try EJBQL and JDOQL. | null | 0 | 1316281704 | False | 0 | c2kkqec | t3_ki83r | null | t1_c2kkqec | t1_c2kjqmg | null | 1427612339 | 2 | t5_2fwo | null | null | null |
True | Taladar | null | Or XML-dialects that fulfill the same function as regular expressions in a more verbose way. | null | 0 | 1316281712 | False | 0 | c2kkqfe | t3_ki52y | null | t1_c2kkqfe | t1_c2kg1om | null | 1427612330 | 1 | t5_2fwo | null | null | null |
True | simonask | null | I was slightly turned off by the !-syntax for templates (seems weird and unnecessary), but I just might give it a shot next time I decide to write a game engine or something like that. :) | null | 0 | 1316281732 | False | 0 | c2kkqif | t3_kikut | null | t1_c2kkqif | t1_c2kkpt7 | null | 1427612331 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | > File every stupid thing under the sun to add perceived value.
Maybe for patent troll companies, but it generally doesn't work that way. | null | 0 | 1316281789 | False | 0 | c2kkqra | t3_khvyw | null | t1_c2kkqra | t1_c2kklus | null | 1427612334 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316281943 | False | 0 | c2kkr3n | t3_ki83r | null | t1_c2kkr3n | t1_c2kknew | null | 1427612347 | 1 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | > the relational model is mapped to the object model
Not at all. That's just ORM propaganda. | null | 0 | 1316281981 | False | 0 | c2kkr8y | t3_ki83r | null | t1_c2kkr8y | t1_c2kknew | null | 1427612341 | 1 | t5_2fwo | null | null | null |
True | abreev8 | null | [The D Programming Language](http://www.amazon.com/D-Programming-Language-Andrei-Alexandrescu/dp/0321635361) describes many of the design decisions. This one, in particular, is discussed in the book. Using '<' and '>' is extremely impractical for the compiler and prevents arbitrary expressions from being used as template parameters (for one, they are operators too). The '!( ... )' syntax is unambiguous to the compiler and allows D to support something like 'foo!(x < y)(...)'. | null | 0 | 1316282245 | False | 0 | c2kksb2 | t3_kikut | null | t1_c2kksb2 | t1_c2kkqif | null | 1427612357 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316282287 | False | 0 | c2kksds | t3_kikut | null | t1_c2kksds | t1_c2kkqif | null | 1427612360 | 1 | t5_2fwo | null | null | null |
True | aardvark179 | null | But it is still being shoe horned in Scala, just have a look at the class files it produces.
Jack will almost certainly get a native traits-like feature as part of the lambdas work.
The idea is that lambdas are pointless unless they are used by the standard libraries, especially collection APIs, but if the new methods are added to the collection interfaces then you break compatibility with existing code, so now there is a really need for interfaces to provide default implementations which concrete classes need not themselves implement. | null | 0 | 1316282288 | False | 0 | c2kkse3 | t3_khpzu | null | t1_c2kkse3 | t1_c2kiqql | null | 1427612360 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316282444 | False | 0 | c2kkt2x | t3_kii9z | null | t1_c2kkt2x | t1_c2kjl0c | null | 1427612365 | 1 | t5_2fwo | null | null | null |
True | mscman | null | True, but the biggest difference between government and academia is simply the amount of paperwork involved :) | null | 0 | 1316282486 | False | 0 | c2kkt8z | t3_kicbo | null | t1_c2kkt8z | t1_c2kj9en | null | 1427612367 | 0 | t5_2fwo | null | null | null |
True | tanishaj | null | I always thought that it was streaming. That is pretty different than downloading it entirely and then feeding it to a stand-alone player.
If I need more than a modern web browser to consume your content then there is a problem. | null | 0 | 1316282527 | False | 0 | c2kktdw | t3_kii9z | null | t1_c2kktdw | t1_c2kj7so | null | 1427612374 | 4 | t5_2fwo | null | null | null |
True | LetsGetDigital | null | >You've given an optimal Python scenario and a worst-case C# scenario.
Yes, to show that *languages don't have speed*. If you need python to be fast, then use a fast implementation. Heck, you can even compile python to native code, and reach C++'s "speed".
>To say speed isn't a factor when in many real-world scenarios it can be 10x slower, requiring 10x more servers, is ignorant.
To say that using language A over language B guarantees you some given speed is ignorant.
edit: too many using's | null | 0 | 1316282623 | True | 0 | c2kktt0 | t3_kii9z | null | t1_c2kktt0 | t1_c2kkq8c | null | 1427612375 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | The resulting class files are just an implementation artifact and not changing the fact that traits work exactly like they should in Scala and are supported in the whole language.
As soon as Scala drops support for Java 5 and Java 6 (or does some version-specific bytecode generation) people will start looking into how things can work more nicely.
Have a look at the Scala Standard Library, especially collection. There are more methods taking higher order functions than methods taking a "normal" value.
Java 8 actually comes with defender methods, which are "traits-light". | null | 0 | 1316282666 | False | 0 | c2kktz2 | t3_khpzu | null | t1_c2kktz2 | t1_c2kkse3 | null | 1427612376 | 3 | t5_2fwo | null | null | null |
True | simonask | null | Right, but I don't see why they couldn't simply cut it out: `foo(x < y)(...)`
I mean, the compiler knows what's a template and what isn't. | null | 0 | 1316282809 | False | 0 | c2kkuht | t3_kikut | null | t1_c2kkuht | t1_c2kksb2 | null | 1428193798 | 1 | t5_2fwo | null | null | null |
True | ruberik | null | His message seemed to be a response to someone saying exactly what you're saying: "Go isn't suited to solving a problem like X that is well-suited for multiple-inheritance." He then solves X effectively, using interfaces. If you have another value for X, you could send it to the same mailing list. | null | 0 | 1316282823 | False | 0 | c2kkun9 | t3_kikut | null | t1_c2kkun9 | t1_c2kkjy5 | null | 1427612385 | 15 | t5_2fwo | null | null | null |
True | kirakun | null | And Boost is pretty extensive template metaprogramming. | null | 0 | 1316282827 | False | 0 | c2kkunu | t3_kikut | null | t1_c2kkunu | t1_c2kki6g | null | 1427612397 | 5 | t5_2fwo | null | null | null |
True | simonask | null | Right, but I don't see why they couldn't simply cut it out: `foo(x < y)(...)`
I mean, the compiler knows what's a template and what isn't. | null | 0 | 1316282848 | False | 0 | c2kkuqo | t3_kikut | null | t1_c2kkuqo | t1_c2kksb2 | null | 1427612393 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | Because fuck you, that's why. | null | 0 | 1316282999 | False | 0 | c2kkvcr | t3_kicbo | null | t1_c2kkvcr | t3_kicbo | null | 1427612398 | -1 | t5_2fwo | null | null | null |
True | gorilla_the_ape | null | My dad once had to work on some code which was originally written in Italian, then transferred to a French speaker, who translated all the comments, then to him.
English keywords as defined in the language.
Italian variable and function names.
French comments.
My dad only speaks English and Spanish. | null | 0 | 1316283057 | False | 0 | c2kkvlf | t3_kicbo | null | t1_c2kkvlf | t1_c2kjkgk | null | 1427612401 | 10 | t5_2fwo | null | null | null |
True | mushishi | null | He does not make it sound like multiple inheritance is worthless. On the contrary, he emphasizes how one should think in the concepts of the language one is using. He's saying that because go has decided to tackle problems without multiple inheritance, one should not think it in terms as if it had, and then translate it into go with closely resembling features. | null | 0 | 1316283149 | False | 0 | c2kkvy1 | t3_kikut | null | t1_c2kkvy1 | t1_c2kkjy5 | null | 1427612405 | 8 | t5_2fwo | null | null | null |
True | LaurieCheers | null | What's a good example of a problem that's well suited for multiple inheritance? | null | 0 | 1316283253 | False | 0 | c2kkwb7 | t3_kikut | null | t1_c2kkwb7 | t1_c2kkjy5 | null | 1427612410 | 18 | t5_2fwo | null | null | null |
True | abreev8 | null | Not entirely sure. My guess is that at the parsing stage of the compiler, how's it supposed to know that foo even takes template args. Maybe foo returns a function and you call that? The alternative would be to require an empty set of parenthesis for any function that doesn't use template parameters as in bar()(...), but that's silly.
Yes, you could work around that, but at the cost of making the compiler slow and complicated. | null | 0 | 1316283256 | False | 0 | c2kkwbf | t3_kikut | null | t1_c2kkwbf | t1_c2kkuht | null | 1427612410 | 2 | t5_2fwo | null | null | null |
True | banuday | null | > typical OO (with inheritance)
Not exactly. Rather, this is a problem typical in OO with [subtype polymorphism](http://en.wikipedia.org/wiki/Subtype_polymorphism), which is an artifact of the Simula strain of OOP.
OOP of the Smalltalk strain (Ruby, ObjC) - which is also OO with inheritance. Objects don't have "interfaces" as such, but rather classes define which messages the object will respond to.
The advantage of subtype polymorphism is type safety, but it is a weak approach. Interestingly, Scala - also an OOP language which also has subtype polymorphism - provides more powerful type safety with implicits and structural typing. | null | 0 | 1316283501 | False | 0 | c2kkxdc | t3_kikut | null | t1_c2kkxdc | t1_c2kj75k | null | 1427612424 | 5 | t5_2fwo | null | null | null |
True | banuday | null | Maybe I'm an idiot, but I recently fixed a bug caused by code I wrote that mixed up single letter indicies within nested for loops. Once I renamed the index names to be more expressive, the mistake in the code was obvious. | null | 0 | 1316283833 | False | 0 | c2kkymi | t3_kikut | null | t1_c2kkymi | t1_c2kjdg3 | null | 1427612442 | 2 | t5_2fwo | null | null | null |
True | OMouse | null | Anything that changes the patent system in the direction of "good" is only a band-aid. The whole damn patent system has to go, it's caused nothing but trouble. The damage done by it is measured in the billions of lawsuits over the years by patent trolls and by large corporations that want to keep everyone else from innovating.
Fuck patents. | null | 0 | 1316283916 | False | 0 | c2kkyx3 | t3_khvyw | null | t1_c2kkyx3 | t3_khvyw | null | 1427612446 | 1 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | NOTE: this got a bit long--sorry about that. TL;DR is that there are some pretty good things in the bill for us, and the things people are saying are bad probably aren't.
NOTE 2: Reddit says this is too long, so I'll split it and continue in a reply.
There is a **huge** amount of confusion about this bill here. Based on the comments it would seem most people think it does two things, and pretty much only those two things.
1\. Change from first to invent to first to file (true) and that this is a huge disaster making it so corporations can steal our software (false).
2\. Makes it so you can only use patents as prior art. (false). I have no idea where this idea came from.
In fact, this is a pretty good bill from a programmer point of view. First to file vs first to invent is mostly irrelevant from the point of view of programmers who are *not* trying to get patents themselves. I'll come back to that at the end of this comment, because I'd rather start with the things that seem to get overlooked in discussion outside patent circles that are very good for us programmers.
But first, let me recommend a blog that programmers should read: [Patently-O](http://www.patentlyo.com/). Like them or not, software patents are a reality in our business that we cannot ignore. Patently-O has good coverage, from a patent attorney's point of view, of patent law. You might not understand everything there as it gets technical, but stick it in your RSS reader and at least glance at the post titles now and then, and take a look at those that seem relevant to software. Patently-O has a fair number of guest posts, and will present both sides of most issues.
On to the really good parts of the new bill:
\1. There is a change to joinder that is very unfavorable to patent trolls. Joinder is a legal process for joining different lawsuits into one suit when the suits involve a common issue and it would be a more efficient use of judicial resources to litigate them together. Patent trolls love joinder.
When a troll sues a bunch of defendants over the same patent, the troll wants it handled as one suit.
That first of all saves the troll a lot of money in litigation costs.
Second, it makes it less likely that any of the defendants will be able to get the case transferred out of the troll's chosen venue to a venue of the defendant's choice. (A few years ago the rules on choice of venue were changed to make it much easier for defendants in patent suits to get the cases transferred from where the plaintiff files to where the defendant resides). A defendant who would like win a motion for change of venue if he were the sole defendant will be much less likely to succeed if he's one of 10 defendants from all over the country being sued over the same patent in one suit.
Third, each separate case the troll litigates runs the risk of them losing the patent. Once a patent is found to be invalid, that's it for that patent. Even in plaintiff-friendly districts, there is a decent chance a troll's patent will be found invalid at a given trial so the troll really would rather not roll the dice too many times.
Under the old law, it was easy for trolls to use joinder. The fact that the multiple defendants were all being sued over the same patent was sufficient. Under the new law, that is *not* sufficient. The troll needs to find some way to significantly connect the cases other than the common patent.
(This provision is not retroactive, so it won't break up the current Lodsys suits unfortunately).
\2. The new law increases the scope of what counts as prior art for invalidating patents. This will make it easier to find relevant prior art to deal with troll patents. For instance, under the old law you could not patent something more than a year after it had been in public use or on sale in the United States. That is no longer limited to in the United States.
Under the old law, there was a one year grace period between the time an invention became publicly known and the time the inventor must file his patent application. For example, suppose X comes up with an idea January 1, 2000. X starts working diligently toward reducing the idea to practice. This takes him several years, and he's still busy working (in secret) on this invention on January 1, 2005.
On January 1, 2005 person Y, who has independently come up with an overlapping invention but after X started, starts selling something that incorporates the invention. This started a one year clock--anyone who wished to try to patent that invention now had until January 1, 2006 to get their application in. After that, Y's public use of the invention would count as prior art and preclude their patent.
Note that during that year, the public cannot be certain what the patent status of the invention is. Even if Y is someone who is not likely to patent the invention (say, a free software developer) there might be an X out there that was working secretly and has priority. So we have at least a year of uncertainty over whether we can use the invention.
Under the new law, it is much simpler. On January 1, 2005, Y's public use becomes prior art for any inventor *other* *than* Y. Any inventor other than Y that does not have a patent application filed by January 1, 2005 is not out of luck. Inventory Y still gets a one year grace period, so he's got until January 1, 2006 to file. (NOTE: not only does Y selling the invention establish prior art, but also describing it in a printed publication counts, so Y publishing an academic paper would do it).
(The above is essentially a consequence of the change to first to file. Since the priority date is now the filing date, things like prior art are determined relative to the filing date. Thus, Y's public use is prior art against subsequent filing by other inventors. Under first to invent, the prior art had to be from before the invention date, so Y's public use was not prior art for X).
The effect of this change should be very good for programmers. It basically means that if you see something used in open source, or described in a printed publication such as an academic journal (I don't know if "printed" requires dead trees or if electronic publication counts), you have a lot less need to worry about someone coming along and patenting it if they don't already have their application in (except for the author of the open source program or the paper--you still need to make sure they don't plan on patenting).
So, to summarize, we've now got a change that seriously raises the costs and risks of patent trolls, the scope of prior art has been increases so it will be easier to invalidate bad software patents, and the interaction of prior art and first to file makes it so open source and academic publications will now stop a lot of patents that would have been allowed under the prior law.
[p_next](http://www.reddit.com/r/programming/comments/khvyw/obama_just_overhauled_the_patent_system_good_for/c2kkz6h)
| null | 0 | 1316283960 | False | 0 | c2kkz43 | t3_khvyw | null | t1_c2kkz43 | t3_khvyw | null | 1427612449 | 12 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | [p_prev](http://www.reddit.com/r/programming/comments/khvyw/obama_just_overhauled_the_patent_system_good_for/c2kkz43)
Now let's talk about first to file vs. first to invent. People are imagining all kinds of scary scenarios that just aren't the way it works. First to file does **NOT** mean that whoever is first to file for a patent on something automatically gets a patent. All it means is that when multiple people would be entitled to a patent, the filing date determines who wins. They still have to meet all the other requirements, such as having actually invented the thing they are claiming.
Under the old system, it was the effective invention date. That was not necessarily the date you actually came up with the idea. You have to "reduce to practice" before you can apply for a patent, and your invention date is basically when you started working diligently to reduce your idea to practice. If there are any gaps in there, when you stop working diligently, the invention date is the end of the last gap before you filed.
The main argument *for* first to invent is that it seems intuitive that whoever invented the thing first should be the one who gets the patent among independent inventors. However, note that because of the way invention date was calculated, as describe in the previous paragraph, this was not necessarily the actual first inventor.
The big problem with first to invent is that it is a pain in the ass to deal with. You invent something. You start tinkering in your garage to work out the kinks and get it to a patentable states. A few months later, I invent something similar, and start tinkering in my garage. A few months after that, GiantMegaCorp invents something similar, and puts a team of engineers onto getting it to a patentable state.
You and I are working hard on getting our inventions ready--but you take a month off because your kid gets seriously ill and has to go to a hospital in another city for a few weeks and you go with him. I take month off here and there because things get busy at my day job.
Eventually, you, me, and GiantMegaCorp all end up at the patent office, with competing patent claims. We have to go through what is in affect a trial to decide who has priority. Maybe we can prove we thought of the idea before GiantMegaCorp, but of the three guess which is most likely to be able to *document* an effective invention date and continuous diligent work on reduction to practice? Probably GiantMegaCorp. When you got back from dealing with the sick kid, you forgot to keep good records of when you went back to work on the invention. I''m just disorganized. Maybe you and I can find witnesses we talked to about working on our inventions, and they can somehow come up with dates, but I doubt it.
In short, first to invent favors the diligent record keeper who has proof of the validity of his records.
First to file says "screw all that crap--the winner is the one who gets to the finish line first, not the one who who started running first". Now one might argue that this still favors GiantMegaCorp, because they can throw a big team of engineers on reducing the idea to practice, so they are going to finish first even if they start last, and there is a considerable amount of truth to this. The small inventor does have a weapon against that--the provisional patent application.
A provisional application is relatively cheap to file (under $300, I believe), and does not require that you have reduced the idea to practice. It basically gets you a filing date, and then you have a certain amount of time (I think it is a year) to file your "real" patent application which I believe counts as having the same filing date as the provisional application.
Personally, I think this works out fine. Ideas are not supposed to be patentable. Inventions are what is supposed to be patentable. You start with an idea, and then you have to turn it into an invention if you want to patent it. If you haven't developed your idea to the point that you can be confident that you are less than a year away from being able to file a patent application, I'd say it is still at the "idea" stage, not the "invention" stage.
| null | 0 | 1316283978 | True | 0 | c2kkz6h | t3_khvyw | null | t1_c2kkz6h | t1_c2kkz43 | null | 1427612449 | 10 | t5_2fwo | null | null | null |
True | grauenwolf | null | * Multiple Windows
* Direct access to a database (System.Data)
* Synchronous calls to the file system
* Full access to WCF
* Incoming TCP/UDP sockets (not sure on this, but I think only out-bound sockets are allowed)
| null | 0 | 1316284095 | False | 0 | c2kkzly | t3_kgb4h | null | t1_c2kkzly | t1_c2ka96y | null | 1427612453 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | Silverlight to WinRT can be trivial. WPF to WinRT is going to be just as painful as WPF to Silverlight. | null | 0 | 1316284167 | False | 0 | c2kkzve | t3_kgb4h | null | t1_c2kkzve | t1_c2k85mm | null | 1427612455 | 2 | t5_2fwo | null | null | null |
True | OMouse | null | Fuck patents for *anything*. If you want to make money off your innovation, then do it without breaking the legs of your competitors. Let the better product win. If you can't make money, then too fucking bad, let someone else have a try.
Closing up human innovation because some patent troll or some other idiot has some silly paper that says "patent" on it is stupid. | null | 0 | 1316284203 | False | 0 | c2kl014 | t3_khvyw | null | t1_c2kl014 | t1_c2ke5hi | null | 1427612458 | 0 | t5_2fwo | null | null | null |
True | grauenwolf | null | It isn't Silverlight, but it is .NET and it is awesome. As it says in the article, if you have a full screen Silverlight app then you have a migration path. It is the ones that mix Silverlight and HTML on one page that will be a big problem. | null | 0 | 1316284246 | False | 0 | c2kl072 | t3_kgb4h | null | t1_c2kl072 | t1_c2k2heo | null | 1427612465 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | What you said wasn't clever/clear, so there is no need to be condescending. If you had presented your point clearly we wouldn't be talking :) | null | 0 | 1316284288 | False | 0 | c2kl0d1 | t3_khtwb | null | t1_c2kl0d1 | t1_c2kjs2m | null | 1427612461 | -1 | t5_2fwo | null | null | null |
True | OMouse | null | How about *no fucking patents*? That means you don't have to think about any edge or corner cases like that at all. | null | 0 | 1316284322 | False | 0 | c2kl0ht | t3_khvyw | null | t1_c2kl0ht | t1_c2kir1x | null | 1427612463 | 0 | t5_2fwo | null | null | null |
True | grauenwolf | null | I foresee Adobe Air running in the Metro environment just like .NET does. | null | 0 | 1316284379 | False | 0 | c2kl0pt | t3_kgb4h | null | t1_c2kl0pt | t1_c2k2lcm | null | 1427612464 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | It might perform better than HTML5 (for now), but as a whole it sucks; it feels like an intruder. Randomly stealing focus, making other things run slow; page as a whole becomes very non-responsive ..etc.
I'm glad YouTube links open in the dedicated Android YouTube (non-Flash) player -- for instance. | null | 0 | 1316284379 | False | 0 | c2kl0pu | t3_hyn1j | null | t1_c2kl0pu | t1_c1znogu | null | 1427612464 | 0 | t5_2fwo | null | null | null |
True | OMouse | null | >I would submit that even without patents, drugs would still be invented
This is *true* and has *always* been true. People don't just stop creating things because there's little or no profit incentive. We're freaking humans, we keep on innovating just because we can. | null | 0 | 1316284399 | False | 0 | c2kl0s8 | t3_khvyw | null | t1_c2kl0s8 | t1_c2keuzy | null | 1427612465 | 3 | t5_2fwo | null | null | null |
True | munificent | null | > The C++ function template approach is quite powerful because it means you never have to cast anything -- if a type has methods (or global functions) with the right names and signatures available, then objects of that type will "just work" with the function template.
Even better, C++'s approach doesn't require boxing the values like interfaces in Go do. The downside, of course, is that "boxing" happens at compile time leading to longer compile times and greater code size. | null | 0 | 1316284409 | False | 0 | c2kl0tu | t3_kikut | null | t1_c2kl0tu | t1_c2kk8fq | null | 1427612465 | 5 | t5_2fwo | null | null | null |
True | OMouse | null | It's too bad they didn't define limited times as precisely 1 year or less. Time to re-write your constitution. | null | 0 | 1316284465 | False | 0 | c2kl12i | t3_khvyw | null | t1_c2kl12i | t1_c2kg7uv | null | 1427612469 | -1 | t5_2fwo | null | null | null |
True | anacrolix | null | Y U NO LEARN REAL LANGUAGE? | null | 0 | 1316284477 | False | 0 | c2kl142 | t3_k3k8l | null | t1_c2kl142 | t3_k3k8l | null | 1427612469 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316284483 | False | 0 | c2kl14q | t3_kii9z | null | t1_c2kl14q | t1_c2kktt0 | null | 1427612469 | 0 | t5_2fwo | null | null | null |
True | gnuvince | null | I wonder why Assembly tutorials for beginners use x86 instead of the much saner MIPS Assembly. Combine that with the excellent [MARS Simulator](http://courses.missouristate.edu/KenVollmar/MARS/) and you have a nice and easy way to start understanding Assembly. After that, you can move to x86 if you still care to. | null | 0 | 1316284525 | False | 0 | c2kl1am | t3_khxzd | null | t1_c2kl1am | t3_khxzd | null | 1427612471 | 2 | t5_2fwo | null | null | null |
True | flussence | null | ~ $ echo '$◎ܫ◎;' | php -l
No syntax errors detected in -
~ $ echo '$☺;' | php -l
No syntax errors detected in - | null | 0 | 1316284580 | False | 0 | c2kl1il | t3_kicbo | null | t1_c2kl1il | t1_c2kjdwq | null | 1427612474 | 1 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | So? That happens under first to invent also. The change doesn't particularly favor corporations over individual inventors.
In fact, I'd say it favors individual inventors by getting rid of the record keeping and evidentiary requirements that you need to worry about under first to invent in order to prove your priority date. | null | 0 | 1316284604 | False | 0 | c2kl1mi | t3_khvyw | null | t1_c2kl1mi | t1_c2kknbb | null | 1427612476 | 3 | t5_2fwo | null | null | null |
True | grauenwolf | null | It isn't just battery life, though that is important, it is the WinRT API not supporting any COM component that needs IDispatch. Even if they wanted to support plugins they can't do it with this implementation. They need to either redesign WinRT or reimplement the plugin architecture from scratch. | null | 0 | 1316284612 | False | 0 | c2kl1nv | t3_kgb4h | null | t1_c2kl1nv | t1_c2k2ypt | null | 1427612476 | 1 | t5_2fwo | null | null | null |
True | cdsmith | null | This would apply to copyright, but is irrelevant when it comes to patents. Then again, if you're a computer programmer, there are always thousands of people that could sue you to hell and back over patents if you breath at them the wrong way... so why start worrying now? | null | 0 | 1316284613 | False | 0 | c2kl1o3 | t3_kgqdd | null | t1_c2kl1o3 | t1_c2kcyp7 | null | 1427612476 | 1 | t5_2fwo | null | null | null |
True | Wolfspaw | null | strange, my Firefox has "Coding: UTF-8" but it does not show the cactus @_@ | null | 0 | 1316284616 | False | 0 | c2kl1ol | t3_kicbo | null | t1_c2kl1ol | t1_c2kkaeb | null | 1427612477 | 2 | t5_2fwo | null | null | null |
True | Peaker | null | The writers of the constitution had installed 14+optional 14 (up to 28 year) copyrights, and 20 years for patents.
So if they had encoded the limited time into the constitution, this is probably around the amount of time that they would use.
That may be long, but copyrights are currently an order of magnitude longer. And technological progress in 2011 is faster than in the 19th century, so it indeed makes no sense that patents still last as long. | null | 0 | 1316284651 | False | 0 | c2kl1t1 | t3_khvyw | null | t1_c2kl1t1 | t1_c2kl12i | null | 1427612478 | 6 | t5_2fwo | null | null | null |
True | OMouse | null | Eliminating all patents would be a great start. | null | 0 | 1316284666 | False | 0 | c2kl1ut | t3_khvyw | null | t1_c2kl1ut | t1_c2ke8z2 | null | 1427612479 | 0 | t5_2fwo | null | null | null |
True | OMouse | null | The changes themselves are band-aids; they don't fix the root problem because the government won't consider "no patents" as a solution. Eliminating the whole system is the only solution to all the problems it causes. | null | 0 | 1316284733 | False | 0 | c2kl24b | t3_khvyw | null | t1_c2kl24b | t1_c2ke9ct | null | 1427612482 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Nah, in programming, there is no intuition. | null | 0 | 1316284764 | False | 0 | c2kl28f | t3_ki52y | null | t1_c2kl28f | t1_c2kgfcz | null | 1427612484 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | No, I was just low on sleep, really pissed off, and thus I made mistakes. While I stand by the conclusions, I really should have had someone else write it for me. | null | 0 | 1316284793 | False | 0 | c2kl2cv | t3_kgb4h | null | t1_c2kl2cv | t1_c2k2g8n | null | 1427612485 | 1 | t5_2fwo | null | null | null |
True | meddlepal | null | I believe Squeryl (A Scala ORM) has made that claim. In fact there is no way to write a raw SQL query in Squeryl as far as I know. My information may be out of date, but this was one of the big turn-offs to me about an otherwise good looking library when I went shopping for database persistence in Scala for a project. | null | 0 | 1316284843 | False | 0 | c2kl2jq | t3_ki83r | null | t1_c2kl2jq | t1_c2kii6n | null | 1427612488 | 1 | t5_2fwo | null | null | null |
True | alexeiz | null | I ran out of my sleep medication, but I don't need it anymore - this presentation works wonders! | null | 0 | 1316284880 | False | 0 | c2kl2oy | t3_kii9z | null | t1_c2kl2oy | t3_kii9z | null | 1427612490 | -7 | t5_2fwo | null | null | null |
True | grauenwolf | null | Farmville will just become an installed application. | null | 0 | 1316284940 | False | 0 | c2kl2xb | t3_kgb4h | null | t1_c2kl2xb | t1_c2k72qh | null | 1427612493 | 1 | t5_2fwo | null | null | null |
True | gotnate | null | are you on OS X Lion or iOS? can you see any of the other [emoji](http://en.wikipedia.org/wiki/Emoji)? For some reason, my lion desktop doesn't show the cactus in my original post (posted from iCab on an iPad), but I do see the cactus emoji in the character picker: 🌵 - and I can see it on both the desktop and the iPad.... I guess it's not perfect yet.
Ok, I just looked at that article on both my iPad and Firefox, and a) firefox doesn't show any emoji, and b) the iPad renders the softbank emoji that lion doesn't. That means the cactus above was probably a softbank emoji (), and the one in this comment was a unicode emoji (🌵). | null | 0 | 1316284946 | True | 0 | c2kl2y9 | t3_kicbo | null | t1_c2kl2y9 | t1_c2kl1ol | null | 1427612493 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316285498 | False | 0 | c2kl51x | t3_kicbo | null | t1_c2kl51x | t1_c2kjdwq | null | 1427612521 | 1 | t5_2fwo | null | null | null |
True | palparepa | null | And ö | null | 0 | 1316285599 | False | 0 | c2kl5fh | t3_kicbo | null | t1_c2kl5fh | t1_c2kj7cw | null | 1427612535 | 6 | t5_2fwo | null | null | null |
True | matthieum | null | Unambiguous but not particularly tasteful :/
I don't understand why with some much thoughtfulness they didn't took more distance from C++'s awkward syntax. | null | 0 | 1316285628 | False | 0 | c2kl5jj | t3_kikut | null | t1_c2kl5jj | t1_c2kksb2 | null | 1427612528 | -2 | t5_2fwo | null | null | null |
True | electronics-engineer | null | I think he is particularly well-suited to be a BEST programmer.
BEST is a programming language that I developed to answer the frequently asked question "Which programming language is best?" once and for all.
BEST is an RFC2795-compliant Befunge-93(2) pseudocompiler written in x87 Malborge(3)(7) with library calls to routines written in Microsoft(4) Visual BogusFORTH++(5) (!Kung edition)(9) that invoke various functions written in(6) Reverse Polish Whitespace(1) (for clarity). It requires the GLaDOS operating system or RUM emulator.
I hope this helps...
References:
(1) http://compsoc.dur.ac.uk/whitespace/
(2) http://catseye.tc/projects/befunge93/doc/website_befunge93.html
(3) http://www.lscheffer.com/malbolge_spec.html
(5) http://www.tlc-systems.com/babbage.htm
(4) http://www.cantrip.org/nobugs.html
(6) http://zapatopi.net/blackhelicopters/
(7) http://www.lscheffer.com/malbolge.shtml
(7) http://docs.freebsd.org/cgi/getmsg.cgi?fetch=1597729+0+archive/2001/freebsd-ports/20010617.freebsd-ports
(9) http://en.wikipedia.org/wiki/!Kung_language
)~( http://zapatopi.net/afdb/
(Q) http://www.ietf.org/rfc/rfc2795.txt
| null | 0 | 1316285910 | False | 0 | c2kl6o3 | t3_kicbo | null | t1_c2kl6o3 | t1_c2kjsbd | null | 1427612542 | 4 | t5_2fwo | null | null | null |
True | matthieum | null | Doug Gregor, from Apple's Clang team, is experimenting with module support in Clang. We might expect some help from this direction (since you would not have to duplicate a definition already provided in the module you import), however it won't fully solve the problem I fear, as independent modules can still define both instances.
Francois Pichet, working on Clang for MSVC compatibility, introduced a late-instanciation feature for templates, meaning that the required definition are generated only at the end of the TU. It seems to speed up compilation time.
Perhaps that combining the two, we could get significant speed up ? | null | 0 | 1316285912 | False | 0 | c2kl6od | t3_kikut | null | t1_c2kl6od | t1_c2kk56l | null | 1427612542 | 2 | t5_2fwo | null | null | null |
True | metaobject | null | Who started calling Assembly language ASM? For some reason, it bothers me, as ASM is not an acronym. Sorry for being grumpy, I just had to get it off my chest. | null | 0 | 1316286046 | False | 0 | c2kl77z | t3_khxzd | null | t1_c2kl77z | t3_khxzd | null | 1427612548 | 1 | t5_2fwo | null | null | null |
True | pbunbun | null | >I wonder why Assembly tutorials for beginners use x86 instead of the much saner MIPS Assembly.
Because most people like actually being able to run their code natively.
I'd argue that doing it in a simulator is far more educational, particularly one of those that allows you to visually inspect the pipeline, find stalls and compare the runtime of various instructions (e.g. div/mul vs. shifts and adds), but it just seems less appealing to most people I guess.
And yeah, x86 assembly seems horrible for this compared to RISC architectures, but also more practical.
Do such simulators exist for x86 or ARM assembly? | null | 0 | 1316286056 | True | 0 | c2kl799 | t3_khxzd | null | t1_c2kl799 | t1_c2kl1am | null | 1427612550 | 5 | t5_2fwo | null | null | null |
True | matthieum | null | I know there are other flavours of OO, thus the precision :)
My point was that the hard-wiring of interfaces at class-design time makes for a very weak system.
Dynamic languages don't have it so rough, but then they turn compilation checks into runtime errors which isn't a direction I appreciate for "real" work (very fine for my scripts toolbox though). | null | 0 | 1316286072 | False | 0 | c2kl7bo | t3_kikut | null | t1_c2kl7bo | t1_c2kkxdc | null | 1427612550 | 1 | t5_2fwo | null | null | null |
True | simonask | null | "Slow and complicated" — hardly from something like this. But I'm sure they have their reasons. | null | 0 | 1316286118 | False | 0 | c2kl7ir | t3_kikut | null | t1_c2kl7ir | t1_c2kkwbf | null | 1427612553 | 2 | t5_2fwo | null | null | null |
True | _asterisk | null | A false assumption based on the file extension sometimes used, .asm? | null | 0 | 1316286135 | False | 0 | c2kl7kx | t3_khxzd | null | t1_c2kl7kx | t1_c2kl77z | null | 1427612554 | 1 | t5_2fwo | null | null | null |
True | SweetIrony | null | What he polled all the JavaScript users and asked if they knew what a stream was? | null | 0 | 1316286171 | False | 0 | c2kl7pw | t3_kc4pc | null | t1_c2kl7pw | t1_c2kbyc6 | null | 1427612555 | 1 | t5_2fwo | null | null | null |
True | desideriumweb | null | Reddit also uses an EAV model. That thing will make you write horrid, horrid queries. | null | 0 | 1316286230 | False | 0 | c2kl7y6 | t3_ki83r | null | t1_c2kl7y6 | t1_c2kjem6 | null | 1427612559 | 1 | t5_2fwo | null | null | null |
True | matthieum | null | Exact, in Europe the patent does not hold, because no software patent does. The copyright does hold, obviously, but reverse-engineering and re-implementing in a "white-box" fashion is perfectly legal, and the resultant work can be used within the terms of its own license. | null | 0 | 1316286230 | False | 0 | c2kl7ye | t3_kgqdd | null | t1_c2kl7ye | t1_c2k9cxf | null | 1427612559 | 1 | t5_2fwo | null | null | null |
True | blergh- | null | Yes, applause for you. Congratulations, you won. | null | 0 | 1316286266 | False | 0 | c2kl83r | t3_kg2sg | null | t1_c2kl83r | t1_c2kk4wf | null | 1427612561 | 1 | t5_2fwo | null | null | null |
True | elperroborrachotoo | null | Ah, ok. When I did sign in, google asked me to give them a phone number for later password recovery, with no option to continue to the content.
May doves shit into their eyes. | null | 0 | 1316286651 | False | 0 | c2kl9ac | t3_kikut | null | t1_c2kl9ac | t1_c2kk2tk | null | 1427612577 | 12 | t5_2fwo | null | null | null |
True | [deleted] | null | Boost is not a monolithic library. When I see posts like this I have to wonder if you've ever even used boost, or you've just heard of it and have a vague knowledge that it involves templates and metaprogramming.
Will boost::intrusive_ptr slow down your compilation speed? No. Will boost::spirit? Yes. | null | 0 | 1316286737 | True | 0 | c2kl9ms | t3_kikut | null | t1_c2kl9ms | t1_c2kkunu | null | 1427612582 | 7 | t5_2fwo | null | null | null |
True | dsquid | null | I think as a practical matter it DOES change things: if I wish to protect and invention my unfiled-yet-documented material is no longer useful in obtaining a patent. Presumably it's still useful as prior art against someone who invents-and-files-first, but I'd have to ask one of my IP attys.
The reality is corporations have plenty of money to file apps against all sorts of ideas (I know, since I ran an IP group with a ~$1MM annual budget), unlike individual inventors or smaller businesses.
I don't see why there's any difference in record-keeping: say I invent and reduce-to-practice (but do not file) 6 before your filing; I still need all that documentation to both protect myself and invalidate your patent. | null | 0 | 1316286759 | False | 0 | c2kl9pq | t3_khvyw | null | t1_c2kl9pq | t1_c2kl1mi | null | 1427612582 | 1 | t5_2fwo | null | null | null |
True | gc3 | null | Exactly. What does multiple inheritance buy you that cannot be solved in interfaces or components?
(In the component model you make an object out of parts, each of which is attached to a containing object, like a computer game character that is made out of an ai, a physics object, and a graphics object). | null | 0 | 1316287079 | False | 0 | c2klao4 | t3_kikut | null | t1_c2klao4 | t1_c2kkwb7 | null | 1427612595 | 13 | t5_2fwo | null | null | null |
True | [deleted] | null | Didn't downvote you but thought I'd point out that it's not a *comment*. It's the function's **documentation** and every public-facing function should carry documentation IMHO regardless of how trivial it is. | null | 0 | 1316287142 | False | 0 | c2klaw8 | t3_kikut | null | t1_c2klaw8 | t1_c2kj8dr | null | 1427612598 | 3 | t5_2fwo | null | null | null |
True | AlyoshaV | null | What the fuck does ORM stand for?
It isn't defined in this blog post, it isn't defined in the linked tweet, it isn't defined in his previous blog post... | null | 0 | 1316287197 | False | 0 | c2klb4h | t3_ki83r | null | t1_c2klb4h | t3_ki83r | null | 1427612601 | 1 | t5_2fwo | null | null | null |
True | moreyes | null | > While I can see that Go's approach of forcing the programmer to explicitly cast to an interface type
You never cast to an interface type in Go. If it quacks (has the same interface method names and signatures), it is always automatically a duck (can be treated as an implementer of the interface without casting).
What requires casting in Go is when a function accepts an interface as parameter and, inside the function, you need to treat that parameter as a concrete type to pass around, return or use methods/attributes that are not present in the interface. | null | 0 | 1316287450 | False | 0 | c2klbz6 | t3_kikut | null | t1_c2klbz6 | t1_c2kk8fq | null | 1427612612 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | wtf is all that xml crap? | null | 0 | 1316287471 | False | 0 | c2klc2e | t3_kikut | null | t1_c2klc2e | t1_c2kjsyc | null | 1427612613 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | From your other comments I think that it is obvious that you have a poorly set up environment. It sounds like you are using a newer version of Visual Studio on older hardware with an older OS and probably managed by IT guys who aren't up to date. The very fact that you call it "devstudio" is telling, considering that you are using a name which was deprecated *14 years ago*. If you are in 20XX using Visual Studio 20XX on a 20XX era OS and working on a 20XX era project then you will be fine. If you start mixing and matching things from different eras you will run into problems. The problems really are the fault of your organization. | null | 0 | 1316287598 | False | 0 | c2klcmj | t3_hudvd | null | t1_c2klcmj | t1_c1ypn5x | null | 1427612620 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | You keep talking about this green? | null | 0 | 1316287604 | False | 0 | c2klcni | t3_kikut | null | t1_c2klcni | t1_c2kk1mg | null | 1427612621 | 3 | t5_2fwo | null | null | null |
True | gawi | null | C++ was not aiming at Lisp developers.
I also prefer Haskell language itself much better but the rest of the development ecosystem makes me doubt that it's enterprise-ready (that's not even the goal of Haskell). Scala might be the right compromise, the right transition from OOP to FP. At least, that how I've approached Scala: a pragmatic compromise. | null | 0 | 1316287666 | False | 0 | c2klcra | t3_gis0z | null | t1_c2klcra | t1_c1nxx3k | null | 1427612622 | 1 | t5_2fwo | null | null | null |
True | wozer | null | Anyone here know more about the details?
It says in the video that type providers access their source (e.g. a database schema) at compile time.
What happens if the schema changes between compile time and runtime? Is the behaviour well defined and easy to debug? | null | 0 | 1316287681 | False | 0 | c2klcul | t3_kii9z | null | t1_c2klcul | t3_kii9z | null | 1427612624 | 3 | t5_2fwo | null | null | null |
True | __j_random_hacker | null | Oh good. Where I got that idea from was this fragment in the article:
> and then the implementations
that accept those interfaces need to write a converson
occasionally
I'm not sure why this would ever be necessary, any ideas? | null | 0 | 1316287788 | False | 0 | c2kldbt | t3_kikut | null | t1_c2kldbt | t1_c2klbz6 | null | 1427612630 | 1 | t5_2fwo | null | null | null |
True | wnoise | null | Most searching utilities let you search for whole words. | null | 0 | 1316287935 | False | 0 | c2kldxa | t3_kikut | null | t1_c2kldxa | t1_c2kjc91 | null | 1428193793 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | What the fuck is a "linked tweet"? What the fuck is a "blog"? | null | 0 | 1316288097 | False | 0 | c2klejz | t3_ki83r | null | t1_c2klejz | t1_c2klb4h | null | 1427612656 | 2 | t5_2fwo | null | null | null |
True | AlyoshaV | null | A tweet is a small bird organ. For "linked tweet", think sausage links. A blog is the text form of a vlog. | null | 0 | 1316288243 | False | 0 | c2klf4z | t3_ki83r | null | t1_c2klf4z | t1_c2klejz | null | 1427612662 | 1 | t5_2fwo | null | null | null |
True | acdha | null | Besides completely undercutting your argument, this is still true: unless your job is writing complex reports all day, the vast majority of the queries you write are going to be well within what an ORM does well and the time savings from not having to manually generate correct queries, test joins, etc. is going to be considerable - you are actually doing something with this data once you retrieve it, right?
Django's ORM isn't as bad as some people make out but I think one of the big points is precisely that there are multiple good ways to bypass the ORM when you need to: [raw queries](https://docs.djangoproject.com/en/dev/topics/db/sql/#performing-raw-queries) are particularly nice for letting you write a gnarly SQL expression - perhaps using something non-portable like tree coalescing - and retrieve a normal list of objects which can be passed to the rest of your code, allowing you to avoid needing to duplicate all of that logic for a corner case. | null | 0 | 1316288305 | False | 0 | c2klfdq | t3_ki83r | null | t1_c2klfdq | t1_c2kij6y | null | 1427612665 | 1 | t5_2fwo | null | null | null |
True | cpearce | null | The reason why http://deoxxa.github.com/frequencer/ doesn't work in Firefox is that the web server is serving wav files with the mime-type "application/octet-stream". Firefox does not content sniff. For HTML5 audio/video to play in Firefox, the webserver must serve it with the correct mime type; wav files need to be served with the mime-type "audio/wav" (or "audio/x-wav") for them to work in Firefox. Internet Explorer 9 also requires correct mime-types for HTML5 audio/video to work. | null | 0 | 1316288341 | False | 0 | c2klfiy | t3_khn6y | null | t1_c2klfiy | t1_c2kb7bo | null | 1427612665 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316288689 | False | 0 | c2klgtu | t3_kiug7 | null | t1_c2klgtu | t3_kiug7 | null | 1427612676 | 1 | t5_2fwo | null | null | null |
True | teletran | null | Of course, if we're going to be as pedantic as compilers, then sure they *do* make mistakes. But it's incredibly rare, especially for beginner programmers to encounter :) | null | 0 | 1316288802 | False | 0 | c2klha9 | t3_khkyd | null | t1_c2klha9 | t1_c2kichy | null | 1427612689 | 1 | t5_2fwo | null | null | null |
True | insertAlias | null | It is because it already exists in several languages, like PHP and Perl. If I were making a new language, I wouldn't include it for international considerations, but since they're already there, we have to deal with it. | null | 0 | 1316289016 | False | 0 | c2kli4y | t3_kicbo | null | t1_c2kli4y | t1_c2kkfka | null | 1427612694 | 6 | t5_2fwo | null | null | null |
True | ascii | null | You seem to be thinking about structural typing as a way to avoid typing «implements Foo», which is backwards. It's a way to send in type X into a function that expects type Y, even if Y is not an interface and X does not inherit from Y. In other words, even if a library author didn't plan for you to be using your own weird super string implementation, you still can,
You can use strucutal typing to implement translatable strings that use lazy typing in order to perform the actual translation at a later point in time. This allows you to use translation functions before the actual locale has been determined, which is sometimes extremely beneficial in web coding. The Django framework uses duck typed string-like objects to do this, and Go could do the same with structural typing.
| null | 0 | 1316289114 | False | 0 | c2klik7 | t3_kikut | null | t1_c2klik7 | t1_c2kjqg3 | null | 1427612699 | 2 | t5_2fwo | null | null | null |
True | Caraes_Naur | null | ...Said the IE team, who *still* don't give a damn about standards. | null | 0 | 1316289171 | False | 0 | c2klise | t3_kicbo | null | t1_c2klise | t1_c2kkvcr | null | 1427612702 | -1 | t5_2fwo | null | null | null |
True | Bamafan | null | >ORMs are not meant as a complete abstraction
So they're leaky by design? Maybe if they'd make this perfectly clear up front, people wouldn't have so many problems with them . | null | 0 | 1316289226 | False | 0 | c2klj0d | t3_ki83r | null | t1_c2klj0d | t1_c2kj1ip | null | 1427612704 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | > Any time you mention SQL you have just broken the I am dealing with a collection of objects abstraction.
Motherfucker, just what do you think a row is? Do you think those shits live at home in pretty little tuples? | null | 0 | 1316289282 | False | 0 | c2klj7o | t3_ki83r | null | t1_c2klj7o | t1_c2kj5r1 | null | 1427612707 | 5 | t5_2fwo | null | null | null |
True | AnythingApplied | null | While I didn't publish any math papers a lot of my friends did and they had no problem with the system.
You get to use the professors name for notoriety. Its like me giving an endorsement and saying this is so good that I would even put my name on it, so everyone who has been a fan of my work should read my student's paper.
Plus it is really easy to spot. Anytime you see a well known name with a co-author who hasn't published anything before its a pretty good assumption that the unknown did all the work and the professor was just the adviser.
You can tell that is obvious because the guy two years later called Dantzig instead of the professor. Since everyone does it its not like it is a secret. Everyone in the math world knows who did the real work. And the system has benefits as it results in your first paper actually getting read by people among other benefits.
EDIT: What in the world? It looks like your post has 40 upvotes and 39 downvotes... that is really strange. | null | 0 | 1316289311 | False | 0 | c2kljc9 | t3_hdeg3 | null | t1_c2kljc9 | t1_c2kj3j0 | null | 1427612709 | 2 | t5_2fwo | null | null | null |
True | EdgarVerona | null | I've worked with large business systems that had nothing resembling an ORM. It was a nightmare of code where either raw SQL was being assembled into strings throughout the application at some points, and at others the logic had been pulled out of the code entirely and instead existed as giant, complex stored procedures that were performing exactly the kind of processing that SQL was never meant to perform.
Sitting in one subsystem of the application was code where obviously a developer or team had decided that they needed to create a layer to abstract the SQL that had scattered freely throughout the program. What did they create? Well, essentially an ORM. And that part was the most pleasant part of the whole system to deal with as a direct result of that decision: I only wish that they had extended it to the rest of the system where it was appropriate to do so.
The vast majority of that code needed an abstraction layer - even a very leaky one - to provide some reins on what the role of the queries were and how data could migrate from objects to persisted storage and back.
Now, this does *not* have to be an ORM: there's a variety of approaches for creating an abstraction layer for database access. But there's nothing inherently flawed with ORM as an abstraction layer: it frequently shares many of the benefits and drawbacks of other database abstraction approaches: it also has some that others lack, and vice versa. They're tools meant for different tasks: different application sizes, different responsiveness requirements, and so on.
Abstractions exist in software to help us better conceptualize problems, and to make it easier on those who come after us to understand the problem as we conceptualized it. Even imperfect ones - such as some (or even all) ORMs take some positive step in that direction.
They're not glorious catch-alls: they're tools that can vastly improve the quality of your code when used properly and for the kinds of roles they fit well, and that can cause a variety of problems when pulled far from that role. The concept should not be ignored simply because it doesn't fit every potential use case.
Certain industries and types of software may use ORM all of the time because the tradeoffs are favorable for them: others may often choose a different approach. But no matter what, an abstraction layer of some sort is essential for the continued maintainability of anything but the smallest of programs.
**TL;DR** What I'm trying to say is: don't hate the tool for its flaws. Understand what those flaws are as well as what its benefits are, and thus where it is appropriate to use it. | null | 0 | 1316289336 | False | 0 | c2kljfj | t3_ki83r | null | t1_c2kljfj | t3_ki83r | null | 1427612712 | 8 | t5_2fwo | null | null | null |
True | Bamafan | null | > I've spend the last 9 years full time writing an O/R mapper system and entity modeling designer, and as a member of the small group of people who actually has written a full, mature O/R mapper I can assure you, this isn't true
I've spent the past decade writing apps that often *use* these ORMS, and I can assure you that it IS true.
| null | 0 | 1316289365 | False | 0 | c2kljiv | t3_ki83r | null | t1_c2kljiv | t1_c2kj937 | null | 1427612712 | 1 | t5_2fwo | null | null | null |
True | EdgarVerona | null | Hmm... I'm going to have to read this book. It does sound compelling, and for some reason I'm drawn to books that create cultural foundations and history vastly different from our own. Much more compelling to me than, say, fiction which occurs at some point in our own history/present day. | null | 0 | 1316289559 | False | 0 | c2klkao | t3_kgbzq | null | t1_c2klkao | t1_c2kjmed | null | 1427612721 | 2 | t5_2fwo | null | null | null |
Subsets and Splits
Filtered Reddit Uplifting News
The query retrieves specific news articles by their link IDs, providing a basic overview of those particular entries without deeper analysis or insights.
Recent Programming Comments
Returns a limited set of programming records from 2020 to 2023, providing basic filtering with minimal analytical value.