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 | frud | null | That slide tech is awful. On my aged laptop it was taking 10 seconds between slides when I got to #400 or so. I skipped the end. | null | 0 | 1318353025 | False | 0 | c2qm7yu | t3_l6yn1 | null | t1_c2qm7yu | t3_l6yn1 | null | 1427716698 | 1 | t5_2fwo | null | null | null |
True | biggerthancheeses | null | I'm not a Ruby programmer so that idea initially strikes me as odd. It makes sense if you anticipate checking for the nullity or your objects a lot (a la Java), but personally I prefer the C way of expression evaluation. | null | 0 | 1318353049 | False | 0 | c2qm847 | t3_l88ny | null | t1_c2qm847 | t1_c2qlzed | null | 1427716700 | 2 | t5_2fwo | null | null | null |
True | malkarouri | null | > I think it is sensible in the long run to get rid of Javascript because of its warts
I agree wholeheartedly. Still, that doesn't deny the fact that people need a bit more encouragement to use a new language rather than compile any of their existing ones to JavaScript, which is an increasingly available option now... | null | 0 | 1318353053 | False | 0 | c2qm852 | t3_l88ny | null | t1_c2qm852 | t1_c2qlwed | null | 1427716700 | 3 | t5_2fwo | null | null | null |
True | bashmohandes | null | This is the worst case shown here, it is like saying that QuickSort takes O(n^2) all the time, that's the overhead of the language, but for 99.9% of the cases you're not writing Hello World, you are doing more, while the overhead will stay constant. | null | 0 | 1318353061 | False | 0 | c2qm86n | t3_l7wry | null | t1_c2qm86n | t3_l7wry | null | 1427716701 | 1 | t5_2fwo | null | null | null |
True | joshuag | null | I feel your pain. FB has one of the worst APIs I've ever worked with. | null | 0 | 1318353089 | False | 0 | c2qm8cx | t3_l8fpj | null | t1_c2qm8cx | t3_l8fpj | null | 1427716703 | 1 | t5_2fwo | null | null | null |
True | snuggl | null | all browsers that supports the js Dart spits out would support the same js, compiled once, at deploy-time.
| null | 0 | 1318353116 | False | 0 | c2qm8hz | t3_l7wry | null | t1_c2qm8hz | t1_c2ql25z | null | 1427716705 | -2 | t5_2fwo | null | null | null |
True | BlitzTech | null | The following toolchain is the current state of affairs for the web:
Javascript Code -> Browser
The suggestion is to change it to the following:
Code -> Standardized Bytecode -> Browser
where "Code" can be any programming language with a compiler that can target the standardized bytecode. This would not pr... | null | 0 | 1318353138 | False | 0 | c2qm8mf | t3_l88ny | null | t1_c2qm8mf | t1_c2qm4ns | null | 1427716706 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | Scala? | null | 0 | 1318353160 | False | 0 | c2qm8r1 | t3_l81mh | null | t1_c2qm8r1 | t1_c2ql9gb | null | 1427716708 | 2 | t5_2fwo | null | null | null |
True | malkarouri | null | If that is the level of discussion you like, do you believe that you have worked with more programming languages than me (a random person on the Internet), or is that just bravado? | null | 0 | 1318353188 | False | 0 | c2qm8x2 | t3_l88ny | null | t1_c2qm8x2 | t1_c2qlzx6 | null | 1427716711 | 2 | t5_2fwo | null | null | null |
True | BlitzTech | null | What kind of application works fine in IE and FF but struggles in Chrome such that you'd have to write it in NaCl?
Truth be told, that sounds *terrifying*. I fear for your sanity! | null | 0 | 1318353194 | False | 0 | c2qm8yi | t3_l88ny | null | t1_c2qm8yi | t1_c2qm53d | null | 1427716711 | 2 | t5_2fwo | null | null | null |
True | Destroyah | null | Not *really*. It's basically for making Javascript syntax a little nicer. *Right now*, that's all Dart is doing as well. The idea with Dart is to push it into it's own language at some point and not have it compile into Javascript. | null | 0 | 1318353259 | False | 0 | c2qm9cb | t3_l88ny | null | t1_c2qm9cb | t1_c2qlmfj | null | 1427716717 | 5 | t5_2fwo | null | null | null |
True | joehillen | null | By making it more like Java? | null | 0 | 1318353411 | False | 0 | c2qma6q | t3_l88ny | null | t1_c2qma6q | t1_c2qkhal | null | 1427716728 | 20 | t5_2fwo | null | null | null |
True | reddit_clone | null | > That works for a single developer, but not for a team of coders who may all have their own ideas about style and framework. And it won't help if you're assigned to a project that's already full of code written in some other style, which you're quite likely to as a C++ programmer.
That's true for any language. Unl... | null | 0 | 1318353448 | False | 0 | c2qmaes | t3_l6yn1 | null | t1_c2qmaes | t1_c2qcy4n | null | 1427716730 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318353479 | False | 0 | c2qmakw | t3_l4l3n | null | t1_c2qmakw | t1_c2q13kw | null | 1427716733 | 0 | t5_2fwo | null | null | null |
True | astrangeguy | null | Because *nobody* listens to a compiler when it doesn't refuse to compile my code, this *clearly* doesn't provide any benifits at all. | null | 0 | 1318353538 | False | 0 | c2qmaxc | t3_l88ny | null | t1_c2qmaxc | t1_c2qlx9q | null | 1427716736 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318353539 | False | 0 | c2qmaxj | t3_l8948 | null | t1_c2qmaxj | t3_l8948 | null | 1427716736 | -4 | t5_2fwo | null | null | null |
True | bitou | null | Actually, the iPhone simulator does not emulate a real CPU neither and no one really complains about it :)
I agree that a real emulator would be more accurate, but it's so slow that it's really a pain. | null | 0 | 1318353546 | False | 0 | c2qmazb | t3_l8cws | null | t1_c2qmazb | t1_c2qlve9 | null | 1427716737 | 6 | t5_2fwo | null | null | null |
True | NruJaC | null | I tried getting this set up a while ago, but ran into some gcc/clang compatibility issues and gave up.
Maybe it's time to give it another go, though I hate the idea of having to use two different compilers (gcc generally works better for me than clang). | null | 0 | 1318353580 | False | 0 | c2qmb6q | t3_l864l | null | t1_c2qmb6q | t3_l864l | null | 1427716740 | 1 | t5_2fwo | null | null | null |
True | reddit_clone | null | Another distinction people fail to make is this. It doesn't matter how complex or hard to read the boost code itself is. Using it in our code is easy enough (at least once you read the documentation and see some samples and tutorials)
I don't grok boost codebase at all. But it shouldn't prevent me from using it effect... | null | 0 | 1318353608 | False | 0 | c2qmbc2 | t3_l6yn1 | null | t1_c2qmbc2 | t1_c2qho31 | null | 1427716742 | 3 | t5_2fwo | null | null | null |
True | AngryDelphiDev | null | >and if the compiler can help me make less mistakes it's a bonus.
Yes, I'd rather have a "feeble" type system that allows productivity over a non-existent one. So what if it is a duck type? I'd rather have the compiler alert me to the fact I might be making an idiotic mistake. | null | 0 | 1318353814 | False | 0 | c2qmcjm | t3_l88ny | null | t1_c2qmcjm | t1_c2qli2o | null | 1427716758 | 2 | t5_2fwo | null | null | null |
True | animalchin99 | null | You're not forcing them, you're just degrading their experience of the Internet, even preventing them from using certain web pages/apps. Much like someone running a 486 trying to install Windows 7. | null | 0 | 1318353827 | False | 0 | c2qmcm0 | t3_l7wry | null | t1_c2qmcm0 | t1_c2qlnzw | null | 1427716759 | 2 | t5_2fwo | null | null | null |
True | ruinercollector | null | A point could be made that the compiler's "library" could be made modular and only load the parts that are needed to run the "compiled" output. | null | 0 | 1318353913 | False | 0 | c2qmd43 | t3_l7wry | null | t1_c2qmd43 | t1_c2qm7w6 | null | 1427716765 | 4 | t5_2fwo | null | null | null |
True | cryo | null | A pretty useless piece of criticism.
Factory pattern: Just because a language makes something easy, and this approach happens to have a name (as a pattern), doesn't make it bad. Languages already "implement" other patterns by that criterium.
Type system can't be used to optimize: Yes it can, and that was explicitly m... | null | 0 | 1318353985 | False | 0 | c2qmdla | t3_l88ny | null | t1_c2qmdla | t3_l88ny | null | 1427716772 | 14 | t5_2fwo | null | null | null |
True | Sargos | null | Many major websites no longer support IE6. Google is the biggest.
I work for a major medical enterprise software company and we stopped supporting IE6 during our last release. We had a bit of flak from one specific customer but for the most part everyone didn't mind.
The days of IE6 dictating web development are comi... | null | 0 | 1318354010 | False | 0 | c2qmdrv | t3_l7wry | null | t1_c2qmdrv | t1_c2qln6a | null | 1427716774 | 1 | t5_2fwo | null | null | null |
True | smeezy | null | I disagree with the author's assessment on the OO weaknesses of Dart. There is nothing wrong with incorporating desirable OO design patterns into the language. In fact, the view that OO design patterns are somehow a sign of some weakness in the language is perplexing to me (well, not so perplexing coming from the perl ... | null | 0 | 1318354018 | False | 0 | c2qmdsr | t3_l88ny | null | t1_c2qmdsr | t3_l88ny | null | 1427716774 | 10 | t5_2fwo | null | null | null |
True | ruinercollector | null | not everyone here is a php script kiddy. some of us know quite a bit about writing compilers. | null | 0 | 1318354038 | False | 0 | c2qmdxt | t3_l7wry | null | t1_c2qmdxt | t1_c2qk2x7 | null | 1427716776 | 9 | t5_2fwo | null | null | null |
True | [deleted] | null | It's been more or less static since the late 90s, everyone gets it.
The devs that only know perl get to feel slightly superior to everyone that only knows php.
That's it I guess. | null | 0 | 1318354060 | False | 0 | c2qme27 | t3_l88ny | null | t1_c2qme27 | t1_c2qm65v | null | 1427716778 | 11 | t5_2fwo | null | null | null |
True | EpistemicFaithCrisis | null | I don't know anything about parallel RNGs. I just looked in my second edition of Knuth volume 2 and didn't see anything; is that something he added in the third edition?
With that said, why can't you take a cryptographically secure RNG like ISAAC and just seed the various instances with different seeds? | null | 0 | 1318354080 | False | 0 | c2qme67 | t3_l77q2 | null | t1_c2qme67 | t1_c2qipxd | null | 1427716779 | 1 | t5_2fwo | null | null | null |
True | ruinercollector | null | "Compiling" doesn't necessarily imply that the target language be machine code. | null | 0 | 1318354090 | False | 0 | c2qme8h | t3_l7wry | null | t1_c2qme8h | t1_c2qjn36 | null | 1427716780 | 4 | t5_2fwo | null | null | null |
True | moreyes | null | No, by allowing static type analysis. The syntax flavor may be unfortunate but the intention is clear: they want to make JavaScript toolable, because they need a way to maintain projects with hundreds of thousands of lines of js. | null | 0 | 1318354090 | False | 0 | c2qme8p | t3_l88ny | null | t1_c2qme8p | t1_c2qma6q | null | 1427716780 | 10 | t5_2fwo | null | null | null |
True | rlee0001 | null | So they build factories into the syntax of the language. Hypocrisy much? | null | 0 | 1318354122 | False | 0 | c2qmefn | t3_l88ny | null | t1_c2qmefn | t1_c2qlwvd | null | 1427716783 | -2 | t5_2fwo | null | null | null |
True | garoththorp | null | I'd argue it never had any -- everything it was designed to do was possible with a combination of shell and awk, and all the new stuff was hacked on so clumsily that it's not worth using.
If you refer to the history of Perl, it was at first designed as a "report producing" language [1] -- that is, it was meant to gath... | null | 0 | 1318354181 | False | 0 | c2qmes7 | t3_l88ny | null | t1_c2qmes7 | t1_c2qm65v | null | 1427716787 | 9 | t5_2fwo | null | null | null |
True | hyperrifts | null | That is a valid point. I modified the test slightly. [pastebin](http://pastebin.com/ppE6seaj)
function nestDiv( parent, total ){
var element = $("<div/>").appendTo( parent );
var repeat = total - 1;
if( repeat > 0 ){
var i = 0;
for( i = 0; i <... | null | 0 | 1318354254 | True | 0 | c2qmf88 | t3_l4cv3 | null | t1_c2qmf88 | t1_c2px408 | null | 1427716793 | 2 | t5_2fwo | null | null | null |
True | neutronbob | null | That's right. Some functions in the standard library are common between the two languages. In those, one standard simply refers to the docs of the other. But they're different standard libraries, with C++'s being a superset. | null | 0 | 1318354272 | False | 0 | c2qmfcb | t3_l7gl3 | null | t1_c2qmfcb | t1_c2qktav | null | 1427716794 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Some would say, due to the heavy use of abstraction and operator overloading in C++, that two independently developed programs written in C++ might as well be written in two different languages. | null | 0 | 1318354335 | False | 0 | c2qmfpb | t3_l6yn1 | null | t1_c2qmfpb | t1_c2qetp7 | null | 1427716799 | 3 | t5_2fwo | null | null | null |
True | sgoguen | null | Consider for a moment that syntax isn't just about making things pretty, but is a mapping to the semantic constructs of a language. It seems to me that the parts of a language that are most used are the ones that require less typing.
CoffeeScript, like F#, creates a fairly uniform syntax which makes prototyping a... | null | 0 | 1318354382 | False | 0 | c2qmfzy | t3_l88ny | null | t1_c2qmfzy | t1_c2qkhal | null | 1427716805 | 7 | t5_2fwo | null | null | null |
True | hyperrifts | null | Hey you can see my reply to this as a [response to another comment](http://www.reddit.com/r/programming/comments/l4cv3/quick_tip_jquery_newbs_stop_jumping_in_the_pool/c2qmf88) | null | 0 | 1318354401 | False | 0 | c2qmg3n | t3_l4cv3 | null | t1_c2qmg3n | t1_c2prvcw | null | 1427716805 | 2 | t5_2fwo | null | null | null |
True | artsrc | null | I think modules should be more like classes. You should be able to supply them parameters, assign them to things etc.
So for example you should be able to say:
myMathLibrary =
if (otherMathInstalled())
OtherMath(float32)
else
java.Math
pi = myMathLibrary.pi
sq... | null | 0 | 1318354417 | False | 0 | c2qmg7d | t3_l88ny | null | t1_c2qmg7d | t1_c2qlvws | null | 1427716808 | 3 | t5_2fwo | null | null | null |
True | DirtAndGrass | null | I'm still not sure why we need dart, what does it provide that vanilla does not? | null | 0 | 1318354539 | False | 0 | c2qmgyl | t3_l7wry | null | t1_c2qmgyl | t3_l7wry | null | 1427716817 | 1 | t5_2fwo | null | null | null |
True | faritoude | null | @"Doesn't look as nice"
This is Java, not _ | null | 0 | 1318354559 | False | 0 | c2qmh27 | t3_l81mh | null | t1_c2qmh27 | t1_c2qjphf | null | 1427716818 | 0 | t5_2fwo | null | null | null |
True | poo_22 | null | Counter-example: www.pyjs.org | null | 0 | 1318354606 | False | 0 | c2qmhbr | t3_l88ny | null | t1_c2qmhbr | t1_c2qkq0z | null | 1427716821 | 4 | t5_2fwo | null | null | null |
True | ordinary_van | null | I know what it is and, unlike you, I know *exactly* when to use it.
``return (this.votes--)`` would've returned the previous value of ``this.votes`` instead of the new value of ``this.votes``. The calculation and redefinition of the variable needs to be performed *before* it gets returned.
Also, the facetious nature ... | null | 0 | 1318354634 | False | 0 | c2qmhhy | t3_l765i | null | t1_c2qmhhy | t1_c2qge7s | null | 1427716824 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318354673 | False | 0 | c2qmhpq | t3_l4l3n | null | t1_c2qmhpq | t1_c2qbfvo | null | 1427716826 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318354694 | False | 0 | c2qmhtu | t3_l77q2 | null | t1_c2qmhtu | t1_c2qme67 | null | 1427716828 | 1 | t5_2fwo | null | null | null |
True | drb226 | null | Why would you fuse two completely different concepts into one, for the sake of a "simpler" language with less keywords? | null | 0 | 1318354792 | False | 0 | c2qmidb | t3_l88ny | null | t1_c2qmidb | t1_c2qm0q3 | null | 1427716837 | 17 | t5_2fwo | null | null | null |
True | omnilynx | null | What he should have realized is that, beyond the naive cases, you can't talk about optimization without talking about use cases. Losing optimization on partial matches in order to gain it on misses makes perfect sense if your average data has more misses than partial matches. | null | 0 | 1318354814 | False | 0 | c2qmihm | t3_l6xnp | null | t1_c2qmihm | t3_l6xnp | null | 1427716843 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318354817 | True | 0 | c2qmii9 | t3_l88ny | null | t1_c2qmii9 | t1_c2qm8yi | null | 1427716843 | 1 | t5_2fwo | null | null | null |
True | evinrows | null | > Deal with it.
I think those exact words were spoken before all revolutions in computer science! | null | 0 | 1318354818 | False | 0 | c2qmiin | t3_l7wry | null | t1_c2qmiin | t1_c2qj7zp | null | 1427716843 | 1 | t5_2fwo | null | null | null |
True | mcherm | null | Because it gives a simpler language with fewer keywords. Why do YOU think they should be kept distinct? | null | 0 | 1318354898 | False | 0 | c2qmizj | t3_l88ny | null | t1_c2qmizj | t1_c2qmidb | null | 1427716853 | 0 | t5_2fwo | null | null | null |
True | anttirt | null | The Scala collection API [provides equivalent functionality.](http://stackoverflow.com/questions/3785413/linq-analogues-in-scala) | null | 0 | 1318354899 | False | 0 | c2qmizr | t3_l81mh | null | t1_c2qmizr | t1_c2qm1y3 | null | 1427716853 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | A lot of his criticisms are based on idiomatic preferences.
1) class-based OO and interfaces. His criticisms about interfaces not allowing inheritance of methods or Dart not using "roles" is weird. There are well-known problems with multiple inheritance (which he advocates) and multiple inheritance of implementation. ... | null | 0 | 1318354910 | False | 0 | c2qmj2e | t3_l88ny | null | t1_c2qmj2e | t1_c2qkllj | null | 1427716848 | 10 | t5_2fwo | null | null | null |
True | drb226 | null | In fact, astrangeguy's pseudocode is almost exactly how [uglymemo](http://hackage.haskell.org/packages/archive/uglymemo/0.1.0.1/doc/html/src/Data-MemoUgly.html#memoIO) works. | null | 0 | 1318354953 | False | 0 | c2qmjc0 | t3_l88ny | null | t1_c2qmjc0 | t1_c2qm3pv | null | 1427716848 | 10 | t5_2fwo | null | null | null |
True | bonch | null | > I'm getting fed up with this shit all over the internet trying to whine about Dart, how hello world compiles to a shitload of unnecessary code.
Well, nobody really cares that you're getting fed up about it. | null | 0 | 1318355007 | False | 0 | c2qmjog | t3_l7wry | null | t1_c2qmjog | t1_c2qje8m | null | 1427716854 | -4 | t5_2fwo | null | null | null |
True | [deleted] | null | This is exactly how Common Lisp and Dylan work (and how Strongtalk worked) and it isn't the worst of both static and dynamic systems. In fact it works very well in practice. Basically you leave out the types while you're designing code and library interfaces, then once you've got the design stabilized you put in type d... | null | 0 | 1318355042 | False | 0 | c2qmjwr | t3_l88ny | null | t1_c2qmjwr | t1_c2qkse6 | null | 1427716856 | 3 | t5_2fwo | null | null | null |
True | moreyes | null | That doesn't add anything to the tooling table. Again, they have a problem to solve, and it is not to please developer eyes: it is to make JavaScript more "toolable". That they have chosen to make it look like Java is unfortunate; on the other hand they kept almost the same syntax and added this or removed that, becaus... | null | 0 | 1318355068 | True | 0 | c2qmk24 | t3_l88ny | null | t1_c2qmk24 | t1_c2qmfzy | null | 1427716857 | 2 | t5_2fwo | null | null | null |
True | artsrc | null | But why not take the opportunity to make JavaScript prettier. C syntax was good for the 70's, but Haskell syntax is better.
From the Dart site:
int fib(int n) {
if (n <= 1) return 0;
return fib(n - 1) + fib(n - 2);
}
Versus:
fib :: Int -> Int
fib n
| n > 1 = ... | null | 0 | 1318355086 | True | 0 | c2qmk4f | t3_l88ny | null | t1_c2qmk4f | t1_c2qkhal | null | 1427716858 | 0 | t5_2fwo | null | null | null |
True | mslob | null | I think they used the technique known as 'compressed sensing', which is the exciting technique that also improved the accuracy of recent face recognition algorithms.
See for example http://bpgergo.blogspot.com/2010/02/compressed-sensing-image-reconstruction.html
The idea of this technique that you assume that the solu... | null | 0 | 1318355090 | False | 0 | c2qmk5u | t3_l8948 | null | t1_c2qmk5u | t3_l8948 | null | 1427716859 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | > guarantee the absence of null pointer exception when the type can be guaranteed to not have a null value
Are you confusing types with objects? I ask this because you can verify a non-null *value* without a type system. It'd be tough to analyze a *type* to ensure it is non-nullable without explicit language suppor... | null | 0 | 1318355120 | False | 0 | c2qmkdr | t3_l88ny | null | t1_c2qmkdr | t1_c2qktvf | null | 1427716862 | 1 | t5_2fwo | null | null | null |
True | bonch | null | Not that much, actually, and it's all fast native code. | null | 0 | 1318355121 | False | 0 | c2qmkei | t3_l7wry | null | t1_c2qmkei | t1_c2qki3g | null | 1427716862 | 3 | t5_2fwo | null | null | null |
True | TheWix | null | This is also more natural for querying. At least I think so. It is kinda too bad that you generally need to add in some methods or chaining for things like distinct, count, first, etc. | null | 0 | 1318355134 | False | 0 | c2qmkhs | t3_l81mh | null | t1_c2qmkhs | t1_c2qkrv2 | null | 1427716864 | 1 | t5_2fwo | null | null | null |
True | k3n | null | My point wasn't specifically regarding IE6, though, that was just an example. To my point, if Dart were installed in every browser today, it would likely be 10+ years before you could be at the point where you wouldn't have to worry if a browser supported it, and that's only if every platform (mobile, tablet, etc.) als... | null | 0 | 1318355191 | False | 0 | c2qmku7 | t3_l7wry | null | t1_c2qmku7 | t1_c2qmdrv | null | 1427716868 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Coffeescript is stills tuck with JS's semantics. It's syntactic sugar. | null | 0 | 1318355218 | False | 0 | c2qml0q | t3_l88ny | null | t1_c2qml0q | t1_c2qlmfj | null | 1427716870 | 1 | t5_2fwo | null | null | null |
True | 5a1 | null | >
the text is explicating simple procedures in very obtuse formalisms.
ev_ind_max :
∀ P : (∀ n : nat, ev n → Prop),
P O ev_0 →
(∀ (n : nat) (e : ev n),
P n e → P (S (S n)) (ev_SS n e)) →
∀ (n : nat) (e : ev n), P n e
**puke**
>
the semiotics and logica... | null | 0 | 1318355221 | True | 0 | c2qml16 | t3_l6dcp | null | t1_c2qml16 | t1_c2qlss2 | null | 1427716870 | 1 | t5_2fwo | null | null | null |
True | nicholas22 | null | Yes but it is more verbose, you either have to provide an anonymous class or implement the interface required, which causes bloat :) | null | 0 | 1318355225 | False | 0 | c2qml1v | t3_l81mh | null | t1_c2qml1v | t1_c2qjnta | null | 1427716870 | 0 | t5_2fwo | null | null | null |
True | moreyes | null | Which syntax looks prettier is just bike-shedding. No, I don't like that they have chosen Java-like syntax, but if it delivers what it promises it is ok to me. | null | 0 | 1318355289 | False | 0 | c2qmlgg | t3_l88ny | null | t1_c2qmlgg | t1_c2qmk4f | null | 1427716876 | 11 | t5_2fwo | null | null | null |
True | yeswecould | null | Next up: Why Perl is not the language of the future. On Dart's webpage? | null | 0 | 1318355297 | False | 0 | c2qmli2 | t3_l88ny | null | t1_c2qmli2 | t3_l88ny | null | 1427716876 | -5 | t5_2fwo | null | null | null |
True | drb226 | null | f :: a -> b
memoize :: (a -> b) -> (a -> b)
map.New :: () -> Map a b
cache :: Map a b
args :: a
memoized :: a -> b
entry :: b
getEntry :: Map a b -> a -> b
apply :: (a -> b) -> a -> b
newval :: b
put :: Map a b -> a -> b -> ()
The `a... | null | 0 | 1318355314 | True | 0 | c2qmllo | t3_l88ny | null | t1_c2qmllo | t1_c2qlmtu | null | 1427716877 | 6 | t5_2fwo | null | null | null |
True | EpistemicFaithCrisis | null | > The reason why I don't want to take the approach you mention is that it doesn't provide a guarantee that generating the numbers in parallel is just as independent as if it was done in serial
It's a cryptographically secure PRNG. It guarantees that every bit unpredictable given the entire stream of bits preceding... | null | 0 | 1318355355 | False | 0 | c2qmlv2 | t3_l77q2 | null | t1_c2qmlv2 | t1_c2qmhtu | null | 1427716881 | 1 | t5_2fwo | null | null | null |
True | artsrc | null | Seems like you are mandating a certain workflow that could be mandated in other ways. For example many compilers allow you to treat warnings as errors.
I like being able to run a unit test when other parts of my code are invalid. You don't this seems to support both our preferences. | null | 0 | 1318355366 | False | 0 | c2qmlxt | t3_l88ny | null | t1_c2qmlxt | t1_c2qkse6 | null | 1427716883 | 1 | t5_2fwo | null | null | null |
True | ehird | null | OK; scepticism based on personal experience is certainly fair. Thankfully the "great success" in this case is public, so you can judge for yourself:
http://cdsmith.wordpress.com/2011/08/03/haskell-for-kids-introduction/
http://cdsmith.wordpress.com/2011/08/07/an-invitation-for-kids-to-learn-programming/
http://cdsmi... | null | 0 | 1318355381 | False | 0 | c2qmm0x | t3_l77q2 | null | t1_c2qmm0x | t1_c2qjo9o | null | 1427716883 | 3 | t5_2fwo | null | null | null |
True | cwmonkey | null | You completely missed the point of what I was saying. You an engineer by chance? | null | 0 | 1318355382 | False | 0 | c2qmm15 | t3_l765i | null | t1_c2qmm15 | t1_c2qk7e8 | null | 1427716883 | 0 | t5_2fwo | null | null | null |
True | kingkilr | null | This would type fine in RPython. | null | 0 | 1318355386 | False | 0 | c2qmm2c | t3_l88ny | null | t1_c2qmm2c | t1_c2qlmtu | null | 1427716883 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | People who use languages with optional typing (Common Lisp and Dylan) do check the compiler output for type warnings. It works well in practice. | null | 0 | 1318355464 | False | 0 | c2qmmkf | t3_l88ny | null | t1_c2qmmkf | t1_c2qmaxc | null | 1427716890 | 10 | t5_2fwo | null | null | null |
True | Chiraa | null | Thank you for this. While I was reading the article I felt like the author was completely over-exaggerating that repeated usage of `$(this)` caused any amount of noticeable overhead, and if your test results are accurate, they confirm my original expectation. | null | 0 | 1318355517 | False | 0 | c2qmmvr | t3_l4cv3 | null | t1_c2qmmvr | t1_c2qmf88 | null | 1427716893 | 1 | t5_2fwo | null | null | null |
True | artsrc | null | I remember zero type errors for collection members in Java before collections where generic. And I did that full time for years.
The thing I like about generics is that they document the types in a collection and they give me better method suggestions when I access members.
Seems like Dart gives me everything I have... | null | 0 | 1318355523 | False | 0 | c2qmmx4 | t3_l88ny | null | t1_c2qmmx4 | t1_c2qkllj | null | 1427716894 | 5 | t5_2fwo | null | null | null |
True | niczar | null | NaCl won't be able to work with the DOM efficiently. Mozilla is phasing out XPCOM for a good reason, and it has less of a speed impact than NaCl or whatever plugin architecture. | null | 0 | 1318355544 | False | 0 | c2qmn1u | t3_l88ny | null | t1_c2qmn1u | t1_c2qlaf7 | null | 1427716896 | 1 | t5_2fwo | null | null | null |
True | NoWeCant | null | Post this to r/netsec and run for cover | null | 0 | 1318355605 | False | 0 | c2qmnf9 | t3_l7bjb | null | t1_c2qmnf9 | t3_l7bjb | null | 1427716901 | 2 | t5_2fwo | null | null | null |
True | weavejester | null | If you consider a language where an argument list is considered to be a tuple, then it's pretty easy to fill in the gaps:
memoize(f :: a -> b) :: a -> b {
var cache :: Map a b = Map.new();
memoized(args... :: a) :: b {
var entry :: Maybe b = cache.getEntry(args);
if(en... | null | 0 | 1318355613 | False | 0 | c2qmnh8 | t3_l88ny | null | t1_c2qmnh8 | t1_c2qlmtu | null | 1427716901 | 2 | t5_2fwo | null | null | null |
True | kaaskop42 | null | The point of LINQ is that it sits on top if IEnumerable and IQueryable, which you can extend with your own operations, and which compiles down to whatever you'd like, including IL code if you were crazy enough to do it, without polluting anybody's namespace, while type inference keeps your code safe (very much _unlike_... | null | 0 | 1318355628 | False | 0 | c2qmnkf | t3_l81mh | null | t1_c2qmnkf | t1_c2qm79v | null | 1427716903 | 9 | t5_2fwo | null | null | null |
True | metamatic | null | Ruby isn't installed everywhere.
That's about it. | null | 0 | 1318355645 | False | 0 | c2qmno4 | t3_l88ny | null | t1_c2qmno4 | t1_c2qm65v | null | 1427716903 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318355692 | False | 0 | c2qmnxp | t3_l88ny | null | t1_c2qmnxp | t1_c2qmn1u | null | 1427716907 | 1 | t5_2fwo | null | null | null |
True | notSorella | null | That's why you have `return --this.votes` :3 | null | 0 | 1318355757 | False | 0 | c2qmoai | t3_l765i | null | t1_c2qmoai | t1_c2qmhhy | null | 1427716911 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | It's FB tradition to create huge inconsistencies in their APIs that piss off users who don't understand where the problem is. They are quite good at this. They get away with it because everyone continues to utilize their platform regardless of quality. | null | 0 | 1318355760 | False | 0 | c2qmoaw | t3_l8fpj | null | t1_c2qmoaw | t3_l8fpj | null | 1427716911 | 1 | t5_2fwo | null | null | null |
True | quotemstr | null | SBCL's type annotations are even better, actually: they turn into assertions. | null | 0 | 1318355780 | False | 0 | c2qmof5 | t3_l88ny | null | t1_c2qmof5 | t1_c2qmmkf | null | 1427716913 | 1 | t5_2fwo | null | null | null |
True | phil_s_stein | null | What does this offer that ctags + vim doesn't? | null | 0 | 1318355796 | False | 0 | c2qmoim | t3_l864l | null | t1_c2qmoim | t3_l864l | null | 1427716914 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | If you can conclude that in order to fix the language, you'd have to start from scratch, then it's not too soon to judge. | null | 0 | 1318355842 | False | 0 | c2qmosk | t3_l88ny | null | t1_c2qmosk | t1_c2qkgs0 | null | 1427716918 | 2 | t5_2fwo | null | null | null |
True | Wolfspaw | null | Thanks a lot Pigeon! I really enjoyed to learn about randomness in the 8-bit era... I did not know that TAS used luck manipulation with the input. Know with your comments it makes a lot of sense! | null | 0 | 1318355935 | False | 0 | c2qmpe0 | t3_l77q2 | null | t1_c2qmpe0 | t1_c2qfq4q | null | 1427716927 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1318355995 | False | 0 | c2qmppk | t3_l88ny | null | t1_c2qmppk | t1_c2qlgt2 | null | 1427716930 | -1 | t5_2fwo | null | null | null |
True | kyrenn | null | I mean, I use gcc 4.6.1 and a lot of c++11 features on a couple of side projects and while I *do* believe you that it has a large number of bugs, I really haven't run into any other than just incomplete or missing features. They're not *production* projects, yes, but it's not all *that* bad.
It is my understanding th... | null | 0 | 1318356096 | False | 0 | c2qmqbn | t3_l7gl3 | null | t1_c2qmqbn | t1_c2qj2nb | null | 1427716938 | 2 | t5_2fwo | null | null | null |
True | marssaxman | null | It doesn't have to be the language of the future: it just has to be substantially better than JavaScript. This does not seem like a high bar to clear. | null | 0 | 1318356120 | False | 0 | c2qmqgo | t3_l88ny | null | t1_c2qmqgo | t3_l88ny | null | 1427716940 | 4 | t5_2fwo | null | null | null |
True | audaxxx | null | You would like ruby and python. | null | 0 | 1318356156 | False | 0 | c2qmqo2 | t3_l88ny | null | t1_c2qmqo2 | t1_c2qmg7d | null | 1427716943 | 3 | t5_2fwo | null | null | null |
True | niczar | null | No I'm not. Haskell has something called [Maybe](http://haskell.org/ghc/docs/6.12.2/html/libraries/base-4.2.0.1/Data-Maybe.html) that you add to a type to indicate that it can be nulled; but then you can't use the non-Maybe type without handling the null ("Nothing") case explicitly (unless you're passing the value to a... | null | 0 | 1318356159 | False | 0 | c2qmqoo | t3_l88ny | null | t1_c2qmqoo | t1_c2qmkdr | null | 1427716943 | 1 | t5_2fwo | null | null | null |
True | i8beef | null | I think you're both right, and this is a matter of taste.
I prefer method chaining myself. | null | 0 | 1318356185 | False | 0 | c2qmqur | t3_l81mh | null | t1_c2qmqur | t1_c2qksbd | null | 1427716946 | 3 | t5_2fwo | null | null | null |
True | midri | null | hate it, 0 is off.
0 == false
1 == true
it just makes sense. | null | 0 | 1318356222 | False | 0 | c2qmr36 | t3_l88ny | null | t1_c2qmr36 | t1_c2qlzed | null | 1427716949 | 2 | t5_2fwo | null | null | null |
True | larsga | null | A concept like factories should be a use case you ensure that the language design supports cleanly, rather than an explicit feature.
Can you explain a useful difference between a function/method and a factory? | null | 0 | 1318356242 | False | 0 | c2qmr6t | t3_l88ny | null | t1_c2qmr6t | t1_c2qmefn | null | 1427716950 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | So you want explicit non-nullable types in Dart, then? | null | 0 | 1318356243 | False | 0 | c2qmr73 | t3_l88ny | null | t1_c2qmr73 | t1_c2qmqoo | null | 1427716950 | 1 | t5_2fwo | null | null | null |
True | poco | null | If it can access private data then you might as well make it an instance method.
If it doesn't access private data then it doesn't need to be part of that class. | null | 0 | 1318356246 | False | 0 | c2qmr7p | t3_l88ny | null | t1_c2qmr7p | t1_c2qm070 | null | 1427716950 | 4 | t5_2fwo | null | null | null |
True | niczar | null | I don't know the current status, but for a few years already they have removed it from all the low-level DOM stuff IIRC. Code that talks to the DOM just uses regular C++ methods. | null | 0 | 1318356284 | False | 0 | c2qmrfo | t3_l88ny | null | t1_c2qmrfo | t1_c2qmnxp | null | 1427716953 | 1 | t5_2fwo | null | null | null |
True | wretcheddawn | null | That's a fair point, but it does present a lot of sub-problems.
Plus, isn't that what NaCl is intended to solve? Seems to me that if you're going to be sending compiled applications to the client, you might as well, send actual client applications. | null | 0 | 1318356290 | False | 0 | c2qmrgs | t3_l88ny | null | t1_c2qmrgs | t1_c2qm8mf | null | 1427716953 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | This is true in Dart as well. Though running the VM in "production" mode disables these assertions, just as the (optimize (safety 0)) declaration in SBCL disables these assertions. | null | 0 | 1318356321 | False | 0 | c2qmrjx | t3_l88ny | null | t1_c2qmrjx | t1_c2qmof5 | null | 1427716955 | 5 | 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.