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 | > Due to the fact that JavaScript is basically the only widely used language that features prototypal inheritance
But but ... Lua. | null | 0 | 1316447678 | False | 0 | c2kzv9f | t3_kketr | null | t1_c2kzv9f | t3_kketr | null | 1427619588 | 13 | t5_2fwo | null | null | null |
True | Drfuzzykins | null | The first one. | null | 0 | 1316447748 | False | 0 | c2kzvkv | t3_kkbpe | null | t1_c2kzvkv | t1_c2kz38l | null | 1427619593 | 2 | t5_2fwo | null | null | null |
True | twotime | null | There is no bright line in either openness or freedom definitons. And the lack of this bright line is *not* a marketing trick.
1. Some people don't consider even GPL to be open enough. So, your bright line is already blurred.
2. But you have a bigger problem too.
Under your definition, open would mean "no-trade-secrets-whatsoever". Right? Do you realize that no company in the world would meet your definition? Do you also realize that the VAST majority of open source developers draws their income from the work which is at least partially proprietary? Kill this source of income and open source software is dead within a month.
In short, your definition of "open" is extreme to the point of meaninglessness. And, yet, some people use an even more extreme defition. | null | 0 | 1316448099 | False | 0 | c2kzx8i | t3_kawp5 | null | t1_c2kzx8i | t1_c2j8mlc | null | 1428193705 | 1 | t5_2fwo | null | null | null |
True | bobindashadows | null | Err... unsafePerformIO It allows you to violate a type which happens to be used for purity. | null | 0 | 1316448561 | False | 0 | c2kzzbz | t3_kjw0j | null | t1_c2kzzbz | t1_c2kzek4 | null | 1427619641 | 1 | t5_2fwo | null | null | null |
True | neoform | null | (apparently people don't know sarcasm judging by the downvotes) | null | 0 | 1316448650 | False | 0 | c2kzzr9 | t3_kketr | null | t1_c2kzzr9 | t1_c2kzpuz | null | 1427619647 | 1 | t5_2fwo | null | null | null |
True | sedaak | null | Wait, when was OS X (or any non-mobile Apple OS) dominant? | null | 0 | 1316448705 | False | 0 | c2kzzzy | t3_kip3s | null | t1_c2kzzzy | t1_c2kw78s | null | 1427619651 | 1 | t5_2fwo | null | null | null |
True | day_cq | null | may I ask when you would want to know if an object is an instance of a specific constructor? as in an example, not general thought of yours. | null | 0 | 1316448717 | False | 0 | c2l002d | t3_kkbpe | null | t1_c2l002d | t1_c2kyyqm | null | 1427619651 | 1 | t5_2fwo | null | null | null |
True | xurble | null | "up to" | null | 0 | 1316448724 | False | 0 | c2l0038 | t3_kkfbs | null | t1_c2l0038 | t1_c2kzpwg | null | 1427619651 | 15 | t5_2fwo | null | null | null |
True | washort | null | Just remember that FORTH isn't so much a programming language so much as it's a mental illness. | null | 0 | 1316448833 | False | 0 | c2l00lj | t3_kkegr | null | t1_c2l00lj | t3_kkegr | null | 1427619658 | 4 | t5_2fwo | null | null | null |
True | YurtDweller | null | In Java you declare your inheritance hierarchy at compile-time, and it's static (for appropriate definition of 'static' - I know there's classloader crap you can do but it involves tons of machinery and is brittle). In JS your inheritance hierarchy is completely dynamic and decided at runtime, and this is simple and baked into the language. This is simplifying matters a bit but gets at one of the fundamental differences between class-based inheritance and prototypal inheritance as implemented in JS. | null | 0 | 1316448899 | False | 0 | c2l00wj | t3_kketr | null | t1_c2l00wj | t1_c2kz1al | null | 1427619663 | 2 | t5_2fwo | null | null | null |
True | day_cq | null | what's wrong with
new Circle(1,2,3).draw(renderer);//renderer has context of drawing... better name would be .drawTo()
new Rect(4,5,6,7).draw(renderer);
or
Renderer.prototype.draw = function(shape) {
drawPolygons(shape.polygons());
} | null | 0 | 1316448907 | False | 0 | c2l00y7 | t3_kkbpe | null | t1_c2l00y7 | t1_c2kzbhc | null | 1427619663 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | While I can't speak for C specifically, it definitely was supposed to offer support for far more than just C++. | null | 0 | 1316449032 | False | 0 | c2l01jq | t3_kk7c6 | null | t1_c2l01jq | t1_c2kyiyw | null | 1427619670 | 2 | t5_2fwo | null | null | null |
True | montibbalt | null | True but with a technicality. The 4th edition of ECMAScript is/was supposed to have classes. iirc Actionscript 3 is based more on the proposed ECMAScript which is why AS3 has classes. | null | 0 | 1316449108 | False | 0 | c2l01xa | t3_kketr | null | t1_c2l01xa | t1_c2kz5hy | null | 1427619675 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316449134 | False | 0 | c2l021o | t3_kjf91 | null | t1_c2l021o | t1_c2ktq7y | null | 1427619676 | 3 | t5_2fwo | null | null | null |
True | montibbalt | null | The mere fact you have to direct people to it means there's people that don't know about it. Not sure why you're so amazed | null | 0 | 1316449221 | False | 0 | c2l02fu | t3_kketr | null | t1_c2l02fu | t1_c2kzoq5 | null | 1427619682 | 5 | t5_2fwo | null | null | null |
True | cowardlydragon | null | Javascript needs to be replaced with a bytecode standardized VM with sandboxing, so that people can use whatever language they want for web dev (just do an include at the top of the page for your desired language).
Of course the best practical VM on the most platforms is the JVM, so that would basically mean the revival of applets to some degree, but since the JVM performantly does Ruby, Python, Lisp variants, Javascript, Scala, as well as java, that would be theoretically a good thing.
Hell, most of the dotNet langs could probably be bridged. | null | 0 | 1316449413 | False | 0 | c2l03bv | t3_kketr | null | t1_c2l03bv | t3_kketr | null | 1427619693 | 9 | t5_2fwo | null | null | null |
True | Jameshfisher | null | > for most objects `typeof` will return "object"
Does this imply there are objects for which `typeof` will return something else? | null | 0 | 1316449702 | False | 0 | c2l04ql | t3_kkbpe | null | t1_c2l04ql | t3_kkbpe | null | 1427619713 | 2 | t5_2fwo | null | null | null |
True | crusoe | null | JSF is craptacular. | null | 0 | 1316449717 | False | 0 | c2l04td | t3_kjwil | null | t1_c2l04td | t3_kjwil | null | 1428193704 | 1 | t5_2fwo | null | null | null |
True | notSorella | null | Apparently Lua is not "widely used" enough =/
Even though JavaScript is the prototypical OO language that has the worst prototypical OO implementation I have seen... Hope they fix it in ES6 by adding real traits and stuff, and saner ways of working with objects out of the box. Doesn't seem to be the case though (there are traits proposals none-the-less, but iirc, bundled with class-syntax...) | null | 0 | 1316449839 | False | 0 | c2l05fb | t3_kketr | null | t1_c2l05fb | t1_c2kzv9f | null | 1427619721 | 8 | t5_2fwo | null | null | null |
True | fullouterjoin | null | I am having my doubts about specialized closures, at least when the name of the function is the same (denotes what it does in that context) and not how it does or the specifics.
Bear with me ..., it would seem that a closure with a mutable upvar is non-functional? I am not sure ...
Thanks for the explanation of groups above, it allowed me to find these pages on abstract algebra which are succinct and lucid, [http://www.millersville.edu/~bikenaga/abstract-algebra/groups/groups.html](http://www.millersville.edu/~bikenaga/abstract-algebra/groups/groups.html) | null | 0 | 1316449885 | False | 0 | c2l05o4 | t3_kj03o | null | t1_c2l05o4 | t1_c2knso3 | null | 1427619726 | 1 | t5_2fwo | null | null | null |
True | MaxGene | null | My new firstworldproblem is people posting these idiotic /r/firstworldproblems comments. | null | 0 | 1316449886 | False | 0 | c2l05o8 | t3_kjw0j | null | t1_c2l05o8 | t1_c2kuv1y | null | 1427619726 | 0 | t5_2fwo | null | null | null |
True | elperroborrachotoo | null | As I understood the documentation - but haven't tried myself: The entire interface is written in COM, thus C/C++ should technically be able to provide / use the full functionality, and the `/CX` part merely simplifies interfacing to .NET, namely generating the meta data that .NET requires and C++ doesn't have. I could be wrong about that, though.
COM *is* a PITA in C (though I see possibilities for improvement if you do it a lot), it's between *bearable* and *OK* in C++ - though the better end pretty much requires to work with _-declspec(property), a proprietary extension | null | 0 | 1316449907 | False | 0 | c2l05s3 | t3_kk7c6 | null | t1_c2l05s3 | t1_c2kz1y7 | null | 1427619731 | 1 | t5_2fwo | null | null | null |
True | deafbybeheading | null | But this kind of thing is *critical* to someone getting into the language. If I want to learn Language X, I don't want to have to read about "How to write an `if` statement"--I want exactly this sort of thing. | null | 0 | 1316449934 | False | 0 | c2l05wa | t3_kketr | null | t1_c2l05wa | t1_c2kyy06 | null | 1427619729 | 8 | t5_2fwo | null | null | null |
True | grauenwolf | null | I think they should just start over. Create a new "profile" like .NET does from time to time with all of the cruft removed. | null | 0 | 1316449954 | False | 0 | c2l05z7 | t3_kjf91 | null | t1_c2l05z7 | t1_c2l021o | null | 1427619730 | 6 | t5_2fwo | null | null | null |
True | mantra | null | I was on a project where we were a "too small" development team (3 people: 1 programmer, 1 creative/art and 1 business manager) and we solved our problem of data to drive the software by figuring out who could and would want to "own" the data content in the context of the resulting output of the system.
We spent a ton of up front time validating the premise and selling that idea of their ownership to the new owners. There's some finesse in that; they came to believe it was their idea so they were very firmly "bought in" with the idea of owning it - we explicitly planned it to work that way. We then specified and designed a distributed content editing/management system with that goal in mind.
Worked out fantastically well. The kernel of the same system is still in use today at the same Fortune 500 company, >10 years later. | null | 0 | 1316449960 | False | 0 | c2l0607 | t3_kk5f4 | null | t1_c2l0607 | t3_kk5f4 | null | 1427619730 | 1 | t5_2fwo | null | null | null |
True | imphasing | null | Uhhh... because windows servers suck ass? Windows servers are expensive as fuck? And they suck a lot of ass?
Seriously dude, I can run a LOT more traffic on a linux server with mod_mono and apache per dollar than an IIS server with windows, licensing costs are a bitch and IIS is a fucking joke in the first place.
> Honestly anybody who developers in WIndows and deploys to linux ought to have their head examined.
Sweet ad-hominm bro, totally respect your opinion. Except not, because you're just some random jackass on the internet.
Why deploy to an inferior and more expensive server? This setup is cheaper, scales better, AND avoids the cantankerous mess that is IIS. You're just mad that I'm not all religious about one or the other I guess, but I really don't care about ideology so much.
What's so insane about uploading a .dll to my apache server? Super annoying bro, can't believe I tolerate it right? Mod_mono is painless, I compile on my windows development machine then upload the assembly to my web server. If this is too complicated for you maybe you need to consider a different profession. | null | 0 | 1316450062 | False | 0 | c2l06h6 | t3_kgl4f | null | t1_c2l06h6 | t1_c2kivra | null | 1427619735 | 0 | t5_2fwo | null | null | null |
True | wesw02 | null | I don't mean to give you a hard time about it, but what did you find new? And what kind of JS development have you done? Presentation code, business code, etc.
Just curious. I do enterprise JS development and I found most of it to be a review. | null | 0 | 1316450067 | False | 0 | c2l06i5 | t3_kketr | null | t1_c2l06i5 | t1_c2kzp6e | null | 1427619735 | 0 | t5_2fwo | null | null | null |
True | notSorella | null | If I remember correctly, Brendan Eich stressed the discussion on that to the infinity on Hacker News, outlining all the reasons why they are not (and will not) be included.
Sadly, I have no link for his comments =/ | null | 0 | 1316450121 | False | 0 | c2l06rq | t3_kketr | null | t1_c2l06rq | t1_c2l03bv | null | 1427619739 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | C and C++ are fine, more recent languages such as D and Go are not -.- | null | 0 | 1316450146 | False | 0 | c2l06vo | t3_kjete | null | t1_c2l06vo | t1_c2kuu2y | null | 1427619740 | 1 | t5_2fwo | null | null | null |
True | punkmonk | null | Well it has been dominant in my circle of friends/colleagues .
| null | 0 | 1316450187 | False | 0 | c2l071w | t3_kip3s | null | t1_c2l071w | t1_c2kzzzy | null | 1427619747 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Even so, implementing classes in JS seems to me a bit more straightforward than in Lua. On the other hand, class libraries are abundant for Lua and not so much for JS, so what do I know? Then again, that might have as much to do with JS's lack of a proper import facility as anything.
On a tangential note, having several commonly used OO libraries with clashing namespaces may be the most annoying possible side effect of a prototype based language. | null | 0 | 1316450252 | False | 0 | c2l07cu | t3_kketr | null | t1_c2l07cu | t1_c2l05fb | null | 1427619746 | 3 | t5_2fwo | null | null | null |
True | OopsLostPassword | null | Or maybe they don't see the interest of your comment in this discussion. | null | 0 | 1316450295 | False | 0 | c2l07kw | t3_kketr | null | t1_c2l07kw | t1_c2kzzr9 | null | 1427619749 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316450315 | False | 0 | c2l07ow | t3_kjm5r | null | t1_c2l07ow | t1_c2ks4w4 | null | 1427619752 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316450321 | False | 0 | c2l07q2 | t3_kketr | null | t1_c2l07q2 | t1_c2kz5hy | null | 1427619752 | 1 | t5_2fwo | null | null | null |
True | zushiba | null | I think I'm more interested in that slick ass page position indicator dealie on the right. | null | 0 | 1316450423 | False | 0 | c2l088a | t3_kketr | null | t1_c2l088a | t3_kketr | null | 1427619758 | 128 | t5_2fwo | null | null | null |
True | SoBoredAtWork | null | Can I get this in PDF, for use on my Nook? | null | 0 | 1316450444 | False | 0 | c2l08cz | t3_kketr | null | t1_c2l08cz | t3_kketr | null | 1427619759 | 3 | t5_2fwo | null | null | null |
True | notSorella | null | You mean like these: https://gist.github.com/1224138 ? | null | 0 | 1316450461 | False | 0 | c2l08gq | t3_kkbpe | null | t1_c2l08gq | t1_c2kysbk | null | 1427619761 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | I direct people to the MDC, various RFCs, google, and other places too, directing people doesn't mean people don't know about the resource, it means they need to be directed to something it contains. | null | 0 | 1316450511 | False | 0 | c2l08q0 | t3_kketr | null | t1_c2l08q0 | t1_c2l02fu | null | 1427619764 | 0 | t5_2fwo | null | null | null |
True | SoBoredAtWork | null | NO ARROW KEY SUPPORT!??!?!?!? | null | 0 | 1316450554 | False | 0 | c2l08xv | t3_kketr | null | t1_c2l08xv | t1_c2kzn4m | null | 1427619767 | 9 | t5_2fwo | null | null | null |
True | stillalone | null | But this is the sort of thing that allows Microsoft to gain a monopoly on developer tools in Windows. C++/CX looks like it would be a better experience for most developers to develop on. That means that most compiler developers have to play catchup in order to retain their existing customer base.
Of course this stuff doesn't matter as much anymore since Borland is pretty much already dead and gcc and clang don't seem as interested in the Windows market. | null | 0 | 1316450771 | False | 0 | c2l09y6 | t3_kk7c6 | null | t1_c2l09y6 | t1_c2kyzyo | null | 1427619781 | -2 | t5_2fwo | null | null | null |
True | rDr4g0n | null | Mostly web app UI kinda stuff. I have done 3 projects so far and all involved creating a front-end for clients to view and enter data. One was for a political action group who needed a way to keep new recruits involved. I worked with a friend who wrote the backend (php/mysql) while I wrote the front end. It ended up being a 1 page web app with lotsa async calls to display info on recruits, allow editing of info (based on the recruits level in the hierarchy), allow recruits to send email invites to new recruits, etc. Finding an easy way to view a hierarchy like that was a challenge, but I settled on what ended up being very easy for the non-savvy political guys to follow lol.
Another project is a CMS my friend and I wrote from scratch, again, him on php/mysql and myself on front-end. We also made this mostly a 1 page web app with all blog posts, articles, etc, being called async and parsed out client side. A simple CMS with the ability to create an edit a few kinds of objects, and some basic admin user stuff.
The third is a comic blog for a friend of mine that extended the CMS we'd previously written.
Obviously to pull all this stuff off I need a good knowledge of how object types, methods/properties/classes work as well as an understanding of scope. But I've never used prototype before, so all of that is new. I've also written a lot of AS3 and I've created classes in there quite a bit (which, If i understand correctly, is roughly what prototype is for).
I guess I knew the first 25% of each section, and kinda grepped the second 25% of each section and the other 50% was stuff I haven't run into simply because the specific scenario has not yet presented itself in a project yet.
[edit] I often worry that I'm one of "those" developers that are only able to code because the barrier of entry has become so low with all the layers of abstraction that we stand on top of now, and that I am probably writing a bunch of icky trash code and polluting the world lol | null | 0 | 1316450784 | True | 0 | c2l0a03 | t3_kketr | null | t1_c2l0a03 | t1_c2l06i5 | null | 1427619782 | 6 | t5_2fwo | null | null | null |
True | ktzar | null | I've created a PDF version to read in the Kindle on my way back home http://www.2shared.com/document/cBgYRTMA/Javascript_Garden.html Just in case you are interested | null | 0 | 1316450837 | False | 0 | c2l0a8k | t3_kketr | null | t1_c2l0a8k | t3_kketr | null | 1427619792 | 11 | t5_2fwo | null | null | null |
True | dand | null | Yes -- that looks pretty nice. | null | 0 | 1316450940 | False | 0 | c2l0amy | t3_kkbpe | null | t1_c2l0amy | t1_c2l08gq | null | 1427619790 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | You can't just look at one word in an entire argument and then base your entire counter-argument off of it, that's being disingenuous.
The overall complaint he made was about MS not using standard features and the disadvantages that come to the consumer for not doing so, of which sure, cost is one. If MS did use standard features then Visual Studio would not be a requirement. Even if VS was free, if they used the C++ standard then WinRT would be a viable product on any standard C++ compiler.
In the end, regardless of whether one pays for VS or not, the issue has to do with whether WinRT is usable with a standard C++ compiler and the answer is, for all practical purposes, no. | null | 0 | 1316451046 | False | 0 | c2l0b4p | t3_kk7c6 | null | t1_c2l0b4p | t1_c2kznef | null | 1427619796 | 0 | t5_2fwo | null | null | null |
True | strangename | null | No, braces only lead to downvotes in Python. | null | 0 | 1316451049 | False | 0 | c2l0b57 | t3_kjdt6 | null | t1_c2l0b57 | t1_c2kt4a8 | null | 1427619797 | 1 | t5_2fwo | null | null | null |
True | FleshyLinkBot | null | [http://news.ycombinator.com/item?id=2982666](http://news.ycombinator.com/item?id=2982666
) | null | 0 | 1316451132 | False | 0 | c2l0bj2 | t3_kketr | null | t1_c2l0bj2 | t1_c2l06rq | null | 1427619810 | 6 | t5_2fwo | null | null | null |
True | skilldrick | null | Yes. For functions and regular expression objects `typeof` will return `"function"`. For host objects the return value is implementation-dependent. Like I said in the post, this has been discussed in detail elsewhere, [for example by Angus Croll](http://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/). | null | 0 | 1316451168 | False | 0 | c2l0bpt | t3_kkbpe | null | t1_c2l0bpt | t1_c2l04ql | null | 1427619804 | 2 | t5_2fwo | null | null | null |
True | notSorella | null | I would assume it's mostly because people mistakenly take the constructor pattern in JavaScript to construct classes. It doesn't help much that the language often looks like Java, sounds like Java and that people often refer to constructors as "Classes".
I think most people who take their time to learn the prototypical pattern, or delve more into JS would rather not have classical OO again, so that helps reducing the number of class-systems for JS (even though I've seen quite a lot of them).
Yeah, clashing methods are usually a problem if people decide to explore prototypes fully, but I think the benefits far outweights the drawbacks, in this case :3 | null | 0 | 1316451183 | False | 0 | c2l0bs5 | t3_kketr | null | t1_c2l0bs5 | t1_c2l07cu | null | 1427619806 | 3 | t5_2fwo | null | null | null |
True | strager | null | Well, you have the JVM and AVM (Flash) at your disposal. Go ahead and write for those VM's. I don't think the web needs to move those alternatives into the browser's standard set of tools, though.
Also, see NaCl. | null | 0 | 1316451321 | False | 0 | c2l0cer | t3_kketr | null | t1_c2l0cer | t1_c2l03bv | null | 1427619814 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | http://stackoverflow.com/questions/7429999/are-there-plans-to-support-type-providers-for-scalas-siq-scalaintegratedquery/7431606#7431606 | null | 0 | 1316451327 | False | 0 | c2l0cfv | t3_kii9z | null | t1_c2l0cfv | t1_c2kzfd8 | null | 1427619814 | 1 | t5_2fwo | null | null | null |
True | neoform | null | Yes, that's why Kilrizzy's spoof of my comment has been voted up. | null | 0 | 1316451363 | False | 0 | c2l0clx | t3_kketr | null | t1_c2l0clx | t1_c2l07kw | null | 1427619817 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | >I would assume it's mostly because people mistakenly take the constructor pattern in JavaScript to construct classes. It doesn't help much that the language often looks like Java, sounds like Java and that people often refer to constructors as "Classes".
Very possibly. Another explanation is that people actually don't use inheritance very often, especially for the kind of stuff that JS is often used for. In these cases, people are working against a class architecture when it's there, trying to get back to, well, Lua minus metatables.
>Yeah, clashing methods are usually a problem if people decide to explore prototypes fully, but I think the benefits far outweights the drawbacks, in this case :3
The main place that I've found it infuriating is when you want to use one library that requires one OO library, and another library that requires a clashing OO library. Sure, you can go through and rename everything, but what a pain. And then you're basically writing two programs that can only interact in limited ways. | null | 0 | 1316451586 | False | 0 | c2l0dpp | t3_kketr | null | t1_c2l0dpp | t1_c2l0bs5 | null | 1427619842 | 5 | t5_2fwo | null | null | null |
True | ntrel2 | null | Well, you can do those things already, but perhaps not easily. You can use D without GC if you really want, but need to avoid certain features - you can tweak the runtime to cause link errors on anything that allocates for the GC.
Better library support for doing non-GC allocation is being worked on. | null | 0 | 1316451962 | False | 0 | c2l0fj2 | t3_kfvm7 | null | t1_c2l0fj2 | t1_c2kodjc | null | 1427619858 | 2 | t5_2fwo | null | null | null |
True | BlitzTech | null | I think I learned more from reading the code powering it than from the rest of the content on the site.
Not that the site is bad; in fact, it's well written, accurate, and informative, it's just that I already knew it. | null | 0 | 1316452126 | False | 0 | c2l0gcf | t3_kketr | null | t1_c2l0gcf | t1_c2l088a | null | 1427619864 | 16 | t5_2fwo | null | null | null |
True | toofishes | null | Used to seeing the "this doesn't belong in /r/programming/" comments, so I thought I'd add the opposite of that- this is cool and relevant stuff, thanks for posting it here. | null | 0 | 1316452159 | False | 0 | c2l0gid | t3_kkfbs | null | t1_c2l0gid | t3_kkfbs | null | 1427619866 | 37 | t5_2fwo | null | null | null |
True | 33a | null | Only 85%? | null | 0 | 1316452228 | False | 0 | c2l0gu9 | t3_kketr | null | t1_c2l0gu9 | t1_c2kyy06 | null | 1427619870 | 0 | t5_2fwo | null | null | null |
True | uzusan | null | Its really nice isn't it? Have you tried resizing your page at all?
It resizes to fit your available space really well. | null | 0 | 1316452421 | False | 0 | c2l0hsh | t3_kketr | null | t1_c2l0hsh | t1_c2l088a | null | 1427619883 | 52 | t5_2fwo | null | null | null |
True | mkantor | null | I haven't used it actually. I'm currently probably most familiar with [Yii's](http://www.yiiframework.com/doc/api) ORM (check out CModel and CActiveRecord), since that's the framework I've been using on my last two projects. | null | 0 | 1316452431 | False | 0 | c2l0hus | t3_ki83r | null | t1_c2l0hus | t1_c2kxmwo | null | 1427619884 | 1 | t5_2fwo | null | null | null |
True | inmatarian | null | I disagree with Code Ownership, as it divides up the team into domains, and team members become unwilling to cross those domains. Then, when a team member leaves (for better employment, or for the unemployment lines), that domain is left undocumented and unknown, and gets dumped on another team member who has no idea on how to maintain the code. This is how organizations create "Legacy Code" that end up being their core product that goes unchanged (bugs and all) for years before a young startup company shows up in the market to disrupt their business model.
Instead, I prefer code co-ownerships. I'm not talking about pair programming, but rather a team dynamic where every member of the team is responsible for every line of code in the project, and the team as a whole is to blame for any mistakes, and the team as a whole is responsible for maintenance. To that end, the team's manager must be a member of that team, the team has to be relatively small, and the team must have really good code review and code integration policies.
Basically, if I write a line of code, my team members need to read it and tell me it sucks. And vice-versa. | null | 0 | 1316452477 | False | 0 | c2l0i1r | t3_kk5f4 | null | t1_c2l0i1r | t3_kk5f4 | null | 1427619886 | 2 | t5_2fwo | null | null | null |
True | Destroyah | null | >JavaScript has a different Array constructor per frame
Can you elaborate a little more on this? | null | 0 | 1316452595 | False | 0 | c2l0ipf | t3_kkbpe | null | t1_c2l0ipf | t1_c2kyvsf | null | 1427619896 | 1 | t5_2fwo | null | null | null |
True | zushiba | null | No I didn't notice. Nice! | null | 0 | 1316452625 | False | 0 | c2l0iv6 | t3_kketr | null | t1_c2l0iv6 | t1_c2l0hsh | null | 1427619897 | 11 | t5_2fwo | null | null | null |
True | axilmar | null | If that so, then how do they dare come up and say that WinRT can be programmed in C++? they should have said that WinRT can be programmed in C++/CX.
| null | 0 | 1316452665 | False | 0 | c2l0j2s | t3_kk7c6 | null | t1_c2l0j2s | t1_c2kzklx | null | 1427619900 | -1 | t5_2fwo | null | null | null |
True | ash_gti | null | As long as it never gets slower I am gonna be happy. | null | 0 | 1316452673 | False | 0 | c2l0j4y | t3_kkfbs | null | t1_c2l0j4y | t1_c2l0038 | null | 1427619900 | 1 | t5_2fwo | null | null | null |
True | Destroyah | null | I think there's an exception case here if I decide to make my own object with a public "length" variable. It would pass that test. | null | 0 | 1316452731 | False | 0 | c2l0jfm | t3_kkbpe | null | t1_c2l0jfm | t1_c2kz65q | null | 1427619905 | 1 | t5_2fwo | null | null | null |
True | fionbio | null | Concerning Object.prototype extension:
> One widely used framework which does this is Prototype. When this framework is included, for in loops that do not use hasOwnProperty are guaranteed to break.
It's a lie. Prototype framework doesn't change Object.prototype. It does change some other prototypes, but not this one. Maybe it did it some 5-6 years ago, but this cannot be said about modern versions. | null | 0 | 1316452844 | False | 0 | c2l0k08 | t3_kketr | null | t1_c2l0k08 | t3_kketr | null | 1427619912 | 5 | t5_2fwo | null | null | null |
True | axilmar | null | Obviously, you are a huge moron.
Please re-read what you wrote.
First of all, **nothing compiles down to native C++**. It compiles to **native code**, in contrast to **bytecode**.
Secondly, **what compiles to native code doesn't mean it can be programmed in C++**.
Haskell can be compiled to native code, however, not all things Haskell can do can be programmed in C++. Same goes for .NET: it can be compiled to native code, but C++ can't do garbage collection.
Thirdly, **COM is unusable** as it is shown in the link you posted. | null | 0 | 1316452892 | False | 0 | c2l0ka3 | t3_kgl4f | null | t1_c2l0ka3 | t1_c2kzin1 | null | 1427619916 | -1 | t5_2fwo | null | null | null |
True | alesis | null | If FORTH is a mental illness then C++ is the Bubonic Plague.
I had an original copy of this book and loved it. But I wonder if FORTH has any place in the modern world? | null | 0 | 1316452954 | False | 0 | c2l0km3 | t3_kkegr | null | t1_c2l0km3 | t1_c2l00lj | null | 1427619920 | 12 | t5_2fwo | null | null | null |
True | axilmar | null | The problem is I cannot use COM without the C++/CX extensions.
If I can, then show me the API that is easy to use that does what you say (hint: WRL, documentation does not exist yet).
| null | 0 | 1316453002 | False | 0 | c2l0kvr | t3_kk7c6 | null | t1_c2l0kvr | t1_c2kyzyo | null | 1427619923 | -2 | t5_2fwo | null | null | null |
True | Pxtl | null | The author's complaints ring true for the various Microsoft systems I've used, but I've heard others are better. Surprising since he didnt' call out Entity Framework in his name-checks.
Entity Framework is the textbook example of how *not* to do ORM. Brittle, slow, trying to be the be-all-and-end-all solution for every problem... what a mess. | null | 0 | 1316453028 | True | 0 | c2l0l0s | t3_ki83r | null | t1_c2l0l0s | t3_ki83r | null | 1427619926 | 2 | t5_2fwo | null | null | null |
True | grauenwolf | null | Hungarian notation, when used as originally intended, tells you things that cannot be derived from the type. Here is a good article on the topic:
http://www.joelonsoftware.com/articles/Wrong.html | null | 0 | 1316453090 | False | 0 | c2l0lbm | t3_kk7c6 | null | t1_c2l0lbm | t1_c2kz0w1 | null | 1427619929 | 7 | t5_2fwo | null | null | null |
True | tinou | null | Instead of parsing `objdump` output, you can use a [library that does the same](https://github.com/sbz/pyudis86). | null | 0 | 1316453129 | False | 0 | c2l0lia | t3_kkih6 | null | t1_c2l0lia | t3_kkih6 | null | 1427619932 | 0 | t5_2fwo | null | null | null |
True | reply_in_brainfuck | null | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------.-------.+++++++++++++++++++.-----------------------------------------------------.++++++++++++++++++++++++++++++++.++.++++++++++++.--------------.++++++++++.----------.+++++++++++++++.+.+++++.---------------------.++++++++.++++++++..-----------.-----.++++++.+++++++++.+.++++++.--------------.+.---------.++.+++++++++++++.+++++++++++.------------.++.+++.-------------.--------------------------------------. | null | 0 | 1316453179 | False | 0 | c2l0lra | t3_k9cbj | null | t1_c2l0lra | t3_k9cbj | null | 1427619935 | 1 | t5_2fwo | null | null | null |
True | stonefarfalle | null | A type error is when the type system allows a transition from state A to state B that is not defined by the operational semantics of the language. Throwing an exception is in the operational semantics of Java in this case. If we are claiming that this is a violation of the type system then I can violate Haskell's type system by calling head on an empty list, because that will throw an exception as well. | null | 0 | 1316453195 | False | 0 | c2l0ltr | t3_kjw0j | null | t1_c2l0ltr | t1_c2kz2eq | null | 1427619936 | 5 | t5_2fwo | null | null | null |
True | grauenwolf | null | Hungarian notation is a way to include extra information that cannot be expressed by the type alone.
Let's say you are dealing with HTML and strings. Some strings have been HTML Encoded, some are not. You can express that as:
heFullname = HtmlEncode(neFullname)
where "he" means html-encoded and "ne" means not encoded.
If you see "sFullname" then you aren't dealing with Hungarian notation, you are just dealing with someone who likes to waste your time. | null | 0 | 1316453341 | False | 0 | c2l0mkk | t3_kk7c6 | null | t1_c2l0mkk | t1_c2ky8gl | null | 1427619956 | 1 | t5_2fwo | null | null | null |
True | ethraax | null | Oh, I see now. You think my reply a few posts back was a full counter-argument. It wasn't, and was never intended to be. I was just correcting one point. I was not trying to imply that his entire argument was incorrect based on that one point (and, in fact, I never even said I disagreed with his general argument). | null | 0 | 1316453360 | False | 0 | c2l0mma | t3_kk7c6 | null | t1_c2l0mma | t1_c2l0b4p | null | 1427619956 | 4 | t5_2fwo | null | null | null |
True | Pxtl | null | They do it, but not well. There are tons of cases where Linq-to-entities has some deep flaws. Too many joins makes it take a year to compile (forcing you to use the precompiled-query mechanism that removes the whole expressive point of using an ORM) - outer join syntax is hideous, etc.
Linq would've been fine if they'd stuck to using it to pull *objects* down from the database and focused on the problem of being able to automatically map the results of a query into your business-objects... but instead they decided that problem was too boring and bungled it while they focused on the linguistic wankery of replicating SQL in C#. | null | 0 | 1316453423 | False | 0 | c2l0n0l | t3_ki83r | null | t1_c2l0n0l | t1_c2kiqbv | null | 1427619954 | 1 | t5_2fwo | null | null | null |
True | Pxtl | null | Microsoft's LINQ/Entity Framework system had that goal.
It works about as well as you'd expect. | null | 0 | 1316453460 | False | 0 | c2l0n7e | t3_ki83r | null | t1_c2l0n7e | t1_c2kipc4 | null | 1427619959 | 1 | t5_2fwo | null | null | null |
True | Pxtl | null | There are often uses to a leaky abstraction, but when I have to learn *two* complete systems instead of one to painful detail, then you've failed.
When I have to learn about the nitty-bitty internal bits of your ORM, it's wasting my time. That's why I'd prefer a simple, intuitive ORM that gets out of the way when it needs to instead of these baroque, elaborate monstrosities.
I want to pull down a graph of objects. As I find I need more objects from the DB, I want to pull them down and tack them onto the existing graph. When I'm done, I want to update my changes to the DB. I'd settle for doing it on a primary-key-only basis, and using SQL for anything else. All the ORMs I've used make even *this* simple pattern too painful. | null | 0 | 1316453597 | False | 0 | c2l0nvz | t3_ki83r | null | t1_c2l0nvz | t1_c2kiohg | null | 1427619965 | 1 | t5_2fwo | null | null | null |
True | some_dev | null | Joel wrote an [interesting article](http://www.joelonsoftware.com/articles/Wrong.html) on hungarian. Apparently, when it first came around it was not designed to convey type information but convey usage. The example in the article was for Excel, wherein you'd prepend integer values meant to reference columns with 'col', and rows with 'rw'. Basically, it was a shorthand for variable naming to make sure that you used them consistently. Somehow, this morphed into the practice of prepending the type.
Normally, I'm skeptical of Joel's insights, but he did work at Microsoft and this seems to make sense. | null | 0 | 1316453758 | False | 0 | c2l0oqe | t3_kk7c6 | null | t1_c2l0oqe | t1_c2kz0w1 | null | 1427619974 | 3 | t5_2fwo | null | null | null |
True | skilldrick | null | Yup. When you do `arr.constructor === Array` you're checking if the constructor of your array is the `Array` constructor function. Each frame gets its own `Array` constructor function, so `Array` in frame 1 and `Array` in frame 2 aren't the same object. Therefore, `arr.constructor === Array` if `arr` is a reference to an array created in a different frame. | null | 0 | 1316453915 | False | 0 | c2l0plc | t3_kkbpe | null | t1_c2l0plc | t1_c2l0ipf | null | 1427619986 | 1 | t5_2fwo | null | null | null |
True | Destroyah | null | >so Array in frame 1 and Array in frame 2 aren't the same object.
Are they given different properties somehow or something? I don't understand how they're different? | null | 0 | 1316454050 | False | 0 | c2l0qay | t3_kkbpe | null | t1_c2l0qay | t1_c2l0plc | null | 1427619995 | 1 | t5_2fwo | null | null | null |
True | jimbokun | null | The kind of "OO" programming that's normal in Smalltalk has little in common with the kind of "OO" programming normally practiced in Java or C++. So I think it could be similar to the way that "functional programming" as practiced in C# is not recognizable to a Haskell programmer as such. | null | 0 | 1316454069 | False | 0 | c2l0qez | t3_kjkxj | null | t1_c2l0qez | t1_c2kyau3 | null | 1427619996 | 1 | t5_2fwo | null | null | null |
True | Zarutian | null | Are you kidding? Do you know how much more functionality you can stuff in to a microcontroler based system by using Forth instead of C? | null | 0 | 1316454140 | False | 0 | c2l0qsn | t3_kkegr | null | t1_c2l0qsn | t1_c2l0km3 | null | 1427620001 | 4 | t5_2fwo | null | null | null |
True | Nebu | null | > Java is not actually a proper statically typed language, since some of the type checking must be done at runtime. [...] The compiler doesn't generate an error for the call above since it doesn't know that boom() actually requires its argument to be a string.
If I were to adopt your definitions of "statically typed" vs "dynamically typed", then I think these terms wouldn't actually apply to languages, but rather to development environments:
1. First of all, note that the code you presented is not actually necessarily "erroneous", and so it wouldn't be appropriate for the compiler to generate a compile error: The code has well defined semantics, and the result of executing the code is deterministic and defined by the language spec.
2. It's conceivable that you could write a compiler which would detect the above situation and generate a warning. The Eclipse compiler, for example, generates warnings above and beyond what Sun/Oracle's compiler does, and yet we still consider both compilers to be "Java" compilers. I.e. different compilers are allowed to generate different warnings for the same language.
3. Thus it's possible for the type of checking you're describing to be done statically, by the compiler, at compiler time.
> Another example of the lack of typing rigor in Java is that any method returning an object may also return null.
Well, in Java, null is defined to be a legal value for expressions with an object type. Your complaint is analogous to saying "language XYZ is not type safe, because it allows 0 as a value for numeric types!" If the underlying language uses natural numbers for their numeric types, then 0 wouldn't be there, and if the underlying language uses whole numbers for their numeric type, then 0 would be there. And any disagreement about whether or not 0 should be there would only stem from a programmer only familiar with their own numeric type system, and incorrectly assuming that if a language uses a different numeric type system, that language is somehow has a "unrigorous" type system.
That said, there exists compile-time tools that do nullness type checking and can again report warnings, and they typically use annotations (e.g. @NonNull) to allow the programmer to signal to the tool their intent.
> In Haskell and ML neither of these conditions can happen because the typing system (enforced by the compiler) forbids such code to be written. In the first case an explicit conversion function is required to "cast" a type into another.
I'm not that familiar with Haskell nor ML, but how exactly have those languages improved the situation, then? If you are receiving an object from an external source (e.g. from user input, or over the internet, etc.), then you cannot perform the "casting" check until at runtime, at which case your code has to respond in some way (e.g. popping up a dialog box telling the user to try again and type something different), which is essentially the same as how Java asks you to deal with invalid cast situations.
> just pointing out Java is usually quite a lousy example when talking about statically typed languages :)
Well, it depends. If you're in a forum where almost everybody knows Haskell and nobody knows Java, then yes, Java is probably a poor choice of example. However, if you're in a forum where almost nobody knows Haskell, but everybody knows Java, then Java is probably a good choice for to use as example of a statically type language, because it is more likely to be successful in conveying the information you intend to convey. | null | 0 | 1316454180 | False | 0 | c2l0qzy | t3_kjw0j | null | t1_c2l0qzy | t1_c2kykqb | null | 1427620007 | 1 | t5_2fwo | null | null | null |
True | jimbokun | null | I would love to read your findings expanded into essay format (or long-ish blog post, even), and would love to share such reading with my current project team. | null | 0 | 1316454263 | False | 0 | c2l0rfj | t3_kjkxj | null | t1_c2l0rfj | t1_c2kv6c3 | null | 1427620013 | 1 | t5_2fwo | null | null | null |
True | jimbokun | null | Just depends if you're more of a Turing Machine or Lamba Calculus kind of guy. | null | 0 | 1316454321 | False | 0 | c2l0rq7 | t3_kjkxj | null | t1_c2l0rq7 | t1_c2kxiyn | null | 1428193700 | 3 | t5_2fwo | null | null | null |
True | Nebu | null | > It allows casts, so some type checking must still be done at runtime [...] In Haskell or ML, there is no casting; all typechecking is done statically at compile-time, and no additional checks are required thereafter.
What if you're expecting the user to type in a number, and the user types in "cat" instead? Surely, there is some sort of conversion from a "String"-like type to a "Numeric"-like type (whether you choose to call this casting or parsing or whatever other term you'd prefer), and surely this check can only be performed at runtime, because you don't know at compile time what the user is going to type in.
Haskell and ML surely must have some mechanism for dealing with this, and so wouldn't that mechanism be analogous to Java's casting mechanism? | null | 0 | 1316454426 | False | 0 | c2l0s9t | t3_kjw0j | null | t1_c2l0s9t | t1_c2kyyf5 | null | 1427620026 | 2 | t5_2fwo | null | null | null |
True | skilldrick | null | The browser instantiates a different Array constructor function for each frame, so they're technically not the same object. They'll be identical in all other ways, but the *actual object* will be different. | null | 0 | 1316454451 | False | 0 | c2l0seo | t3_kkbpe | null | t1_c2l0seo | t1_c2l0qay | null | 1427620026 | 2 | t5_2fwo | null | null | null |
True | jimbokun | null | Which sidebar rules does this violate? | null | 0 | 1316454469 | False | 0 | c2l0sij | t3_kjkxj | null | t1_c2l0sij | t1_c2ktwwr | null | 1427620028 | 1 | t5_2fwo | null | null | null |
True | skilldrick | null | No, because your `length` property would be enumerable, as all new properties are in JavaScript (unless you're using ES5). That's what the `!obj.propertyIsEnumerable("length");` check is for. | null | 0 | 1316454547 | False | 0 | c2l0swf | t3_kkbpe | null | t1_c2l0swf | t1_c2l0jfm | null | 1427620039 | 1 | t5_2fwo | null | null | null |
True | ethraax | null | If you're that pressed for space, wouldn't dropping down to assembly be a better choice? | null | 0 | 1316454592 | False | 0 | c2l0t4i | t3_kkegr | null | t1_c2l0t4i | t1_c2l0qsn | null | 1427620034 | 4 | t5_2fwo | null | null | null |
True | redditor_dt | null | http://www.reddit.com/r/explainlikeimfive/ | null | 0 | 1316454603 | False | 0 | c2l0t6n | t3_kkod0 | null | t1_c2l0t6n | t3_kkod0 | null | 1427620034 | 4 | t5_2fwo | null | null | null |
True | dah01 | null | That isn't really true, as people who buy netbooks don't do it to play games. If they play games, they likely have another PC that will more than meet the prereqs. | null | 0 | 1316454705 | False | 0 | c2l0tpo | t3_kfiuk | null | t1_c2l0tpo | t1_c2k68oo | null | 1427620041 | 1 | t5_2fwo | null | null | null |
True | jimbokun | null | Because just having a lot of lines of code does not necessarily imply that the program has scaled well. | null | 0 | 1316454731 | False | 0 | c2l0tud | t3_kjkxj | null | t1_c2l0tud | t1_c2kxxoh | null | 1427620041 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316454752 | False | 0 | c2l0txp | t3_kkod0 | null | t1_c2l0txp | t3_kkod0 | null | 1427620042 | 3 | t5_2fwo | null | null | null |
True | epsy | null | Actually, about 42. | null | 0 | 1316454785 | False | 0 | c2l0u3p | t3_kketr | null | t1_c2l0u3p | t1_c2l0gu9 | null | 1427620044 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316454785 | False | 0 | c2l0u3s | t3_kk7c6 | null | t1_c2l0u3s | t1_c2kz6yw | null | 1427620044 | -1 | t5_2fwo | null | null | null |
True | stonefarfalle | null | No, it is type safe in a fully non-misleading way if you understand what it means to be type safe. A quick and dirty definition of type safe is: the type system has to disallow any code that would violate language semantics. It is easy to show C and C++ is not type safe because you can easily set up something that invokes undefined behavior, say fooling around with unions. PHP is type safe not because the type system disallows any code, but because all state to state transitions are defined even the stupid ones.
So java is type safe, period end of story. It doesn't matter that typecasts require runtime type information it is impossible to violate language semantics with a typecast, because the language semantics account for what happens in either scenario. Just because you don't like ClassCastExceptions doesn't mean they violate the language semantics. | null | 0 | 1316454800 | False | 0 | c2l0u65 | t3_kjw0j | null | t1_c2l0u65 | t1_c2kyyf5 | null | 1427620045 | 2 | t5_2fwo | null | null | null |
True | Destroyah | null | Ah okay, I didn't realize that all new properties were enumerable. I guess my point still applies if I decide to change enumerable to false on the property, but that's being a bit pedantic.
| null | 0 | 1316454837 | False | 0 | c2l0uc1 | t3_kkbpe | null | t1_c2l0uc1 | t1_c2l0swf | null | 1427620047 | 1 | t5_2fwo | null | null | null |
True | Bipolarruledout | null | I do not agree. There are long term costs to everything. In the domain of IT however it's generally been proven most cost effective to use long term file systems (non-deletion). As data becomes larger and more complex the benefits of security, redundancy, and accountability greatly make up for the marginal cost increases. This will become even more apparent as the cost of storage is driven lower and lower.
The only downside is certain algorithmic limitations which may disturb redundacy and reliability. These should be easily overcome by increasing hash sizes. | null | 0 | 1316455027 | True | 0 | c2l0vc2 | t3_kk8o3 | null | t1_c2l0vc2 | t3_kk8o3 | null | 1427620060 | 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.