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 | adrianmonk | null | > Personally, I'm not seeing a big problem with calling the class that manages the execution of the db2 loader, "loader".
IMHO, the thing that the author is trying to fight against is defining a class as something open-ended, and "the class that manages the execution of the db2 loader" is open-ended. That class can contain *anything* related to the whole process of loading. Or at least its name fails to remind you specifically what it should and shouldn't contain. | null | 0 | 1317105205 | False | 0 | c2mvxws | t3_krzdp | null | t1_c2mvxws | t1_c2mtexm | null | 1427652284 | 1 | t5_2fwo | null | null | null |
True | zumpiez | null | I believe Benjamin Franklin said it best: "It is the utmost folly to spend more time considering what a class ought to be called than what a class ought to be." | null | 0 | 1317105391 | False | 0 | c2mvygq | t3_krzdp | null | t1_c2mvygq | t3_krzdp | null | 1427652292 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317105574 | False | 0 | c2mvyzu | t3_krzdp | null | t1_c2mvyzu | t1_c2mrzwu | null | 1427652298 | 2 | t5_2fwo | null | null | null |
True | FredFnord | null | > I guess I don't care how ugly people make their browsers, as long as I don't have to use their PC.
It might startle you to realize this, but there are a lot more people out there who are not you than there are people who are you. And thus it behooves developers to think about those other people, as well as about you.
| null | 0 | 1317105618 | False | 0 | c2mvz4l | t3_krv1k | null | t1_c2mvz4l | t1_c2mtwbk | null | 1427652300 | 1 | t5_2fwo | null | null | null |
True | FredFnord | null | > Besides more choice is never a bad idea.
No more evidence is needed that you haven't the faintest idea what makes a good user interface.
Might I suggest that you read a good book on the subject? Or are you the kind of person who also thinks you know more about automotive design than an automobile designer, just because 'if you think about it it's obvious!' | null | 0 | 1317105756 | False | 0 | c2mvziz | t3_krv1k | null | t1_c2mvziz | t1_c2msso6 | null | 1427652306 | 3 | t5_2fwo | null | null | null |
True | refaptoring | null | Names like this make C++ compilation faster, because the name mangler has less work to do. | null | 0 | 1317105803 | False | 0 | c2mvzo5 | t3_krzdp | null | t1_c2mvzo5 | t1_c2mrggi | null | 1427652308 | 26 | t5_2fwo | null | null | null |
True | f0nd004u | null | Well, doesn't the market make that decision at some point? In a world with applications that are "over-functional" and "under-functional but have cozy UIs", wouldn't the application that has the biggest market share be the one that has the balance users want? | null | 0 | 1317105878 | False | 0 | c2mvzwu | t3_krv1k | null | t1_c2mvzwu | t1_c2mvu2f | null | 1427652311 | 1 | t5_2fwo | null | null | null |
True | FredFriendship | null | I actually took CS420 at U of I with the professor that is the head of that group. We used charm++ for several of our assignments, and it's a very different way of thinking about parallelism than what people are used to in MPI/OpenMP.
MPI and OpenMP are, for the most part, very explicit as to how the work gets spread across multiple threads. You tell it, I have x work, and I want to split it across exactly y threads. On the other hand, charm++ is an object oriented parallelism framework where you create objects, called chares, that do work and communicate with each other simply by calling the methods on the other chares. It takes care of figuring out how to actually pass the message from chare to chare for you so that it is as simple as just calling a method on another chare.
When you run a charm++ program, you give it a number of cores to use, and then the runtime figures out how to distribute the chares across those cores. If I remember correctly, the runtime is also capable of balancing the load on all the cores throughout the execution of the program by redistributing the chares from more heavily used cores to less used cores. This is all done automatically for you, so you don't actually have to worry about it if you don't want to.
It has been a couple of years since I took that class, so I'm sure I've left out/forgotten some important details, but I do seem to remember the documentation actually being pretty good. | null | 0 | 1317106161 | False | 0 | c2mw0rj | t3_ksm2f | null | t1_c2mw0rj | t1_c2mv8n5 | null | 1427652322 | 4 | t5_2fwo | null | null | null |
True | akira410 | null | You just succinctly described about 7 years of my life. | null | 0 | 1317106171 | False | 0 | c2mw0sl | t3_ks1qu | null | t1_c2mw0sl | t1_c2muqcg | null | 1427652323 | 11 | t5_2fwo | null | null | null |
True | jfb3 | null | So, if they've got the same version number, how do you tell if you've got the update or not??? | null | 0 | 1317106218 | False | 0 | c2mw0wv | t3_ksoff | null | t1_c2mw0wv | t3_ksoff | null | 1427652323 | 2 | t5_2fwo | null | null | null |
True | ziom666 | null | If you're that good and you know why you are so good, you can easily turn around your code to make it dumb | null | 0 | 1317106411 | False | 0 | c2mw1g4 | t3_ks1qu | null | t1_c2mw1g4 | t1_c2mukzz | null | 1427652330 | 2 | t5_2fwo | null | null | null |
True | sysop073 | null | Every time Facebook makes a design change, they should immediately follow it up with a fake second change, and then cave to public pressure and revert the second change a couple hours later | null | 0 | 1317106496 | False | 0 | c2mw1of | t3_krv1k | null | t1_c2mw1of | t1_c2mrxnl | null | 1427652333 | 3 | t5_2fwo | null | null | null |
True | I_TYPE_IN_ALL_CAPS | null | MY ISSUE IS LESS ABOUT THE VALIDITY OF -ER CLASSES (OF WHICH I'M SURE YOU CAN CONTRIVE ANY NUMBER OF EXAMPLES THAT ARE, IN FACT, QUITE ACCEPTABLE), BUT RATHER WITH THE NOTION OF SIMPLE RULES BEING VALID OR EVEN VAGUELY USEFUL IN SOFTWARE DEVELOPMENT. SD IS A CRAFT, AND A DIFFICULT ONE AT THAT.
YOUR PERSON EXAMPLE IS BASICALLY MEANINGLESS TO ME. ACADEMIC EXAMPLES WHICH PROVIDE NEAT AND TIDY METAPHORS ARE USUALLY OF ABSOLUTELY NO USE IN REAL-WORLD PROGRAMMING. I WILL CHOOSE THE ARCHITECTURE WHICH I BELIEVE BEST SOLVES THE PROBLEM AT HAND, AND IF THAT ENTAILS A CLASS ENDING IN -ER I WON'T BAT AN EYE ABOUT IT.
| null | 0 | 1317106679 | False | 0 | c2mw25r | t3_krzdp | null | t1_c2mw25r | t1_c2mqx49 | null | 1427652344 | 2 | t5_2fwo | null | null | null |
True | laoong | null | I've tried attached sources and it seems that my previous statement is not exactly true: the support is present, but buggy - the sources do not compile :( | null | 0 | 1317106735 | False | 0 | c2mw2bc | t3_krzd8 | null | t1_c2mw2bc | t1_c2mvtxb | null | 1427652342 | 5 | t5_2fwo | null | null | null |
True | elucubra | null | disr.uptive | null | 0 | 1317106765 | False | 0 | c2mw2eq | t3_krv1k | null | t1_c2mw2eq | t1_c2mvn3g | null | 1427652354 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I use closures to avoid filling the global namespace with my functions. That way I can call my funcs anything I like without hammering someone else's code (a real concern in my line of work).
| null | 0 | 1317106836 | False | 0 | c2mw2m6 | t3_kroia | null | t1_c2mw2m6 | t1_c2ms2x2 | null | 1427652347 | 2 | t5_2fwo | null | null | null |
True | check3streets | null | I have an app where I need to synchronize a model (well models) across many different clients/views. I think publishing change commands (oops, I'm supposed to say events) to all subscribing clients is valid, as long as you're prepared to handle dropped changes (yeah, kinda like dropped TCP packets). Also, all consumers must be able to process the commands in the same way. But I can see where you can make communication a lot lighter than...
The alternative is just syndicating the model, and I think if the model's smallish (or segmentable), it's probably preferable. I don't see how this is necessarily to the exception of storing your modification commands though, for playback or auditing purposes.
EDIT: it occurs to me that another benefit of event source is feedback or explanation of what is responsible for changing the model, like right now. Like availability on parking garage level 3 is 0 because it's full of cars or level 3 is shut-down because of a car fire.
Another EDIT: This article is a much more compelling description of the topic:
http://cqrsinfo.com/documents/events-as-storage-mechanism/ | null | 0 | 1317106982 | True | 0 | c2mw2zm | t3_ks4su | null | t1_c2mw2zm | t3_ks4su | null | 1427652352 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I went there and trust me. There was no porn. | null | 0 | 1317107331 | False | 0 | c2mw3ww | t3_krpem | null | t1_c2mw3ww | t1_c2mnu1s | null | 1427652364 | -6 | t5_2fwo | null | null | null |
True | molslaan | null | did you write on the whiteboard? | null | 0 | 1317107352 | False | 0 | c2mw3yd | t3_ks1qu | null | t1_c2mw3yd | t1_c2muqku | null | 1427652364 | 1 | t5_2fwo | null | null | null |
True | Branan | null | In my (admittedly limited) experience, Factories are almost always *procedures*, not objects. They may be shoehorned into a class because of language limitations, or simply for the sake of consistency, but ultimately they have no data and only one useful method. You could just as easily pass a function pointer around as a Factory object.
edit: and if your factory has state (like a list of created objects) it's absolutely misnamed. It does more than just create objects at that point. | null | 0 | 1317107557 | False | 0 | c2mw4hc | t3_krzdp | null | t1_c2mw4hc | t1_c2mt1c1 | null | 1427652370 | 2 | t5_2fwo | null | null | null |
True | FredFnord | null | Goodness. You mean that was unrealistic? Say it ain't so!
The entire *point* of the exercise was to build a straw man and demolish it, and here you are pretending that some kind of conclusions can be drawn about the *character* of the cardboard cutouts propped up by the author. The only thing they're good for is getting a good idea of the author's own preconceptions and biases.
The cardboard cutout you're putting on display is similarly useless for telling us anything about anything other than you. It is pretty informative on that score, though. Here's how your comment reads:
* BUZZWORD BUZZWORD BUZZWORD "LOOK AT ME GUYS I'M SMART" BUZZWORD BUZZWORD!
* CONDESCENSION TOWARDS PEOPLE WHO ARE ACTUALLY MORE EMOTIONALLY MATURE "LOOK AT ME GUYS I'M EXPERIENCED AND NOT A WIMP!"
* MACHO MACHO "LOOK AT ME GUYS I'M AN ALPHA MALE! REALLY I AM!" INTERNET TOUGH-GUY-ISM!
Did I miss anything?
Oh, and I pretty much guarantee that I'm older than you are. I'm *certainly* older than 30. And I've likely been in the industry longer than you have, too. | null | 0 | 1317107573 | False | 0 | c2mw4j3 | t3_krv1k | null | t1_c2mw4j3 | t1_c2mt7zq | null | 1427652371 | 1 | t5_2fwo | null | null | null |
True | FredFnord | null | Yeah, pretty soon he'll be able to work his way up to wood. | null | 0 | 1317107669 | False | 0 | c2mw4s2 | t3_krv1k | null | t1_c2mw4s2 | t1_c2mu5j8 | null | 1427652374 | 3 | t5_2fwo | null | null | null |
True | BigCheezy | null | I guess making software that lets you figure out of the source of an E. Coli outbreak makes you Public Enemy #1 | null | 0 | 1317107815 | False | 0 | c2mw571 | t3_ks1qu | null | t1_c2mw571 | t1_c2muago | null | 1427652380 | 5 | t5_2fwo | null | null | null |
True | DeepDuh | null | Not bad, I've watched the video. There is one key difference in the OSX search system though: Once you've looked for something two or three times, you know where it's at in the menu (or you even know its hotkey). With that Add-on, as far as I see it, you still have no idea where a feature is located, so you will end up using this search every time for that particular feature - which isn't efficient at all.
See, the beauty of the OSX GUI is that it's easy for beginners WHILE allowing you to grow into becoming more efficient and using all the power of an application. Windows UI is typically also easy for beginners while having powerful features for advanced users BUT there is quite a disconnect inbetween. Many Windows users haven't really got better using it even after 15 years, I'm pretty sure this would look better on Mac. | null | 0 | 1317107852 | False | 0 | c2mw5am | t3_krv1k | null | t1_c2mw5am | t1_c2ms1l0 | null | 1427652380 | 1 | t5_2fwo | null | null | null |
True | happyscrappy | null | I've rarely heard of anything stupider. | null | 0 | 1317108093 | False | 0 | c2mw5xv | t3_krzdp | null | t1_c2mw5xv | t3_krzdp | null | 1427652389 | 1 | t5_2fwo | null | null | null |
True | julesjacobs | null | The way the code gets transformed seems related to Data Parallel Haskell. | null | 0 | 1317108118 | False | 0 | c2mw609 | t3_ks0s7 | null | t1_c2mw609 | t3_ks0s7 | null | 1427652390 | 1 | t5_2fwo | null | null | null |
True | bitchessuck | null | AMD's OpenCL implementation for CPUs doesn't do autovectorization, to take advantage of SIMD you have to use vector types like `float4`. AMD's implementation seems to focus on GPUs. The CPU implementation is supposed to be used for debugging and development.
Then again, where's Intel's GPU implementation? I'm not even sure it's feasible with Intel's current GPU hardware. | null | 0 | 1317108262 | False | 0 | c2mw6eh | t3_ks0s7 | null | t1_c2mw6eh | t1_c2mql19 | null | 1427652396 | 3 | t5_2fwo | null | null | null |
True | bonzinip | null | Primitives are copy_rectangles, new_surface, show_surface, hide_surface, destroy_surface, move_resize_surface, set_transient_for, put_rgb, put_rgba. | null | 0 | 1317108296 | False | 0 | c2mw6hi | t3_krzdn | null | t1_c2mw6hi | t1_c2mv5u7 | null | 1427652397 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317108323 | False | 0 | c2mw6k8 | t3_ksqba | null | t1_c2mw6k8 | t3_ksqba | null | 1427652398 | 0 | t5_2fwo | null | null | null |
True | kingkilr | null | Build a graph of the transitions, BFS it. | null | 0 | 1317108384 | False | 0 | c2mw6pq | t3_ksqba | null | t1_c2mw6pq | t3_ksqba | null | 1427652400 | 5 | t5_2fwo | null | null | null |
True | bonzinip | null | Not any harder than Cappuccino or GWT. | null | 0 | 1317108550 | False | 0 | c2mw766 | t3_krzdn | null | t1_c2mw766 | t1_c2mvwgh | null | 1427652405 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | can anyone elaborate on the reason behind consistent allcaps "SPAM" throughout this post and other posts? | null | 0 | 1317108616 | False | 0 | c2mw7d0 | t3_ksnfm | null | t1_c2mw7d0 | t3_ksnfm | null | 1427652409 | 2 | t5_2fwo | null | null | null |
True | kellyjosephprice | null | I'm just learning about graphs. Why wouldn't you use Dijkstra's alogrithm?
EDIT: It is a breadth-first search... | null | 0 | 1317108649 | True | 0 | c2mw7g5 | t3_ksqba | null | t1_c2mw7g5 | t1_c2mw6pq | null | 1427652410 | 1 | t5_2fwo | null | null | null |
True | NadirPointing | null | you could just draw some arrows, its not like its going to be compiled on the whiteboard. | null | 0 | 1317108711 | False | 0 | c2mw7m3 | t3_ks1qu | null | t1_c2mw7m3 | t1_c2mufbx | null | 1427652412 | 2 | t5_2fwo | null | null | null |
True | arulprasad | null | Fair enough. | null | 0 | 1317108725 | False | 0 | c2mw7nl | t3_krzdn | null | t1_c2mw7nl | t1_c2mw766 | null | 1427652412 | 5 | t5_2fwo | null | null | null |
True | A_for_Anonymous | null | You're stuck in the marketing era. Windows XP still tells people to restart when I change network settings. | null | 0 | 1317108762 | False | 0 | c2mw7rm | t3_irt4s | null | t1_c2mw7rm | t1_c2671nv | null | 1427652414 | 0 | t5_2fwo | null | null | null |
True | tsk05 | null | No, [this does.](http://www.reddit.com/r/programming/comments/ks1qu/how_to_rock_an_algorithms_interview/c2mrsxg) Work in any other area just props up their main area, which I'll let wiki explain:
>[After Palantir was discovered planning attacks on a journalist,] the House Armed Services Subcommittee on Emerging Threats and Capabilities asked the Defense Department and the National Security Agency to provide any contracts with Palantir Technologies for investigation. This might pose an existential threat to Palantir since a *very large part of their business* is based on those entities. | null | 0 | 1317108815 | False | 0 | c2mw7wr | t3_ks1qu | null | t1_c2mw7wr | t1_c2mw571 | null | 1427652419 | 8 | t5_2fwo | null | null | null |
True | LenHolgate | null | Quite...
My worry is that it will make it hard when hosting the CLR yourself, you now can't differentiate between an assembly that needs 4 or 4.5 ...
Also, even if it DOES work perfectly, it's hardly a good example to set. All the versioning stuff is there for a reason; now we'll have pointy haired bosses saying that it's OK to send out a new set of code with the same version details as MS can do it... | null | 0 | 1317108867 | False | 0 | c2mw820 | t3_ksoff | null | t1_c2mw820 | t3_ksoff | null | 1427652418 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317108976 | False | 0 | c2mw8bs | t3_krzdn | null | t1_c2mw8bs | t3_krzdn | null | 1427652423 | 1 | t5_2fwo | null | null | null |
True | kingkilr | null | Because each of the transitions has a distance of 1 (or alternatively it's unweighted, every transition is a one char change). Dijkstra's on an unweighted graph is the same as either a BFS or a DFS, I forget which. | null | 0 | 1317109112 | False | 0 | c2mw8nv | t3_ksqba | null | t1_c2mw8nv | t1_c2mw7g5 | null | 1427652426 | 1 | t5_2fwo | null | null | null |
True | lingnoi | null | Depends on your definition of "web application". I'd personally say no because a typical "web application" is typically described as something that sits on a web server which can concurrently handle multiple users.
It's is more like VNC, single user, remote connection. | null | 0 | 1317109126 | False | 0 | c2mw8p6 | t3_krzdn | null | t1_c2mw8p6 | t1_c2mvl8i | null | 1427652426 | 2 | t5_2fwo | null | null | null |
True | jinglebells | null | What can't you do in OS X by keyboard, out of interest? | null | 0 | 1317109225 | False | 0 | c2mw8xw | t3_krv1k | null | t1_c2mw8xw | t1_c2mrvbj | null | 1427652429 | 1 | t5_2fwo | null | null | null |
True | kellyjosephprice | null | I fairly sure it would be a BFS. You would be checking all current possibilities, before checking the depth of any given one. | null | 0 | 1317109369 | False | 0 | c2mw995 | t3_ksqba | null | t1_c2mw995 | t1_c2mw8nv | null | 1427652432 | 1 | t5_2fwo | null | null | null |
True | TikiTDO | null | Often times if you make use of one of these words, the function should be simple enough to deduce from the context. If I have a class named Render in my MVC framework, I doubt you'd have any trouble figuring out that it is responsible for rendering a view going to a browser. Yes, there are other things that may be rendered, but I'd hope that you'd know if you were reading the code for a game engine, or a photo editing program, or whatnot.
Even if a name does cause you to lump unrelated things together into a catchall class, some rational analysis after the fact should be enough to remind you that maybe you're better off breaking these features into their own class. Silly naming conventions don't stop bad practices; logical thought does. | null | 0 | 1317109534 | True | 0 | c2mw9na | t3_krzdp | null | t1_c2mw9na | t1_c2mvx1p | null | 1427652437 | 6 | t5_2fwo | null | null | null |
True | [deleted] | null | I work for a small start-up that isn't even profitable yet but we still have a fairly customisable system that is used by many 'normal' users in hospitals, schools and other companies by non-technical people. Sure we do get calls and maybe we could do without the guy custom support guy but I think most of our problems with configuration are resolved with good documentation in both text, video and audio formats. It's cheaper than you think to produce and it works.
Most of our support calls have to do with things out of reach like the school's firewall not allowing the device to communicate with our server and despite help in this area they still come to us. Mainly because their IT guy refuses to acknowledge it is his fault and blames it on us. They trust him so they query it but while some people would say that is a waste of our resources we do get a lot of positive feedback by answering those same questions over and over and the business is growing.
Question about the actual device / software are usually resolved pretty quickly due to well planned out logging and paths created to find out what went wrong. If you do offer configuration you need to provide a good way to figure out what went wrong. Perhaps a button or separate application that sends off their configuration and any other relevant information to you and then you can diagnose the problem. | null | 0 | 1317109607 | False | 0 | c2mw9t8 | t3_krv1k | null | t1_c2mw9t8 | t1_c2mvmdv | null | 1427652439 | 2 | t5_2fwo | null | null | null |
True | guruthegreat | null | Did you say Hastur^Hastur^Hastur? | null | 0 | 1317109694 | False | 0 | c2mwa0p | t3_krzdp | null | t1_c2mwa0p | t1_c2mqzsg | null | 1427652442 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | Saying something like only 5% of people ever change options in Word therefore there doesn't need to be so many options is catering to the lowest common denominator. It's saying just because I get a lot of inexperienced users means experienced users should suffer.
That's wrong. Options for the sake of having options is wrong but having a lot of relevant useful options is a good thing. | null | 0 | 1317109760 | False | 0 | c2mwa6j | t3_krv1k | null | t1_c2mwa6j | t1_c2msxl4 | null | 1427652444 | 1 | t5_2fwo | null | null | null |
True | phantamines | null | We are talking about email groups, not animated scroll bars here, in a address book application. Email groups are not a *setting*, it's functionality that is absolutely appropriate to easing every day workflow. Hiding/removing functionality for the sake of a pretty "bookmark" button is design, not UX. Search was there before, now search is all you get. Even Google moved from their position from "search only email" to allowing label nesting (basically folder support, finally!). | null | 0 | 1317109872 | False | 0 | c2mwaf9 | t3_krv1k | null | t1_c2mwaf9 | t1_c2mvu2f | null | 1427652448 | 1 | t5_2fwo | null | null | null |
True | rmeredit | null | Who said that? Not me, and it's not my argument. | null | 0 | 1317110005 | False | 0 | c2mwaql | t3_krv1k | null | t1_c2mwaql | t1_c2mwa6j | null | 1427652452 | 0 | t5_2fwo | null | null | null |
True | phantamines | null | Sadly more people still use Hotmail over Gmail, by almost double. And Internet Explorer... *shudder* | null | 0 | 1317110151 | False | 0 | c2mwb3b | t3_krv1k | null | t1_c2mwb3b | t1_c2mvzwu | null | 1427652457 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | I see it similar. In every paradigm I've encountered the modeling of the data structure comes first, whether it is in functional programming, one of the imperative approaches (procedural, OOP), or designing database schemata. The main reason why I think it is the better approach lies in the fact that a data model is in general not as dynamic as the processing logic that uses it. | null | 0 | 1317110287 | False | 0 | c2mwbe0 | t3_krzdp | null | t1_c2mwbe0 | t1_c2mqahc | null | 1427652461 | 2 | t5_2fwo | null | null | null |
True | cizpre | null | Why would you care? If people like having a browser that you think looks ugly, let them. You don't *have* to install six toolbars, if you don't want to. | null | 0 | 1317110382 | False | 0 | c2mwbkq | t3_krv1k | null | t1_c2mwbkq | t1_c2mtv4u | null | 1427652465 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | Every type of assertion for every unit testing library accepts a message parameter. This is more that sufficent to indicate what part of the test failed. | null | 0 | 1317110401 | False | 0 | c2mwblx | t3_kq001 | null | t1_c2mwblx | t1_c2mtqcd | null | 1427652465 | 1 | t5_2fwo | null | null | null |
True | opkode | null | >Forbidden
| null | 0 | 1317110525 | False | 0 | c2mwbva | t3_ksm23 | null | t1_c2mwbva | t3_ksm23 | null | 1427652468 | 1 | t5_2fwo | null | null | null |
True | grauenwolf | null | You are wrong, I have nothing against unit testing when it is done correctly. What I don't like is the bastardization of unit testing. As for your so called "best pratices", I've seen them in use enough times to see them for the folly that they are. Nothing but shallow tests with a single trivial assertion, more often than not proving nothing but that the mocking framework isn't broken.
Meanwhile I see that you can't count, there are two assertions in your first test. Meanwhile you forgot the property changed notification, for which there are two that must be raised. | null | 0 | 1317110593 | False | 0 | c2mwc0l | t3_kq001 | null | t1_c2mwc0l | t1_c2mtq2c | null | 1427652469 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Those would be results from a time when a very small percentage of people were computer literate enough to know that there even *were* options that could be modified. And most of them would probably have assumed that MS Word was like a toaster, or a microwave. You don't need to tweak settings. It just "works"
These days, with Facebook privacy option concerns everywhere, Wi-fi on/off toggles on phones and so on, people are much more aware of the options available to them, and a more open to changing the behaviour of the systems they use.
Of course, it's probably still a small percentage of people that will actively alter the functionality of a system they use, but it's most likely a fair bit higher than 5% | null | 0 | 1317110655 | False | 0 | c2mwc58 | t3_krv1k | null | t1_c2mwc58 | t1_c2mp1p6 | null | 1427652472 | 1 | t5_2fwo | null | null | null |
True | BorgDrone | null | > Would selecting IMAP vs. POP3 or TLS vs. STARTTLS do so or do you have another qualification on your definition?
Yes, that is also a design flaw. As a user, I just want to read my e-mail. I don't care *how* it gets to me at all. | null | 0 | 1317110746 | False | 0 | c2mwcc9 | t3_krv1k | null | t1_c2mwcc9 | t1_c2mv4d4 | null | 1427652473 | 1 | t5_2fwo | null | null | null |
True | zokier | null | Is it just me, or is Unicode handling pita in every language? | null | 0 | 1317110799 | False | 0 | c2mwcg7 | t3_ksqu1 | null | t1_c2mwcg7 | t3_ksqu1 | null | 1427652475 | 1 | t5_2fwo | null | null | null |
True | ahminus | null | I ask these sort of questions, too. Sadly, I think I end up passing a lot of people that can't actually write code, know how the compiler works in a given environment, understand how to examine a core, etc.
There is some practical knowledge in every situation that is crucially important.
| null | 0 | 1317110840 | False | 0 | c2mwciy | t3_ks1qu | null | t1_c2mwciy | t3_ks1qu | null | 1427652476 | 1 | t5_2fwo | null | null | null |
True | beej71 | null | While Levenshtein is one of my favs, it won't give the intermediate valid words between two other words. | null | 0 | 1317110850 | False | 0 | c2mwcjq | t3_ksqba | null | t1_c2mwcjq | t1_c2mw6k8 | null | 1427652476 | 1 | t5_2fwo | null | null | null |
True | makis | null | you mean everything should look like windows 95? | null | 0 | 1317110962 | False | 0 | c2mwcrp | t3_krv1k | null | t1_c2mwcrp | t1_c2mvzwu | null | 1427652479 | 1 | t5_2fwo | null | null | null |
True | tilio | null | i'm under 30 and the fact that you think split tests and cost benefits analyses are buzzwords explains why i can "pretty much guarantee" that i make a lot more than you do. how's that passive aggressiveness working out for you? | null | 0 | 1317110988 | False | 0 | c2mwctz | t3_krv1k | null | t1_c2mwctz | t1_c2mw4j3 | null | 1427652481 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | Based on reading comments, I suspect you'll see a chromium build in late October or so with it.
Seneca college offers some courses where they teach development using Firefox; this feature will be implemented by one of their instructors as an example for the course this fall. | null | 0 | 1317111052 | False | 0 | c2mwcyl | t3_ksdfr | null | t1_c2mwcyl | t1_c2mtbao | null | 1427652481 | 3 | t5_2fwo | null | null | null |
True | makis | null | that's a hell of interface!
in real world address books, red ribbons are used for groups too!
so easy to understand! | null | 0 | 1317111062 | False | 0 | c2mwczd | t3_krv1k | null | t1_c2mwczd | t1_c2mrxu0 | null | 1427652482 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317111226 | True | 0 | c2mwdbv | t3_ksqba | null | t1_c2mwdbv | t1_c2mwcjq | null | 1427652487 | 1 | t5_2fwo | null | null | null |
True | DeepDuh | null | I didn't really explain well. In OSX the commands that don't have a hotkey are not impossible to reach by keyboard - it would be just highly inefficient. You would have to either press a combination for 'help' and start typing the command's name or press a combination for the menu focus and navigate there with the arrow keys - in both cases it's much faster to just use your trackpad or mouse to get there.
In general I would say, Mac OS is good for having an efficient combination of keyboard and mouse. Windows shines the most when you want a fully keyboard-controlled GUI.
edit: Btw. Dialog boxes are another example: Other than OK/Cancel you can only reach the other buttons by tabbing through the GUI elements in OSX. That's something that actually always bothered me and is a real weakness of that OS. It's a shame because it would be pretty easy to solve. | null | 0 | 1317111239 | False | 0 | c2mwdcp | t3_krv1k | null | t1_c2mwdcp | t1_c2mw8xw | null | 1427652487 | 1 | t5_2fwo | null | null | null |
True | makis | null | but maybe they want fries too with the burger
and maybe you put them well visible on the menu, you don't hide them in a closet, waiting for someone to look in the manual or google to find them... | null | 0 | 1317111245 | False | 0 | c2mwdd7 | t3_krv1k | null | t1_c2mwdd7 | t1_c2mr9g5 | null | 1427652488 | -1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317111272 | False | 0 | c2mwdf7 | t3_krv1k | null | t1_c2mwdf7 | t1_c2mp1p6 | null | 1427652488 | 1 | t5_2fwo | null | null | null |
True | big-o-notation | null | That is absolutely crazy. | null | 0 | 1317111339 | False | 0 | c2mwdka | t3_krzdn | null | t1_c2mwdka | t1_c2mv3av | null | 1427652490 | 1 | t5_2fwo | null | null | null |
True | LargeDickington | null | Gnome is wanna be macosx. | null | 0 | 1317111459 | False | 0 | c2mwdsf | t3_krv1k | null | t1_c2mwdsf | t1_c2mr7jz | null | 1427652492 | 0 | t5_2fwo | null | null | null |
True | Carnagh | null | Ignore the article, the author simply doesn't understand nouns. | null | 0 | 1317111510 | False | 0 | c2mwdw6 | t3_krzdp | null | t1_c2mwdw6 | t1_c2mppxk | null | 1427652493 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317111586 | False | 0 | c2mwe0s | t3_kq001 | null | t1_c2mwe0s | t1_c2mugqp | null | 1427652495 | 1 | t5_2fwo | null | null | null |
True | makis | null | The fact that you don't care, means that the UI have to become counter-intuitive?
"Oh, that's what it does." implies that no one can say what's the functionality behind the ribbon, not even you! | null | 0 | 1317111720 | False | 0 | c2mweab | t3_krv1k | null | t1_c2mweab | t1_c2mqvz8 | null | 1427652498 | 1 | t5_2fwo | null | null | null |
True | adrianmonk | null | Sure, that's valuable. I'm trying to differentiate between usability and fun. Actually, I think fun can be part of usability, similar to how if you are taking a class, if your teacher makes it fun or interesting, that can encourage learning, at least compared to the same material presented in a totally dry manner.
I guess to me the idea piece of software is well-engineered, and it has good usability, and it is enjoyable to use. But not everyone enjoys working toward each of these attributes. | null | 0 | 1317111773 | False | 0 | c2mwedz | t3_krv1k | null | t1_c2mwedz | t1_c2mwdd7 | null | 1427652500 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317111870 | False | 0 | c2mwel1 | t3_krv1k | null | t1_c2mwel1 | t3_krv1k | null | 1427652502 | 1 | t5_2fwo | null | null | null |
True | makis | null | are you kidding?
what Apple does is "I removed the front door, it was used only 4% of the time" | null | 0 | 1317111898 | False | 0 | c2mwen7 | t3_krv1k | null | t1_c2mwen7 | t1_c2mvve6 | null | 1427652503 | 2 | t5_2fwo | null | null | null |
True | bitchessuck | null | Popular open source software demonstrates the bad side effects of excessive configurability. Ever used a friend's emacs or vim configuration? It's damn nearly impossible, since these programs have no decent default configuration and you have to come up with your own.
I think this is a big problem with lots of old-school open source software overall, no sane defaults. | null | 0 | 1317112305 | True | 0 | c2mwfhp | t3_krv1k | null | t1_c2mwfhp | t1_c2mvl65 | null | 1427652514 | 4 | t5_2fwo | null | null | null |
True | ucbmckee | null | What a remarkably awful idea. | null | 0 | 1317112388 | False | 0 | c2mwfnf | t3_ksoff | null | t1_c2mwfnf | t3_ksoff | null | 1427652516 | 1 | t5_2fwo | null | null | null |
True | nikolag | null | this should do some good to my newsletter app | null | 0 | 1317112440 | False | 0 | c2mwfr9 | t3_ksnfm | null | t1_c2mwfr9 | t3_ksnfm | null | 1427652517 | 2 | t5_2fwo | null | null | null |
True | orjan | null | [Hamming distance](http://en.wikipedia.org/wiki/Hamming_distance) would be more appropriate than Levenshtein, since the problem states that the words should be of equal length. | null | 0 | 1317112656 | False | 0 | c2mwg60 | t3_ksqba | null | t1_c2mwg60 | t1_c2mwcjq | null | 1427652524 | 0 | t5_2fwo | null | null | null |
True | Inverter | null | Oh, right, I didn't realize that the keys in the map were only types, not instances. So you get all three at the cost of being overly verbose — now that sounds exactly like typical C++ ;-) | null | 0 | 1317112928 | False | 0 | c2mwgns | t3_kqtat | null | t1_c2mwgns | t1_c2mpqlf | null | 1427652529 | 1 | t5_2fwo | null | null | null |
True | dougrathbone | null | 'cause I like to yell that word... or maybe because I'm an illiterate idiot, who knows - either way thanks for spotting that :) | null | 0 | 1317113207 | True | 0 | c2mwh64 | t3_ksnfm | null | t1_c2mwh64 | t1_c2mw7d0 | null | 1427652537 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317113371 | True | 0 | c2mwhhk | t3_ksoff | null | t1_c2mwhhk | t3_ksoff | null | 1427652541 | 1 | t5_2fwo | null | null | null |
True | bbibber | null | > So, yes, the default settings need to be pretty damn good
Of course, still doesn't really make the case against removing the settings for the other 5% though. | null | 0 | 1317113459 | False | 0 | c2mwhnr | t3_krv1k | null | t1_c2mwhnr | t1_c2mp1p6 | null | 1427652543 | 2 | t5_2fwo | null | null | null |
True | g4bor | null | the author is mixing up unicode and encodings (as many other articled do too). i understand that it sounds confusing, but the basics are these (please note, i will oversimplify a lot of things here to make this short. at the end i will add comments about it):
* UNICODE is a mapping from characters to integers. it's basically numbering all the characters in the world.
* ENCODINGS (for example utf8, utf16, ucs2 etc.) define how those integers are written to files
so, let's take my firstname "Gábor". the unicode mapping says the numbers for the characters are [71, 225, 98, 111, 114]. now, if i want to save this to disk, i have several options how to save it, some examples:
* in utf8. there the bytes written to disk would be: [71, 195, 161, 98, 111, 114] (the second number got represented as 2 bytes)
* in utf16. there the bytes written do disk would be: [0, 71, 0, 225, 0, 98, 0, 111, 0, 114] (the numbers got padded to 16bits).
p.s: as i said, i was oversimplifying, there are a bunch of complications that i skipped (UNICODE is a standard, it also deals with other things, like sorting strings; saying "character" is a little imprecise, because there are graphemes and glyphs and other crazy stuff; my name can be written in other ways in unicode because of combining characters; there are several versions of utf16, based on endianness and BOM). simply google them if you want to learn more about them | null | 0 | 1317113608 | False | 0 | c2mwhxv | t3_ksqu1 | null | t1_c2mwhxv | t3_ksqu1 | null | 1427652547 | 9 | t5_2fwo | null | null | null |
True | bbibber | null | Can only agree if you have that annoying 'first use, fill in these things' window. If you have a default, then you've made a decision and allowed your users to be flexible with it. Win. Win. | null | 0 | 1317113671 | False | 0 | c2mwi2r | t3_krv1k | null | t1_c2mwi2r | t1_c2mr95l | null | 1427652548 | 2 | t5_2fwo | null | null | null |
True | binaryecho | null | Google is a good start. They seem to know what they're doing. | null | 0 | 1317113745 | False | 0 | c2mwi7n | t3_krzys | null | t1_c2mwi7n | t3_krzys | null | 1427652550 | -3 | t5_2fwo | null | null | null |
True | bbibber | null | You wife likes it. I don't. Now what? | null | 0 | 1317113842 | False | 0 | c2mwie2 | t3_krv1k | null | t1_c2mwie2 | t1_c2mpuie | null | 1427652553 | -1 | t5_2fwo | null | null | null |
True | kalmakka | null | Oh, right.
I'm not used to D slices. It seems to me to be a horrible mess of unpredictability. The fact that the output of
a[0] = 10;
int[] b = a;
a ~= 5;
a[0] = 20;
writef(b[0]);
depends on the internal state of **a** (appart from that it is non-empty) really doesn't seem right.
I had therefore expected that when a slice is assigned to another they are reffing to the same structure (like object references in C++), so that after doing **int[] b = a;** any mutations of a and b (not just set operations under certain circumstances) would be reflected in the other. In that case, **stack.length = stack.length - 1** would be quite different from **stack = stack[0 .. $-1]**, as one mutates the slice, the other one reassigns the slice reference. | null | 0 | 1317114014 | False | 0 | c2mwipu | t3_kqoz2 | null | t1_c2mwipu | t1_c2mtk5e | null | 1427652557 | 1 | t5_2fwo | null | null | null |
True | masklinn | null | It is, or at least in most, but for two quite valid reasons:
1. Unicode itself is *very fucking complex*, because it has to deal with socially evolved crap. It's trying to encode all human scripts (as well as their local specifics in sorting &al)
2. In most languages, strings are still considered arrays of some code unit (generally int8 or int16) period. Unicode streams are not arrays, they're sequences, and they're not made of simple code units (not at all levels anyway).
The *simplest* part of unicode is the transformation formats (conversion between unicode codepoint streams and on-disk or on-wire bytes representation), but even that is fraught with perils. | null | 0 | 1317114094 | False | 0 | c2mwiut | t3_ksqu1 | null | t1_c2mwiut | t1_c2mwcg7 | null | 1427652559 | 7 | t5_2fwo | null | null | null |
True | HansWurst121 | null | I have no idea why I coded that :) It's java and seems to work...
import java.io.*;
import java.util.*;
public class Dictionary {
/**
* Path to the dictionary file
*/
private static final String path = "US.dic";
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
String from = sc.next();
String to = sc.next();
Set<Integer>[] graph = constructGraph(from, to);
bfs(graph);
}
/**
* Simple breath first search
*
* @param graph
*/
private static void bfs(Set<Integer>[] graph) {
boolean visited[] = new boolean[graph.length];
Queue<Pair<Integer, Integer>> queue = new LinkedList<Pair<Integer, Integer>>();
queue.add(new Pair<Integer, Integer>(0, 0));
visited[0] = true;
while (!queue.isEmpty()) {
Pair<Integer, Integer> node = queue.poll();
if (node.first == graph.length - 1) {
System.out.println("Distance: " + node.second);
return;
}
for (int a : graph[node.first]) {
if (!visited[a]) {
queue.add(new Pair<Integer, Integer>(a, node.second + 1));
visited[a] = true;
}
}
}
System.out.println("No valid distance found.");
}
/**
* Replace character at position i with a space
*
* @param string
* @param i
* @return
*/
private static String getKey(String string, int i) {
char[] temp = string.toCharArray();
temp[i] = ' ';
return new String(temp);
}
/**
* Reads the dictionary file, constructs graph as an array of adjacency
* sets. Two nodes are adjacent if they have hamming distance smaller or
* equal 1
*
* @param from
* @param to
* @return
* @throws IOException
*/
@SuppressWarnings("unchecked")
private static Set<Integer>[] constructGraph(String from, String to)
throws IOException {
int n = from.length();
if (n != to.length())
throw new RuntimeException();
Map<String, ArrayList<Integer>> map = new HashMap<String, ArrayList<Integer>>();
BufferedReader in = new BufferedReader(new FileReader(path));
String line;
int count = 1;
while ((line = in.readLine()) != null) {
if (line.length() == n && !line.startsWith("%")) {
for (int i = 0; i < n; i++) {
String key = getKey(line, i);
if (!map.containsKey(key))
map.put(key, new ArrayList<Integer>());
map.get(key).add(count);
}
++count;
}
}
Set<Integer> graph[] = new Set[count + 2];
for (int i = 0; i < count + 2; i++)
graph[i] = new TreeSet<Integer>();
for (int i = 0; i < n; i++) {
String key = getKey(from, i);
if (map.containsKey(key)) {
for (int a : map.get(key)) {
graph[0].add(a);
}
}
}
for (int i = 0; i < n; i++) {
String key = getKey(to, i);
if (map.containsKey(key)) {
for (int a : map.get(key)) {
graph[a].add(count + 1);
}
}
}
for (ArrayList<Integer> list : map.values()) {
for (int a : list) {
for (int b : list) {
graph[a].add(b);
graph[b].add(a);
}
}
}
return graph;
}
/**
* Pair of two values
*
* @param <A>
* @param <B>
*/
private static class Pair<A, B> {
A first;
B second;
public Pair(A first, B second) {
this.first = first;
this.second = second;
}
}
}
| null | 0 | 1317114722 | False | 0 | c2mwjzg | t3_ksqba | null | t1_c2mwjzg | t3_ksqba | null | 1427652573 | 1 | t5_2fwo | null | null | null |
True | phunphun | null | No, it's a strawman argument. | null | 0 | 1317114958 | False | 0 | c2mwkfb | t3_krv1k | null | t1_c2mwkfb | t1_c2mtebk | null | 1427652580 | 3 | t5_2fwo | null | null | null |
True | phunphun | null | Not GNOME, Just [William John McCann](http://blogs.gnome.org/mccann/). He's responsible for so much OSX aping in GNOME 3 it's not even funny.
Makes me sick, to be honest. | null | 0 | 1317115029 | False | 0 | c2mwkjz | t3_krv1k | null | t1_c2mwkjz | t1_c2mwdsf | null | 1427652582 | -1 | t5_2fwo | null | null | null |
True | deverdev | null | So what? | null | 0 | 1317115563 | False | 0 | c2mwlip | t3_krrz1 | null | t1_c2mwlip | t1_c2mr7as | null | 1427652594 | 2 | t5_2fwo | null | null | null |
True | BeatLeJuce | null | Colors could be changed by changing the constants in the write() call at the end, and the code could be optimized by turning the recursion into an iteration, or by leaving out the linear filter (that one would incur a loss in picture quality, though). However, as explained in the original article, changing the code would probably destroy it's ability to be written as a mandelbrot. | null | 0 | 1317115625 | False | 0 | c2mwlmp | t3_krpem | null | t1_c2mwlmp | t1_c2mt1k1 | null | 1427652596 | 3 | t5_2fwo | null | null | null |
True | LargeDickington | null | Lets fork it already | null | 0 | 1317115710 | False | 0 | c2mwlrq | t3_krv1k | null | t1_c2mwlrq | t1_c2mwkjz | null | 1427652597 | -4 | t5_2fwo | null | null | null |
True | runvnc | null | So this is somehow limited to one client at a time.. what happens when a second client attempts to connect? | null | 0 | 1317115757 | False | 0 | c2mwlum | t3_krzdn | null | t1_c2mwlum | t3_krzdn | null | 1427652598 | 1 | t5_2fwo | null | null | null |
True | BeatLeJuce | null | having the same file open wouldn't be the problem. The way pixels are stored in the file would probably be, though. So it would be better to safe the file into some memory buffer. In that case you could easily multithread it. However due to the GIL, the speedup will probably not be linear. | null | 0 | 1317115855 | False | 0 | c2mwm1e | t3_krpem | null | t1_c2mwm1e | t1_c2mtq8l | null | 1427652603 | 1 | t5_2fwo | null | null | null |
True | flukus | null | So add 2 more tests, that brings the total to 5 which is still less than half the dozen you said would be required.
>Meanwhile I see that you can't count, there are two assertions in your first test.
Yes, because the single assert principal as a guideline that shouldn't be followed dogmatically. | null | 0 | 1317115873 | False | 0 | c2mwm2q | t3_kq001 | null | t1_c2mwm2q | t1_c2mwc0l | null | 1427652603 | 1 | t5_2fwo | null | null | null |
True | JonDum | null | and it's actually quite beautiful in how simple it is. | null | 0 | 1317115874 | False | 0 | c2mwm2t | t3_krzdp | null | t1_c2mwm2t | t1_c2muag6 | null | 1427652603 | 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.