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 | mzcr | null | Couldn't agree more. And I think yellowjacketcoder is right about team ownership. Individual ownership with barriers preventing others from coming in would be counter-productive especially in the long term, with turn over or developers moving on to different groups or products.
Maybe the right way to phrase it is there must be ownership of the code, at a minimum by one developer, but ideally by a team of developers, any one of which could step up to solve a problem when needed.
I work for a small company that multi-tasks to the extreme. So for us a lot of code is owned by individuals (or not at all). | null | 0 | 1316438528 | False | 0 | c2kyvmo | t3_kk5f4 | null | t1_c2kyvmo | t1_c2kxmv6 | null | 1427619059 | 1 | t5_2fwo | null | null | null |
True | axilmar | null | > Oh, how useful.
The whole Microsoft plan is flawed, that's what I am trying to tell you.
> WinRT is COM-callable, thus does not require C++/CLI.
And COM in standard C is a royal pain in the ass to use.
I am searching for WRL documentation, but there is none. I suspect WRL will be a 2nd class citizen for Microsoft, forcing everyone to use C++/CX.
| null | 0 | 1316438559 | False | 0 | c2kyvq4 | t3_kk7c6 | null | t1_c2kyvq4 | t1_c2kyq9t | null | 1427619059 | -1 | t5_2fwo | null | null | null |
True | skilldrick | null | That's definitely true, although the reason I didn't give it as an example is because JavaScript has a different Array constructor per frame, so if you're checking for an array cross-frame you can't use this technique. In most instances it's fine though. | null | 0 | 1316438579 | False | 0 | c2kyvsf | t3_kkbpe | null | t1_c2kyvsf | t1_c2kyv64 | null | 1427619061 | 1 | t5_2fwo | null | null | null |
True | iLiekCaeks | null | It is, but then again some take these ideas very seriously. | null | 0 | 1316438626 | False | 0 | c2kyvxt | t3_kkbyj | null | t1_c2kyvxt | t1_c2kyr8k | null | 1427619061 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | 1. Do you think I am wrong? IMHO it's the reason that chromeos is currently so underdeveloped, they want to produce good NaCL apps to fill in the gaps that html5 can't.
2. There is a massive.difference between bolting on a scripting engine into a game and writing everything except the opengl part in js. Mainly, you can still write anything performance heavy in c/c++. However you can prove me wrong very easily, just link me to js game with current gen gfx.
3. I shouldn't have said" responsive". Having to code html+ajax+css just to make a user interface is sub optimal and is widely acknowledged as such.
| null | 0 | 1316438696 | True | 0 | c2kyw6d | t3_kitgf | null | t1_c2kyw6d | t1_c2ky8oe | null | 1427619064 | 1 | t5_2fwo | null | null | null |
True | rjberry | null | Yes, it would be faster, as it could pull the data directly from the index (if you run an EXPLAIN on the query it'll say 'Using index' in the rightmost column if the data is all covered by the index). For so trivial a query as that though it makes no real difference. It's more useful for if you're selecting a lot of rows that aren't likely to be located next to one another (i.e. if you're searching for all users where first name is 'Robert' - it's very unlikely all of the Roberts would've signed up sequentially, so they'll be all over the place). If the data's in the index it can be pulled straight from memory then - if it's not it then has to go look up all of those rows individually in the table, which is pretty much random IO. | null | 0 | 1316438772 | False | 0 | c2kywfa | t3_ki83r | null | t1_c2kywfa | t1_c2ky4q5 | null | 1427619066 | 2 | t5_2fwo | null | null | null |
True | bobindashadows | null | Didn't you hear? Haskell means you can't write incorrect code and *certainly* doesn't have [type-system escape hatches like java](http://users.skynet.be/jyp/html/base/System-IO-Unsafe.html). | null | 0 | 1316438812 | False | 0 | c2kywk2 | t3_kjw0j | null | t1_c2kywk2 | t1_c2kyopr | null | 1427619067 | -1 | t5_2fwo | null | null | null |
True | joesb | null | I don't understand, if you have prior use right then how come that patent passed? As it obviously has prior art. | null | 0 | 1316438903 | False | 0 | c2kywu5 | t3_khvyw | null | t1_c2kywu5 | t1_c2kt2gi | null | 1427619071 | 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? | null | 0 | 1316439085 | False | 0 | c2kyx5w | t3_kkbpe | null | t1_c2kyx5w | t1_c2kyi87 | null | 1427619075 | 1 | t5_2fwo | null | null | null |
True | Sc4Freak | null | So... you mean the WRL?
Classic COM and Win32 had the ATL, and WinRT has the WRL template library which wraps around and provides helpers for WinRT using standard ISO C++. It's not nearly as clean as C++/CX, but it uses nothing except standard C++.
Something that a lot of people seem to be missing is that C++/CX is completely optional. It's certainly the *cleanest* and *easiest* way to interface with WinRT, but plain old COM (or the WRT helper library) is still available for people who prefer to use standard ISO C++. | null | 0 | 1316439291 | False | 0 | c2kyxop | t3_kjja4 | null | t1_c2kyxop | t1_c2kxn15 | null | 1427619081 | 4 | t5_2fwo | null | null | null |
True | wesw02 | null | I would expect most JavaScript "developers" to know 85% of the material explained on this page. Probably better for learning JavaScript, but it's well written and thus earns my upvote. | null | 0 | 1316439406 | False | 0 | c2kyy06 | t3_kketr | null | t1_c2kyy06 | t3_kketr | null | 1427619085 | 37 | t5_2fwo | null | null | null |
True | grelphy | null | It allows casts, so some type checking must still be done at runtime (e.g., calling `boom(new Object())` will result in a `ClassCastException` that could not be predicted at compile time). It is typesafe *except* for the special case of typecasts (and some fringe behavior with unchecked exceptions). In Haskell or ML, there is no casting; *all* typechecking is done statically at compile-time, and no additional checks are required thereafter.
As a tangential sidenote, C also avoids runtime typechecks by treating all data uniformly (as bitstrings of a particular length) with respect to typecasting, but calling this "type safety" is very misleading. =) | null | 0 | 1316439552 | False | 0 | c2kyyf5 | t3_kjw0j | null | t1_c2kyyf5 | t1_c2kyopr | null | 1427619091 | 4 | t5_2fwo | null | null | null |
True | DatFridge | null | Snow? I think you confuse Javascript's [prototype concept](http://en.wikipedia.org/wiki/Prototype-based_programming) with the [framework](http://www.prototypejs.org/) of the same name. | null | 0 | 1316439630 | False | 0 | c2kyynq | t3_kkbpe | null | t1_c2kyynq | t1_c2kyi5w | null | 1427619094 | 1 | t5_2fwo | null | null | null |
True | skilldrick | null | I'm not saying that this is something you'd need to do very often in JavaScript. It's not something I ever do. But it's important to know what `constructor` and `instanceof` do so you can understand code that *does* use them. | null | 0 | 1316439653 | False | 0 | c2kyyqm | t3_kkbpe | null | t1_c2kyyqm | t1_c2kyx5w | null | 1427619095 | 1 | t5_2fwo | null | null | null |
True | mzcr | null | Many smart programmers are right there with you. If at any moment it's just as easy for someone else to become the owner, because of good docs, a well designed API, or training courses, then your life is made easier. Doing it right the first time pays dividends. | null | 0 | 1316439817 | False | 0 | c2kyz7y | t3_kk5f4 | null | t1_c2kyz7y | t1_c2kxwb0 | null | 1427619103 | 1 | t5_2fwo | null | null | null |
True | back-in-black | null | This is a great talk. It's sad it doesn't have more upvotes. | null | 0 | 1316439849 | False | 0 | c2kyzby | t3_j18lc | null | t1_c2kyzby | t3_j18lc | null | 1427619104 | 2 | t5_2fwo | null | null | null |
True | Sc4Freak | null | Er. Exactly what standard features of C++ would help in creating a standard cross-language library? C++ doesn't even have a standard ABI. The **best you can do** using standard C++ is to use COM, which is what WinRT is based on already!
You *can already* use standard C++ if you want and interface with COM yourself. The C++/CX extensions are optional, and if you don't like them, then don't use them! So what's the problem? | null | 0 | 1316440042 | False | 0 | c2kyzyo | t3_kk7c6 | null | t1_c2kyzyo | t1_c2kyf7r | null | 1427619111 | 12 | t5_2fwo | null | null | null |
True | le_kommie | null | I'm not surprised there is nothing like this in the spec. Maybe MSFT wanted this to be in the spec, maybe it was in one of the drafts and then never made it, maybe they said "but that's how everyone else will do it anyway", who knows. The evolution of COM pretty much coincided with the evolution of C++ standard.
Damn, that was quite a while since I touched COM and all this, looks like this WinRT will bring this back... | null | 0 | 1316440138 | False | 0 | c2kz0aw | t3_kk7c6 | null | t1_c2kz0aw | t1_c2kys7o | null | 1427619115 | 1 | t5_2fwo | null | null | null |
True | SymetriX | null | Ok guys, I got this. I'll take the downvotes for the team...
instanceof and constructor are completely useless.
As the author mentioned in his revised article, "constructor" can be assigned any value you want. You have no guarantee that it actually represents the constructor.
And what would you be checking it for, anyway?
That leads me to my next point: instanceof is equally worthless.
"Hey, I know that this object is an instance of another object!"
So what?
Does that guarantee that a function or property exists? Nope!
I can have an object with a prorotype called foo with a method bar(), and on the object itself bar could be replaced with another function which does something totally unrelated, or it could be replaced with "undefined" and not exist at all!
typeof does have limited uses, but even then, you still need assistance from other trickery to find out something as simple as whether a variable is an array. | null | 0 | 1316440290 | False | 0 | c2kz0sh | t3_kkbpe | null | t1_c2kz0sh | t3_kkbpe | null | 1427619123 | 2 | t5_2fwo | null | null | null |
True | Sc4Freak | null | Hungarian notation has been around forever at Microsoft. They started using it 30 years ago back when nobody knew any better. Obviously now we know that hungarian notation is dumb (partly because we have IDEs and compilers to tell us type information), but Microsoft still does it because they did it 30 years ago, and it's better to be consistent than it is to be "correct". | null | 0 | 1316440316 | False | 0 | c2kz0w1 | t3_kk7c6 | null | t1_c2kz0w1 | t1_c2ky8gl | null | 1427619124 | 3 | t5_2fwo | null | null | null |
True | nixle | null | I've written some fairly complex JS code with classes, but neve quite understood the whole prototype concept (I come from a JAVA background)
| null | 0 | 1316440432 | False | 0 | c2kz1al | t3_kketr | null | t1_c2kz1al | t3_kketr | null | 1427619129 | 7 | t5_2fwo | null | null | null |
True | mzcr | null | Excellent point. I would argue that "assigned ownership" from management is vastly different from "ideal ownership. If it's assigned ownership and there isn't developer buy-in and motivation, then it's not going to get you very far. | null | 0 | 1316440457 | False | 0 | c2kz1dm | t3_kk5f4 | null | t1_c2kz1dm | t1_c2ky786 | null | 1427619130 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | The fact that VC++ is free is hardly the issue.
The issue is that VC++ is no where near standard compliant and also lacks far too many core language features, whereas Mingw32, while not perfect, does a MUCH better job. | null | 0 | 1316440458 | False | 0 | c2kz1do | t3_kk7c6 | null | t1_c2kz1do | t1_c2kyqgy | null | 1427619130 | 0 | t5_2fwo | null | null | null |
True | thesystemx | null | So it's easier to vote down without actually having to read it? | null | 0 | 1316440470 | False | 0 | c2kz1ff | t3_kb1gc | null | t1_c2kz1ff | t1_c2kfklt | null | 1427619130 | 1 | t5_2fwo | null | null | null |
True | mangodrunk | null | I'm not sure why anyone is upvoting your comments. As it's just your side of the story, you don't provide any proof that you ever took a class with him, no proof that you found a shortcut, and that he subsequently gave you a C because of it. And this is off topic to the discussion at hand. Thanks for ruining discussion on this post. | null | 0 | 1316440495 | False | 0 | c2kz1iv | t3_kk1hp | null | t1_c2kz1iv | t1_c2kwzwv | null | 1427619132 | 7 | t5_2fwo | null | null | null |
True | [deleted] | null | Put simply... if the guys at Boost can make C++ compatible with Python without proprietary extensions, Microsoft should be able to make C++ compatible with .NET. | null | 0 | 1316440582 | False | 0 | c2kz1ue | t3_kk7c6 | null | t1_c2kz1ue | t1_c2kyn0z | null | 1427619136 | 0 | t5_2fwo | null | null | null |
True | Sc4Freak | null | Not precisely - WinRT comes with a number of extensions to C++, collectively known as "C++/CX" ("C++ Component Extensions"). They're syntactic sugar over COM, and are completely optional.
WinRT needs to interop with several languages (C#, VB, JS, C, C++), and the only good way to do that is COM. So WinRT is based on COM, but COM isn't exactly very easy to use, so C++/CX was developed as syntactic sugar over C++ to make interop with COM easier. For people who want to use standard C++, you can talk to COM directly or use the WRL (which is like the ATL, but for WinRT). | null | 0 | 1316440615 | False | 0 | c2kz1y7 | t3_kk7c6 | null | t1_c2kz1y7 | t1_c2kyn0z | null | 1427619137 | 3 | t5_2fwo | null | null | null |
True | thesystemx | null | Why should it not be in the standard library? It's a really generic/universal system to do parallel computations. Perfect fit if you'd ask me... | null | 0 | 1316440678 | False | 0 | c2kz25c | t3_kjdt6 | null | t1_c2kz25c | t1_c2ky023 | null | 1427619139 | 0 | t5_2fwo | null | null | null |
True | skilldrick | null | `typeof` isn't meant to be used to find out if a variable is an array - it's used for distinguishing primitive types.
I do generally agree with your point about `instanceof` and `constructor` though. I generally don't work with JS constructors so they're not something I need to use very often. Like I've said elsewhere on this thread though, it's useful to know what they do in case you see them in code you're reading.
The purpose of my article wasn't to make a value judgement on various parts of the language, purely to explain the difference between three confusingly similar aspects. | null | 0 | 1316440690 | False | 0 | c2kz273 | t3_kkbpe | null | t1_c2kz273 | t1_c2kz0sh | null | 1427619140 | 4 | t5_2fwo | null | null | null |
True | attekojo | null | What is, then, a type error in Java? Doesn't NullPointerException mean that you're trying to use an object of null type in place of an object type? | null | 0 | 1316440754 | False | 0 | c2kz2eq | t3_kjw0j | null | t1_c2kz2eq | t1_c2kyopr | null | 1427619143 | 1 | t5_2fwo | null | null | null |
True | thesystemx | null | >The F/J framework in Java 7 cannot run on a server
It absolutely can run on the server, just not in the EJB module or when using EJBs/managed code/managed transactions.
In Java EE 7 there most likely will be a managed counterpart.
For now, it's perfectly usable in the web module. | null | 0 | 1316440799 | False | 0 | c2kz2k6 | t3_kjdt6 | null | t1_c2kz2k6 | t1_c2kyjs0 | null | 1427619145 | 3 | t5_2fwo | null | null | null |
True | illvm | null | In that case you'd have to do something like
Object.prototype.toString.call([]) === '[object Array]';
But I guess if you're using ES5 you can just do Array.isArray([]) :) | null | 0 | 1316440833 | False | 0 | c2kz2og | t3_kkbpe | null | t1_c2kz2og | t1_c2kyvsf | null | 1427619146 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Easy threading in Qt:
Use C++11 | null | 0 | 1316440891 | False | 0 | c2kz2wn | t3_kjebe | null | t1_c2kz2wn | t3_kjebe | null | 1427619150 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Wait guys I got this
Woosh!
(or I'm being wooshed. can't tell) | null | 0 | 1316440996 | False | 0 | c2kz38l | t3_kkbpe | null | t1_c2kz38l | t1_c2kyynq | null | 1427619155 | 2 | t5_2fwo | null | null | null |
True | mangodrunk | null | What hyperbole.
>Instead of continuing in the tradition of a small, powerful language suitable as a workbench for experimentation and research...
Blindly following a tradition is something we don't need in computer science. What was added in R6RS that made it any less conducive for research?
>The damage this did to the community is huge...
How have you measured this? Do you have any evidence to back it up, or is it just a baseless claim?
>Add to that the humility exhibited by some of the greatest minds...
I think you're romanticizing a bit or you don't know the history of science and math. | null | 0 | 1316441218 | False | 0 | c2kz3zp | t3_kk1hp | null | t1_c2kz3zp | t1_c2kxpdk | null | 1427619167 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Wow, I'm amazed people don't know about this page, I thought everyone did. | null | 0 | 1316441382 | False | 0 | c2kz4l7 | t3_kketr | null | t1_c2kz4l7 | t3_kketr | null | 1427619173 | -16 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316441642 | True | 0 | c2kz5gs | t3_kk1hp | null | t1_c2kz5gs | t1_c2kz1iv | null | 1427619251 | 8 | t5_2fwo | null | null | null |
True | FaustTheBird | null | You actually can't write Ecmascript code with classes. Ecmascript does not have classes. You've been using Ecmascript's features to create something where the syntax and behavior are close enough to classes to make you feel comfortable, but don't fool yourself into thinking you're using classes. They don't exist in Ecmascript. | null | 0 | 1316441652 | False | 0 | c2kz5hy | t3_kketr | null | t1_c2kz5hy | t1_c2kz1al | null | 1427619253 | 16 | t5_2fwo | null | null | null |
True | SymetriX | null | Right, but you can use the typeof in combination with other checks to determine if it is an array.
Ex:
function isArray(obj) {
return typeof obj == "object" && typeof obj.length == "number" && !obj.propertyIsEnumerable("length");
}
I see your point about explaining what the code does, but I would always add a grain of salt that these constructs do not offer the usefulness you would get in a strong-typed language. | null | 0 | 1316441831 | False | 0 | c2kz65q | t3_kkbpe | null | t1_c2kz65q | t1_c2kz273 | null | 1427619259 | 3 | t5_2fwo | null | null | null |
True | pnpbios | null | To address some complaints in this thread.
> **Sure T^ looks better than CComPtr<T>, but for professional software, using standard features of a language buys you a great deal of safety and saves cost. By not using standard features, for example, I cannot use Mingw32 to write WinRT applications, I have to buy Visual Studio.**
No, you do not. The platform SDK has been free and will always be free.
In fact, you can download the latest version here.
http://www.microsoft.com/download/en/details.aspx?id=8279
Code::blocks has built in support for compiling with visual c++.
http://wiki.codeblocks.org/index.php?title=Installing_a_supported_compiler#Microsoft_Visual_C.2B.2B
> Code::Blocks will work with any edition of Visual C++ since the 2003 edition (MSVC 7.1). The commercial editions of Visual Studio may require additional configuration in Code::Blocks to work correctly. You can also download the most recent "Express" edition of Visual C++ for free from microsoft.com/express/vc. If you choose an "Express" edition of Visual C++, it is highly recommended that you also install Microsoft's Platform SDK in order to develop programs for Windows.
.
> **Microsoft does the same shit again: making it difficult to use the standard language, and very easy to use its proprietary extensions, in order to lock developers into its tools.
Shame on you Microsoft, for not using the standard features of the languages.**
I'm curious if you are also going to complain about QT, GCC, and LLVM/Clang then, as they also have language extensions.
QT: http://en.wikipedia.org/wiki/Qt_(framework)
> Qt uses standard C++ but makes extensive use of a special code generator (called the Meta Object Compiler, or moc) together with several macros to enrich the language.
GCC: http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Extensions.html
> The GNU compiler provides these extensions to the C++ language (and you can also use most of the C language extensions in your C++ programs). If you want to write code that checks whether these features are available, you can test for the GNU compiler the same way as for C programs: check for a predefined macro __GNUC__. You can also use __GNUG__ to test specifically for GNU C++ (see Predefined Macros).
LLVM/Clang: http://clang.llvm.org/docs/LanguageExtensions.html
> This document describes the language extensions provided by Clang. In addition to the language extensions listed here, Clang aims to support a broad range of GCC extensions. Please see the GCC manual for more information on these extensions.
| null | 0 | 1316442048 | False | 0 | c2kz6yw | t3_kk7c6 | null | t1_c2kz6yw | t3_kk7c6 | null | 1427619270 | 27 | t5_2fwo | null | null | null |
True | skilldrick | null | Ok - the canonical version of isArray I've found uses [illvm's approach](http://www.reddit.com/r/programming/comments/kkbpe/understanding_typeof_instanceof_and_constructor/c2kz2og).
Again, I agree that they're not very useful! I do think that `typeof` is useful in its place, mostly for checking function arguments in my experience. | null | 0 | 1316442197 | False | 0 | c2kz7jb | t3_kkbpe | null | t1_c2kz7jb | t1_c2kz65q | null | 1427619278 | 2 | t5_2fwo | null | null | null |
True | eaturbrainz | null | You know, there used to be a time when "functional language" meant a language with first-class and higher-order functions rather than a language built on pure referential transparency. This whole purity cult is so ridiculously self-limiting: more and more of the world goes old-meaning functional while less and less of the world fits into the new, more restrictive definitions of "functional".
There was a time when Lisp was the *standard* functional language. Then there was a time when ML was the *standard* functional language. Now it's just Haskell or Clean or *bust*, you're not functional? /fuckthatshit.jpg! I simply think the purity religion has gone too far when Scheme, ML or Disciple can no longer count as functional languages. | null | 0 | 1316442214 | False | 0 | c2kz7lh | t3_kjkxj | null | t1_c2kz7lh | t1_c2kuex4 | null | 1427619279 | 1 | t5_2fwo | null | null | null |
True | Sc4Freak | null | A WinRT type can be written in C++, C#, VB.NET, or JavaScript and can be consumed by any language supporting COM (including the aforementioned languages). So basically you want MS to write the equivalent of boost::python for every single language so that C++ can talk to .NET, JavaScript can talk to C++, .NET can talk to JS, and all the other millions of permutations of languages out there?
The *whole point* of using COM in the first place is to define a standard ABI which can be consumed by all languages so that you don't need to write boost::python, boost::javascript, boost::dotnet, and a hundred other libraries to interop with other languages.
That's why WinRT is based on COM. C++/CX is just syntactic sugar over COM to make life easier for developers. If you prefer standard ISO C++ and want the equivalent of boost::python for WinRT, then use the WRL which is a standard C++ library for that exact purpose. | null | 0 | 1316442361 | False | 0 | c2kz86t | t3_kk7c6 | null | t1_c2kz86t | t1_c2kz1ue | null | 1427619287 | 10 | t5_2fwo | null | null | null |
True | zokier | null | Oh, I'm sorry. I was completely unaware of WRL. I haven't seen it mentioned on any material I have encountered yet. I'll go check it out. But I have to say that MS doesn't seem to be advertising WRL very loudly.
edit: The only reference to WRL which I found was a comment from Sutter in a discussion for one of his presentations. Browsed through all slides from relevant presentations, no reference to WRL at all. | null | 0 | 1316442407 | True | 0 | c2kz8cp | t3_kjja4 | null | t1_c2kz8cp | t1_c2kyxop | null | 1427619289 | 1 | t5_2fwo | null | null | null |
True | eaturbrainz | null | >Java checked exceptions illustrate how side-effects could be tracked by the compiler. Maybe it would be avoided as much as checked exceptions, but it seems like an experiment worth trying.
See: Disciple | null | 0 | 1316442420 | False | 0 | c2kz8et | t3_kjkxj | null | t1_c2kz8et | t1_c2kulvo | null | 1428193709 | 2 | t5_2fwo | null | null | null |
True | a_redditor | null | Please don't use url shorteners on submissions. It makes you look like a spammer to the spam filter. | null | 0 | 1316442443 | False | 0 | c2kz8ig | t3_kkfsg | null | t1_c2kz8ig | t3_kkfsg | null | 1427619295 | 11 | t5_2fwo | null | null | null |
True | Sc4Freak | null | Yeah, it's still pre-beta software. There's a lot of documentation missing - and the WRL is one of those things that they haven't completed the documentation for. Herb Sutter and the rest of the MS guys have been talking about it, so I expect we'll see the docs later (maybe once they hit beta). | null | 0 | 1316442541 | False | 0 | c2kz8wj | t3_kjja4 | null | t1_c2kz8wj | t1_c2kz8cp | null | 1427619301 | 1 | t5_2fwo | null | null | null |
True | niczar | null | It's gonna be used by <.01% of all Java programs. The whole JRE will have to be updated every time there's a bug in it, the code will have downloaded by >99.9% of installs that will never use it. Plus the attack surface of the whole Java stack will increase. Why?? | null | 0 | 1316442642 | False | 0 | c2kz9b5 | t3_kjdt6 | null | t1_c2kz9b5 | t1_c2kz25c | null | 1427619305 | 0 | t5_2fwo | null | null | null |
True | eaturbrainz | null | >I mean, the compiler knows what's a template and what isn't.
A context-free parser really doesn't. | null | 0 | 1316442664 | False | 0 | c2kz9e9 | t3_kikut | null | t1_c2kz9e9 | t1_c2kkuht | null | 1427619306 | 1 | t5_2fwo | null | null | null |
True | reddit_clone | null | Most people don't seem to realize that the level of performance difference discussed here does not matter for most applications in most situations.
What matters to a number crunching program that deals with arrays of millions of items does not matter to an application program which may load a few hundreds of items into an array once.
For most people, this discussion is premature optimization. | null | 0 | 1316442973 | False | 0 | c2kzan8 | t3_kf43e | null | t1_c2kzan8 | t3_kf43e | null | 1427619319 | 1 | t5_2fwo | null | null | null |
True | skilldrick | null | Don't know why this got downvoted - it's entirely accurate. | null | 0 | 1316443122 | False | 0 | c2kzb9u | t3_kketr | null | t1_c2kzb9u | t1_c2kz5hy | null | 1427619327 | 3 | t5_2fwo | null | null | null |
True | munificent | null | That only lets you dispatch on one argument (the receiver). Sometimes, you want to have a method that already has a receiver, but also make it (conceptually) overloaded. Say you're making a graphics library and you want to allow something like:
renderer.draw(new Circle(1, 2, 3));
renderer.draw(new Rect(4, 5, 6, 7));
An implementation of `draw()` might look like:
Renderer.prototype.draw = function(what) {
if (what instanceof Circle) {
...
} else if (what instanceof Square) {
...
}
}
You *could* use dynamic dispatch for that by faking double dispatch with the visitor pattern, but that's pretty cumbersome and not always worth the trouble. | null | 0 | 1316443173 | False | 0 | c2kzbhc | t3_kkbpe | null | t1_c2kzbhc | t1_c2kyhm7 | null | 1427619329 | 2 | t5_2fwo | null | null | null |
True | pnpbios | null | I agree, for much of minecraft, a request/response model would make a lot more sense. | null | 0 | 1316443441 | False | 0 | c2kzcle | t3_kfiuk | null | t1_c2kzcle | t1_c2jxb7j | null | 1427619344 | 1 | t5_2fwo | null | null | null |
True | paulydavis | null | http://en.wikipedia.org/wiki/Sunk_costs
**EDIT More like this http://en.wikipedia.org/wiki/Sunk_cost_dilemma ***
| null | 0 | 1316443568 | True | 0 | c2kzd5f | t3_ki52y | null | t1_c2kzd5f | t1_c2kxn7k | null | 1427619353 | 1 | t5_2fwo | null | null | null |
True | nixle | null | yeah I know. But let's just call them that. | null | 0 | 1316443589 | False | 0 | c2kzd90 | t3_kketr | null | t1_c2kzd90 | t1_c2kz5hy | null | 1427619354 | 23 | t5_2fwo | null | null | null |
True | Whanhee | null | People always seem to want expressiveness, but I think clarity is more important. They often go hand in hand, but they are not necessarily related. Thoughts? | null | 0 | 1316443630 | False | 0 | c2kzdf6 | t3_kjw0j | null | t1_c2kzdf6 | t1_c2kyfu3 | null | 1427619356 | 3 | t5_2fwo | null | null | null |
True | pnpbios | null | Always something new to complain about isn't there. | null | 0 | 1316443662 | True | 0 | c2kzdk4 | t3_kfyc7 | null | t1_c2kzdk4 | t3_kfyc7 | null | 1427619358 | 1 | t5_2fwo | null | null | null |
True | NruJaC | null | Java is statically typed, but its type system is weak (not used here as a synonym for bad, just as a descriptor). In Java, not all type checking is done at compile time. The proof of this is the exceptions you can throw at runtime: NullPointer, ClassCast, etc.. In a strongly-typed language like Haskell, everything is bound to its type. You can't throw a null pointer exception because if you try, you'll throw a compile-time error. This system isn't perfect, and its difficult to absorb/master, but it is different. | null | 0 | 1316443796 | False | 0 | c2kze54 | t3_kjw0j | null | t1_c2kze54 | t1_c2kyopr | null | 1427619370 | 3 | t5_2fwo | null | null | null |
True | skew | null | Do you know how to violate type safety with unsafePerformIO? Purity, maybe, but violating type safety with it is trickier than you might think.
With [this little gem](http://users.skynet.be/jyp/html/base/GHC-Prim.html#24) it's a different story. | null | 0 | 1316443893 | False | 0 | c2kzek4 | t3_kjw0j | null | t1_c2kzek4 | t1_c2kywk2 | null | 1427619371 | 1 | t5_2fwo | null | null | null |
True | GayHitl3r | null | Professing belief in a sort of group prescience among programmers? | null | 0 | 1316443931 | False | 0 | c2kzepz | t3_kketr | null | t1_c2kzepz | t1_c2kz4l7 | null | 1427619372 | 3 | t5_2fwo | null | null | null |
True | Eirenarch | null | What happens if the schema changes between when the code is written and runtime for any other language including dynamic languages? Well the code throws an error this is what happens. You cannot expect that you'll write a code against a service and the code will work if the service is changed or even if it goes away. | null | 0 | 1316443975 | False | 0 | c2kzeww | t3_kii9z | null | t1_c2kzeww | t1_c2klcul | null | 1427619375 | 1 | t5_2fwo | null | null | null |
True | Eirenarch | null | "Scala will support this too"
reference please | null | 0 | 1316444082 | False | 0 | c2kzfd8 | t3_kii9z | null | t1_c2kzfd8 | t1_c2kixp3 | null | 1427619381 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | No COM is not the issue and despite it's 'ugliness' it's really no worse than many other bindings. Heck the CPython API is an absolute horror to work with as well.
My argument is mostly that standard C++ has all the functionality needed for interop without the need of proprietary extensions built right into the language. And even if it didn't, the worst case scenario would be to do what Qt does, and write a C++ preprocessor that's compatible with any standard C++ compiler.
Instead they decided to create their own new language, one based off of C++ and looks like C++, but is not standard C++ and as such a developer is required to use MS's non-conforming compiler to work with WinRT.
Given how poor VS11's support for C++ is, that means another 2-3 years of littering my codebase with #ifdefs and other crap to get my libraries to work in a cross-platform fashion. | null | 0 | 1316444089 | True | 0 | c2kzfee | t3_kk7c6 | null | t1_c2kzfee | t1_c2kz86t | null | 1427619381 | 0 | t5_2fwo | null | null | null |
True | 0xABADC0DA | null | You answered the question of why use interfaces, but nobody asked that question and you didn't answer the question of why have implicit interfaces.
Case 1: Some library code has functions you want to use, but they used structs not interfaces. Google Go doesn't help you at all here, it's the same problem as Java.
Case 2: Some library code has functions you want to use and they used interfaces. In Google Go you just call the functions. In Java, you add "implements TheirInterface" and call the functions. So there's no benefit here either.
Case 3: You want to use some library's objects in your code and you can use the object's methods as-is. In Google Go you can define an interface that matches their objects. In Java you can define an interface, and make an adapter that forwards to their object.
Case 4: You want to use some other library's code, but the functions do not exactly fit with your code. In Google Go, you write an adapter that modifies and forwards. In Java you write an adapter that modifies and forwards.
There are other minor cases, but in general you can see that Google Go's automatic interfaces only helps in case 3, when you can exactly use some other code as-is. And as I said before, if Java had a "+= AnInterface" then you could add the interface in case 3 to the library's objects and use them directly, getting exactly the benefit of Google Go's automatic interfaces. You never explained how Google Go's interfaces are any better than this one feature that could be added to Java.
On the other hand, implicit interfaces cause all sorts of problems because there's no way to say "this is a different type" or "these types are related". This is the problem with error handling. I'm sure you've seen [this code](http://www.reddit.com/r/programming/comments/k9ud6/comparing_go_with_lua/c2ipl1f) showing proper error handling in Google Go. This is a direct consequence of implicit interfaces, and not having to write "implements X" once vs having to write 5 lines of boilerplate to handle errors is not a good tradeoff. | null | 0 | 1316444174 | False | 0 | c2kzfqn | t3_kikut | null | t1_c2kzfqn | t1_c2kpq72 | null | 1427619385 | 2 | t5_2fwo | null | null | null |
True | afiefh | null | Cool! I always thought that indexes are only used when all the index's rows are in the WHERE condition. Much obliged. | null | 0 | 1316444211 | False | 0 | c2kzfwt | t3_ki83r | null | t1_c2kzfwt | t1_c2kywfa | null | 1427619387 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316444235 | False | 0 | c2kzfzt | t3_kkfbs | null | t1_c2kzfzt | t3_kkfbs | null | 1427619388 | 0 | t5_2fwo | null | null | null |
True | Cintax | null | Knowing the material and knowing the details and the reasons why are very different. At first glance I think I knew about 75% of it off the top of my head, but a lot of that was through experience and just knowing "This doesn't work" as opposed to **why** it doesn't work (for example, I never knew why the "Notation of Keys" example was that way, but I knew not to use plain characters from seeing bugs when developing). | null | 0 | 1316444353 | False | 0 | c2kzghm | t3_kketr | null | t1_c2kzghm | t1_c2kyy06 | null | 1427619395 | 27 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316444532 | False | 0 | c2kzhae | t3_kketr | null | t1_c2kzhae | t1_c2kzb9u | null | 1427619406 | 0 | t5_2fwo | null | null | null |
True | neosiv | null | Interesting proof of concept, though I'm not sure why anyone would want to do this in practice. It's better to use something like GWT or Valaadin if you want generate a web front-end using pure java. | null | 0 | 1316444620 | False | 0 | c2kzhp0 | t3_kjwil | null | t1_c2kzhp0 | t3_kjwil | null | 1427619418 | 2 | t5_2fwo | null | null | null |
True | vplatt | null | Well, that would be reddit or /. or hn. At any rate, I hadn't seen this page before. | null | 0 | 1316444708 | False | 0 | c2kzi2i | t3_kketr | null | t1_c2kzi2i | t1_c2kzepz | null | 1427619419 | 1 | t5_2fwo | null | null | null |
True | MothersRapeHorn | null | That's cute, because C# has done more for bringing FP concepts to the business masses than any other language. | null | 0 | 1316444780 | False | 0 | c2kzied | t3_kjkxj | null | t1_c2kzied | t3_kjkxj | null | 1427619422 | 7 | t5_2fwo | null | null | null |
True | GayHitl3r | null | I guess it was too much of a PITA to code up a blog in BASIC ;-P | null | 0 | 1316444781 | False | 0 | c2kzief | t3_kajta | null | t1_c2kzief | t1_c2itiob | null | 1427619422 | 1 | t5_2fwo | null | null | null |
True | reddit_clone | null | Beauty is in the eyes of the beholder and all that.
If you know the convention they are using, it might not look as ugly.
It also depends on the background of the original author. In the implementation of 'Scheme in one day', C code was formatted like Scheme code. Looked pretty weird at first. But once I figured out the reason, I got comfortable with it.
| null | 0 | 1316444808 | False | 0 | c2kziiz | t3_kf43e | null | t1_c2kziiz | t1_c2jsaqp | null | 1427619432 | 1 | t5_2fwo | null | null | null |
True | KyteM | null | For fuck's sake. ANYTHING THAT COMPILES DOWN TO NATIVE C++ CAN AND WILL, EVENTUALLY, BE REPRESENTED IN PURE C++ CODE.
It's obvious they just haven't shown how yet because they're showing the *new* stuff off. In fact, [someone else already figured it out](http://stackoverflow.com/questions/7436144/using-winrt-from-c).
There's your pure C++. It's basically COM. Happy now? | null | 0 | 1316444837 | False | 0 | c2kzin1 | t3_kgl4f | null | t1_c2kzin1 | t1_c2kye8e | null | 1427619424 | 1 | t5_2fwo | null | null | null |
True | kindoblue | null | Thank God it is almost 2012 :) | null | 0 | 1316444870 | False | 0 | c2kzirp | t3_kjf91 | null | t1_c2kzirp | t3_kjf91 | null | 1427619425 | 1 | t5_2fwo | null | null | null |
True | zuvembi | null | I think you're probably right. I'm a developer in other languages who had fallen in to using Javascript because I've coded a continuous code review application and really needed some front-end Javascript. I can't really say I've taken the time to learn Javascript right. I've sort of cargo-culted and done bits and pieces here and there.
I really should take a couple days and plow through a bunch of Javascript material. Maybe when my minion gets back from his family emergency (sick Mother). | null | 0 | 1316444936 | False | 0 | c2kzj2t | t3_kketr | null | t1_c2kzj2t | t1_c2kyy06 | null | 1427619431 | 3 | t5_2fwo | null | null | null |
True | naasking | null | Not just web apps. NaCL is a general, low-overhead sandboxing architecture for native code. Great idea for native code plugins. | null | 0 | 1316445035 | False | 0 | c2kzji4 | t3_kitgf | null | t1_c2kzji4 | t3_kitgf | null | 1427619434 | 1 | t5_2fwo | null | null | null |
True | KyteM | null | ...the only place where you'd use Component Extensions would be with Metro-style apps, which are *inherently tied to Windows*.
Cross-platform what? | null | 0 | 1316445187 | False | 0 | c2kzk5m | t3_kk7c6 | null | t1_c2kzk5m | t1_c2kzfee | null | 1427619443 | 5 | t5_2fwo | null | null | null |
True | KyteM | null | You do realize not even the WinRT docs are complete and there's many, *many* blanks pages everywhere? | null | 0 | 1316445289 | False | 0 | c2kzklx | t3_kk7c6 | null | t1_c2kzklx | t1_c2kyvq4 | null | 1427619448 | 3 | t5_2fwo | null | null | null |
True | squirrel5978 | null | I believe the free one does not even allow you to compile for 64 bit, or use OpenMP, and has a bunch of other missing features. | null | 0 | 1316445463 | False | 0 | c2kzldm | t3_kk7c6 | null | t1_c2kzldm | t1_c2kyqgy | null | 1427619459 | 0 | t5_2fwo | null | null | null |
True | _Lar_ | null | Small (Java) question incoming:
There is a small thing I don't get about this C++ code:
class gadget;
class widget
{
private:
shared_ptr<gadget> g;
};
class gadget
{
private:
weak_ptr<widget> w;
}
He says that in Java you would have to write dispose methods and remeber to dispose a gadget from a widget, but not viceversa. Could someone explain me why that is (i. e. in what scenario would that be needed), since from what Java I know, one would write the above code and it should "just work"...? | null | 0 | 1316445603 | False | 0 | c2kzm0j | t3_kjja4 | null | t1_c2kzm0j | t3_kjja4 | null | 1427619468 | 2 | t5_2fwo | null | null | null |
True | deadfones | null | >JavaScript Garden is a growing collection of documentation about the most quirky parts of the JavaScript programming language.
IOW, a comprehensive reference. | null | 0 | 1316445674 | False | 0 | c2kzmcd | t3_kketr | null | t1_c2kzmcd | t3_kketr | null | 1427619476 | 22 | t5_2fwo | null | null | null |
True | neoform | null | Javascript? Who uses that anymore? jQuery is like, way better. | null | 0 | 1316445831 | False | 0 | c2kzn0m | t3_kketr | null | t1_c2kzn0m | t3_kketr | null | 1427619481 | 11 | t5_2fwo | null | null | null |
True | spellspoil | null | This is a good resource too
http://ejohn.org/apps/learn/ | null | 0 | 1316445856 | False | 0 | c2kzn4m | t3_kketr | null | t1_c2kzn4m | t3_kketr | null | 1427619482 | 11 | t5_2fwo | null | null | null |
True | GayHitl3r | null | Integration is firmly not programming. | null | 0 | 1316445869 | False | 0 | c2kzn6g | t3_k3nab | null | t1_c2kzn6g | t1_c2i3b9m | null | 1427619483 | 1 | t5_2fwo | null | null | null |
True | ethraax | null | Actually, no, the fact that VC++ is free *is* the issue that axilmar, the person I responded to, had. Here's a quote from him:
> By not using standard features, for example, I cannot use Mingw32 to write WinRT applications, I have to buy Visual Studio.
It seems like he's directly complaining about having to buy Visual Studio. This is wrong, and I'm just pointing it out. | null | 0 | 1316445919 | False | 0 | c2kznef | t3_kk7c6 | null | t1_c2kznef | t1_c2kz1do | null | 1427619485 | 7 | t5_2fwo | null | null | null |
True | GayHitl3r | null | Not that bad. | null | 0 | 1316445994 | False | 0 | c2kznqi | t3_k3nab | null | t1_c2kznqi | t1_c2hbcev | null | 1427619495 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | What? No, I'm just frequently in the same chatroom as these guys, they've been working on it [for a long time](https://github.com/BonsaiDen/JavaScript-Garden/commit/75c02cfca1fe43ae28ff8b6ce89c094ad9df80c0) and it gets tons of views as it is. It's one of the first resources I direct people to when they have questions, right up there with MDC. | null | 0 | 1316446209 | False | 0 | c2kzoq5 | t3_kketr | null | t1_c2kzoq5 | t1_c2kzepz | null | 1427619502 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | Cross-platform dependencies, such as libraries my Metro-style app might want to make use of.
For my particular use case I develop financial trading software, the meat of which does use a lot of the new C++11 functionality especially for a lot of the I/O and threading and which is a shared codebase across all the platforms I support. On the GUI side of things most of my clients use Windows, and it may be worthwhile to develop a Metro-style app (who knows)... the point is that if I want to do so in C++ I now have to use the Visual Studio compiler, which is simply broken and a product MS has admitted to putting very little resources into.
To give you an idea... right now if I build my dependencies in VS10 or VS11 (which admittedly is still in beta) without all the crazy #ifdefs, the compiler simply crashes. | null | 0 | 1316446247 | False | 0 | c2kzow7 | t3_kk7c6 | null | t1_c2kzow7 | t1_c2kzk5m | null | 1427619504 | 3 | t5_2fwo | null | null | null |
True | rDr4g0n | null | I've written a lot of javascript, but much of this is new to me. | null | 0 | 1316446308 | False | 0 | c2kzp6e | t3_kketr | null | t1_c2kzp6e | t1_c2kyy06 | null | 1427619508 | 21 | t5_2fwo | null | null | null |
True | thesystemx | null | Perhaps, although don't forget that GWT is not only about generating the front-end using Java, but you're actually generating a Javascript application that runs on the client.
This is a paradigm change that you may not want to make.
Besides that, GWT has also started offering a declarative way to build the UI, so why should JSF not be 'allowed' to exploit the programmatic way? *(it's of course not JSF doing this but just some guy who tries something out, but I hope you get the idea)* | null | 0 | 1316446422 | False | 0 | c2kzpn2 | t3_kjwil | null | t1_c2kzpn2 | t1_c2kzhp0 | null | 1427619514 | 4 | t5_2fwo | null | null | null |
True | kilrizzy | null | Right!?! I haven't even coded in PHP since I started using CodeIgniter | null | 0 | 1316446475 | False | 0 | c2kzpuz | t3_kketr | null | t1_c2kzpuz | t1_c2kzn0m | null | 1427619517 | 25 | t5_2fwo | null | null | null |
True | [deleted] | null | 10% faster code... hmm sounds good. | null | 0 | 1316446488 | False | 0 | c2kzpwg | t3_kkfbs | null | t1_c2kzpwg | t3_kkfbs | null | 1427619517 | 3 | t5_2fwo | null | null | null |
True | bluefinity | null | Also not a good idea: the tooltips on everything. | null | 0 | 1316446533 | False | 0 | c2kzq2c | t3_kjkxj | null | t1_c2kzq2c | t1_c2ksba0 | null | 1427619519 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | Add their photo viewers to that list. The one in Windows 7/8 was probably designed by Liberace.
| null | 0 | 1316446575 | False | 0 | c2kzq9c | t3_kjf91 | null | t1_c2kzq9c | t1_c2kypkm | null | 1427619522 | 1 | t5_2fwo | null | null | null |
True | thesystemx | null | If it's about consumers and about the JRE, don't worry... it's modular and starts with a very small kernel, then downloads on demands additional parts when needed.
For most other uses, it's a benefit to have this available by default. It makes it easier for developers to actually use this, which is a Good Thing.
(on OS X, there's also GCD available by default for Cocoa apps, no download or install necessary) | null | 0 | 1316446757 | False | 0 | c2kzr15 | t3_kjdt6 | null | t1_c2kzr15 | t1_c2kz9b5 | null | 1427619533 | 1 | t5_2fwo | null | null | null |
True | simonask | null | Nope. But the *compiler* does, and the parser doesn't need to be the part that knows it. :) | null | 0 | 1316447053 | False | 0 | c2kzsdg | t3_kikut | null | t1_c2kzsdg | t1_c2kz9e9 | null | 1427619550 | 1 | t5_2fwo | null | null | null |
True | GayHitl3r | null | I had no idea the creator of Qt was being held.
I'll be here all day folks. | null | 0 | 1316447135 | False | 0 | c2kzsrc | t3_k1k9b | null | t1_c2kzsrc | t3_k1k9b | null | 1427619555 | 1 | t5_2fwo | null | null | null |
True | KyteM | null | Ah, I understand now.
On one hand, you can always develop the different parts in the environment more suited to the task. They did put a good bit of effort in interop and all that jazz.
On the other hand, it's proven that you can use WinRT with pure C++, so at worst someone can always create something like boost::winrt. It's a write-once effort, after all. | null | 0 | 1316447291 | True | 0 | c2kztfe | t3_kk7c6 | null | t1_c2kztfe | t1_c2kzow7 | null | 1427619564 | 3 | t5_2fwo | null | null | null |
True | tragomaskhalos | null | Back in the pre-.NET days when Microsoft were looking to address the problems inherent in COM development (i.e. very fiddly under C++ or frowned-upon-by-techies-and-underpowered under VB), they were kicking around a proprietary flavour of C++ that hid a lot of the COM ugliness away (I remember reading a white paper on it that can no longer find).
This of course morphed into a more radical overhaul in the form of .NET, so it's bizarre to see the wheel come full circle and for that C++ variant to make a comeback as C++/CX.
| null | 0 | 1316447595 | True | 0 | c2kzuw2 | t3_kk7c6 | null | t1_c2kzuw2 | t1_c2kyzyo | null | 1427619590 | 2 | t5_2fwo | null | null | null |
Subsets and Splits
Filtered Reddit Uplifting News
The query retrieves specific news articles by their link IDs, providing a basic overview of those particular entries without deeper analysis or insights.
Recent Programming Comments
Returns a limited set of programming records from 2020 to 2023, providing basic filtering with minimal analytical value.