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 | EdgarVerona | null | I do the exact same thing. Just a couple of days ago I got in an argument with someone about - of all things - Scrabble. He said something that jolted me back into reality, at which point I felt pretty silly for having spent that much time arguing about something so trivial. The internet seems to... do that to people, myself included. =( Don't know if it's the anonymity, or the inability to see facial expressions/hear intonation, or what... but I totally know where you're coming from. | null | 0 | 1316289729 | False | 0 | c2klky2 | t3_kgbzq | null | t1_c2klky2 | t1_c2k7e0b | null | 1427612730 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | My solution is not difficult at all, conceptually or in implementation. Right now pharma patents aren't very long. So, implement a fix like I described and that's taken care of. I'm more worried about software patents (of any length) and copyrights lasting for decades and decades, in effect 100+ years. | null | 0 | 1316289775 | False | 0 | c2kll40 | t3_khvyw | null | t1_c2kll40 | t1_c2kl0ht | null | 1427612732 | 1 | t5_2fwo | null | null | null |
True | abreev8 | null | During the parsing stage of a compiler, you can't possibly know yet the meaning of foo and know whether to expect the optional template argument list or not. To wait until you have that knowledge to finish parsing would be a nightmare. | null | 0 | 1316290021 | False | 0 | c2klm13 | t3_kikut | null | t1_c2klm13 | t1_c2kl7ir | null | 1427612752 | 3 | t5_2fwo | null | null | null |
True | Bamafan | null | > Hibernate is pretty clear from the outset, that a good knowledge of the relational model, and SQL...
Where is this? I want to see exactly where this is spelled out "from the outset" (not 50 pages deep in random doc ). It's not on their front page, or at the beggining of their "Getting Started Guide" or their Core reference guide.
> The dox even give examples of when raw SQL is preferable.
Yes, those examples cover about 20% of the surface area. What's needed is for a doc explaining when Hibernate should be ignored completely (but you'll never see that from them). | null | 0 | 1316290045 | False | 0 | c2klm4r | t3_ki83r | null | t1_c2klm4r | t1_c2kisvj | null | 1427612745 | -1 | t5_2fwo | null | null | null |
True | abreev8 | null | What would you suggest? | null | 0 | 1316290053 | False | 0 | c2klm5q | t3_kikut | null | t1_c2klm5q | t1_c2kl5jj | null | 1427612745 | 4 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | You probably mean custom result classes, a.k.a. 'Constructor Expressions' (in JPA). | null | 0 | 1316290057 | False | 0 | c2klm67 | t3_ki83r | null | t1_c2klm67 | t1_c2kitiy | null | 1427612745 | 1 | t5_2fwo | null | null | null |
True | EdgarVerona | null | That's a very good point, and totally true.
I lived in Sacramento, CA, and it was very much like this on opposite sides of town. When my younger brothers were growing up, schools in south and central Sacramento had (for example) textbooks that were so old that they still referred to Russia and the breakoff states as the Soviet Union. The building was in shambles. Perhaps ten miles down the road you had Folsom High School, which was new and perfect (along with its textbooks), and even had an *observatory* on its campus.
I definitely agree that it's already tiered in that manner, and that is something we need to resolve as opposed to let grow and thrive. (In my opinion, of course) | null | 0 | 1316290112 | False | 0 | c2klmde | t3_kgbzq | null | t1_c2klmde | t1_c2kcd5b | null | 1427612749 | 1 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | As far as corporations go, they had plenty of money to file applications under first to invent. They'll still have plenty of money to file applications under first to file.
If you invent and reduce to practice, but keep it secret, it is not prior art against someone else's patent under either first to file or first to invent.
The record keeping I was referring to is the records to prove under first to invent your priority date. Invention date is not necessarily when you first conceived the invention. It is the earliest date such that you worked diligently at reduction to practice from that date through filing.
An individual inventor is likely to have gaps in their work on reduction to practice, and the resumption of work at the end of each gap becomes the new priority date. When multiple inventors claim the same invention, the time and duration of those gaps becomes important, so you need good verifiable records.
Under first to file, you don't need to show exactly when you started your final run of diligent work on reduction to practice, and hence there are less records you need to keep. | null | 0 | 1316290252 | False | 0 | c2klmxh | t3_khvyw | null | t1_c2klmxh | t1_c2kl9pq | null | 1427612764 | 3 | t5_2fwo | null | null | null |
True | BlatantFootFetishist | null | It's a documentation comment. Placing it on every public member is just bad style. Every such comment has a cost: code readability and code maintainability. | null | 0 | 1316290252 | False | 0 | c2klmxj | t3_kikut | null | t1_c2klmxj | t1_c2klaw8 | null | 1427612764 | 0 | t5_2fwo | null | null | null |
True | MrDOS | null | Firefox 6 on Windows 7 x64 doesn't render either sort of emoji. | null | 0 | 1316290370 | False | 0 | c2klneu | t3_kicbo | null | t1_c2klneu | t1_c2kl2y9 | null | 1427612767 | 2 | t5_2fwo | null | null | null |
True | Flarelocke | null | object/relational mapping | null | 0 | 1316290583 | False | 0 | c2klob9 | t3_ki83r | null | t1_c2klob9 | t1_c2klb4h | null | 1427612775 | 2 | t5_2fwo | null | null | null |
True | simonask | null | No? The parser doesn't need to know what `foo` exactly is (and most likely it already has no clue). `foo` is not resolved to mean anything until the binding stage of the compilation process. I am not familiar with the internals of any D compilers, but I *strongly* doubt that the *parser* handles type checking and name lookups. :) | null | 0 | 1316290764 | False | 0 | c2klp14 | t3_kikut | null | t1_c2klp14 | t1_c2klm13 | null | 1427612783 | 2 | t5_2fwo | null | null | null |
True | fuzzynyanko | null | And man, Java also can be pretty monolithic | null | 0 | 1316290764 | False | 0 | c2klp16 | t3_kii9z | null | t1_c2klp16 | t1_c2kko3i | null | 1427612783 | 2 | t5_2fwo | null | null | null |
True | mistralol | null |
I actually find there to be very little savings from using an ORM based model on most of the projects I have worked on quite often the complexity forces even the best of lib's to die. | null | 0 | 1316290850 | False | 0 | c2klpcx | t3_ki83r | null | t1_c2klpcx | t1_c2kiibv | null | 1427612787 | 3 | t5_2fwo | null | null | null |
True | harlows_monkeys | null | So the provisions that greatly increase costs for patent trolls, make it harder for patent trolls to determine venue, make it easier to find prior art against patent trolls, and greatly increase the risk that patent trolls will lose their patents if they litigate them not improvements!? | null | 0 | 1316291074 | False | 0 | c2klq6f | t3_khvyw | null | t1_c2klq6f | t1_c2keil8 | null | 1427612798 | 6 | t5_2fwo | null | null | null |
True | rasherdk | null | Unicode doesn't specify them as being in colour. That's something Apple decided to do. I see a b/w cactus. | null | 0 | 1316291298 | False | 0 | c2klr12 | t3_kicbo | null | t1_c2klr12 | t1_c2kkaeb | null | 1427612809 | 2 | t5_2fwo | null | null | null |
True | mistralol | null |
Yes I have seen this and heard this from a lot of developers. Personally I have avoided using this sort's of support lib's. I have never had a problem maintaining massive databases with 50+ tables some of which have 50m rows etc.. in them.
Typically the sql that is required to be written for these apps really doesn't actually take that long to write in the first place. Even more so that after you have been in the sql <-> oo game for a while you figure out that you have already solved "most" issues over the years and can simply pull old code into a new project :) this includes the sql / stored procedures / tables / index's and you know it works already :)
| null | 0 | 1316291342 | False | 0 | c2klr5z | t3_ki83r | null | t1_c2klr5z | t1_c2kj4xu | null | 1427612812 | 2 | t5_2fwo | null | null | null |
True | rozap | null | Exactly. We all sucked at programming at one point...and its such a broad field, the more you know, the more you feel like you don't know really applies here. Some of us are here to learn. | null | 0 | 1316291355 | False | 0 | c2klr8u | t3_kii9z | null | t1_c2klr8u | t1_c2kjzpb | null | 1427612813 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316291363 | False | 0 | c2klr9y | t3_kii9z | null | t1_c2klr9y | t3_kii9z | null | 1427612813 | 1 | t5_2fwo | null | null | null |
True | JL235 | null | I find more canvas bugs in Chrome and FireFox, then in IE 9. I even found a spot today, where Chrome works differently in regards to 'lineWidth', then other browsers.
So at least what IE 9 does support, it supports well. | null | 0 | 1316291386 | False | 0 | c2klrdq | t3_kicbo | null | t1_c2klrdq | t1_c2klise | null | 1427612815 | 9 | t5_2fwo | null | null | null |
True | mistralol | null |
IF you find that your are writing the same crap over and over then you are probably doing it wrong in the first place. Weather that be code or sql .... | null | 0 | 1316291411 | False | 0 | c2klrhc | t3_ki83r | null | t1_c2klrhc | t1_c2kj7o1 | null | 1427612816 | 5 | t5_2fwo | null | null | null |
True | rasherdk | null | You just need to get the right fonts. Install Symbola from [this page](http://users.teilar.gr/~g1951d/) and you should see most (all?) emoji. However, it will be black/white, because you know, it's a goddamn font and fonts aren't in full colour! | null | 0 | 1316291450 | False | 0 | c2klrn7 | t3_kicbo | null | t1_c2klrn7 | t1_c2klneu | null | 1427612818 | 2 | t5_2fwo | null | null | null |
True | adrianmonk | null | > This does not concern finding the proof.
I don't see what I'm missing here. To me, the plain English meaning of the word "figuring out if P = NP" *is* finding the proof. Apparently other people think it means something else, but I can't figure out what. | null | 0 | 1316291765 | False | 0 | c2klsv0 | t3_kgfhb | null | t1_c2klsv0 | t1_c2kit3w | null | 1427612833 | 1 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | People have been using ORM frameworks long enough to gain firsthand experience and see their deficits and shortcomings. Time for a reality check. | null | 0 | 1316292020 | False | 0 | c2kltus | t3_ki83r | null | t1_c2kltus | t1_c2kk2jn | null | 1427612845 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316292038 | False | 0 | c2kltwy | t3_khvyw | null | t1_c2kltwy | t1_c2khtwc | null | 1427612845 | 4 | t5_2fwo | null | null | null |
True | badsectoracula | null | Since most of the geometry is static, it is better to use geometry-only display lists instead of VBOs. The driver is free to modify the list for better performance (something that nVidia's drivers actually do and DLs are the best option in nVidia hardware for static geometry) and DLs are compatible with basically every OpenGL implementation out there. | null | 0 | 1316292322 | False | 0 | c2klv18 | t3_kgq62 | null | t1_c2klv18 | t1_c2ka7b9 | null | 1428193786 | 4 | t5_2fwo | null | null | null |
True | jeff_hanson | null | Wasn't this considered evil when it was called ActiveX? | null | 0 | 1316292344 | False | 0 | c2klv3t | t3_kitgf | null | t1_c2klv3t | t3_kitgf | null | 1428193787 | 5 | t5_2fwo | null | null | null |
True | ErstwhileRockstar | null | > It was a nightmare of code where either raw SQL was being assembled into strings throughout the application at some points
JPAQL strings are still assembled randomly throughout the application. But nowadays this is called ORM and it reprsents modern Enterprise technology.
| null | 0 | 1316292362 | False | 0 | c2klv62 | t3_ki83r | null | t1_c2klv62 | t1_c2kljfj | null | 1427612863 | 5 | t5_2fwo | null | null | null |
True | audaxxx | null | SQLAlchemy for example:
>SQLAlchemy is most famous for its object-relational mapper (ORM), an optional component that provides the data mapper pattern, where classes can be mapped to the database in open ended, multiple ways - allowing the object model and database schema to develop in a cleanly decoupled way from the beginning.
And Hibernate:
>Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects.
Perls DBIx::Class:
>DBIx::Class is a SQL->OOP mapper. This means that it can represent your SQL tables as perl classes, and give you convenient accessors and methods for retrieving and updating information from your SQL database.
You can't really call them leaky, because they want to give you the Power of your database in convenient, language specific ways. For example SQLAlchemy for Python works great with OOP and with functional patterns, so you can manipulate your queries with all your tools. ORMs are a way to _integrate_ the database API in your language for example by translating your queries into objects or functions (like in haskell) or whatever you want and suits the language you use. There are probably even ORMs for XSLT...
| null | 0 | 1316292390 | False | 0 | c2klv9p | t3_ki83r | null | t1_c2klv9p | t1_c2klj0d | null | 1427612864 | 7 | t5_2fwo | null | null | null |
True | Fuco1337 | null | If I have a proof of some theorem, I can write it down, and it has a constant length. If you ask for a proof of P=NP, and if the proof exist, I should be able to write it down as a constant length sequence of instructions/statements. If I can do it, surely a TM can do it.
If I want to figure out if P=NP, I can simply get this TM, and let it print either YES or NO, and I can then decide in a single step. So proving this theorem is constant time operation.
I think this is mostly playing with words. What you're probably after is stuff like [Automated theorem proving](http://en.wikipedia.org/wiki/Automated_theorem_prover), where even Propositional logic proofs are damn difficult (Co-NP complete actually). | null | 0 | 1316292469 | False | 0 | c2klvkf | t3_kgfhb | null | t1_c2klvkf | t1_c2klsv0 | null | 1427612878 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | With a bit of work I bet you can run it on .NET Micro and all those embedded devices that don't even have an OS. | null | 0 | 1316292671 | False | 0 | c2klwcc | t3_kii9z | null | t1_c2klwcc | t1_c2kk4u7 | null | 1427612881 | 1 | t5_2fwo | null | null | null |
True | KayRice | null | Article doesn't seem to arrive at a rationale reason that ORM is a flawed design pattern. | null | 0 | 1316292792 | False | 0 | c2klwt3 | t3_ki83r | null | t1_c2klwt3 | t3_ki83r | null | 1427612891 | 1 | t5_2fwo | null | null | null |
True | mistralol | null |
Yeah the problem you meet in that is there are too many developers who don't care about sql. If they freely scatter sql code throughout a large and complex system. It will be almost impossible to test. If you have dba's involved they will also hate you since they cannot see only their side of the problem. Since they don't really care about the app they only want to be involved in the database and that it is working fast enough and holding data integrity.
Something that also happens with developers is they tend to produce dynamic sql where it is not needed. Something that I came up with was to force all developers to store their static sql inside static functions. So that it could be converted to sproc's later when it had matured enough. The static's were stored in a class named the same as the leading table that was quried in the select. It worked really well.
The really nice thing about it was the ability to hand the problem off to dba's for performance issues which they didn't mind since they were only reading sql with quotes around it instead of 100's of lines of mush that they did not care about.
We also solved a lot of issues with developers creating dynamic sql. Using the same sort of thing. However we would limit 1 dynamic sql statement per class. Only all the variables had to be described in the class then the sql was build sequentiality inside the class. This result in really clean and easy to understand code for variable sql statements. It also results in almost no failed sql statements at runtime. Mostly because it made it really easy to test the dynamic stuff for stability, security and performance. Note some of the sql above was reaching around 1000+ lines of sql code for a single run.
| null | 0 | 1316292794 | False | 0 | c2klwth | t3_ki83r | null | t1_c2klwth | t1_c2kljfj | null | 1427612891 | 2 | t5_2fwo | null | null | null |
True | davidk01 | null | I am not impressed. Generating data from some data source combined with some meta-data has been around for a while. What I'm interested in is how easy or hard it is to write these data providers for sources of data that don't necessarily fit into the categories he's using. The examples he provides don't give a good sense of that. | null | 0 | 1316292810 | False | 0 | c2klwvv | t3_kii9z | null | t1_c2klwvv | t3_kii9z | null | 1427612891 | 2 | t5_2fwo | null | null | null |
True | EdgarVerona | null | True, I think some ORMs really can get ugly on that front.
However there's alternatives, like Linq expressions that query against the object model, and under the surface the object model query is translated into a SQL query, and it's returned back as objects.
Linq queries expressed in terms of the object model protects from a lot of the ugliness of forming a SQL query (as well as the potential security risks).
One could argue that you're still "building a query": and yes, at some point you've got to say what you need to find. But I'd rather express that in terms of the object model in applications where clarity of purpose in the application is more important than realtime responsiveness. That's just my take though.
Not to say that your point isn't valid though. There's plenty of ORMs that just change what the ugliness is. And there's definitely an argument that even approaches like Linq are still ugly. I can't speak on the latter though, as I seldom feel that way. They feel very readable and are formed in the language of the object model, and to me that feels solid and comprehensible. | null | 0 | 1316292846 | False | 0 | c2klx0t | t3_ki83r | null | t1_c2klx0t | t1_c2klv62 | null | 1427612893 | 2 | t5_2fwo | null | null | null |
True | EdgarVerona | null | Ah, aye: that's a good example of an alternative abstraction approach, and it sounds like it ended up working well for you once you established the ground rules (and would for others as well, I imagine). Definitely goes to show that there's a lot of tools and approaches out there. | null | 0 | 1316293060 | False | 0 | c2klxuj | t3_ki83r | null | t1_c2klxuj | t1_c2klwth | null | 1427612898 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316293068 | True | 0 | c2klxvo | t3_kf4hn | null | t1_c2klxvo | t1_c2jx46y | null | 1427612899 | 1 | t5_2fwo | null | null | null |
True | rubygeek | null | I think the basic problem this this guy has with ORM's is that the model classes are being treated as part of the applications data model as opposed to as a model of the database storage.
If you act on them with disregard for how they are stored and retrieved from a relational database, you'll end up with horrendous performance and other problems.
If you act on them them in performance optimal ways, then database abstraction issues leak all over your other code, unless you've been very strict about adding methods to the model classes themselves that expose a much higher level API to the rest of your application. But even then the model classes themselves will then often be full of code that mixes business logic with code that could have been abstracted down into a cleaner layer below.
| null | 0 | 1316293073 | False | 0 | c2klxw7 | t3_ki83r | null | t1_c2klxw7 | t1_c2kljfj | null | 1427612899 | 5 | t5_2fwo | null | null | null |
True | grauenwolf | null | On possible reason is the name of the assembler is often simply asm.exe. | null | 0 | 1316293099 | False | 0 | c2klxzi | t3_khxzd | null | t1_c2klxzi | t1_c2kl77z | null | 1427612899 | 1 | t5_2fwo | null | null | null |
True | gwiazdorrr | null | I wish I could upvote it a hundred times. Extremely informative. | null | 0 | 1316293127 | False | 0 | c2kly3a | t3_khryi | null | t1_c2kly3a | t3_khryi | null | 1427612901 | 3 | t5_2fwo | null | null | null |
True | jeff_hanson | null | What kind of fool would WANT to run Windows on a server? | null | 0 | 1316293196 | False | 0 | c2klydu | t3_kii9z | null | t1_c2klydu | t1_c2kjgpe | null | 1427612904 | -1 | t5_2fwo | null | null | null |
True | davebrk | null |
>May doves shit into their eyes.
That's going into my favorite curses collection. I'm going to reserve it for all the old ladies that feed those very same doves in my area. | null | 0 | 1316293198 | False | 0 | c2klyep | t3_kikut | null | t1_c2klyep | t1_c2kl9ac | null | 1427612905 | 4 | t5_2fwo | null | null | null |
True | rubygeek | null | You don't need to give up objects to use relational algebra. A good ORM lets you express pretty much any SQL and still get a nice object mapping back.
| null | 0 | 1316293367 | False | 0 | c2klz5k | t3_ki83r | null | t1_c2klz5k | t1_c2kjv91 | null | 1427612915 | 2 | t5_2fwo | null | null | null |
True | boondogglesafflated | null | LOL this is hilarious! [Iphone Robot](http://www.wirelessgadgets.info) | null | 0 | 1316293586 | False | 0 | c2km04c | t3_ka4h8 | null | t1_c2km04c | t3_ka4h8 | null | 1427612928 | 1 | t5_2fwo | null | null | null |
True | banuday | null | > hard-wiring of interfaces at class-design time makes for a very weak system.
Not necessarily. I brought up Scala precisely because it also uses hard-wired interfaces (subtype polymorphism) just like Java. However, it also provides [structural subtyping](http://langexplr.blogspot.com/2007/07/structural-types-in-scala-260-rc1.html) which is nearly identical to the Go feature, but operates in accordance to the principles of OOP, basically implementing something like the dynamic message dispatch of Smalltalk/Ruby/ObjC but in a statically-checked type-safe manner.
| null | 0 | 1316293687 | True | 0 | c2km0iy | t3_kikut | null | t1_c2km0iy | t1_c2kl7bo | null | 1427612934 | 3 | t5_2fwo | null | null | null |
True | EdgarVerona | null | That is definitely a good point, and definitely true detriments of ORMs: but I think those points address more the benefits and drawbacks of ORM as a tool, rather than that ORM is fundamentally bad (as the title suggests). There's some apps where, for example, performance isn't really an issue: or they can "throw so much hardware" at the problem that the level of stress undertaken is minimal. | null | 0 | 1316293688 | False | 0 | c2km0j8 | t3_ki83r | null | t1_c2km0j8 | t1_c2klxw7 | null | 1427612934 | 3 | t5_2fwo | null | null | null |
True | moreyes | null | Because it is irrelevant to the subject of the post. | null | 0 | 1316293737 | False | 0 | c2km0qb | t3_kikut | null | t1_c2km0qb | t1_c2kjtrn | null | 1427612936 | 6 | t5_2fwo | null | null | null |
True | Paiev | null | Not really? My interpretation is pretty much the only one that makes sense. Reread the sentence. "If a single x is blah, then all of them are bluh". "Them" clearly refers to "x", not "x-complete", which isn't even mentioned in his reply. And given the quote he was basing this on, it's perfectly possible that he would have this misunderstanding.
It's not minor pedantry, it's... basic reading comprehension. | null | 0 | 1316293768 | False | 0 | c2km0ud | t3_kgfhb | null | t1_c2km0ud | t1_c2kj3ix | null | 1427612946 | 1 | t5_2fwo | null | null | null |
True | freeall | null | I'm sorry, and please let the downvotes comes.
But I was in the cinema earlier and saw a trailer for a movie where the director was called Singleton. At the time I thought it was quite funny - yeah, I know, it doesn't take much. | null | 0 | 1316293976 | False | 0 | c2km1mk | t3_kiymt | null | t1_c2km1mk | t3_kiymt | null | 1427612948 | 0 | t5_2fwo | null | null | null |
True | kmeisthax | null | Uh, I thought there was a skip this link on that page, last I got hit with it... | null | 0 | 1316294007 | False | 0 | c2km1rg | t3_kikut | null | t1_c2km1rg | t1_c2kl9ac | null | 1427612949 | 3 | t5_2fwo | null | null | null |
True | jdeisenberg | null | My brain must be working slowly today; it took me nearly 30 seconds to make the connection. | null | 0 | 1316294127 | False | 0 | c2km28a | t3_kiymt | null | t1_c2km28a | t3_kiymt | null | 1427612958 | 1 | t5_2fwo | null | null | null |
True | kmeisthax | null | So basically, Go interfaces are like C++ concepts?
(Or, at least, what were going to be C++ concepts before they were axed from 0x at the last minute?) | null | 0 | 1316294134 | False | 0 | c2km29g | t3_kikut | null | t1_c2km29g | t1_c2kjjwa | null | 1427612960 | 2 | t5_2fwo | null | null | null |
True | mistralol | null |
I have got tired of working in startups and small companies that might make it or might not. I have just moved to a bank :) | null | 0 | 1316294180 | False | 0 | c2km2ga | t3_khx0u | null | t1_c2km2ga | t3_khx0u | null | 1427612959 | 2 | t5_2fwo | null | null | null |
True | babazka | null | ...unless said browser is IE10 in Metro mode.
Other than that, it's cool. | null | 0 | 1316294287 | False | 0 | c2km2uu | t3_kitgf | null | t1_c2km2uu | t3_kitgf | null | 1427612963 | -9 | t5_2fwo | null | null | null |
True | [deleted] | null | > In Java, something has to expicitly implement an interface in order to be cast:able to that interface. In structurally typed languages like Go, it is enough to have a compatible type signature in order to be cast:able to a type.
Sorry, but I'm a bit lost here. What's the difference? In order to have a compatible type signature don't those types need to implement the interfaces? | null | 0 | 1316294330 | False | 0 | c2km30j | t3_kikut | null | t1_c2km30j | t1_c2kjjwa | null | 1427612966 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316294531 | False | 0 | c2km3ry | t3_khnlm | null | t1_c2km3ry | t3_khnlm | null | 1427612975 | 1 | t5_2fwo | null | null | null |
True | JL235 | null | In most languages, when you work with SQL, you are not using SQL at all. You are working with strings, which are then parsed as SQL.
As a result there is a huge loss of context, which can lead to epic amounts of string concatenation, more debugging, and a higher potential for security holes.
The single aspect I like with ORMs is that they allow you to avoid the majority of SQL. Being able to access the DB, in the language I am using, makes me far more productive. | null | 0 | 1316294532 | False | 0 | c2km3s4 | t3_ki83r | null | t1_c2km3s4 | t3_ki83r | null | 1427612975 | 2 | t5_2fwo | null | null | null |
True | freeall | null | But it only took so long the first time you had to make the connection. After that it was instant. Right? :) | null | 0 | 1316294569 | False | 0 | c2km3wt | t3_kiymt | null | t1_c2km3wt | t1_c2km28a | null | 1427612978 | 2 | t5_2fwo | null | null | null |
True | badsectoracula | null | > or at least no one has managed to speak loud enough to make everybody to use say ^[^[ to signify an escape key press in a terminal. Mind boggles.
But i tend to press <ESC><num> (f.e. <ESC>3) instead of function keys wherever i cannot press the press the function key for whatever reason (f.e. the F3 key in Mac OS X is bound system-wide to Expose and i need to do keyboard gymnastics to actually send the F3 keycode to the terminal so pressing <ESC> and 3 is usually simpler).
| null | 0 | 1316294602 | False | 0 | c2km41m | t3_kgl4f | null | t1_c2km41m | t1_c2kep6i | null | 1427612980 | 1 | t5_2fwo | null | null | null |
True | Drfuzzykins | null | I know that this is largely irrelevant to the content of the post, but [rpartition](http://ruby-doc.org/core/classes/String.html#M001216):
klass = method_name.rpartition('::').first
klass.empty? ? 'Object' : klass | null | 0 | 1316294636 | False | 0 | c2km46r | t3_khnlm | null | t1_c2km46r | t3_khnlm | null | 1427612989 | 1 | t5_2fwo | null | null | null |
True | 0xABADC0DA | null | So if in Google Go you can pass a struct X in where a method expects struct Y then what is the purpose of interfaces? Why not just use a struct?
Or are you saying with structural typing you can do these things you mentioned, but structural typing in Google Go is not good enough to?
EDIT: I was expecting too much of readers. In Google Go you *cannot* pass type X to a function that expects type Y unless Y is an interface (same as Java). If the library author did not plan for you to be using your own weird implementation, you can't. | null | 0 | 1316295065 | True | 0 | c2km5x8 | t3_kikut | null | t1_c2km5x8 | t1_c2klik7 | null | 1427613004 | 0 | t5_2fwo | null | null | null |
True | adelie42 | null | >at least what IE 9 does support, it supports well
Kind of like a Mac? | null | 0 | 1316295155 | False | 0 | c2km69e | t3_kicbo | null | t1_c2km69e | t1_c2klrdq | null | 1427613017 | -3 | t5_2fwo | null | null | null |
True | Solon1 | null | This version number thing is just another bikeshed.
It is non technical so everyone's got an opinion.
And there are still major and minor updates, as the current version is 6.0.2. The ".0.2" part is the update. So not only is this just another bikeshed, this specific thread on the need for minor versions, is nonsense. | null | 0 | 1316295509 | False | 0 | c2km7ml | t3_kghid | null | t1_c2km7ml | t1_c2k2uuo | null | 1427613025 | 2 | t5_2fwo | null | null | null |
True | mistralol | null |
Why? | null | 0 | 1316295742 | False | 0 | c2km8ji | t3_kgqnz | null | t1_c2km8ji | t1_c2kb038 | null | 1427613037 | 1 | t5_2fwo | null | null | null |
True | ntr0p3 | null | I can't speak to this, other than to say it is more about curiosity than anything in those technical fields.
CS and EE came as easily to me as reading to moderately smart kids. I still use CS/EE as my fallback skills, because they take little enough effort that I can support myself well while focusing real effort on more important fields.
OTOH I know many people who were forced up the CS chain, and are barely competent (if that) as adults. | null | 0 | 1316295761 | False | 0 | c2km8mk | t3_khf6j | null | t1_c2km8mk | t1_c2kcuo4 | null | 1427613038 | 2 | t5_2fwo | null | null | null |
True | Heterogenic | null | I hate having to upvote this... but... | null | 0 | 1316295808 | False | 0 | c2km8tb | t3_kiymt | null | t1_c2km8tb | t3_kiymt | null | 1427613040 | 1 | t5_2fwo | null | null | null |
True | seydar | null | An analogy that probably nobody here would understand is that it's like your weekly run mileage. It's a great post-game analysis, but it should not be your goal because you will miss a lot of important attributes like intervals, run quality, and injury. If I'm running 7 days/week and 50 mi/week, if I miss one day I can lose maybe 15% of my mileage. This will look REALLY bad in the mileage report. However, if it's only one day out of a block of 90 straight days that I've been running, the missed mileage is meaningless. | null | 0 | 1316295810 | False | 0 | c2km8tl | t3_khhdj | null | t1_c2km8tl | t1_c2kb9so | null | 1427613041 | 1 | t5_2fwo | null | null | null |
True | seydar | null | > We want good test coverage, but we don't define bad.
That's a PERFECT way to say it! Thank you, I'm going to be using this elsewhere to define similar scenarios. | null | 0 | 1316295840 | False | 0 | c2km8yp | t3_khhdj | null | t1_c2km8yp | t1_c2kfm50 | null | 1427613042 | 1 | t5_2fwo | null | null | null |
True | mistralol | null |
Though I read into as. Have systems not been doing this for years?
Every time somebody somewhere comes up with a new incompatible way for things to communicate with other things so everyone has to go an change everything :)
| null | 0 | 1316295871 | False | 0 | c2km946 | t3_kgqnz | null | t1_c2km946 | t1_c2k7pbi | null | 1427613045 | 1 | t5_2fwo | null | null | null |
True | ascii | null | I'm not 100 % up to speed with C++0x, but from my understanding, yes. | null | 0 | 1316295918 | False | 0 | c2km9au | t3_kikut | null | t1_c2km9au | t1_c2km29g | null | 1427613048 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | > For other people named John Singleton, see John Singleton (disambiguation).
| null | 0 | 1316295923 | False | 0 | c2km9bj | t3_kiymt | null | t1_c2km9bj | t3_kiymt | null | 1427613048 | 3 | t5_2fwo | null | null | null |
True | s73v3r | null | That's where you're wrong. For the hardware they've got, existing tablet OSes do an excellent job in utilizing the hardware. Some of the stuff on the iPad is damn impressive.
And again, you're not going to be able to run legacy Windows apps in the Metro environment. So either you're going to have to port your app to run in tablet mode, or always have the hardware keyboard and mouse, in which case you might as well just have a laptop. | null | 0 | 1316295958 | False | 0 | c2km9g3 | t3_kejwo | null | t1_c2km9g3 | t1_c2k7uu4 | null | 1427613049 | 1 | t5_2fwo | null | null | null |
True | jyper | null | What about [Concepts\(wiki\)](http://en.wikipedia.org/wiki/Concepts_%28C%2B%2B%29) | null | 0 | 1316296017 | False | 0 | c2km9ny | t3_kikut | null | t1_c2km9ny | t1_c2kkbix | null | 1427613053 | 0 | t5_2fwo | null | null | null |
True | adrianmonk | null | > If you ask for a proof of P=NP, and if the proof exist, I should be able to write it down as a constant length sequence of instructions/statements. If I can do it, surely a TM can do it.
Yes, sure. A Turing machine includes a tape. If you want, you can use a Turing machine as a tape recorder. In this (degenerate) case, the complexity is O(1). I just don't see what it gains you to use a Turing machine as a tape recorder. | null | 0 | 1316296043 | False | 0 | c2km9ru | t3_kgfhb | null | t1_c2km9ru | t1_c2klvkf | null | 1427613054 | 1 | t5_2fwo | null | null | null |
True | danharaj | null | **------->** | null | 0 | 1316296098 | False | 0 | c2km9zf | t3_kiymt | null | t1_c2km9zf | t3_kiymt | null | 1427613057 | 0 | t5_2fwo | null | null | null |
True | deong | null | I was under the impression that the venue-shopping clauses were stripped out and that nothing changed on that front. Can't be buggered to look that up right now... | null | 0 | 1316296485 | False | 0 | c2kmbhf | t3_khvyw | null | t1_c2kmbhf | t1_c2klq6f | null | 1427613077 | 2 | t5_2fwo | null | null | null |
True | deong | null | You don't even have to read it to answer that question. Any law passed in the United States is beneficial to its citizens only insofar as their interests happen to coincide with those of corporations.
There are no known exceptions to this rule. | null | 0 | 1316296573 | False | 0 | c2kmbtl | t3_khvyw | null | t1_c2kmbtl | t3_khvyw | null | 1427613080 | 7 | t5_2fwo | null | null | null |
True | audaxxx | null | Let's look at ORMs in Haskell... | null | 0 | 1316296611 | False | 0 | c2kmbyx | t3_ki83r | null | t1_c2kmbyx | t1_c2kkr8y | null | 1427613083 | 1 | t5_2fwo | null | null | null |
True | rubygeek | null | I'm not arguing that ORM's are bad, because I think that's a far too wide claim. I do however have issues with a lot of how people tend to use ORM's, and *particularly* the widespread use of active record type ORM's (not just *the* ActiveRecord, but the overall pattern) that pretty much encourage you to write code that is pretty much SQL with object syntax and/or brutally abuse the database (that is **not** to say that you *can't* write clean code using both ActiveRecord in particular and the active record pattern in general, just that it's down to developer discipline, and I can't say I've known many disciplined developers in my career).
If only more people had continued to read Fowler's book past the chapter on active record before starting to write ORM's.... But most peoples exposure to ORM's still seem to be pretty much only the active record pattern.
A lot of these problems would go away if people would use ORM's based on more avanced patterns and/or if people would encapsulate their model layer in something that would expose much narrower API's to their application (that would force code that depend on the database organization to go into either the ORM's model classes or the intermediate layer).
Of course some of the more advanced patterns *do* encourage a separation that makes narrower API's easy.
| null | 0 | 1316296751 | False | 0 | c2kmci2 | t3_ki83r | null | t1_c2kmci2 | t1_c2km0j8 | null | 1427613091 | 3 | t5_2fwo | null | null | null |
True | washort | null | Yes, because ActiveX made no attempt at security at all. NaCl is based on virtualization/sandboxing tech that prevents access outside the granted abilities. (Google has already paid bounties to people who have found weaknesses in this, and fixed the stuff they found.) | null | 0 | 1316297093 | False | 0 | c2kmdsb | t3_kitgf | null | t1_c2kmdsb | t1_c2klv3t | null | 1427613107 | 29 | t5_2fwo | null | null | null |
True | EdgarVerona | null | Good points all around, and I agree with you on all of it. I definitely tend to chafe more against ActiveRecord than other types of database abstractions, I have to admit. I tend to use it primarily for prototypes, where I know that if it's successful there'll be the funds available to replace that which we quickly built. But I'm with you, I've seen systems built with ActiveRecord that stuck with it: and at a certain point of complexity it tends to fall apart. | null | 0 | 1316297122 | False | 0 | c2kmdwp | t3_ki83r | null | t1_c2kmdwp | t1_c2kmci2 | null | 1427613110 | 2 | t5_2fwo | null | null | null |
True | thoomfish | null | Not all languages have fast implementations, and the speed of the fastest implementation can and does vary between languages. The fastest Ruby implementation, for example, is at least an order of magnitude slower than the fastest C# implementation. | null | 0 | 1316297226 | False | 0 | c2kmeb3 | t3_kii9z | null | t1_c2kmeb3 | t1_c2kktt0 | null | 1427613113 | 1 | t5_2fwo | null | null | null |
True | dons | null | valid in Haskell -- http://www.reddit.com/r/haskell/comments/kixek/a_play_in_one_act/ | null | 0 | 1316297231 | False | 0 | c2kmebv | t3_kicbo | null | t1_c2kmebv | t3_kicbo | null | 1427613113 | 3 | t5_2fwo | null | null | null |
True | szaero | null | You're right, but that doesn't happen in the real world.
People constantly write software and come back later to fill in documentation, or never come back at all. No matter what the rules are, or the best intentions. The only thing you can infer from the absence of documentation is that it hasn't been written. If you infer that it needs no documentation you're definitely making a mistake. | null | 0 | 1316297320 | False | 0 | c2kmeoa | t3_kikut | null | t1_c2kmeoa | t1_c2kjuwg | null | 1427613117 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | There is, its called WRL. see Windows Kits\8.0\Include\winrt\wrl | null | 0 | 1316297327 | True | 0 | c2kmepe | t3_kgs75 | null | t1_c2kmepe | t1_c2k536m | null | 1427613119 | 3 | t5_2fwo | null | null | null |
True | jyper | null | Do you mean typeclasses? I think those don't count since you have to declare what you are implementing even if you can have the implementation in different places. (To be fair I don't know that much haskell so it could be some other feature) | null | 0 | 1316297406 | False | 0 | c2kmf0q | t3_kikut | null | t1_c2kmf0q | t1_c2kjzo6 | null | 1427613123 | 1 | t5_2fwo | null | null | null |
True | gperlman | null | If it's sandboxed, then how is it better than just-in-time compiled JavaScript? I guess because you could write code in C rather than JavaScript. That's about it. | null | 0 | 1316297459 | False | 0 | c2kmf7r | t3_kitgf | null | t1_c2kmf7r | t3_kitgf | null | 1427613125 | 0 | t5_2fwo | null | null | null |
True | ascii | null | Consider a method foo that accepts a single parameter of type Bar:
void foo(Bar param){
...
}
class Bar {
public void call1(){
...
}
}
Now, suppose that you want to future proof that code. When unit testing your code, it might be necessary to send in a fake Foo object. Or you might want to use some kind of remote proxy to a Foo object on a different machine. Those things won't extend Foo. That's when interfaces come in. We rewrite the above as:
interface IBar {
void call1();
....
}
class Bar implements IBar {
public void call1(){
...
}
}
void foo(IBar param){
...
}
That's much more future proof! When we do our unit test we can write a short circuted little fake TestBar class and send that to foo. We can create our cool remote proxy object, and so on. The foo method is officially future proof!
But what about the other 1000 methods in an average sized program or library? When you start thinking about it, there really are no methods where it _isn't_ useful to be able to send in a work-alike object instead of the one you originally had in mind. But if we want to future proof every method we create, we need an interface for each and every class we create. That will probably increase our code size by something like 20 to 50 %. And it will double the number of source code files. And how many times will you add an extra method to your class and forget about updating the interface? Suddenly, this is starting to look like an _enormous_ maintenance nightmare.
Enter structural typing. Given this code:
void foo(Bar param){
...
}
_any class_ that has all the members of Bar can be used as the parameter for foo. Interfaces without the maintenance nightmare. How very useful.
There is a strong parallel between structural typing and the concept of properties, as used in e.g, Python, Object Pascal or C#?.
* In Java, it's frowned upon to use public member variables, because what if in the future, you want to e.g. run an even handler when the value changes or calculate the value programatically.
* For that reason, it is best practice to use getters and setters in stead of public member variables.
* A bunch of other languages figure out that creating getters and setters for all your member variables is a bunch of boring useless and error prone busy work, so they come up with the idea of properties. Suddenly, you can create all the public member variables you like, and if you want to e.g. run a event dispatcher whenever the value changes, you can redefine the member variable as a property and do whatever you want - and your objects public interface hasn't changed.
* The advantage is that you don't need write 6 useless lines of code for *every single member variable* just to make sure your public interface is future proof.
Properties future proof public member variables. Structural typing future proof input parameters to methods. They both allow you to to concentrate on writing code that does what you want today, and let the compiler take care of making the code extensible abstractable and future proof. Neat! | null | 0 | 1316297750 | False | 0 | c2kmgcr | t3_kikut | null | t1_c2kmgcr | t1_c2km30j | null | 1427613140 | 4 | t5_2fwo | null | null | null |
True | LetsGetDigital | null | Yes, that is true. The point was that's dependent on the implementation, not the language itself. It also matters what you're doing. If you're heavily I/O bound and not doing a lot of math, it doesn't really matter what you're writing it in. | null | 0 | 1316297864 | False | 0 | c2kmgsv | t3_kii9z | null | t1_c2kmgsv | t1_c2kmeb3 | null | 1427613145 | 2 | t5_2fwo | null | null | null |
True | paul_mendoza | null | They made the editor way faster now. It uses multiple cores now to continually rebuild code in the background and alert you to errors quicker. | null | 0 | 1316297948 | False | 0 | c2kmh54 | t3_kg44k | null | t1_c2kmh54 | t1_c2k14kp | null | 1427613150 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | You aren't factoring in the startups that fail (which is most of them) | null | 0 | 1316297997 | False | 0 | c2kmhck | t3_khx0u | null | t1_c2kmhck | t1_c2kjmyj | null | 1427613153 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | >If it's sandboxed, then how is it better than just-in-time compiled JavaScript? I guess because you could write code in C rather than JavaScript. That's about it.
You can write code and make use of libraries that target x86. There are vast libraries written in C/C++ that can now be made available in web-apps. | null | 0 | 1316298009 | False | 0 | c2kmhe8 | t3_kitgf | null | t1_c2kmhe8 | t1_c2kmf7r | null | 1427613154 | 3 | t5_2fwo | null | null | null |
True | ascii | null | Interfaces are useful when a method expects only a subset of the members of any existing struct. For example, a sort method needs a way to way to compare two elements and a way to swap two elements, but e.g. a List will also provide methods for iterating, assigning, slicing and various other things. If the sort method expects a list, then any non-list that we want to be able to sort will need to implement a bunch of extra methods that aren't actually required for sorting and that might not make sense for that type of data structure. | null | 0 | 1316298066 | False | 0 | c2kmhmt | t3_kikut | null | t1_c2kmhmt | t1_c2km5x8 | null | 1427613157 | 3 | t5_2fwo | null | null | null |
True | abreev8 | null | That's my point. How do you parse foo(...)(...) when you've omitted the '!'? | null | 0 | 1316298107 | False | 0 | c2kmht8 | t3_kikut | null | t1_c2kmht8 | t1_c2klp14 | null | 1427613159 | 2 | t5_2fwo | null | null | null |
True | Porges | null | Unicode also is trying to get round-trip compatibility with legacy encodings. That means it's basically a superset of all encodings ever. | null | 0 | 1316298160 | False | 0 | c2kmi09 | t3_kicbo | null | t1_c2kmi09 | t1_c2kk6ky | null | 1427613163 | 5 | t5_2fwo | null | null | null |
True | 00kyle00 | null | Only practical difference i see is you don't need to explicitly say you do implement them. No sure why its such a big deal though.
In fact i see a (slight and probably far fetched) disadvantage in that someone could implement an interface accidentally (and thus not follow required semantics). | null | 0 | 1316298218 | False | 0 | c2kmi8p | t3_kikut | null | t1_c2kmi8p | t1_c2km30j | null | 1427613165 | 3 | t5_2fwo | null | null | null |
True | Solon1 | null | I just starting reading your reply, but it is already clear that there is a lot of useful, well expressed information in it. | null | 0 | 1316298459 | False | 0 | c2kmj5h | t3_khryi | null | t1_c2kmj5h | t1_c2khgul | null | 1427613176 | 0 | t5_2fwo | null | null | null |
True | dsfox | null | And ☠ | null | 0 | 1316298510 | False | 0 | c2kmjce | t3_kicbo | null | t1_c2kmjce | t1_c2kka2p | null | 1427613179 | 5 | t5_2fwo | null | null | null |
True | noumuon | null | >musical prodigies aren't considered prodigies just for their mechanical abilities, but because they express a similar musicality (i.e. expression, emotion, and the like) to adults despite their young age. fyi.
expression and emotion are still technically mechanical abilities. perhaps dryly perform is the wrong wording. child prodigies are considered such simply by their age relative to their ability at the task as compared to a trained adult. there is also the fact that "child prodigy" is not a binary notion. not all prodigies are capable of the same level of aptitude - hence my edit. | null | 0 | 1316298565 | False | 0 | c2kmjjj | t3_khf6j | null | t1_c2kmjjj | t1_c2kic77 | null | 1427613183 | 0 | t5_2fwo | null | null | null |
True | Bamafan | null | How does this series of random quotes disprove my original point? Those quotes (with the exception of the Hibernate one) are completely unrelated to my original point!
And on the Hibernate quote -- if you think stored-procedure driven apps are the only place that Hibernate leaks, then you haven't used Hibernate. | null | 0 | 1316298569 | False | 0 | c2kmjk9 | t3_ki83r | null | t1_c2kmjk9 | t1_c2klv9p | null | 1427613183 | 0 | 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.