archived stringclasses 2
values | author stringlengths 3 20 | author_fullname stringlengths 4 12 ⌀ | body stringlengths 0 22.5k | comment_type stringclasses 1
value | controversiality stringclasses 2
values | created_utc stringlengths 10 10 | edited stringlengths 4 12 | gilded stringclasses 7
values | id stringlengths 1 7 | link_id stringlengths 7 10 | locked stringclasses 2
values | name stringlengths 4 10 ⌀ | parent_id stringlengths 5 10 | permalink stringlengths 41 91 ⌀ | retrieved_on stringlengths 10 10 ⌀ | score stringlengths 1 4 | subreddit_id stringclasses 1
value | subreddit_name_prefixed stringclasses 1
value | subreddit_type stringclasses 1
value | total_awards_received stringclasses 19
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
True | [deleted] | null | [deleted] | null | 0 | 1316360671 | False | 0 | c2krhis | t3_kjhvo | null | t1_c2krhis | t1_c2kr2wc | null | 1427615512 | 1 | t5_2fwo | null | null | null |
True | henk53 | null | p.s. I do remember some other chips from Sun that weren't natively executing Java, but were optimized for self modifying code which is something the JVM does or did a lot. Supposedly JVM implementations for those architectures would run quite a bit faster. | null | 0 | 1316360679 | False | 0 | c2krhk0 | t3_kjf91 | null | t1_c2krhk0 | t1_c2kqthx | null | 1427615513 | 6 | t5_2fwo | null | null | null |
True | dotwaffle | null | A programme would be a bit of an exaggeration, considering it was probably something like:
*SAY HELLO REDDIT
See: http://www.youtube.com/watch?v=t8wyUsaDAyI | null | 0 | 1316360730 | False | 0 | c2krhqv | t3_kjhvo | null | t1_c2krhqv | t1_c2kra7s | null | 1427615525 | 2 | t5_2fwo | null | null | null |
True | Bibblejw | null | Different quote, but similar sentiment. One implies a higher-power, design principle, the other refers to the many-faceted nature of human beings, and the unknowability of it's extents.
Personally, I prefer the Adams version, because, in my experience, when a fool is messing a system up, it's because they are intentionally doing something with it that it is not designed to do. Rightly or wrongly, they are displaying ingenuity, aswell as ignorance of common or safe practices. | null | 0 | 1316360752 | False | 0 | c2krhsl | t3_kjhvo | null | t1_c2krhsl | t1_c2krgs7 | null | 1427615520 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | That's why I don't like object oriented programming.
| null | 0 | 1316360769 | False | 0 | c2krhut | t3_kjhvo | null | t1_c2krhut | t1_c2kr1lb | null | 1427615520 | 13 | t5_2fwo | null | null | null |
True | Necraz | null | Arduino is C++. Arduino IDE concatenates your "sketch" with some standard library code and compiles it with avr-gcc. You're correct that using Arudino is easier than cross-compiling GCC and configuring AVRDude, but none of that is because it's a different language. | null | 0 | 1316360795 | False | 0 | c2krhxk | t3_kj1na | null | t1_c2krhxk | t1_c2kn678 | null | 1427615517 | 2 | t5_2fwo | null | null | null |
True | Durinthal | null | [](/c20) Not really, but the problem is they ask me to fix it first. I just send them off to the Apple store where they have to wait two weeks while it gets shipped out and back. | null | 0 | 1316360850 | False | 0 | c2kri5c | t3_kjhvo | null | t1_c2kri5c | t1_c2krgxe | null | 1427615520 | 1 | t5_2fwo | null | null | null |
True | GMNightmare | null | "in which he debunks all of the people who dismiss astrology as being crap"
Sorry, I don't see that. At all. I think you're seeing in that quote only what you want to see... he basically debunked astrology in that quote.
Maybe you need the FULL quote:
"I know that astrology isn't a science... Of course it isn't. It's just an arbitrary set of rules like chess or tennis.... The rules just kind of got there. They don't make any kind of sense except in terms of themselves." | null | 0 | 1316360878 | False | 0 | c2kri8l | t3_kjhvo | null | t1_c2kri8l | t1_c2kr8y6 | null | 1427615522 | 22 | t5_2fwo | null | null | null |
True | BlueThen | null | Not a programming quote, but it's certainly very relevant. | null | 0 | 1316360950 | False | 0 | c2krii4 | t3_kjhvo | null | t1_c2krii4 | t1_c2kr424 | null | 1427615526 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | It specifically breaks the first one:
* Some seem to think this reddit is for "links that programmers might find interesting or funny". No. It's for programming links. Programming. *Programming*. **Programming**. | null | 0 | 1316360989 | False | 0 | c2krimn | t3_kjhvo | null | t1_c2krimn | t1_c2kr424 | null | 1427615586 | 6 | t5_2fwo | null | null | null |
True | geon | null | Yes, it is true. It should also be obvious *why* it is true.
> cat directory.txt | grep @ | awk '{print $3}' | perl -pe 's/\n/,/'
The line above is not merely a few tools used together. It is *programming*.
A GUI that worked similarly would indeed be possible. I have used a few, for more limited domains. [.werkkzeug](http://www.theprodukkt.com/werkkzeug1) comes to mind.
The problem is, the intended user is not a programmer, and would not find t easy to use. Should they string together the contacts list with an enumerator tool, a search tool, the search string, a list display tool, a list selection tool, and a contact calling tool just to search the contact database for a contact and call it?
Yes, a feature like that would be built in, put the same example works for any other task.
Aesthetics and usability issues aside, non-programmers just wouldn't get it.
I do wish Apple would offer better app interoperability, but tiny component tools only is not the answer. | null | 0 | 1316361006 | False | 0 | c2kriou | t3_kgqnz | null | t1_c2kriou | t3_kgqnz | null | 1427615528 | 0 | t5_2fwo | null | null | null |
True | kypeli | null | When you add threads to an app, then it will of course be a magnitude more complex and only the experienced programmers understand protection to shared objects. This doesn't mean that you should not add threads when necessary (after you evaluated that threads is the only way to solve some issue) and in that case you should not be afraid of them.
I think Qt has done a very nice thing with QtConcurrent, lowering the barrier to use threads. But, as always with concurrent programming, you need to take care of the (meh) concurrency. | null | 0 | 1316361059 | False | 0 | c2krivw | t3_kjebe | null | t1_c2krivw | t1_c2kr4w8 | null | 1427615589 | 2 | t5_2fwo | null | null | null |
True | tarantulus | null | When something becomes a necessity, the free market breaks down.
We see this with Gas prices right now, everyone needs it so the providers can do whatever they like without harm to their business. | null | 0 | 1316361102 | False | 0 | c2krj1s | t3_kgbzq | null | t1_c2krj1s | t1_c2kr5xm | null | 1427615591 | 1 | t5_2fwo | null | null | null |
True | Bibblejw | null | To be even more pedantic, I believe he actually described himself as being (the equivalent of) a geek, but having little actual skill in the area. I believe it was an interview with the BBC, later included as part of the "Douglas Adams at the BBC" set.
And, as has been noted above, using a computer in those days meant typing code. Downloaders, UIs and the like were significantly less prevalent, and a computer could not really be used without some form of code being entered. | null | 0 | 1316361132 | False | 0 | c2krj5e | t3_kjhvo | null | t1_c2krj5e | t1_c2krgq6 | null | 1427615593 | 3 | t5_2fwo | null | null | null |
True | Whanhee | null | All that really matters is that you are consistent. There are more important issues with programming practice. | null | 0 | 1316361367 | False | 0 | c2krk07 | t3_kjjzd | null | t1_c2krk07 | t3_kjjzd | null | 1427615603 | 5 | t5_2fwo | null | null | null |
True | Kowzorz | null | When I was making my school project with a bunch of other people, it was part of the coding standard to always have braces after if statements, even for single line ones. I think I agree with having it like that. For longer if statement conditions (I've had many that were on several lines), it makes it easier to see where the condition ends and the code following begins. Just look for the curly bracket. Also, as mentioned in the article, it is slightly more extensible which is a core part of object oriented programming and I'm sure programming in general. Someone who comes along after you made an if without braces has to make the braces or sometimes will absentmindedly forget to. Having the braces there means all they have to do is hit enter and type their code.
The only times I exclude braces are when both the condition and the code following are short, the if is repeated many times and I know that no one will be adding anything to the body of the if in the future. | null | 0 | 1316361383 | False | 0 | c2krk2b | t3_kjjzd | null | t1_c2krk2b | t3_kjjzd | null | 1427615604 | 3 | t5_2fwo | null | null | null |
True | mikemol | null | Corrected. No much more embarassing than that... | null | 0 | 1316361400 | False | 0 | c2krk4g | t3_kj87w | null | t1_c2krk4g | t1_c2kot6n | null | 1427615605 | 2 | t5_2fwo | null | null | null |
True | mikemol | null | I was aware of OEIS. I was not aware they had a list of primes.
(edit) And I specifically formatted my list for programmatic convenience. | null | 0 | 1316361427 | False | 0 | c2krk80 | t3_kj87w | null | t1_c2krk80 | t1_c2kop0g | null | 1427615606 | 1 | t5_2fwo | null | null | null |
True | jkff | null | I'm gonna hang this on my wall. Probably most useful programming quote I've ever read (others were mostly just funny). | null | 0 | 1316361439 | False | 0 | c2krka3 | t3_kjhvo | null | t1_c2krka3 | t3_kjhvo | null | 1427615607 | 1 | t5_2fwo | null | null | null |
True | toggo | null | This is a pretty nice solution, especially as Facebook insist on HTTPS urls for all apps from 1st Oct. | null | 0 | 1316361541 | False | 0 | c2krknk | t3_kgs39 | null | t1_c2krknk | t3_kgs39 | null | 1427615612 | 1 | t5_2fwo | null | null | null |
True | juletre | null | That book features a program that tries to solve, by bruteforce, how the sofa stuck in the stairs can be removed in one piece. | null | 0 | 1316361565 | False | 0 | c2krkqn | t3_kjhvo | null | t1_c2krkqn | t1_c2kr690 | null | 1427615613 | 8 | t5_2fwo | null | null | null |
True | SeriousWorm | null | It's <100KB though, so it's really easy to add to your project as a library. | null | 0 | 1316361568 | False | 0 | c2krkr1 | t3_kje6b | null | t1_c2krkr1 | t1_c2kqs8p | null | 1427615613 | 2 | t5_2fwo | null | null | null |
True | simonask | null | Ah. Thanks for your rationale. The decision seems sensible. :)
I disagree that the parser necessarily needs symbol table information, but of course that presumes that the AST has a unified representation for template arguments and function call arguments, which I guess is not the case, judging from your explanation. | null | 0 | 1316361569 | False | 0 | c2krkrc | t3_kikut | null | t1_c2krkrc | t1_c2kr0e9 | null | 1427615613 | 2 | t5_2fwo | null | null | null |
True | SeriousWorm | null | Try MigLayout. It's awesome. | null | 0 | 1316361623 | False | 0 | c2krkym | t3_kje6b | null | t1_c2krkym | t1_c2kqfxp | null | 1427615616 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | This is TL:DR version of the 1,000 page Jaquar automobile owner's manual condensed. | null | 0 | 1316361660 | False | 0 | c2krl34 | t3_kjhvo | null | t1_c2krl34 | t3_kjhvo | null | 1427615617 | 3 | t5_2fwo | null | null | null |
True | LaurieCheers | null | It tells you a key additional piece of information: "indexes".
And you're severely overthinking this simple code example. | null | 0 | 1316361725 | False | 0 | c2krlaj | t3_kikut | null | t1_c2krlaj | t1_c2kk8r8 | null | 1427615620 | 2 | t5_2fwo | null | null | null |
True | fakerific | null | No, that doesn't work.
1) find the sign up link
Guess what, you can't find it on that page!
2) click log in
Oh, look, a sign up link appears there by the login form
3) click Sign up
Oh, look, a 404 message, like I said.
| null | 0 | 1316361740 | False | 0 | c2krlcg | t3_ixjy6 | null | t1_c2krlcg | t1_c27kn2g | null | 1427615621 | 1 | t5_2fwo | null | null | null |
True | Ziggamorph | null | Every repair I've had done to a Mac has been done within a day by my local Apple Store. | null | 0 | 1316361809 | False | 0 | c2krlmf | t3_kjhvo | null | t1_c2krlmf | t1_c2kri5c | null | 1427615625 | 3 | t5_2fwo | null | null | null |
True | simonask | null | > Well, it would shift the decision of what is a template parameter and what is not from the parsing stage to the semantic stage. Furthermore, the parser would have to allow types as function arguments, like this:
As a firm believer in metaprogramming, I think this is a benefit rather than a drawback. :) Ideally, the programmer could be oblivious as to what is calculated at runtime and what is calculated at compile-time, and types could be seen as first-class values.
> Therefore, it would make both parsing and semantic analysis somewhat slower, but I am not sure it would be conceivable.
I'm having trouble seeing why this type of semantic analysis would be fundamentally slower. It would certainly be structured differently, and more decisions would be left to the compiler, but my guess is that the added overhead is negligible. | null | 0 | 1316361816 | False | 0 | c2krlnf | t3_kikut | null | t1_c2krlnf | t1_c2kqx9e | null | 1427615626 | 1 | t5_2fwo | null | null | null |
True | tgehr | null | Well, if they just keep adding features that are generic (channels and slices are both generic types), instead of adding generics, that harms the orthogonality of the language. | null | 0 | 1316362002 | False | 0 | c2krmco | t3_kikut | null | t1_c2krmco | t1_c2kqt8t | null | 1427615635 | 7 | t5_2fwo | null | null | null |
True | simonask | null | > Also, it can even be shorter in some cases, because if there is only one argument, the parens can be left out, eg
That's a nice feature, of the type I wish C++ had more.
Good example, by the way, although the main feature that `!` brings to the table is the option to leave out the parens. That's a language design choice — I don't think it's the prettiest decision, but after all it's a fairly small thing. | null | 0 | 1316362014 | False | 0 | c2krme1 | t3_kikut | null | t1_c2krme1 | t1_c2kqvsh | null | 1427615635 | 1 | t5_2fwo | null | null | null |
True | dyydvujbxs | null | Why is there a downvote brigade charging at Steve132 ? | null | 0 | 1316362118 | False | 0 | c2krmpd | t3_kikut | null | t1_c2krmpd | t1_c2kmn09 | null | 1427615639 | 0 | t5_2fwo | null | null | null |
True | gasche | null | "cool story, bro"
</self-referential cynical joke mentioning that obvious sarcasm tags are ridiculous> | null | 0 | 1316362124 | False | 0 | c2krmqf | t3_kjhvo | null | t1_c2krmqf | t1_c2kr2wc | null | 1427615640 | -1 | t5_2fwo | null | null | null |
True | thechao | null | No. FP and OO are (nearly) orthogonal concepts to the notion of 'thinking with functions' that danharaj is talking about. Probably a better analogy would be 'data structure oriented' to 'algorithm oriented'. For instance, the difference between writing your structures first, and fitting your algorithms to them, versus, say generic programming, where you write the algorithms first, and adapt data-structures to the algorithms. | null | 0 | 1316362127 | False | 0 | c2krmr0 | t3_kj03o | null | t1_c2krmr0 | t1_c2knnwu | null | 1427615640 | 2 | t5_2fwo | null | null | null |
True | mnp | null | Yea, who cares for personal, or throwaway code, or for school projects, sure.
But in the real world, readability and maintainability matter because most of the effort in code is not writing or testing it, but maintaining, debugging, and extending it for many years afterwards. An extra few seconds to understand the code adds up if you have to repeat it all week.
As for these things, I agree with Whanhee, if you line them up so it's obvious, or if you leave a blank line after them, they improve readability. As soon as you need any complexity though, it better have all its braces and indents. | null | 0 | 1316362369 | False | 0 | c2krnnu | t3_kjjzd | null | t1_c2krnnu | t1_c2krfdl | null | 1427615652 | 5 | t5_2fwo | null | null | null |
True | holyatheismbatman | null | The eye will believe the indentation of the code. So if someone goofs up and forgets the braces or adds to the single, unbraced statement, it may take a long time to find the problem.
| null | 0 | 1316362429 | False | 0 | c2krnvh | t3_kjjzd | null | t1_c2krnvh | t3_kjjzd | null | 1427615654 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Is your 'g' broken? Feel free to copy these for times of need: g G | null | 0 | 1316362460 | False | 0 | c2kro0a | t3_kjhvo | null | t1_c2kro0a | t1_c2krl34 | null | 1427615656 | 4 | t5_2fwo | null | null | null |
True | EvilTerran | null | Is there a subreddit for "links that programmers might find interesting or funny"? Maybe there should be a link to one in the sidebar, next to that rule. [/r/programmers](/r/programmers) looks like it's meant for that, although I note it's only got 7 subscribers at the moment. | null | 0 | 1316362488 | False | 0 | c2kro3r | t3_kjhvo | null | t1_c2kro3r | t1_c2krimn | null | 1427615656 | 6 | t5_2fwo | null | null | null |
True | LiveOnSteak | null | I think you have astrology confused with something that isn't bull. Astrology is the art of saying things so vague they apply to anyone and everyone. You may be confusing psychology with astrology, which is an easy mistake to make; they both deal with how people think. The difference between them is that one needs an education, the other needs a desire to scam people. | null | 0 | 1316362602 | False | 0 | c2kroip | t3_kjhvo | null | t1_c2kroip | t1_c2kr8y6 | null | 1427615663 | 0 | t5_2fwo | null | null | null |
True | Koreija | null | > I don't have a CS degree and I'm quite able to write a specification
Really? I wonder where you got your knowledge about discrete mathematics or logics. There are only few autodidacts in that area.
> How about non-boring ones?
With "typical programmer job" I meant implementing trivial stuff with standard technology (parsing configuration files, reading/writing to databases, display simple results to user interfaces - or even more boring: writing make files).
> who can explain me the intricacies of the halting problem but introduces race conditions
I don't know where they got their degree. In my university race conditions where taught in introductory courses on operating system design backed up by theoretical lectures on model checking and different calculi to prove that there is no race condition.
> because they didn't know what a stack frame was
Same here. We had obligatory basic courses on electrical engineering, circuit technique, processor and hardware architecture, operating systems... That's all undergraduate level, from calculating pipeline hazards with pencil and paper up to writing services for L4. | null | 0 | 1316362622 | False | 0 | c2kroli | t3_khkyd | null | t1_c2kroli | t1_c2kqhrj | null | 1427615664 | -1 | t5_2fwo | null | null | null |
True | thechao | null | The only patent I've seen like that had all of its claims invalidated. You can *file* anything you want (given you pay$$$), but getting those claims patented is a different matter, entirely. | null | 0 | 1316362668 | False | 0 | c2kror5 | t3_khvyw | null | t1_c2kror5 | t1_c2kjo8a | null | 1427615666 | 4 | t5_2fwo | null | null | null |
True | lintmonkey | null | Maybe if Markdown supported underlining of text, this situation would have been prevented. | null | 0 | 1316362670 | False | 0 | c2krorl | t3_kjhvo | null | t1_c2krorl | t1_c2krimn | null | 1427615666 | 2 | t5_2fwo | null | null | null |
True | LiveOnSteak | null | Albert Einstein was far from implying that fools are intelligently designed. | null | 0 | 1316362676 | False | 0 | c2krosm | t3_kjhvo | null | t1_c2krosm | t1_c2krhsl | null | 1427615666 | 3 | t5_2fwo | null | null | null |
True | omicron8 | null | That's because anything that "works" is technology. I have never had to get a banana to work. | null | 0 | 1316362677 | False | 0 | c2kross | t3_kjhvo | null | t1_c2kross | t1_c2kr1lb | null | 1427615666 | 6 | t5_2fwo | null | null | null |
True | wreel | null | You can always read through different style guides of successful groups. But with trivial matters like that it usually comes down to the style preferences of the main contributors. My personal preference actually aligns more with the Google C++ style. For one statement braces are optional, more than one statement and they are required for all blocks.
The most important thing however is *documenting* a style guide for a project. Fewer variations in style leads to less mental work in reading code.
Google C++ Style Guide:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Conditionals
Free BSD Kernel:
http://www.gsp.com/cgi-bin/man.cgi?section=9&topic=style
Joint Strike Fighter C++ Coding Standards (Huge):
http://www2.research.att.com/~bs/JSF-AV-rules.pdf | null | 0 | 1316362686 | False | 0 | c2krou0 | t3_kjjzd | null | t1_c2krou0 | t3_kjjzd | null | 1427615667 | 1 | t5_2fwo | null | null | null |
True | kirakun | null | And I'm saying your experience with Boost is very limited to see how bad the compile time and link time is for anything that is more than your trivial homework assignments. | null | 0 | 1316362859 | False | 0 | c2krpgp | t3_kikut | null | t1_c2krpgp | t1_c2koofg | null | 1427615675 | -2 | t5_2fwo | null | null | null |
True | kirakun | null | Things are also "simple" to those who know only half of it. | null | 0 | 1316362888 | False | 0 | c2krpl5 | t3_kikut | null | t1_c2krpl5 | t1_c2kqzex | null | 1427615677 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | http://www.patentstorm.us/patents/7028023/fulltext.html | null | 0 | 1316362992 | False | 0 | c2krpzc | t3_khvyw | null | t1_c2krpzc | t1_c2kror5 | null | 1427615683 | 0 | t5_2fwo | null | null | null |
True | ContractionsAreEvil | null | I seem to remember? | null | 0 | 1316363019 | False | 0 | c2krq2o | t3_kjhvo | null | t1_c2krq2o | t1_c2kr690 | null | 1427615684 | 1 | t5_2fwo | null | null | null |
True | andralex | null | D supports dependent types to the extent needed for e.g. algebraic types and variadic zipWith, but indeed not GADTs. (For example I just implemented a multiSort routine that accepts variadic sorting criteria.) I'm looking for motivating examples for furthering support in that direction. | null | 0 | 1316363040 | False | 0 | c2krq5f | t3_kikut | null | t1_c2krq5f | t1_c2krghf | null | 1427615696 | 1 | t5_2fwo | null | null | null |
True | tgehr | null | Do you mean like this?
struct List(T, size_t length) if(length==0){}
struct List(T, size_t length) if(length>0){
T head;
List!(T,length-1) tail;
}
edit: fixed code to make empty lists available. | null | 0 | 1316363042 | True | 0 | c2krq5w | t3_kikut | null | t1_c2krq5w | t1_c2krghf | null | 1427615696 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316363102 | False | 0 | c2krqdf | t3_kjhvo | null | t1_c2krqdf | t3_kjhvo | null | 1427615688 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1316363145 | False | 0 | c2krqiu | t3_kjhvo | null | t1_c2krqiu | t3_kjhvo | null | 1427615690 | 1 | t5_2fwo | null | null | null |
True | ISvengali | null | Ahh, indeed. Next time Ill try pointing it out without being as much of a jerk.
The worst is when you're looking at some code and thinking mean thoughts about the programmer, then you find out it was you who wrote it, hahah. | null | 0 | 1316363176 | False | 0 | c2krqmt | t3_kj87w | null | t1_c2krqmt | t1_c2krk4g | null | 1427615692 | 1 | t5_2fwo | null | null | null |
True | conjury | null | Those aren't variables. They're literals. | null | 0 | 1316363244 | False | 0 | c2krqwq | t3_ki52y | null | t1_c2krqwq | t1_c2khr3y | null | 1427615695 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Reasons I sometimes hate programming - I have to occasionally work with happy-clappy arseholes like this. | null | 0 | 1316363254 | False | 0 | c2krqyc | t3_kjkwb | null | t1_c2krqyc | t3_kjkwb | null | 1427615695 | 4 | t5_2fwo | null | null | null |
True | trezor2 | null | He lost me when he constructed a false problem by claiming that the result of a query sent through the ORM has to result in discrete objects mapping 100% to the "base-form" of the objects, ie their table-based definition and that this causes immense problems when you have relations and dependencies based on those.
In C#, using LInQ I can specify exactly what columns I want, how I want things joined, and how the resulting object should composed, without the need for adding additional named classes or augment my data-model. I get control of what gets sent to my DB and I get only the information I need returned, in the form I desire. And I certainly hope that C# still qualifies as an OOP language.
His rant seems to be that inadequate ORMs is an anti-pattern. But isn't investing anything in something you know to be inadequate by definition an anti-pattern? He is making his own circular argument and then trying to sneak up the scope beyond what is valid.
Needless to say, I think his argument is simplified, based on dated information and this invalid. | null | 0 | 1316363340 | False | 0 | c2krrad | t3_ki83r | null | t1_c2krrad | t3_ki83r | null | 1427615700 | 5 | t5_2fwo | null | null | null |
True | andralex | null | A GADT is considerably more [elaborate](http://en.wikipedia.org/wiki/Generalized_algebraic_data_type) as it e.g. has items of heterogeneous types. | null | 0 | 1316363349 | False | 0 | c2krrbn | t3_kikut | null | t1_c2krrbn | t1_c2krq5w | null | 1427615700 | 2 | t5_2fwo | null | null | null |
True | thechao | null | I don't know about any optimizations regarding 'octrees', but as a GPU driver developer, I can tell you with 100% assurance: the fewer polys you send down, the faster the GPU will run, all other things being equal. For Minecraft (one of the games I ... uh ... profile at work), the limiting rate is IO bandwidth to the discrete parts. For integrated parts, the limiting rate is the number of polys. In both cases, lots of polys is bad. | null | 0 | 1316363685 | False | 0 | c2krslz | t3_kgq62 | null | t1_c2krslz | t1_c2k7adc | null | 1427615717 | 5 | t5_2fwo | null | null | null |
True | tgehr | null | The benefit would be that functions working on those types would not have to be templated, and that the values the types depend on can be inputs of the program. The practical applications are mainly that dependent types have the potential to give proof that some high-level invariant holds (eg, that a list has the same length as before after merge sort). | null | 0 | 1316363690 | False | 0 | c2krsmr | t3_kikut | null | t1_c2krsmr | t1_c2krft0 | null | 1427615717 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | The problem is that programmers are *completely oblivious* to the fact that these are NOT jokes about programming at all. I've seen age old jokes about product lifecycle that programmers assume are about the software industry, when in fact they probably originated from the boat building trade 300 years ago or something. Programmers just tend to be oblivious to other fields of engineering. | null | 0 | 1316363729 | False | 0 | c2krsrn | t3_kjhvo | null | t1_c2krsrn | t1_c2kr9cx | null | 1427615718 | 5 | t5_2fwo | null | null | null |
True | mishagale | null | Well, it'd also need to read a file and iterate over its contents, and record whether the dog barked (since Dirk was absent a lot of the time it was running) | null | 0 | 1316363755 | False | 0 | c2krsvq | t3_kjhvo | null | t1_c2krsvq | t1_c2krhqv | null | 1427615719 | 1 | t5_2fwo | null | null | null |
True | cdsmith | null | > JS is already just 3-5X slower than C++. In a year it will be even faster. When JS gets to 2X slower than C++, is there a need for something like NaCl?
We'll see. I'm personally skeptical that JavaScript will ever get to that point. JavaScript has been improving drastically because its performance wasn't as much of a priority until recently, and so we saw drastic -- orders of magnitude, in some cases -- improvements when smart people decided for the first time to start working on optimizing it. But it's still got its share of performance limitations. Firefox will get faster when they add their type inference stuff, but then I really see very few opportunities for continued improvement. The future of JavaScript benchmarks beyond that looks very flat. | null | 0 | 1316363774 | False | 0 | c2krsxy | t3_kitgf | null | t1_c2krsxy | t1_c2krdgn | null | 1427615721 | 3 | t5_2fwo | null | null | null |
True | kirakun | null | Not sure if joking or trolling, but the fundamental premises of encapsulation, polymorphism (not sure about inheritance) have been design patterns way before OOP was coined and also have been successfully incorporated into many large software, the UNIX filesystem API being one great example.
Of course, if you have shitty programmers, then no paradigm will save you. Perhaps you were referring to your own programming skill instead? ;)
BTW, if you are a good programming, does it matter what paradigm you use? Just recall a certain person who wrote a certain famous flavor of the UNIX kernel and a certain source revision system. | null | 0 | 1316363939 | True | 0 | c2krtmk | t3_kjhvo | null | t1_c2krtmk | t1_c2krhut | null | 1427615730 | -7 | t5_2fwo | null | null | null |
True | stkerr | null | The license was longer than the article... Downvote for that, otherwise, decent article | null | 0 | 1316363966 | False | 0 | c2krtqy | t3_kjkxj | null | t1_c2krtqy | t3_kjkxj | null | 1427615732 | 1 | t5_2fwo | null | null | null |
True | tgehr | null | try 2:
struct List(alias X, size_t length) if(length==0){}
struct List(alias X, size_t length) if(length>0){
X!length head;
List!(X,length-1) tail;
}
edit: fixed to make empty lists available | null | 0 | 1316363972 | True | 0 | c2krtrt | t3_kikut | null | t1_c2krtrt | t1_c2krrbn | null | 1427615732 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Easiers than std::thread and intel TBB? I think not | null | 0 | 1316364000 | False | 0 | c2krtw1 | t3_kjebe | null | t1_c2krtw1 | t3_kjebe | null | 1427615733 | 1 | t5_2fwo | null | null | null |
True | inmatarian | null | Easy threading in Qt:
1. Derive QRunnable. Design the class to contain everything it needs to work.
2. Implement a unit of work in ::run. Again, only use the objects you have within the class, do not leave the class for any reason.
3. Attach a signal/slot pair in Qt::QueuedConnection for signaling when the work is done.
4. Hand an instance of the class over to QThreadPool::globalInstance()->start(). You can use your own QThreadPool instance if you want.
And you're done. Perfect for doing things like rendering. Although, you'd have to use QImage instead of QPixmap when out of the main thread, and the QPen/QBrush/QFont/etc. objects are shared, so you have to detach them via some means (I like serializing them into a QByteArray and letting the other thread deserialize them). | null | 0 | 1316364126 | False | 0 | c2krufb | t3_kjebe | null | t1_c2krufb | t3_kjebe | null | 1427615740 | 4 | t5_2fwo | null | null | null |
True | thechao | null | You should read that [patent](http://www.google.com/patents?id=Szh4AAAAEBAJ&printsec=frontcover&dq=7028023&hl=en&ei=sx52Tv6LA8rmiALPsuyzAg&sa=X&oi=book_result&ct=result&resnum=1&ved=0CC8Q6AEwAA) bit more closely. I don't think the work is original enough to merit a patent, but it is *not* a patent on linked lists as programmer's usually think of them. I think [this](http://www.google.com/patents?id=qth_AAAAEBAJ&pg=PA1&dq=7028023&hl=en&ei=sx52Tv6LA8rmiALPsuyzAg&sa=X&oi=book_result&ct=result&resnum=2&ved=0CDIQ6AEwAQ#v=onepage&q=7028023&f=false) patent is worse than the one you linked. | null | 0 | 1316364140 | False | 0 | c2kruhh | t3_khvyw | null | t1_c2kruhh | t1_c2krpzc | null | 1427615741 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | Thai's why I always go for tea break. | null | 0 | 1316364263 | False | 0 | c2krv08 | t3_kjhvo | null | t1_c2krv08 | t3_kjhvo | null | 1427615748 | 1 | t5_2fwo | null | null | null |
True | TKN | null | Yes, that was it. | null | 0 | 1316364483 | False | 0 | c2krvx4 | t3_kjhvo | null | t1_c2krvx4 | t1_c2krkqn | null | 1427615762 | 1 | t5_2fwo | null | null | null |
True | cowhead | null | He only asked for two decimal places. Easy! | null | 0 | 1316364609 | False | 0 | c2krwfp | t3_kgfhb | null | t1_c2krwfp | t1_c2kc2ol | null | 1427615767 | 1 | t5_2fwo | null | null | null |
True | dnew | null | > A lot of C++'s syntactic struggles are caused by complexity and power.
No, a lot of C++'s syntactic struggles are caused by trying to be syntax-compatible with C, a language lacking that complexity and power. I don't think anyone would argue that C++ is wildly more powerful than LISP, yet LISP's syntax is minimalistic compared even to C. | null | 0 | 1316364748 | False | 0 | c2krwz9 | t3_kikut | null | t1_c2krwz9 | t1_c2kk7x8 | null | 1427615774 | 4 | t5_2fwo | null | null | null |
True | kypeli | null | This is a good approach for having threads upfront in your application if you know from the beginning that you need them for some (larger) specific task like rendering. While using QRunnables is not difficult, it could be a bit more of a refactoring to add them afterwards to your app.
I'd say QtConcurrent offers tools to add threads afterwards to your application or when there are very specific and isolated methods that you want to run concurrently. | null | 0 | 1316364844 | False | 0 | c2krxdg | t3_kjebe | null | t1_c2krxdg | t1_c2krufb | null | 1427615779 | 1 | t5_2fwo | null | null | null |
True | chengiz | null | Title specifically says "programming quote". | null | 0 | 1316364854 | False | 0 | c2krxf1 | t3_kjhvo | null | t1_c2krxf1 | t1_c2krii4 | null | 1427615779 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | If you think so, perhaps *you're* not programming. | null | 0 | 1316364891 | False | 0 | c2krxks | t3_kjhvo | null | t1_c2krxks | t1_c2kr5g3 | null | 1427615780 | -4 | t5_2fwo | null | null | null |
True | dnew | null | > The advantage of subtype polymorphism is type safety
I was under the impression that Go is basically "OOP of the Smalltalk strain" except statically typed. Statically duck-typed, as it were. | null | 0 | 1316364957 | False | 0 | c2krxvv | t3_kikut | null | t1_c2krxvv | t1_c2kkxdc | null | 1427615785 | 1 | t5_2fwo | null | null | null |
True | agottem | null | This, coming from the man who just created a new Windows API (WinRT) that is entirely dependent on non-standard C++? | null | 0 | 1316364957 | False | 0 | c2krxvw | t3_kjja4 | null | t1_c2krxvw | t3_kjja4 | null | 1427615785 | -3 | t5_2fwo | null | null | null |
True | tgehr | null | As far as I can see it sure has them if all parameters are compile time values. How could its type system be Turing complete otherwise? | null | 0 | 1316364966 | False | 0 | c2krxxc | t3_kikut | null | t1_c2krxxc | t1_c2krq5f | null | 1427615786 | 3 | t5_2fwo | null | null | null |
True | BrotherSeamus | null | We're just programmed to think that way. | null | 0 | 1316364994 | False | 0 | c2kry1p | t3_kjhvo | null | t1_c2kry1p | t1_c2kr2wc | null | 1427615787 | 3 | t5_2fwo | null | null | null |
True | kamatsu | null | How would you construct that value? (I know little D, so forgive my ignorance). Wouldn't you need to specify the length of the list? Therefore, wouldn't the length of the list have to be known at compile time?
In Agda (altered so that it admits the empty list, excluding it seems strange to me):
data List (A : Set) : Nat -> Set where
[] : List 0
_::_ : A -> List A n -> List A (suc n)
Here head can be forced to work only on nonempty lists, much like your tail, from what I can tell
head : {A : Set} -> List A (suc n) -> A
head (x :: xs) = x
But also, to construct the list, it's just as easy as a regular list:
onetwothree : List Nat 3
onetwothree = 1 :: 2 :: 3 :: [] | null | 0 | 1316364998 | False | 0 | c2kry29 | t3_kikut | null | t1_c2kry29 | t1_c2krq5w | null | 1427615788 | 3 | t5_2fwo | null | null | null |
True | shawnturner | null | I believe good practice is what your team agrees is good practice where local coding conventions are concerned.
I personally write one liner ifs on a single line (js/c/c#), without bracers. I read that as a single statement.
However, I have encountered many programmers who dislike the convention. | null | 0 | 1316365008 | False | 0 | c2kry3r | t3_kjjzd | null | t1_c2kry3r | t3_kjjzd | null | 1427615788 | 1 | t5_2fwo | null | null | null |
True | danharaj | null | Lisp is also vastly simpler than C++ or most other languages really. C++ is more powerful than Lisp in some ways just because you can work at levels of abstraction that are too low for you to want to use Lisp. I wouldn't do systems programming in Lisp even if I could do it.
Also, templates would have easier syntax if they weren't made to accommodate so much expressive power. There are some features in C++ that add power, but the cost is syntactic and semantic overhead. | null | 0 | 1316365031 | False | 0 | c2kry78 | t3_kikut | null | t1_c2kry78 | t1_c2krwz9 | null | 1427615789 | 6 | t5_2fwo | null | null | null |
True | danharaj | null | > * Some seem to think this reddit is for "links that programmers might find interesting or funny". No. It's for programming links. Programming. Programming. Programming.
> * Just because it has a computer in it doesn't make it programming
> * If there is no code in your link, it probably doesn't belong here.
> * /r/programming is not a place to ask for help, run polls, rant, demo your app (unless your demo includes code or architecture discussion), or otherwise use as a captive audience. For that try /r/learnprogramming or StackOverflow. | null | 0 | 1316365094 | False | 0 | c2krygl | t3_kjhvo | null | t1_c2krygl | t1_c2krxks | null | 1427615793 | 2 | t5_2fwo | null | null | null |
True | kamatsu | null | Er, GADT Lists need not have items of heterogeneous types, although you could use them for that purpose. The real purpose of GADTs is just to give you indexed types. | null | 0 | 1316365169 | False | 0 | c2kryrr | t3_kikut | null | t1_c2kryrr | t1_c2krrbn | null | 1427615797 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | Not the best quote, how many times have you come across a task that you thought was impossible only to solve it a couple days later? I come across seemingly impossible tasks several times a week, almost all get resolved eventually. | null | 0 | 1316365235 | False | 0 | c2krz1c | t3_kjhvo | null | t1_c2krz1c | t3_kjhvo | null | 1427615800 | 1 | t5_2fwo | null | null | null |
True | abattle | null | I see your point. I think what's happening is the NTFS compressor is simply chewing the zero-bytes that can't be marked as sparse regions (because they are <64kb and since it's unit is 4kb it is deallocating these zero-byte blocks that are compressed away.
This seams to be the most reasonable explanation given the fact that NTFS is probably using a form of deflate anyway and there is little to recompress in zlib level-6 (at least with deflate.) Yet we know there are zero-byte padding to round written data to 64kb boundaries and we can see a significant reduction when using NTFS compression atop the deflated data. | null | 0 | 1316365245 | False | 0 | c2krz2u | t3_kjete | null | t1_c2krz2u | t1_c2kr484 | null | 1427615801 | 1 | t5_2fwo | null | null | null |
True | tgehr | null | > How would you construct that value? (I know little D, so forgive my ignorance). Wouldn't you need to specify the length of the list? Therefore, wouldn't the length of the list have to be known at compile time?
You are perfectly right.
andralex wrote:
> It already has support for dependent types as long as the dependee values are known during compilation.
| null | 0 | 1316365341 | False | 0 | c2krzhs | t3_kikut | null | t1_c2krzhs | t1_c2kry29 | null | 1427615806 | 3 | t5_2fwo | null | null | null |
True | dnew | null | Sure. What do you do if your graph node implements Len(), Swap(), and Smaller() [instead of Less()]? | null | 0 | 1316365417 | False | 0 | c2krzt9 | t3_kikut | null | t1_c2krzt9 | t1_c2kldbt | null | 1427615811 | 1 | t5_2fwo | null | null | null |
True | MarshallBanana | null | So you're saying you're telling people not to get a Mac because you are not competent to fix them. | null | 0 | 1316365457 | False | 0 | c2krzzk | t3_kjhvo | null | t1_c2krzzk | t1_c2kri5c | null | 1427615813 | 4 | t5_2fwo | null | null | null |
True | dnew | null | In Java-speak, everything with a Run() method is a Runnable, regardless of whether you declared that it implements Runnable or not. | null | 0 | 1316365461 | False | 0 | c2ks004 | t3_kikut | null | t1_c2ks004 | t1_c2km30j | null | 1427615814 | 1 | t5_2fwo | null | null | null |
True | gospelwut | null | >"I am rarely happier than when spending an entire day programming my computer to perform automatically a task that it would otherwise take me a good ten seconds to do by hand."
I think this described every side project I have ever done. | null | 0 | 1316365463 | False | 0 | c2ks00a | t3_kjhvo | null | t1_c2ks00a | t1_c2krgq6 | null | 1427615814 | 12 | t5_2fwo | null | null | null |
True | gospelwut | null | /r/learnprogramming seems to be the ad hoc place for anything that isn't in /r/programming's ruleset. | null | 0 | 1316365558 | False | 0 | c2ks0dv | t3_kjhvo | null | t1_c2ks0dv | t1_c2kro3r | null | 1427615819 | 1 | t5_2fwo | null | null | null |
True | jamie1414 | null | Why would you link to such an ugly website instead of just adding the text? | null | 0 | 1316365575 | False | 0 | c2ks0gv | t3_kjhvo | null | t1_c2ks0gv | t3_kjhvo | null | 1427615820 | 1 | t5_2fwo | null | null | null |
True | tgehr | null | > (altered so that it admits the empty list, excluding it seems strange to me)
You are right. Fixed:
struct List(T,size_t len) if(len==0){}
struct List(T,size_t len) if(len>0){
T head;
List!(T,len-1) tail;
} | null | 0 | 1316365728 | True | 0 | c2ks136 | t3_kikut | null | t1_c2ks136 | t1_c2kry29 | null | 1427615828 | 3 | t5_2fwo | null | null | null |
True | ouphe | null | Thanks. I've been meaning to change my ~/.signature for some time; now I finally can. | null | 0 | 1316365851 | False | 0 | c2ks1kr | t3_kjhvo | null | t1_c2ks1kr | t3_kjhvo | null | 1427615834 | 1 | t5_2fwo | null | null | null |
True | azakai | null | > The future of JavaScript benchmarks beyond that looks very flat.
Actually, I can't disagree more: There are great things ahead :)
Currently SpiderMonkey has type inference, and V8 has an SSA optimizing compiler. Those are complementary methods, each extremely useful on its own. When a single engine combines them, we should see great results. SpiderMonkey is working on an SSA optimizing compiler as we speak (IonMonkey), and we can assume that V8 is working on type inference (development there is less open, so hard to be sure, but it's a likely guess). Should be less than a year for these things to happen.
That should get us fairly close to the speed of Java. But there are plenty of additional optimizations to explore:
* If code uses just a simple, statically analyzable subset of JS, it could be compiled into native code with the same speed as C++. Exactly in the way that PyPy compiles RPython into C. Compiling this takes longer, but it could be done in the background. (PNaCl will have the same problem, incidentally, but it's less clear that it can start running code before compilation is complete.)
* JS engines currently use little to no SIMD optimizations. Typical patterns could be recognized and optimized that way (say, initializing a continuous region of an array to a constant). The language may also be extended, Intel released some code that implements 'Parallel Arrays' in JS.
* In addition, there is plenty of room to refine existing methods (more passes to your SSA optimizing compiler, etc.).
I think we have every reason to believe that we will see JS get to the speed of Java. (What may remain insurmountable though is some startup delay, before code is fully optimized; again, this is the same with PNaCl, but at least JS can start running during that time.)
Getting better than Java, however, may be very difficult, as there is some price to pay for being portable and secure (which are requirements for Java and JS, but not for C++).
| null | 0 | 1316365851 | False | 0 | c2ks1ks | t3_kitgf | null | t1_c2ks1ks | t1_c2krsxy | null | 1427615834 | 1 | t5_2fwo | null | null | null |
True | banuday | null | I guess you could say that, except of course that Go does not support inheritance (so, there is OOP, but it's not exactly Smalltalk strain and not exactly Simula strain, but somewhere in the middle). | null | 0 | 1316365908 | True | 0 | c2ks1ti | t3_kikut | null | t1_c2ks1ti | t1_c2krxvv | null | 1427615837 | 3 | t5_2fwo | null | null | null |
True | dnew | null | > Lisp is also vastly simpler than C++
I think you'd have to categorize what you meant by "simpler". That's why I used the term "more powerful."
> systems programming in Lisp
You mean, like LISP machines, where the entire OS is written in LISP? I think lots of the problems with using "high level languages" like Smalltalk or LISP for "systems" programming is due to "systems" being designed for languages like C or C++. Smalltalk and LISP both implement their own OS just fine, as long as you're not *also* trying to run C++ on them. For that reason, I'd even say that LISP runs well on machines with C++ as the main language, but C++ runs poorly on machines where LISP is the main language, and that makes LISP more powerful also. ;-) [Really, not trying to start a flame fest. I have no emotional investment in the situation.]
> accommodate so much expressive power.
They don't really accommodate more expressive power than the trivial syntax of LISP macros. Indeed, LISP macros have been doing more than C++ templates for quite a long time, including "read macros" that let you change the syntax of the language you're parsing in a way barely starting to be seen in the latest C++ standards work. I think it's easy to imagine a language just as powerful as C++ that didn't try to be syntax-compatible with C and which had a much simpler syntax. | null | 0 | 1316365925 | False | 0 | c2ks1vw | t3_kikut | null | t1_c2ks1vw | t1_c2kry78 | null | 1427615838 | 1 | t5_2fwo | null | null | null |
True | kamatsu | null | The practical applications are using the type system as a theorem prover ;) Your type system is turing complete though, which makes it logically inconsistent. | null | 0 | 1316365930 | False | 0 | c2ks1wr | t3_kikut | null | t1_c2ks1wr | t1_c2krft0 | null | 1427615838 | 7 | 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.