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 | Huh? It says that was for Thief 2 and System Shock 2. | null | 0 | 1317189923 | False | 0 | c2n60u9 | t3_ktd67 | null | t1_c2n60u9 | t1_c2n5xfv | null | 1427657105 | 1 | t5_2fwo | null | null | null |
True | kds71 | null | After you "master" vim you don't have to remember all the commands - you just do it automatically. Everything is in the muscle memory, so you can concentrate only on the code. If you want to jump 3 words forward you hit "3w" and you don't have to remember it or think about it - you just do it. And yes, it is way faster than moving your hand to the mouse and clicking 3 words ahead.
I use vim exclusively and believe me - it is really, really fast. It makes you more productive, because your hands stay in one place all the time, all you need is to move your fingers.
The problem with vim is that takes a long time to achieve this level, where you can do everything without thinking at all.
| null | 0 | 1317189942 | True | 0 | c2n60wf | t3_ktenx | null | t1_c2n60wf | t1_c2n5v70 | null | 1427657105 | 10 | t5_2fwo | null | null | null |
True | chub79 | null | A little off side, thinking that Eidos is still unclear about Thief 4 makes me sad considering how that series has been such a good one :/ | null | 0 | 1317190047 | False | 0 | c2n619t | t3_ktd67 | null | t1_c2n619t | t3_ktd67 | null | 1427657109 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317190306 | False | 0 | c2n623i | t3_ktg7o | null | t1_c2n623i | t1_c2n2zm4 | null | 1427657120 | 1 | t5_2fwo | null | null | null |
True | vplatt | null | Not a bad choice from a syntax point of view. It might be a good first iteration if you don't care about being able to read the generated program. OTOH - There's probably ways to make sense of BF programs that I don't know about (e.g. BF -> Python?), so that might be moot. | null | 0 | 1317190348 | False | 0 | c2n6281 | t3_ktg7o | null | t1_c2n6281 | t1_c2n5ytn | null | 1427657122 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | **K**eep **I**t **S**imple **S**tupid | null | 0 | 1317190693 | False | 0 | c2n639o | t3_ktg8c | null | t1_c2n639o | t1_c2n5ifp | null | 1427657139 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317190804 | False | 0 | c2n63n3 | t3_ktg7o | null | t1_c2n63n3 | t1_c2n5zrw | null | 1427657141 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317191059 | False | 0 | c2n64fq | t3_kteac | null | t1_c2n64fq | t1_c2n2r5s | null | 1428192714 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317191061 | True | 0 | c2n64g2 | t3_ktenx | null | t1_c2n64g2 | t1_c2n2ttg | null | 1427657152 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Hell.. I enjoy writing some things in assembly. | null | 0 | 1317191087 | False | 0 | c2n64j7 | t3_kteac | null | t1_c2n64j7 | t1_c2n396c | null | 1427657153 | 3 | t5_2fwo | null | null | null |
True | match451 | null | Thief 1 has two renderers, software and Direct3D. The software renderer for Thief II and System Shock 2 was phased out, though it's at least present in Dromed, since I've had it fall back to the software renderer a couple times. | null | 0 | 1317191188 | False | 0 | c2n64uk | t3_ktd67 | null | t1_c2n64uk | t1_c2n60u9 | null | 1427657158 | 2 | t5_2fwo | null | null | null |
True | greyfade | null | The majority of people don't read the spec. I do, but only because I read specs and implement grammars as a hobby. But the majority of Javascript "programmers" don't, and end up making these silly mistakes because the language tries to be smarter than them.
Yes, you can learn the rules, and you can work in that. But this is a problem for the very people it was intended to help.
Consistency is, in my mind, a far superior asset than helpfulness or simplicity. Inserting semicolons automatically is not consistent in the minds of those who don't take time out to download the ECMA-262 PDF. | null | 0 | 1317191387 | False | 0 | c2n65g6 | t3_kswql | null | t1_c2n65g6 | t1_c2n3bge | null | 1427657165 | 2 | t5_2fwo | null | null | null |
True | match451 | null | [Relevant](http://www.youtube.com/watch?v=Qe9qSLYK5q4).
Not a rickroll. Honest.
I wouldn't say it looks "*great*" though, I'd say it looks... *okay*. | null | 0 | 1317191441 | True | 0 | c2n65m8 | t3_ktd67 | null | t1_c2n65m8 | t1_c2n36hh | null | 1427657167 | 10 | t5_2fwo | null | null | null |
True | doitincircles | null | In the sense that this specific application is completely useless in practise, you haven't misunderstood.
The point was just to demonstrate GA techniques; clearly, using *any* search algorithm where the result is already known is redundant. | null | 0 | 1317191478 | False | 0 | c2n65qv | t3_ktg7o | null | t1_c2n65qv | t1_c2n46n4 | null | 1427657168 | 2 | t5_2fwo | null | null | null |
True | fatbunyip | null | I would say that it would be like natural evolution in a very closed environment (eg Lake Vostok?). Or perhaps top predators (for example sharks) which have remained essentially unchanged because of lower environmental pressures, as opposed to things lower down the food chain which need to adapt to counter more severe and numerous constraints.
Evolution has no end goal, merely optimizing for constraints. If the constraints are static then evolution *can* possibly reach an endpoint (in that it is the optimal solution for those constraints).
However, it is very common in these genetic algorithms for the solution to "plateau" at a non-optimal point - something that random mutations help overcome.
| null | 0 | 1317191490 | False | 0 | c2n65s9 | t3_ktg7o | null | t1_c2n65s9 | t1_c2n4kr4 | null | 1427657169 | 1 | t5_2fwo | null | null | null |
True | bitshifternz | null | I'm on Linux and their flash version has never worked properly for me. Maybe it's Slideshare that's really the problem ;)
edit: Looks good to me, Firefox 7 on Ubuntu 11.04 amd64. | null | 0 | 1317191540 | True | 0 | c2n65xo | t3_kt17p | null | t1_c2n65xo | t1_c2n1cnj | null | 1427657171 | 1 | t5_2fwo | null | null | null |
True | evilgwyn | null | executeSql is an asynchronous call. [http://www.w3.org/TR/webdatabase/#executing-sql-statements](http://www.w3.org/TR/webdatabase/#executing-sql-statements) | null | 0 | 1317191589 | False | 0 | c2n662x | t3_kt72f | null | t1_c2n662x | t1_c2n4zap | null | 1427657172 | 2 | t5_2fwo | null | null | null |
True | fatbunyip | null | >and I'm not aware of any printers that can print video streams.
There are not many printers that can print interactive forms either, yet interactive forms are an extremely useful feature of PDF. | null | 0 | 1317191696 | False | 0 | c2n66fi | t3_kssyt | null | t1_c2n66fi | t1_c2n5r1e | null | 1427657176 | 1 | t5_2fwo | null | null | null |
True | king_of_blades | null | Try [Readability](http://www.readability.com/). | null | 0 | 1317191763 | False | 0 | c2n66lt | t3_ktd67 | null | t1_c2n66lt | t1_c2n5xp7 | null | 1427657179 | 6 | t5_2fwo | null | null | null |
True | ReturningTarzan | null | >And yes, it is way faster than moving your hand to the mouse and clicking 3 words ahead.
But that's not how you move 3 words ahead in a regular text editor. | null | 0 | 1317191815 | False | 0 | c2n66rb | t3_ktenx | null | t1_c2n66rb | t1_c2n60wf | null | 1427657180 | 0 | t5_2fwo | null | null | null |
True | computers_in_space | null | I've seen it in many of the tools I need from national labs and universities. I assumed it was common.
I have also seen things make it out of a tech transfer office with GPL3, but this is usually because it had been out there for a while with GPL3 on it before they caught wind of it. It seems if you want to get free software out, you have to "sneak" it out. This would be pretty difficult with such a large, departmental effort.
Of course, this is anecdotal and I don't know much about licenses besides liking what I see of GPL. | null | 0 | 1317192056 | False | 0 | c2n67fq | t3_ksm2f | null | t1_c2n67fq | t1_c2n38fo | null | 1427657189 | 1 | t5_2fwo | null | null | null |
True | Gigablah | null | I'll assume you're not a *web* graphics professional, since you mistook the default browser styling as a deliberate "MS Word" styling.
In any case, the lack of styling is more understandable if you consider the author's (Sean Barret) philosophy that [the browser or end user should customize the viewing experience, rather than the content author](http://nothings.org/writing/websucks.html). And there are indeed ways to achieve this, like [Readability](http://www.readability.com/). | null | 0 | 1317192144 | False | 0 | c2n67p5 | t3_ktd67 | null | t1_c2n67p5 | t1_c2n43v0 | null | 1427657193 | 8 | t5_2fwo | null | null | null |
True | bonzinip | null | > What is proper name for a facade then?
It depends on what the facade interacts with. Wikipedia's [example of a facade](http://en.wikipedia.org/wiki/Facade_pattern) calls the facade class simply Computer (it's a facade for CPU, Memory and HardDrive).
> And I don't want to decipher your creative names when reading code.
Most of the time you would not even notice. | null | 0 | 1317192151 | True | 0 | c2n67pu | t3_krzdp | null | t1_c2n67pu | t1_c2mxgnp | null | 1427657193 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Wow, thanks.
ST2TWoK is my favorite SciFi film. It's a masterwork which would have been great even if it wasn't a Star Trek movie. And it's made even more awesome by showcasing the first really good CGI sequence. | null | 0 | 1317192156 | False | 0 | c2n67qd | t3_ktd67 | null | t1_c2n67qd | t1_c2n65m8 | null | 1427657193 | 1 | t5_2fwo | null | null | null |
True | artytrue | null | Awesome. Are you in the computer gaming industry now? | null | 0 | 1317192244 | False | 0 | c2n680d | t3_ktd67 | null | t1_c2n680d | t1_c2n5i3e | null | 1427657198 | 2 | t5_2fwo | null | null | null |
True | artsrc | null | Is the stuff.length check is irrelevant to this discussion?
Is the problem is that your colleague thought that executeSql was synchronous or guaranteed to take less that 100ms.
This seems like an odd understanding.
| null | 0 | 1317192304 | False | 0 | c2n686s | t3_kt72f | null | t1_c2n686s | t1_c2n662x | null | 1427657200 | 1 | t5_2fwo | null | null | null |
True | bonzinip | null | > E.g. if something is named FooBarVisitor then clearly code is structured around Visitor pattern.
That's perfectly fine for the _abstract_ visitor class. In concrete subclasses do not have to remark that it's a visitor. You call the subclass ProgramAnalysis, not ProgramAnalysisVisitor. That it's a visitor is obvious from your code:
ProgramAnalysis a = new ProgramAnalysis();
program.visit(a);
or even
ProgramVisitor a = new ProgramAnalysis();
program.visit(a);
... because after that single line of code that invoked `visit()`, the important thing is that `a` contains the results of the analysis, not that it did a visit on the program. | null | 0 | 1317192347 | True | 0 | c2n68au | t3_krzdp | null | t1_c2n68au | t1_c2mxfje | null | 1427657201 | 1 | t5_2fwo | null | null | null |
True | fatbunyip | null | >Chrome displays PDFs.
And it only displays PDFs, which is a very big limitation. If you're just looking at PDFs that's fine, but it's the same as using Windows Picture Viewer for looking at pictures. You can only look at them.
If you want to do some really basic shit with them, then you have MSPaint (Adobe Reader) but anything more advanced then you need Photoshop (Adobe Pro, Foxit or any other PDF editor).
All these companies make money off the editors, not the free PDF readers.
Adobe is famous for adding random crap to their editors that require Adobe Reader to read/interact with PDFs generated by them. | null | 0 | 1317192357 | False | 0 | c2n68c8 | t3_kssyt | null | t1_c2n68c8 | t1_c2n2k0s | null | 1427657202 | 2 | t5_2fwo | null | null | null |
True | evilgwyn | null | The stuff.length check is essential to this discussion. And he knew that the executeSql check was asynchronous. It was a pretty foolish bit of code. | null | 0 | 1317192413 | False | 0 | c2n68h5 | t3_kt72f | null | t1_c2n68h5 | t1_c2n686s | null | 1427657204 | 1 | t5_2fwo | null | null | null |
True | egonelbre | null | By default everything is in one thread. With web workers it's possible to do parallel computing. | null | 0 | 1317192466 | False | 0 | c2n68m9 | t3_kt72f | null | t1_c2n68m9 | t1_c2n5zol | null | 1427657206 | 2 | t5_2fwo | null | null | null |
True | evilgwyn | null | No javascript is not concurrent in that sense. But you can create all of the artifacts of multithreaded code (such as race conditions, shared state, concurrent access, deadlocks and so on) using things like asynchronous file io, DB, intervals, timeouts and other stuff like that. | null | 0 | 1317192516 | False | 0 | c2n68qy | t3_kt72f | null | t1_c2n68qy | t1_c2n5zol | null | 1427657208 | 1 | t5_2fwo | null | null | null |
True | fatbunyip | null | >See, it's things like this which sets Acrobat apart from the rest.
You know why? Because none of the other companies give a fuck. It's an insane amount of work to make an editor display and interact with random 3d formats. For what? 0.01% of editor users? That's why most companies don't have the niche functionality that sets Adobe apart.
Adobe has had years of head start time over everyone else (and a budget unmatched by any competitor).
| null | 0 | 1317192605 | False | 0 | c2n68zl | t3_kssyt | null | t1_c2n68zl | t1_c2mxrqe | null | 1427657211 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | There are a couple of common patterns in BF programs that are easy to recognize. I believe it would be trivial to write up a small BF parser that spreads the code out over multiple lines, indents loops and such and comments the code automatically. An interesting exercise in its own I think. | null | 0 | 1317192687 | False | 0 | c2n6970 | t3_ktg7o | null | t1_c2n6970 | t1_c2n6281 | null | 1427657214 | 1 | t5_2fwo | null | null | null |
True | elmuerte | null | Software rendering is a bit of a misnomer. Even when using Direct3D or OpenGL it's software that does the rendering. It's just that the rastering step (i.e. making a 2D image) is mostly left to hardware.
So it's actually software rasterer vs hardware rasterer. Even when using Direct3D you could resort to software rastering. The best example of this would be pixomatic: http://www.radgametools.com/pixomain.htm
It's a shame not more game use pixomatic, as I think it will perform better than the Intel GMA used in most netbooks. | null | 0 | 1317192906 | True | 0 | c2n69r5 | t3_ktd67 | null | t1_c2n69r5 | t1_c2n5yhq | null | 1427657220 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Let's make it extra hard, and restrict the random letters to A, C, T and G! | null | 0 | 1317193009 | False | 0 | c2n69v6 | t3_ktg7o | null | t1_c2n69v6 | t1_c2n5jsd | null | 1427657222 | 26 | t5_2fwo | null | null | null |
True | bonzinip | null | Observer is a pattern, not a class. Your classes will be Event and whatever dispatches the event. In a realization of Observer, perhaps you need to create an _interface_ named Observer or Listener, but not a class. | null | 0 | 1317193084 | False | 0 | c2n6a2o | t3_krzdp | null | t1_c2n6a2o | t1_c2mu1g1 | null | 1427657224 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Perl 6 does have a nice set of features, that's for sure. | null | 0 | 1317193085 | False | 0 | c2n6a36 | t3_kteac | null | t1_c2n6a36 | t1_c2n4538 | null | 1427657225 | 2 | t5_2fwo | null | null | null |
True | Iggyhopper | null | hows the weather up there? | null | 0 | 1317193140 | False | 0 | c2n6aav | t3_ktenx | null | t1_c2n6aav | t1_c2n4xgu | null | 1427657227 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317193200 | False | 0 | c2n6agy | t3_ktmdr | null | t1_c2n6agy | t3_ktmdr | null | 1427657230 | 2 | t5_2fwo | null | null | null |
True | Gotebe | null | It's a *massive* design error to allow for "cleanup" path to report failures. This applies to coding in languages with exceptions, and translates to "destructors shall not throw" rule of C++, or "suppressing" exceptions e.g. from various "close()" methods e.g. in Java or whatever.
But... Dig this (and many people fail to realize), the same rule applies to error-return languages (e.g. C). Once you are in cleanup, it's a bloody bad idea to return error. First off, you can't just return, you have to clean up all there's to clean (e.g. close two files, not one). Second, you can't really report an error well from cleanup phase, because if you get to cleanup phase with a previous error, what error do you report? The original one, or the cleanup one, or both? And if you do both, do you really think that's going to be handled, like *ever*? Because, a vast majority of error-reporting schemes in error-return languages are "return error number", or "indicate failure, provide error number aside". It's *extremely* rare that there's a stack of errors or something similar in error-return languages or their libraries.
So... the ground rule is: cleanup (destructors, code in "finally") is no-throw code (meaning, you, the programmer have to make sure of that), and you do not return error from cleanup path in error-return code.
If, however, something extraordinary happens that you feel you *do* have to do that, you use some out-of-bounds mechanism and inspect that manually.
Finally... Cleanup code "logically" does not err. A cleanup operation really should not fail, and if it does, in a vast majority of cases, there's nothing code can do about it. E.g. fclose fails. Now what? Since code reached that fclose, it means it doesn't need that FILE\* anymore, and it likely can't do anything with it even if it wanted. There's nothing meaningful to do except forget about it, and hope that system didn't lie, and that e.g. previous writes and flush really did what they were supposed to do and that all is really fine (bar file being *possibly* unavailable in near future, or something like that).
In fact, I'd argue that, when resource cleanup really fails, there's two good paths:
* ignore (possibly log the event for inspection, but *do not* report error to calling code)
* die on the spot, right there.
An example: you have a mutex, you obtain a lock, do whatever you want, and than you try to unlock, and that fails. Now what? This is one of situations where I'd judge best to die on the spot than continue and possibly corrupt shared data.
Finally... Why does then fclose (or close() of Java) throw at all? I guess because these are libraries, and therefore care more about being as precise as possible, and less about actual logic of your program.
Finally (2)... If you look at recent Throwable.add/getSupressed of Java, that is *exactly* out-of-bounds mechanism to report cleanup erros that I evoked before. But dig this: how do you think addSuppressed handles e.g. out-of-memory (imagine that it holds suppressed exceptions in some container, and adding seventh suppressed exception to it fails with OOM). What will it do? It can either let OOM unwind and break it's own mechanism, or swallow OOM (ignore error). I don't know what it actually does, but in the end, there's no magic ;-). | null | 0 | 1317193236 | False | 0 | c2n6akt | t3_krrz1 | null | t1_c2n6akt | t1_c2mxy3k | null | 1427657231 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | Cool, thanks for that. I pulled the stuff in the article completely out of my ass; I had no real (formal) idea what I was doing. It's good to see similarities between your code and mine. | null | 0 | 1317193476 | False | 0 | c2n6b8p | t3_ktg7o | null | t1_c2n6b8p | t1_c2n54hn | null | 1427657240 | 2 | t5_2fwo | null | null | null |
True | warpcowboy | null | I disagree. I started with vimtutor which just loaded a text file and had to make the changes yourself. The drills got me to acknowledge that I knew what the buttons did. It made me practice.
I feel that this tutorial did too much of the work for you. You don't learn by typing along with blinking buttons, nor do you learn by watching what each button does once. It also didn't provide objectives.
This tutorial should be rewritten to emulate vimtutor. Teach vim in small steps that lets you master each one before moving on. First, just let use know what hjkl do and make us navigate to different characters in a paragraph with those keys. Then make us hop around a paragraph with only the w/e/b keys. Then make us edit a paragraph with x. Etc.
Instead, I think that someone trying to learn vim for the first time with this will get that anxiety you feel when you see the gamepad control layout during the loading screen of a video game for the first time and feel like you have to memorize it. Instead, a good game will introduce the buttons to you one at a time as you play. | null | 0 | 1317193533 | False | 0 | c2n6be4 | t3_ktenx | null | t1_c2n6be4 | t1_c2n4xgu | null | 1427657242 | 2 | t5_2fwo | null | null | null |
True | mcandre | null | Same thing in [Haskell](https://github.com/mcandre/genetics). | null | 0 | 1317193650 | False | 0 | c2n6bo4 | t3_ktg7o | null | t1_c2n6bo4 | t3_ktg7o | null | 1427657245 | 5 | t5_2fwo | null | null | null |
True | ropers | null | Thanks very much. :) | null | 0 | 1317193763 | False | 0 | c2n6c0f | t3_ktenx | null | t1_c2n6c0f | t1_c2n5ve4 | null | 1427657251 | 0 | t5_2fwo | null | null | null |
True | nikniuq | null | PDF makes the baby jesus cry. | null | 0 | 1317193810 | False | 0 | c2n6c4c | t3_kssyt | null | t1_c2n6c4c | t3_kssyt | null | 1427657251 | 1 | t5_2fwo | null | null | null |
True | killerstorm | null | Yes, it is obvious from this code. But what if you just see class names: Program and ProgramAnalysis, and you don't know how they are related. Large programs have thousands of classes which can be related in vague way, and so when class name are informative it absolutely does not hurt.
Really, what is a problem calling it `ProgramAnalysisVisitor`. Aesthetics?
But, you know, `ProgramAnalysis` can be a facade or adapter for that analysis, and `ProgramAnalysisVisitor` is a technical class which does traversal and performs data collection. I.e. you would write:
ProgramAnalysis anal = new ProgramAnalysis(myProgram);
And then `ProgramAnalysis` constructor creates visitor and does mumbo-jumbo under the hood. Using `visit()` method directly just exposes unnecessary details in API, it is a bad design IMO. | null | 0 | 1317193990 | False | 0 | c2n6cla | t3_krzdp | null | t1_c2n6cla | t1_c2n68au | null | 1427657259 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Exactly. That's why I've switched on my laptop to XFCE and my work pc to KDE. | null | 0 | 1317194038 | False | 0 | c2n6cq5 | t3_krv1k | null | t1_c2n6cq5 | t1_c2mwxab | null | 1427657260 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | It's true there is no regard for typography.
I think for me it's more about it being a clearly properly written HTML document. Headers are headers, lists are lists, paragraphs are paragraphs, etc., etc.
No hacks, no superfluous HTML elements, no IEx fallbacks. Everything is simple and ordered.
Exactly what one would expect from the programmer type. | null | 0 | 1317194076 | True | 0 | c2n6ct1 | t3_ktd67 | null | t1_c2n6ct1 | t1_c2n5p8a | null | 1427657261 | 14 | t5_2fwo | null | null | null |
True | kataire | null | The answer is actually that you never know it, even if it wasn't UTF8. Without metadata, you can only guess based on statistics such as frequencies and pattern matching.
Character encoding is hard. ASCII don't cut it anymore. | null | 0 | 1317194101 | False | 0 | c2n6cv1 | t3_ksqu1 | null | t1_c2n6cv1 | t1_c2n43qx | null | 1427657262 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317194223 | True | 0 | c2n6d6e | t3_ktenx | null | t1_c2n6d6e | t1_c2n5v70 | null | 1427657266 | 4 | t5_2fwo | null | null | null |
True | virt_vera | null | > shared state, concurrent access
It's a little hard to NOT share state with yourself.
No, it's not *concurrent* access, it's explicitly and definitively *sequential* access. The problem is lack of atomicity.
| null | 0 | 1317194386 | False | 0 | c2n6dl5 | t3_kt72f | null | t1_c2n6dl5 | t1_c2n68qy | null | 1427657271 | 3 | t5_2fwo | null | null | null |
True | LargeDickington | null | Or dialog could say:
> Saving anmälda.txt as Text (tab delimited) will lose functionality, are you sure you want to save?
> Yes, No, Help
| null | 0 | 1317194460 | False | 0 | c2n6drr | t3_krv1k | null | t1_c2n6drr | t1_c2n5s45 | null | 1427657273 | 1 | t5_2fwo | null | null | null |
True | trahloc | null | I personally don't like nano since for it to work reliably you need to use nano -w so that it doesn't enter returns when lines wrap and I always forget having to remember to do that. Also ctrl-w screws with me when i use windows notepad but thats just my screwy somatic memory. So learning vi just made sense. It's in every single major OS by default and works exactly the same on them all. The only exception I noticed was gentoo which doesn't have it by default. | null | 0 | 1317194468 | False | 0 | c2n6dsd | t3_ktenx | null | t1_c2n6dsd | t1_c2n4fw1 | null | 1427657274 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | In the same glorious way that ooxml is recognized as a standard? | null | 0 | 1317194588 | False | 0 | c2n6e30 | t3_kssyt | null | t1_c2n6e30 | t1_c2n1fzk | null | 1427657277 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | The fitness function was written completely separate. I had no idea how I was going to implement the mutation function or the rest of the program. I wanted a larger change in the wrong direction (away from the correct value) to have a much worse score. I figured, that way it would not overtake other, different, variations in the genepool that were closer to the target. Squaring the difference did that for me, so I went with it. | null | 0 | 1317194617 | False | 0 | c2n6e58 | t3_ktg7o | null | t1_c2n6e58 | t1_c2n5xex | null | 1427657278 | 1 | t5_2fwo | null | null | null |
True | jinglebells | null | The developer tools are great. Visual Studio is one of the best IDEs (Xcode is also pretty amazing), SQL Server is great, I think the problem is the multiple layers of management who would rather save face than admit they're wrong about something and do the Right Thing.
I dunno what's up. I'm looking at Windows Server 2008 and thinking 'Seriously, you didn't have any designers spare?'. Until I can do _everything_ from the command line, I'm going to have to spend at least some of my time administrating a GUI which looks like ass. | null | 0 | 1317194651 | False | 0 | c2n6e8s | t3_krv1k | null | t1_c2n6e8s | t1_c2n2gyg | null | 1427657280 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317194946 | False | 0 | c2n6exo | t3_ktenx | null | t1_c2n6exo | t1_c2n6be4 | null | 1427657288 | 1 | t5_2fwo | null | null | null |
True | antrn11 | null | And then you find a bug in one of those libraries that has been known for ten years and still hasn't been fixed. And that bug prevents half of the users from using the software.
Sigh. | null | 0 | 1317194996 | False | 0 | c2n6f21 | t3_ktd67 | null | t1_c2n6f21 | t1_c2n4nl2 | null | 1427657290 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | My interest wasn't in evolving anything useful. I just wanted to see if I could come up with a evolutionary algorithm. I picked a pre-defined string because the fitness function for it is very easy to write, and it is also very easy to see problems with the algorithm since you can just view the plain text "evolving" after each generation. As an end-result, it is completely utterly useless, but as a exercise in getting insight into Evolutionary algorithms, it has been very valuable to me. | null | 0 | 1317195159 | False | 0 | c2n6fg3 | t3_ktg7o | null | t1_c2n6fg3 | t1_c2n5o21 | null | 1427657294 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Schools can be roughly divided into two groups, historically they were called the "C" schools and the "java" schools, based on the default language most classes were in.
The first group has smarter students and is more rigorous. The curriculum will include courses related to CS (programming languages, foundations of computer science) as well as lower level stuff (systems programming, assembly). Students will encounter a half dozen languages or more. This kind of school will prepare you pretty well for anything: working at a company, writing software on your own, getting a PhD, etc... however at the entry level you may have trouble competing for jobs at poorly run companies (that is most of them)
The second group is almost purely vocational and will focus on preparing students for a lifetime of creating CRUD apps. The focus is on learning APIs, software engineering buzzwords, and making contacts in the industry. Students will only encounter 2-3 programming languages but will be pretty well set up in terms of employment opportunities.
I have no numbers but I would assume that 30% of schools are "C" schools and the rest are "java" schools. | null | 0 | 1317195193 | False | 0 | c2n6fj3 | t3_kteac | null | t1_c2n6fj3 | t1_c2n5mpk | null | 1427657295 | -2 | t5_2fwo | null | null | null |
True | warpcowboy | null | I don't agree that Vim probably isn't for you just because you don't find tapping along with a blinking indicator pleasant or helpful. | null | 0 | 1317195211 | False | 0 | c2n6fkr | t3_ktenx | null | t1_c2n6fkr | t1_c2n6exo | null | 1427657296 | 1 | t5_2fwo | null | null | null |
True | smek2 | null | >you use keys h, j, k, and l instead of arrow keys to move cursor
As much as i love Vim, it's not the 70's anymore. Keyboards do have cursor keys. And having to constantly switch between two "modes" is usually interrupting my flow. On my old Toshiba laptop i use SciTE, which is way more comfortably to use than gvim and runs equally well. | null | 0 | 1317195244 | False | 0 | c2n6fnj | t3_ktenx | null | t1_c2n6fnj | t3_ktenx | null | 1427657297 | 6 | t5_2fwo | null | null | null |
True | bonzinip | null | > Large programs have thousands of classes which can be related in vague way, and so when class name are informative it absolutely does not hurt.
I agree, but adding -`Visitor` everywhere is not useful, in my opinion. A visitor is a pretty central part of an architecture, so you can usually spot visitor classes quite easily. If you see the superclass name, or the method names (`acceptSomething`) it is usually quite obvious that a class is a visitor. But yes, I would definitely prefer to have an -`AnalysisVisitor` rather than an -`Analyzer`, if I really have to choose.
The idea of separating the analysis and results objects is nice (unless the analysis has to be incremental, of course). I would still prefer `ProgramAnalysis` and `AnalysisResults` in that case, but I agree that whenever classes are internal naming classes with action nouns is not a big deal. (That was my point for iterators :)). | null | 0 | 1317195421 | False | 0 | c2n6g2n | t3_krzdp | null | t1_c2n6g2n | t1_c2n6cla | null | 1427657302 | 1 | t5_2fwo | null | null | null |
True | Troebr | null | > ./configure; make; make install
I often have to spend a little more time than that, plus installing a bajillion of other libs. | null | 0 | 1317195427 | False | 0 | c2n6g35 | t3_ktto0 | null | t1_c2n6g35 | t3_ktto0 | null | 1427657302 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | So what advantage does vim have over something like graphic text editor? I use vim now and then but only when firing up a text editor would take longer. But with larger projects I go with Kate. | null | 0 | 1317195608 | False | 0 | c2n6ghs | t3_ktenx | null | t1_c2n6ghs | t3_ktenx | null | 1427657309 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | It is unremarkable that a textual algorithm produces broken programs sometimes. It is unremarkable that a non-determnistic algorithm produces different outputs for the same input. There is no proof that over the set of all inputs Darcs or any other system is more "correct" than Git. That doesn't mean people can't for whatever reason prefer one algorithm over another, but pretending there's some kind of objective flaw going on here is unfounded. The author of the blog post is also mistaken; there is no proof in that in general Git's recursive merge is more correct than a 3-way. It's a matter of subjective judgment on the part of the Git community as to which strategy gets put in as the default. | null | 0 | 1317195640 | False | 0 | c2n6gk9 | t3_kt058 | null | t1_c2n6gk9 | t1_c2n1msk | null | 1427657310 | 0 | t5_2fwo | null | null | null |
True | badsectoracula | null | Only the first 3D accelerators did just rasterization. Later GPUs did transformation, lighting, clipping, etc. Modern GPUs do a lot of extra stuff beyond rasterization - one of the latest additions is tesselation. | null | 0 | 1317195731 | False | 0 | c2n6gr5 | t3_ktd67 | null | t1_c2n6gr5 | t1_c2n69r5 | null | 1427657311 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | Start-up time is a problem for me -- 2 minutes to start my biggest application.
I actually recommend not using Play templates at all. They suck. Really bad. I almost exclusively use Closure Templates, and the vast majority of rendering is done in the browser.
Something you didn't mention is the team behind Play are a bit douchey. They don't want to include essential features like GZIP compression, minifying and bundling JS and CSS, etc. I made a custom fork that does these things automatically and my bandwidth used went way down and sites are faster. | null | 0 | 1317195869 | False | 0 | c2n6h23 | t3_kt682 | null | t1_c2n6h23 | t3_kt682 | null | 1427657316 | 9 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317196024 | False | 0 | c2n6hfw | t3_ktenx | null | t1_c2n6hfw | t1_c2n6fkr | null | 1427657320 | 2 | t5_2fwo | null | null | null |
True | repsilat | null | This is the most important thing about these pages - if the HTML is sensible you can format it however you want without having to fight with its idiotic CSS (or even worse, some moronic javascript trying to do fancy things when you scroll).
If you set up your browser with a decent default stylesheet *all* pages formatted this way will look nice. | null | 0 | 1317196045 | False | 0 | c2n6hhi | t3_ktd67 | null | t1_c2n6hhi | t1_c2n66lt | null | 1427657322 | 8 | t5_2fwo | null | null | null |
True | sporadicity | null | I read it on my phone and assumed it was a deliberately simplified mobile layout. | null | 0 | 1317196147 | False | 0 | c2n6hp4 | t3_ktd67 | null | t1_c2n6hp4 | t1_c2n4kji | null | 1427657324 | 9 | t5_2fwo | null | null | null |
True | poormeboohoo2 | null | Boo fucking hoo. It's not 1995 anymore. You're not a computer novice (if you are reading this forum, anyway). You can't cope with something over 1024x768? Give me a break. | null | 0 | 1317196304 | False | 0 | c2n6i2b | t3_ktenx | null | t1_c2n6i2b | t1_c2n2sws | null | 1427657329 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | Mind -> code transfer would be done through an emacs plugin anyways. | null | 0 | 1317196369 | False | 0 | c2n6i6z | t3_ktenx | null | t1_c2n6i6z | t1_c2n3b79 | null | 1427657331 | 3 | t5_2fwo | null | null | null |
True | OopsLostPassword | null | This article is childish and I had to install adblock just to try reading it. | null | 0 | 1317196410 | False | 0 | c2n6ial | t3_kteac | null | t1_c2n6ial | t1_c2n2ze4 | null | 1427657332 | 2 | t5_2fwo | null | null | null |
True | repsilat | null | Similar things happen with video codecs. Faster processors allows more computation to take place per frame, enabling fancier compression - lower bitrates for the same picture quality, or better picture quality for the same bitrate, or bigger picture etc etc.
(Of course, hardware implementations and algorithmic improvements happen alongside this too...) | null | 0 | 1317196548 | False | 0 | c2n6il5 | t3_ktd67 | null | t1_c2n6il5 | t1_c2n5713 | null | 1427657336 | 1 | t5_2fwo | null | null | null |
True | BillOReillysCumSock | null | On pages like this I'll just use chromes inspector to center it and add a width, makes it so much easier to read. | null | 0 | 1317196988 | False | 0 | c2n6jhv | t3_ktd67 | null | t1_c2n6jhv | t1_c2n5p8a | null | 1427657348 | 3 | t5_2fwo | null | null | null |
True | refaptoring | null | The way I see is that you can just look at other editors (and then back at vim) and see that they often come with a vim emulation mode. Vim, on the other hand, thinks that if you want to beat yourself over the head with a two-by-four instead of editing text, you can procure your own two-by-four. It doesn't try to emulate anything. It's vi(m) all the way to the bottom.
| null | 0 | 1317197047 | False | 0 | c2n6jmd | t3_ktenx | null | t1_c2n6jmd | t3_ktenx | null | 1427657349 | 4 | t5_2fwo | null | null | null |
True | ropers | null | Hello, resolution snob! | null | 0 | 1317197080 | False | 0 | c2n6jp1 | t3_ktenx | null | t1_c2n6jp1 | t1_c2n6i2b | null | 1427657350 | -4 | t5_2fwo | null | null | null |
True | aaronblohowiak | null | changes within a stack are atomic. if you unwind the stack to the event loop, you lose the stack. that is a LOT more simple than classic shared mutable state. | null | 0 | 1317197101 | False | 0 | c2n6jqp | t3_kt72f | null | t1_c2n6jqp | t1_c2n5abh | null | 1427657351 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Regardless of what I have said, if you want to improve the typography, while keeping the "classic HTML" aesthetic you have, the below CSS should be a nice compromise between the two.
hr {
margin: 30px 0;
}
body {
border-top: 3px solid #444;
margin: 0;
padding: 30px;
}
p, ul, ol {
font-family: "Times New Roman", serif;
font-size: 1.25em;
line-height: 1.75em;
}
p, ul, ol, h1, h2, h3 {
width: 600px;
color: #444;
}
a {
color: black;
text-decoration: none;
border-bottom: 1px dotted black;
}
a:hover {
background-color: #ff9;
} | null | 0 | 1317197257 | True | 0 | c2n6k2q | t3_ktd67 | null | t1_c2n6k2q | t1_c2n6ct1 | null | 1427657355 | 6 | t5_2fwo | null | null | null |
True | ekabanov | null | Be sure to comment on the blog post as well, so that more people would see your opinion when googling. | null | 0 | 1317197617 | False | 0 | c2n6ksm | t3_kt682 | null | t1_c2n6ksm | t1_c2n6h23 | null | 1427657365 | 2 | t5_2fwo | null | null | null |
True | fnord123 | null | I understand their API stability is quite good and will help some programs run. But their compatability is legendary in the wrong way as well. For example the whole "DOS ain't done til Lotus don't run," fiasco. Vbscript, and jscript, etc are examples of incompatible extensions, while their HTML support until ie7 or 8 was poor.
And seriously, without posix compliance I have difficulty letting such a claim go by without a comment. :)
Fwiw, Solaris and AIX have similar code for some of their large customers. | null | 0 | 1317197924 | False | 0 | c2n6lda | t3_kssyt | null | t1_c2n6lda | t1_c2n2dow | null | 1427657373 | 0 | t5_2fwo | null | null | null |
True | zoon_politikon | null | wow I read the explanation on Pentadactyl's site and decided to make the switch. Best browser decision ever! It's fast and looks like the good old vimperator once again! thanks! | null | 0 | 1317197993 | False | 0 | c2n6lic | t3_ktenx | null | t1_c2n6lic | t1_c2n5gog | null | 1427657375 | 2 | t5_2fwo | null | null | null |
True | voxoxo | null | Libreoffice's support for powerpoint is shit, and the equivalent tool to powerpoint (impress) is even worse. And it's true that it is not the role of PDFs, but hey, if it can help me, I'm gonna take it. And beamer does a pretty good job at making decent looking presentations, even in PDFs. | null | 0 | 1317198004 | False | 0 | c2n6lj8 | t3_kssyt | null | t1_c2n6lj8 | t1_c2n326g | null | 1427657375 | 1 | t5_2fwo | null | null | null |
True | Tetha | null | I find that tiny constants that seem almost silly also help a lot. Take a look at this, for example:
Person tooYoung = Person("max", 17);
Person oldEnough = Person("karl", 18);
assertFalse(tooYoung.aboveAgeOfConsent());
assertTrue(oldEnough.aboveAgeOfConsent());
This looks pretty good, but has two problems: I remember the names, because they might be relevant, and I don't know about the numbers. Adding these tiny constants would turn this into:
String irrelevantName = "max";
int ageOfConstent = 18;
Person tooYoung = Person(irrelevantName, ageOfConstent - 1);
Person tooOld = Person(irrelevantName, ageOfConsent);
This allows me to forget about the name instantly. Also, it removes some subtle duplication about the age of consent here. | null | 0 | 1317198052 | False | 0 | c2n6lmj | t3_ktg8c | null | t1_c2n6lmj | t3_ktg8c | null | 1427657376 | 7 | t5_2fwo | null | null | null |
True | the_argus | null | I use php which is like the pbr of programming languages. | null | 0 | 1317198219 | False | 0 | c2n6lxo | t3_kteac | null | t1_c2n6lxo | t3_kteac | null | 1427657380 | 3 | t5_2fwo | null | null | null |
True | xcbsmith | null | No. I'm saying that many aspects of them don't conform to the original intent of HTML. Technically, they kind of do, as there was always the notion that you could provide rendering instructions for certain displays, and there is support for that in CSS in particular.
That said, the original idea with HTML was to be agnostic to the device and rendering mechanism of the browser (which is part of why it was built from SGML), and simply give the browser information about the structure of the document so it could render it as it saw fit. This was and remains important because of the wide variety of devices that render the web, and as a bonus it allows the structure of a document to be understood by code. This goal would have made DPS a non-starter as a practical design decision.
Of course, HTML failed miserably in this regard right from the get go, and arguably might not have been as successful as it was had it succeeded. | null | 0 | 1317198251 | True | 0 | c2n6lzs | t3_kssyt | null | t1_c2n6lzs | t1_c2n2lu6 | null | 1427657381 | 3 | t5_2fwo | null | null | null |
True | killerstorm | null | > If nano does it, I don't know how to make it do it.
Upgrade it. Works right out of the box on Ubuntu 10.04 and up. | null | 0 | 1317198340 | False | 0 | c2n6m60 | t3_ktenx | null | t1_c2n6m60 | t1_c2n4gq5 | null | 1427657383 | 1 | t5_2fwo | null | null | null |
True | Jameshfisher | null | *Not programming.* | null | 0 | 1317198679 | False | 0 | c2n6mtc | t3_kt17p | null | t1_c2n6mtc | t3_kt17p | null | 1427657393 | 5 | t5_2fwo | null | null | null |
True | vyzivus | null | What is it for? Ruby does not use hardware threads. Also, all classes are thread-unsafe, because there is no memory model defined. | null | 0 | 1317199175 | False | 0 | c2n6npr | t3_kt292 | null | t1_c2n6npr | t3_kt292 | null | 1427657409 | 2 | t5_2fwo | null | null | null |
True | RedditUser1186 | null | What would the impact be of replacing the squaring with an absolute value. It will still ensure that that there was no canceling(positive changes would always be positive, and negative negative).
I am reasonably sure the program would take more iterations to reach the goal, but how much of an impact are we talking about? Seems interesting to me. Any math geeks or experimentalists with any ideas?
On a similar note, what were the results when nothing was applied(no squaring/abs). What other forcing could you add to prevent stagnation at wrong answers? How about weighting(but not suareing to remove negativity based on order. So that "hello worle" scores much better than "iello world?"
"In the real world, adaptations often do have conflicting impacts. So I'd be curious to see where that goes. Though I suppose in the real world there is no "right answer."
What happens if you add more than one target, and let a phrase be "suitable" to either. So that you have "phr4s3 tw0" and "phr4s3 one3" both being equally close to targets "phrase one" and phrase two." Respectively.
How about going more meta? What about a program that runs a certain set fitness criteria many times and compares the average performance to other criteria. It could perhaps report on many things. Speed, stability(once a decent chunk appears, how likely is it to be lost?). Perhaps rankings at achieving certain percentages of completion. I assume that some algorithms will get to 25% much faster, but really struggle with the last 5%. Others might have more uniform performance.
"using absolute value.
I dunno, like you... I've never done anything serious in this area. But that's my food for thought on stuff I would want to play with for my intellectual curiosity if I was sitting over your shoulder and didn't have to do any of the work :P.
| null | 0 | 1317199192 | True | 0 | c2n6nqx | t3_ktg7o | null | t1_c2n6nqx | t1_c2n2zm4 | null | 1427657404 | 4 | t5_2fwo | null | null | null |
True | elperroborrachotoo | null | Hmm... that would be easily solved if windows implemented this:
MSGDATAEX mdx = { 0 };
BOOL ok = GetMessageData(&mdx, GMD_EXTENDED_DATA, sizeof(msdx));
if (!ok) throw "up!";
if (mdx.ambientCues & (MDX_AC_LAUGHTER_STIFFLED | MDX_AC_LAUGHTER_ROARING))
throw "Halp! I'm geting prank called!";
| null | 0 | 1317199536 | False | 0 | c2n6ocm | t3_ktv1z | null | t1_c2n6ocm | t3_ktv1z | null | 1427657411 | 16 | t5_2fwo | null | null | null |
True | coder21 | null | Not really subjective: recursive is the same as 3-way, only better, because it handles cases that 3-way simply can't, like the one described. | null | 0 | 1317199755 | False | 0 | c2n6oqc | t3_kt058 | null | t1_c2n6oqc | t1_c2n6gk9 | null | 1427657416 | 1 | t5_2fwo | null | null | null |
True | kataire | null | It is similar to brute-force in a way. The difference is that rather than linearly progressing through a set of possible solutions or guessing (i.e. relying on purely random selection), it defines the criteria for an acceptable solution and then tries to match that solution by building on the best attempts made so far.
That said, GAs won't come up with the perfect answer unless your fitness function is strict enough. Natural evolution came up with lots of crappy solutions yet we assume a computer will always be perfect. GAs excel when there isn't a perfect solution but lots of possible outcomes that are just good enough. | null | 0 | 1317199812 | False | 0 | c2n6ot4 | t3_ktg7o | null | t1_c2n6ot4 | t1_c2n5zrw | null | 1427657418 | 2 | t5_2fwo | null | null | null |
True | hakonlo | null | Pro tip: unsubscribe to /r/reddit.com, /r/pics, /r/wtf etc. | null | 0 | 1317199819 | False | 0 | c2n6otl | t3_ktd67 | null | t1_c2n6otl | t1_c2n5fhg | null | 1427657418 | 2 | t5_2fwo | null | null | null |
True | zsakuL | null | With the last program, why doesn't the fun() run as soon as async is called? It seems a bit pointless to wait for a get() call on the future before starting the async function. | null | 0 | 1317200040 | False | 0 | c2n6p7h | t3_krzd8 | null | t1_c2n6p7h | t3_krzd8 | null | 1427657423 | 2 | t5_2fwo | null | null | null |
True | sreguera | null | Real hipsters program in [Icon](http://www.cs.arizona.edu/icon/). | null | 0 | 1317200093 | False | 0 | c2n6pb1 | t3_kteac | null | t1_c2n6pb1 | t1_c2n2n22 | null | 1427657424 | 3 | t5_2fwo | null | null | null |
True | chneukirchen | null | If you make your window so wide you can't read it, it's your fault, isn't it? | null | 0 | 1317200455 | False | 0 | c2n6pwp | t3_ktd67 | null | t1_c2n6pwp | t1_c2n5p8a | null | 1427657432 | 5 | t5_2fwo | null | null | null |
True | [deleted] | null | Engineers don't grow up, they throw up. | null | 0 | 1317200471 | False | 0 | c2n6pxu | t3_ktv1z | null | t1_c2n6pxu | t1_c2n6ocm | null | 1427657432 | 17 | t5_2fwo | null | null | null |
True | iLiekCaeks | null | Google Docs has encountered an error. We are looking into the problem now. Please reload this page to continue. | null | 0 | 1317200630 | False | 0 | c2n6q7a | t3_ksdfr | null | t1_c2n6q7a | t1_c2muxt9 | null | 1427657435 | 1 | 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.