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 | mikesamuel | null | Yeah, didn't work. To the best of my knowledge, I am still not. | null | 0 | 1318299428 | False | 0 | c2qgqyu | t3_l7bjb | null | t1_c2qgqyu | t1_c2qgl6t | null | 1427714052 | 7 | t5_2fwo | null | null | null |
True | tau-lepton | null | 1) I'm not a language designer, just a user, but from what I've seen of Dart it is a step backwards. I've grown to appreciate the power that a prototypical dynamically typed language provides. I'm reserving judgement until I use it, but it doesn't appeal to me so far.
2) Who cares? I'm more concerned about it being... | null | 0 | 1318299435 | False | 0 | c2qgr04 | t3_l6uwv | null | t1_c2qgr04 | t1_c2qft4u | null | 1427714052 | 4 | t5_2fwo | null | null | null |
True | kirakun | null | Works the same way like this too:
{
value: 'Mikhail',
// writable: true,
configurable: true
}
| null | 0 | 1318299482 | False | 0 | c2qgraz | t3_l765i | null | t1_c2qgraz | t1_c2qgodk | null | 1427714056 | 1 | t5_2fwo | null | null | null |
True | munificent | null | > int and double and some other "types" are not actually types, but interfaces?
All types in the static sense of the word are interfaces. Even when you refer to a class's type, you're actually referring to the implicit interface associated with that class. All values are runtime are instances of classes. So `num` i... | null | 0 | 1318299491 | False | 0 | c2qgrd4 | t3_l6uwv | null | t1_c2qgrd4 | t1_c2qgmc0 | null | 1427714057 | 1 | t5_2fwo | null | null | null |
True | tau-lepton | null | IMHO it's not as essential as one might think, most developers know at least three languages, in many cases a language is well suited to a specific set of problems. GWT and Microsoft's ASP.Net both suffer from the same problem, trying to hide moderate complexity with another moderately (being generous) complex layer. | null | 0 | 1318299632 | True | 0 | c2qgs4r | t3_l6uwv | null | t1_c2qgs4r | t1_c2qf6ji | null | 1427714067 | 1 | t5_2fwo | null | null | null |
True | tau-lepton | null | D or C++? | null | 0 | 1318299707 | False | 0 | c2qgsj4 | t3_l6uwv | null | t1_c2qgsj4 | t1_c2qfcwx | null | 1427714072 | 2 | t5_2fwo | null | null | null |
True | tau-lepton | null | That would be awful. | null | 0 | 1318299742 | False | 0 | c2qgsqk | t3_l6uwv | null | t1_c2qgsqk | t1_c2qds7r | null | 1427714075 | 2 | t5_2fwo | null | null | null |
True | setuid_w00t | null | It seems kind of ridiculous to charge money for a programming language specification. | null | 0 | 1318299751 | False | 0 | c2qgsse | t3_l7gl3 | null | t1_c2qgsse | t1_c2qe7f3 | null | 1427714075 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | But if you comment out the last one it will break without also removing the preceding comma.
The thought is that you're usually adding and removing items on the end of the list.
It becomes even more useful when you have functions throw into the mix:
var something = {
add: function(){
// a few l... | null | 0 | 1318299773 | True | 0 | c2qgswo | t3_l765i | null | t1_c2qgswo | t1_c2qgraz | null | 1427714077 | 2 | t5_2fwo | null | null | null |
True | UnpopularStatment | null | Tone down the buzzwords. | null | 0 | 1318299787 | False | 0 | c2qgszc | t3_l7769 | null | t1_c2qgszc | t1_c2qbyog | null | 1427714079 | 1 | t5_2fwo | null | null | null |
True | setuid_w00t | null | Google and Microsoft think it's still relevant. Perhaps you should call to inform them of their mistake. | null | 0 | 1318299850 | False | 0 | c2qgtan | t3_l7gl3 | null | t1_c2qgtan | t1_c2qeskr | null | 1427714082 | 13 | t5_2fwo | null | null | null |
True | tau-lepton | null | I've really gotten to enjoy prototypical inheritance. | null | 0 | 1318299857 | False | 0 | c2qgtc6 | t3_l6uwv | null | t1_c2qgtc6 | t1_c2qdihz | null | 1427714082 | 3 | t5_2fwo | null | null | null |
True | tau-lepton | null | Verbosity. | null | 0 | 1318299881 | False | 0 | c2qgtgw | t3_l6uwv | null | t1_c2qgtgw | t1_c2qcz7e | null | 1427714084 | 1 | t5_2fwo | null | null | null |
True | stochasticasfuck | null | AWWWWW. WHO IS GOING TO LEARN HTML AS SOON AS THEY CAN READ. WHO IS? YOU ARE, THAT'S RIGHT LITTLE BABY. </babytalk> | null | 0 | 1318299906 | False | 0 | c2qgtma | t3_l7sk2 | null | t1_c2qgtma | t3_l7sk2 | null | 1427714086 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | I never said that easy means good. I didn't want to point out the obvious, namely what one would find if one read the article. I'm well aware of what's in that article. | null | 0 | 1318299918 | False | 0 | c2qgtp0 | t3_l77q2 | null | t1_c2qgtp0 | t1_c2qgq7y | null | 1427714087 | 1 | t5_2fwo | null | null | null |
True | shillbert | null | So basically, both software engineers in the example could be good. The girl could be better at debugging and making sure edge cases don't cause problems (maybe a test programmer), and the boy could be better at putting together a readable high-level program, taking into account organizational concepts of OOP. If *all*... | null | 0 | 1318299964 | False | 0 | c2qgtxr | t3_l6yn1 | null | t1_c2qgtxr | t1_c2qbr11 | null | 1427714091 | -1 | t5_2fwo | null | null | null |
True | tau-lepton | null | Agreed, I think it may die unless there is something more compelling than classical inheritance and some syntactical sugar. | null | 0 | 1318299977 | False | 0 | c2qgu01 | t3_l6uwv | null | t1_c2qgu01 | t1_c2qce5j | null | 1427714092 | 1 | t5_2fwo | null | null | null |
True | tau-lepton | null | Reminds me of old MS code samples. | null | 0 | 1318300077 | False | 0 | c2qguje | t3_l6uwv | null | t1_c2qguje | t1_c2qgmou | null | 1427714098 | 1 | t5_2fwo | null | null | null |
True | tau-lepton | null | Casting is a sign that you're doing it wrong. | null | 0 | 1318300145 | False | 0 | c2qguxr | t3_l6uwv | null | t1_c2qguxr | t1_c2qbcp3 | null | 1427714104 | 2 | t5_2fwo | null | null | null |
True | tau-lepton | null | And they are different languages. | null | 0 | 1318300202 | False | 0 | c2qgvbo | t3_l6uwv | null | t1_c2qgvbo | t1_c2qbs9n | null | 1427714109 | 0 | t5_2fwo | null | null | null |
True | notSorella | null | As @beaucollins pointed already, it's called "comma first style".
People use it for different reasons, I just think it looks visually nicer not having the trailing comma at the end of every line, and it adds a visual aid on where each new item starts if I ever need to split up an item in several lines.
Other people u... | null | 0 | 1318300348 | False | 0 | c2qgw62 | t3_l765i | null | t1_c2qgw62 | t1_c2qgm2a | null | 1427714120 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318300385 | False | 0 | c2qgwem | t3_l7gl3 | null | t1_c2qgwem | t3_l7gl3 | null | 1427714124 | 1 | t5_2fwo | null | null | null |
True | notSorella | null | That sounds really painful... | null | 0 | 1318300396 | False | 0 | c2qgwfm | t3_l765i | null | t1_c2qgwfm | t1_c2qgo2l | null | 1427714124 | 1 | t5_2fwo | null | null | null |
True | mb86 | null | The new stuff is useful, but stick with the book you have for now. It'll be 5-10 years before compilers catch up (GCC's still working on C99, Visual Studio doesn't even do C89). | null | 0 | 1318300395 | False | 0 | c2qgwfv | t3_l7gl3 | null | t1_c2qgwfv | t1_c2qfik9 | null | 1427714124 | -3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318300414 | False | 0 | c2qgwkj | t3_l7gl3 | null | t1_c2qgwkj | t3_l7gl3 | null | 1427714125 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318300418 | False | 0 | c2qgwl9 | t3_l7gl3 | null | t1_c2qgwl9 | t3_l7gl3 | null | 1427714126 | 1 | t5_2fwo | null | null | null |
True | tau-lepton | null | Exactly. | null | 0 | 1318300419 | False | 0 | c2qgwlq | t3_l6uwv | null | t1_c2qgwlq | t1_c2qc569 | null | 1427714126 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318300456 | False | 0 | c2qgwtg | t3_l7gl3 | null | t1_c2qgwtg | t1_c2qfik9 | null | 1427714128 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | The problem isn't the tedious finger typing. The problem is forcing the programmer to think about types up front before writing functions that actually do things.
When I work in Lisp, I "program by tinkering." If I'm writing a parser, for example, I jump to the part where I get a character from the input stream. I do... | null | 0 | 1318300474 | False | 0 | c2qgwx3 | t3_l6uwv | null | t1_c2qgwx3 | t1_c2qgipd | null | 1427714131 | 0 | t5_2fwo | null | null | null |
True | ubernostrum | null | Protip: the way you're used to referring to names, if you've been around for a while, will make them look correct here. So, you know, `grep` and `ed` instead of **grep** and **ed**. | null | 0 | 1318300476 | False | 0 | c2qgwxh | t3_l6xnp | null | t1_c2qgwxh | t1_c2qchb3 | null | 1427714131 | 1 | t5_2fwo | null | null | null |
True | anikom15 | null | Well C99 and C89 are not C++ standards. | null | 0 | 1318300511 | False | 0 | c2qgx53 | t3_l7gl3 | null | t1_c2qgx53 | t1_c2qgwfv | null | 1427714134 | 11 | t5_2fwo | null | null | null |
True | kyle2143 | null | I'm always shocked to find things like this anywhere. I'm always the skeptic and when I find out something like this, this huge wealth of knowledge, exists for free it boggles my mind. I feel like I see things like this all the time in the programming community and that just makes me happy to be a part of it, however s... | null | 0 | 1318300515 | False | 0 | c2qgx61 | t3_l742f | null | t1_c2qgx61 | t3_l742f | null | 1427714134 | 5 | t5_2fwo | null | null | null |
True | dnew | null | I'd still argue that "full access to the underlying system when you need it" is somewhat an exaggeration. There's plenty of things modern CPUs can do that C++ doesn't give you access to. | null | 0 | 1318300521 | False | 0 | c2qgx7a | t3_l7gl3 | null | t1_c2qgx7a | t3_l7gl3 | null | 1427714134 | 0 | t5_2fwo | null | null | null |
True | foldor | null | It makes you wonder what was going on in the intervening years. | null | 0 | 1318300523 | False | 0 | c2qgx7o | t3_l7gl3 | null | t1_c2qgx7o | t3_l7gl3 | null | 1427714134 | -1 | t5_2fwo | null | null | null |
True | tau-lepton | null | Jesus, I hope it's not really a singleton.
For new software developers, an old rant http://sites.google.com/site/steveyegge2/singleton-considered-stupid
Edit, added link | null | 0 | 1318300525 | True | 0 | c2qgx7y | t3_l6uwv | null | t1_c2qgx7y | t1_c2qa4st | null | 1427714134 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | The problem isn't the tedious finger typing. The problem is forcing the programmer to think about types up front before writing functions that actually do things.
When I work in Lisp, I "program by tinkering." If I'm writing a parser, for example, I jump to the part where I get a character from the input stream. I do... | null | 0 | 1318300549 | False | 0 | c2qgxdj | t3_l6uwv | null | t1_c2qgxdj | t1_c2qgipd | null | 1427714137 | 3 | t5_2fwo | null | null | null |
True | micro_cam | null | I'm not saying it is better but I can see it being more appealing to the kind of person who feels they need strong typing to write good code (this is the biggest reason java programers give me for not wanting to use python), buys into the write-once-run-anywhere promis of java or feels the core concept of node.js (ever... | null | 0 | 1318300584 | False | 0 | c2qgxkm | t3_l6uwv | null | t1_c2qgxkm | t1_c2qfpm8 | null | 1427714139 | 1 | t5_2fwo | null | null | null |
True | justicereform | null | Over 50 Free Programming Languages Books should be the title to this article.
(Programming != Programming Languages, as you well know. There is more (much more) to programming than the study of languages.) | null | 0 | 1318300645 | False | 0 | c2qgxy6 | t3_l742f | null | t1_c2qgxy6 | t3_l742f | null | 1427714145 | -5 | t5_2fwo | null | null | null |
True | justicereform | null | Over 50 Free Programming Languages Books should be the title to this article.
(Programming != Programming Languages, as you well know. There is more (much more) to programming than the study of languages.) | null | 0 | 1318300661 | False | 0 | c2qgy1p | t3_l742f | null | t1_c2qgy1p | t3_l742f | null | 1427714145 | -4 | t5_2fwo | null | null | null |
True | tau-lepton | null | I have to disagree, the syntax is not a problem for most competent developers. Ruby is easy to pickup, and even Haskell's syntax isn't bad, it is the new paradigms that trip up developers. Using C syntax for closures does not make closures any easier to understand, and potentially makes it harder. | null | 0 | 1318300775 | False | 0 | c2qgyqn | t3_l6uwv | null | t1_c2qgyqn | t1_c2qfh5n | null | 1427714154 | 2 | t5_2fwo | null | null | null |
True | washort | null | A profiler for OSX. "Instruments" is the thing for that now. | null | 0 | 1318300940 | False | 0 | c2qgzqq | t3_l6xnp | null | t1_c2qgzqq | t1_c2qgdzg | null | 1427714167 | 2 | t5_2fwo | null | null | null |
True | ultimatebuster | null | Personally I think c++ is a terrible first language these days. | null | 0 | 1318301048 | False | 0 | c2qh0f0 | t3_l7gl3 | null | t1_c2qh0f0 | t1_c2qfik9 | null | 1427714176 | 0 | t5_2fwo | null | null | null |
True | mb86 | null | Well, by virtue of them aiming for interoperability with C, they are.
But regardless, it still speaks about their urgency to keep up with standards. | null | 0 | 1318301069 | False | 0 | c2qh0ik | t3_l7gl3 | null | t1_c2qh0ik | t1_c2qgx53 | null | 1427714177 | -8 | t5_2fwo | null | null | null |
True | [deleted] | null | If you're working in a language where you know that line termination is statement termination you would know not to do this, also an interpreter should be able to generate a warning here. | null | 0 | 1318301208 | False | 0 | c2qh17u | t3_l6uwv | null | t1_c2qh17u | t1_c2qgno5 | null | 1427714186 | 1 | t5_2fwo | null | null | null |
True | mb86 | null | Yeah, wouldn't that be contrary to the very definition of open standard? By putting it behind a paywall? | null | 0 | 1318301338 | False | 0 | c2qh1x6 | t3_l7gl3 | null | t1_c2qh1x6 | t1_c2qgsse | null | 1427714196 | 3 | t5_2fwo | null | null | null |
True | _georgesim_ | null | Yes but we're talking about why C does switch cases like it does. When it was designed, optimization wasn't in the state it is today. | null | 0 | 1318301507 | False | 0 | c2qh2ui | t3_l4p6z | null | t1_c2qh2ui | t1_c2qfw93 | null | 1427714208 | 1 | t5_2fwo | null | null | null |
True | Deltigre | null | Everything you speak of involves zeroes. Are you trying to define C++ as unary? | null | 0 | 1318301513 | False | 0 | c2qh2vm | t3_l7gl3 | null | t1_c2qh2vm | t1_c2qfq0l | null | 1427714208 | 4 | t5_2fwo | null | null | null |
True | anikom15 | null | The funny thing is UNIX has been doing what Powershell does for over 30 years, but in a simpler and superior way. | null | 0 | 1318301585 | False | 0 | c2qh3bk | t3_l5v0e | null | t1_c2qh3bk | t1_c2q28ph | null | 1427714214 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318301655 | False | 0 | c2qh3p8 | t3_l7gl3 | null | t1_c2qh3p8 | t1_c2qe7pt | null | 1427714219 | 1 | t5_2fwo | null | null | null |
True | mango_feldman | null | where? | null | 0 | 1318301674 | False | 0 | c2qh3t9 | t3_l7gl3 | null | t1_c2qh3t9 | t1_c2qe7pt | null | 1427714220 | 1 | t5_2fwo | null | null | null |
True | typon | null | Thank you. I wouldve said pretentious douchebag to be honest though. | null | 0 | 1318301755 | False | 0 | c2qh480 | t3_l6yn1 | null | t1_c2qh480 | t1_c2qgm90 | null | 1427714225 | 7 | t5_2fwo | null | null | null |
True | tekknolagi | null | oh you could at least tag me. i'm tekknolagi. naturally. | null | 0 | 1318301805 | False | 0 | c2qh4hc | t3_kh9sr | null | t1_c2qh4hc | t3_kh9sr | null | 1427714229 | 1 | t5_2fwo | null | null | null |
True | michaelstripe | null | Are you sure about that? My three year old GeForce 8600M didn't ship with OpenGL 3 support but drivers came out supporting OpenGL 3.3 on it. | null | 0 | 1318301825 | False | 0 | c2qh4ll | t3_l579f | null | t1_c2qh4ll | t1_c2pys4s | null | 1427714230 | 1 | t5_2fwo | null | null | null |
True | hookeslaw | null | Stuff like this always makes me wonder how long it will be until the next language revolution happens and all this language specific knowledge accumulated over the years is rendered useless. | null | 0 | 1318301854 | False | 0 | c2qh4s8 | t3_l6yn1 | null | t1_c2qh4s8 | t3_l6yn1 | null | 1427714234 | 1 | t5_2fwo | null | null | null |
True | NotCoffeeTable | null | I'm on windows and found it very easy installed and ran through the tutorials in < 30 minutes without any Lisp/Clojure experience. Linux should be equally easy as long as your sound card works.
* Download Lein (download the windows distribution it has a bat and wget), unpack it somewhere and add the folder to your ... | null | 0 | 1318302040 | True | 0 | c2qh5sc | t3_l5s9p | null | t1_c2qh5sc | t1_c2q1e9b | null | 1427714246 | 1 | t5_2fwo | null | null | null |
True | kyrenn | null | Actually, g++ 4.6 has fairly good support for c++11, you just have to add -std=c++0x as a parameter.
See [here](http://gcc.gnu.org/projects/cxx0x.html). | null | 0 | 1318302044 | False | 0 | c2qh5t2 | t3_l7gl3 | null | t1_c2qh5t2 | t1_c2qgwfv | null | 1427714246 | 11 | t5_2fwo | null | null | null |
True | NruJaC | null | I'm not sure I'd term ML or Haskell as having "complex" type systems. Or at least, it depends on how you define the word complex.
As far as type systems go, Haskell (the language I'm more familiar with) has a rather nice type system: it does type inference, the rules for declaring types is succinct and regular, and i... | null | 0 | 1318302101 | False | 0 | c2qh64s | t3_l6uwv | null | t1_c2qh64s | t1_c2qfrb4 | null | 1427714250 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318302201 | False | 0 | c2qh6qm | t3_l6yn1 | null | t1_c2qh6qm | t1_c2qewr5 | null | 1427714259 | 2 | t5_2fwo | null | null | null |
True | NruJaC | null | Yea, I thought about adding scala to my above response, but I wasn't sure if it counted (being so closely tied to java, interop between the two makes a null reference unavoidable). It's an interesting language for sure. | null | 0 | 1318302271 | False | 0 | c2qh756 | t3_l6uwv | null | t1_c2qh756 | t1_c2qfktf | null | 1427714264 | 1 | t5_2fwo | null | null | null |
True | alekseykorzun | null | What's the point of this? Define a white list and ask people to XSS your code? And think you are some sort of security Guru?
http://canyouxssthis.com/You-Are-Retarded | null | 0 | 1318302318 | False | 0 | c2qh7e9 | t3_l7bjb | null | t1_c2qh7e9 | t3_l7bjb | null | 1427714267 | -12 | t5_2fwo | null | null | null |
True | tau-lepton | null | Quite a few people manage to deal with it just fine. My first language was Fortran, get used to large paradigm shifts every decade or so, can't wait to learn QML. | null | 0 | 1318302319 | False | 0 | c2qh7ep | t3_l765i | null | t1_c2qh7ep | t1_c2qcklk | null | 1427714267 | 1 | t5_2fwo | null | null | null |
True | teambob | null | but #define's are evil! It would be much better to do this using some kind of complicated template metaprogramming. | null | 0 | 1318302343 | False | 0 | c2qh7k2 | t3_l7gl3 | null | t1_c2qh7k2 | t1_c2qfq0l | null | 1427714269 | 7 | t5_2fwo | null | null | null |
True | shillbert | null | That's a problem with mixed paradigms: a + b is only associative in a functional paradigm. As soon as you bring imperative functions that allow side-effects into the language, the operator is no longer truly associative. | null | 0 | 1318302375 | False | 0 | c2qh7pg | t3_l6yn1 | null | t1_c2qh7pg | t1_c2qf0yq | null | 1427714272 | 2 | t5_2fwo | null | null | null |
True | writetoalok | null | Cheers, [here's](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf) the link for those who want to get at the final draft quickly. | null | 0 | 1318302376 | False | 0 | c2qh7pk | t3_l7gl3 | null | t1_c2qh7pk | t1_c2qe760 | null | 1427714272 | 11 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318302389 | False | 0 | c2qh7rr | t3_l6yn1 | null | t1_c2qh7rr | t1_c2qf0yq | null | 1427714272 | 1 | t5_2fwo | null | null | null |
True | swiz0r | null | You are also the [Magpie](http://magpie-lang.org/) person. You've been busy. | null | 0 | 1318302431 | False | 0 | c2qh80p | t3_l6uwv | null | t1_c2qh80p | t1_c2q9lpp | null | 1427714275 | 2 | t5_2fwo | null | null | null |
True | tilio | null | technically, that's mangling user input.
also, you're also technically creating a denial of service, because your sanitizer suppresses output if it detects a possible XSS. anyone using your system cannot talk about XSS. in fact, using <a href=http://google.com target=%blank>google</a> (replace the % with... | null | 0 | 1318302594 | True | 0 | c2qh8vx | t3_l7bjb | null | t1_c2qh8vx | t1_c2qg3cy | null | 1427714286 | 2 | t5_2fwo | null | null | null |
True | zzing | null | It costs money to make? Just a thought. I want it free too.
| null | 0 | 1318302604 | False | 0 | c2qh8y4 | t3_l7gl3 | null | t1_c2qh8y4 | t1_c2qh1x6 | null | 1427714287 | 2 | t5_2fwo | null | null | null |
True | tmcw | null | I'll try not to snark here, but Closure Compiler performs no better on the examples I give - even in advanced mode - and I'm surprised that people would claim it does without a quick testaroo. | null | 0 | 1318302626 | False | 0 | c2qh92l | t3_l3dsw | null | t1_c2qh92l | t1_c2pszwv | null | 1427714289 | 1 | t5_2fwo | null | null | null |
True | zzing | null | Don't ignore it. But don't embrace it fully either. Some things will be useful to get into if it is supported on your compiler.
For example, a ranged for (like 'for ... in ...' in other languages). Another one is variadic templates which is a way to make a typesafe variable argument list. | null | 0 | 1318302682 | False | 0 | c2qh9dp | t3_l7gl3 | null | t1_c2qh9dp | t1_c2qfik9 | null | 1427714292 | 3 | t5_2fwo | null | null | null |
True | mb86 | null | I've no issue with commercial products. Use them all the time. Many of which are worth paying for. But they're not pretending to be open. | null | 0 | 1318302932 | False | 0 | c2qhasn | t3_l7gl3 | null | t1_c2qhasn | t1_c2qh8y4 | null | 1427714312 | 1 | t5_2fwo | null | null | null |
True | JL235 | null | I've seen this example multiple times, but only ever in Reddit comments. I've never seen it out in the wild. | null | 0 | 1318303003 | False | 0 | c2qhb5l | t3_l6uwv | null | t1_c2qhb5l | t1_c2qgno5 | null | 1427714316 | 1 | t5_2fwo | null | null | null |
True | -kilo | null | Right, if they come from the same origin, there's no reason to insulate them from eachother, spec-wise. | null | 0 | 1318303012 | False | 0 | c2qhb7p | t3_l7bjb | null | t1_c2qhb7p | t1_c2qgpf3 | null | 1427714317 | 1 | t5_2fwo | null | null | null |
True | Tiwazz | null | No wonder the site looks like it was done in Crayon... | null | 0 | 1318303130 | False | 0 | c2qhbuu | t3_l7sk2 | null | t1_c2qhbuu | t3_l7sk2 | null | 1427714325 | 1 | t5_2fwo | null | null | null |
True | anikom15 | null | vim + books, that's my preferred method for all languages. | null | 0 | 1318303293 | False | 0 | c2qhcpx | t3_l2vfc | null | t1_c2qhcpx | t1_c2pfm75 | null | 1427714337 | 1 | t5_2fwo | null | null | null |
True | huyvanbin | null | So as I understand it, this is supposed to be a replacement for javascript? Is Steve Yegge involved in this? I only ask since he's a former Reddit superstar who was working on JS.
If I may make a humble suggestion: in my limited experience, simply duplicating the functionality of a given system is not enough. You have... | null | 0 | 1318303295 | False | 0 | c2qhcqa | t3_l6uwv | null | t1_c2qhcqa | t1_c2q9t7h | null | 1427714337 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318303306 | False | 0 | c2qhcsh | t3_l6uwv | null | t1_c2qhcsh | t1_c2q9t7h | null | 1427714337 | 1 | t5_2fwo | null | null | null |
True | JL235 | null | I mostly agree.
I really dislike languages that let you run incorrect code, as it's simply buggy, end of. This ends up making the issue harder to debug, since it does run.
Validating types at compile time should either be fully embraced, or not at all. Consistency is really important for reducing potential ambiguity ... | null | 0 | 1318303307 | False | 0 | c2qhcsj | t3_l6uwv | null | t1_c2qhcsj | t1_c2qbx9m | null | 1427714337 | 3 | t5_2fwo | null | null | null |
True | ultimatebuster | null | Which was also why I had to ditch that browser. Sigh | null | 0 | 1318303447 | False | 0 | c2qhdku | t3_l6uwv | null | t1_c2qhdku | t1_c2qduv0 | null | 1427714348 | 1 | t5_2fwo | null | null | null |
True | -kilo | null | I don't believe JS is that fragile.
After testing, I know that JS is not that fragile. Ending an initializer list with comma is fine, though likely jarring to you. | null | 0 | 1318303454 | False | 0 | c2qhdm5 | t3_l765i | null | t1_c2qhdm5 | t1_c2qgswo | null | 1427714348 | -2 | t5_2fwo | null | null | null |
True | ultimatebuster | null | Which was also why I had to ditch that browser. Sigh | null | 0 | 1318303487 | False | 0 | c2qhdtv | t3_l6uwv | null | t1_c2qhdtv | t1_c2qduv0 | null | 1427714351 | 0 | t5_2fwo | null | null | null |
True | hiffy | null | No. That's not quite what an open standard means. The exact definition changes, but it's more or less interpreted to mean something along the lines of "lots of people got together and made this standard" and "everyone can use this standard without an issue".
Charging small fees to access the spec itself, or even in so... | null | 0 | 1318303664 | False | 0 | c2qherq | t3_l7gl3 | null | t1_c2qherq | t1_c2qh1x6 | null | 1427714363 | 8 | t5_2fwo | null | null | null |
True | -kilo | null | Which bug? Testing basic cases of ending an N element array initialization with a comma yields the correct length of N. I suppose I'm only testing on Firefox, but did the other major browsers not resolve this, or is it an IE 5 fix, or something? | null | 0 | 1318303679 | False | 0 | c2qheuq | t3_l765i | null | t1_c2qheuq | t1_c2qgw62 | null | 1427714365 | 1 | t5_2fwo | null | null | null |
True | dokuhebi | null | Thanks. I came here to say this. While I agree that some items (i.e. "function(void)" instead of function()) might be good practice, the rest of it seemed like "compiler tricks" that could easily break.
However, when debugging code, knowing how a compiler acts in precarious situations can greatly help track down pro... | null | 0 | 1318303850 | False | 0 | c2qhfsn | t3_l6yn1 | null | t1_c2qhfsn | t1_c2qcbkf | null | 1427714376 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318303887 | False | 0 | c2qhfyv | t3_l7gl3 | null | t1_c2qhfyv | t1_c2qherq | null | 1427714380 | 1 | t5_2fwo | null | null | null |
True | hiffy | null | >Don't be on Google Plus to find out what relatives/people you know are up to.
We have a marketing issue then :P. | null | 0 | 1318303887 | False | 0 | c2qhfzr | t3_l6uwv | null | t1_c2qhfzr | t1_c2qbssi | null | 1427714380 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318303899 | False | 0 | c2qhg23 | t3_l7gl3 | null | t1_c2qhg23 | t1_c2qherq | null | 1427714381 | 1 | t5_2fwo | null | null | null |
True | Darkmoth | null | I'd agree with simpler. Superior is debatable - I get that text is universal, but it must be parsed at every stage of the pipe (in some fashion), and there is no error detection built in. Personally, I think composable objects are a step ahead of composable text processors. | null | 0 | 1318303917 | False | 0 | c2qhg6q | t3_l5v0e | null | t1_c2qhg6q | t1_c2qh3bk | null | 1427714382 | 3 | t5_2fwo | null | null | null |
True | mb86 | null | That covers "standard", but it does not cover "open". Ask Google or GNU or anyone like that (who ironically form the majority of the C++ committee, but that's part of a larger criticism I won't go into) and they'll tell you open means free and community driven. C++ is clearly neither. | null | 0 | 1318303921 | False | 0 | c2qhg7p | t3_l7gl3 | null | t1_c2qhg7p | t1_c2qherq | null | 1427714383 | -5 | t5_2fwo | null | null | null |
True | anikom15 | null | I'm unimpressed, too. Seems like Python without the things that make Python great like duck typing and lack of braces. | null | 0 | 1318303933 | False | 0 | c2qhg9z | t3_l2z8p | null | t1_c2qhg9z | t1_c2pd9cj | null | 1427714383 | 1 | t5_2fwo | null | null | null |
True | Darkmoth | null | I'd agree with simpler. Superior is debatable - I get that text is universal, but it must be parsed at every stage of the pipe (in some fashion), and there is no error detection built in. Personally, I think composable objects are a step ahead of composable text processors. | null | 0 | 1318303997 | False | 0 | c2qhgms | t3_l5v0e | null | t1_c2qhgms | t1_c2qh3bk | null | 1427714387 | -1 | t5_2fwo | null | null | null |
True | vishbar | null | Really?
I've never really worked with Haskell. I'm familiar with functional languages but...what about
random i = (j, ans)
where j = 7 * i `mod` 101
ans = (j - 1) `mod` 10 + 1 -- just the ones place, but 0 means 10
is difficult to understand? It's a relatively trivial arithmetic operat... | null | 0 | 1318304028 | False | 0 | c2qhgsq | t3_l77q2 | null | t1_c2qhgsq | t1_c2qf40z | null | 1427714390 | 2 | t5_2fwo | null | null | null |
True | Tenareth | null | But it probably wouldn't be the top comment. | null | 0 | 1318304127 | False | 0 | c2qhhas | t3_l6yn1 | null | t1_c2qhhas | t1_c2qgm90 | null | 1427714397 | -1 | t5_2fwo | null | null | null |
True | Darkmoth | null | I'd agree with simpler. Superior is debatable - I get that text is universal, but it must be parsed at every stage of the pipe (in some fashion), and there is no error detection built in. Personally, I think composable objects are a step ahead of composable text processors. | null | 0 | 1318304218 | False | 0 | c2qhhqn | t3_l5v0e | null | t1_c2qhhqn | t1_c2qh3bk | null | 1427714403 | -1 | t5_2fwo | null | null | null |
True | frodokun | null | As an author, I thank you. | null | 0 | 1318304223 | False | 0 | c2qhhrv | t3_l742f | null | t1_c2qhhrv | t1_c2qdirp | null | 1427714403 | 2 | t5_2fwo | null | null | null |
True | hiffy | null | The wiki article clearly says "open standard".
Take it up with them, and the thousands of people who use that etymology. It's just a different meaning than what you were expecting. | null | 0 | 1318304233 | False | 0 | c2qhhtu | t3_l7gl3 | null | t1_c2qhhtu | t1_c2qhg7p | null | 1427714403 | 7 | t5_2fwo | null | null | null |
True | Darkmoth | null | I'd agree with simpler. Superior is debatable - I get that text is universal, but it must be parsed at every stage of the pipe (in some fashion), and there is no error detection built in. Personally, I think composable objects are a step ahead of composable text processors. | null | 0 | 1318304275 | False | 0 | c2qhi0y | t3_l5v0e | null | t1_c2qhi0y | t1_c2qh3bk | null | 1427714406 | -1 | t5_2fwo | null | null | null |
True | 5a1 | null | Oh, I won't argue there is value behind proving correctness. And the advances math has brought CS in terms of analysis tools is unparalleled. Any basic algorithms analysis class shows that immediately.
Unfortunately though I don't think it is the end-all-be-all that people think it is.
Think of the computer... | null | 0 | 1318304302 | True | 0 | c2qhi6h | t3_l6dcp | null | t1_c2qhi6h | t1_c2qeqrg | null | 1427714408 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | Tamper data just gives you a form that you can enter url encoded data. it should have sent a null byte when I entered %00, it's worked everywhere else I've tried it.
Edit: as a note, entering %20 (Which I'm sure you know is space) doesn't change the page at all, which is the same as entering an actual space in the bo... | null | 0 | 1318304328 | True | 0 | c2qhib9 | t3_l7bjb | null | t1_c2qhib9 | t1_c2qgfi3 | null | 1427714410 | 2 | t5_2fwo | null | null | null |
True | Contero | null | Well it's a good thing I got the job where I only write code, not the job where I only debug code. | null | 0 | 1318304493 | False | 0 | c2qhj52 | t3_l6yn1 | null | t1_c2qhj52 | t1_c2qgcga | null | 1427714421 | 4 | 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.