archived stringclasses 2 values | author stringlengths 3 20 | author_fullname stringlengths 4 12 ⌀ | body stringlengths 0 22.5k | comment_type stringclasses 1 value | controversiality stringclasses 2 values | created_utc stringlengths 10 10 | edited stringlengths 4 12 | gilded stringclasses 7 values | id stringlengths 1 7 | link_id stringlengths 7 10 | locked stringclasses 2 values | name stringlengths 4 10 ⌀ | parent_id stringlengths 5 10 | permalink stringlengths 41 91 ⌀ | retrieved_on stringlengths 10 10 ⌀ | score stringlengths 1 4 | subreddit_id stringclasses 1 value | subreddit_name_prefixed stringclasses 1 value | subreddit_type stringclasses 1 value | total_awards_received stringclasses 19 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
True | [deleted] | null | [deleted] | null | 0 | 1317056941 | False | 0 | c2mpnw7 | t3_krv1k | null | t1_c2mpnw7 | t1_c2mpk0d | null | 1427649260 | 3 | t5_2fwo | null | null | null |
True | dnew | null | Sure. Raviolli code is bad. But that's because it's insufficiently modular. How many bugs have you found in stdio? In gcc? Would you rather write a small database manager or use a large existing SQL server? Because they're modular *enough*, you can rely on them.
Running compiled code is still the primary form of code reuse today. :-) | null | 0 | 1317056945 | False | 0 | c2mpnws | t3_krklz | null | t1_c2mpnws | t1_c2mo8wf | null | 1427649260 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Should count *tokens*, not lines or characters or KB. A variable name is a token regardless of length. Same with function or class names. Each operator is a token, and parantheses, block open/close. In python, a newline is a token, in Java, the semi-colon is a token. | null | 0 | 1317056958 | False | 0 | c2mpo0d | t3_krklz | null | t1_c2mpo0d | t1_c2mngvy | null | 1427649261 | 3 | t5_2fwo | null | null | null |
True | Iggyhopper | null | If you have that much of a difference then you're doing something wrong. Move it to a function. | null | 0 | 1317056965 | False | 0 | c2mpo1p | t3_krklz | null | t1_c2mpo1p | t1_c2mniug | null | 1427649261 | 2 | t5_2fwo | null | null | null |
True | nealibob | null | Agreed 100%.
Unfortunately, the developer is all too often the UX person, and possibly even the designer. In some cases, that works great, because there are some folks who really can do it all. I'll wager that those folks are few and far between, though.
Actually, I suppose that what I am saying is that there often isn't a designer nor a UX person, and quality suffers for that. I think this goes back to the classic "what are you really trying to do" question. Anything short of watching someone do their job and developing an understanding of its essence will not be able to yield software that is very beneficial, in general. | null | 0 | 1317056982 | False | 0 | c2mpo4u | t3_krv1k | null | t1_c2mpo4u | t1_c2mpk0d | null | 1427649262 | 29 | t5_2fwo | null | null | null |
True | bramblerose | null | > Instead, one must actually spend time with users and observe them doing their jobs.
Which, interestingly, is exactly what Microsoft has done with the Office UI: http://blogs.msdn.com/b/jensenh/archive/2008/03/12/the-story-of-the-ribbon.aspx
Of course, every engineer I have spoken to thinks the office 2007 UI is horrible, which makes it clear again: engineers are not your average user. | null | 0 | 1317056997 | False | 0 | c2mpo7j | t3_krv1k | null | t1_c2mpo7j | t1_c2mpdjv | null | 1427649263 | 41 | t5_2fwo | null | null | null |
True | omgz0r | null | It looks like it's been fixed, either that or my browser configuration is the only one he was shooting for. | null | 0 | 1317057049 | False | 0 | c2mpoio | t3_krklz | null | t1_c2mpoio | t1_c2mmjzv | null | 1427649268 | 1 | t5_2fwo | null | null | null |
True | comment-dwim | null | No, it's Python, [this](http://compsoc.dur.ac.uk/whitespace/) is whitespace. | null | 0 | 1317057207 | False | 0 | c2mppes | t3_krpem | null | t1_c2mppes | t1_c2mowyz | null | 1427649279 | 10 | t5_2fwo | null | null | null |
True | CynicalTyler | null | This sounds like good advice, but I don't come away from this article with a sense of what it *means* to bind behavior to data rather than the other way around. How does the rookie programmer apply this? | null | 0 | 1317057295 | False | 0 | c2mppxk | t3_krzdp | null | t1_c2mppxk | t3_krzdp | null | 1427649286 | 28 | t5_2fwo | null | null | null |
True | matthieum | null | Actually, the advantage of Boost.Fusion, there is no efficiency loss because it's all template computation based (well... the compilation is slightly longer). Therefore you've got all 3 :) | null | 0 | 1317057403 | False | 0 | c2mpqlf | t3_kqtat | null | t1_c2mpqlf | t1_c2mi7ea | null | 1427649295 | 1 | t5_2fwo | null | null | null |
True | MarcuBot | null | Apparently you've never used intellisence | null | 0 | 1317057424 | False | 0 | c2mpqpo | t3_kr2x5 | null | t1_c2mpqpo | t1_c2mmrx8 | null | 1427649298 | -2 | t5_2fwo | null | null | null |
True | thegeek2 | null | Every engineer (including myself) I've spoken to have grown to like the ribbon. | null | 0 | 1317057494 | False | 0 | c2mpr3j | t3_krv1k | null | t1_c2mpr3j | t1_c2mpo7j | null | 1427649303 | 26 | t5_2fwo | null | null | null |
True | dnew | null | Modular code will be bigger. But modular code doesn't have to all be yours. What do you think is better: reusing gcc and stdio and sql-lite, or reimplementing exactly the part of that code that you happen to be using in your particular application?
Again, code you don't have to write doesn't cause bugs. | null | 0 | 1317057500 | False | 0 | c2mpr4x | t3_krklz | null | t1_c2mpr4x | t1_c2mn4qq | null | 1427649303 | 1 | t5_2fwo | null | null | null |
True | dnew | null | Yep. Except that's not sufficiently modular, because the module is still part of the code you have to worry about. | null | 0 | 1317057536 | False | 0 | c2mprbw | t3_krklz | null | t1_c2mprbw | t1_c2mo9y2 | null | 1427649305 | 1 | t5_2fwo | null | null | null |
True | nealibob | null | My observation is that the more time you spend in an application, the more likely you are to want to tweak it. For example, I rarely use a word processor, and I have even more rarely found a need to change a setting in one. It might also be that the default settings are so well researched, or I am so conditioned to expect the default settings, that I have no desire to change them.
I agree about the Lion apps. iCal in Snow Leopard, though not perfect, was basically a study in how to design a UI. Now, it's harder to use and performs as gimmicky as it appears. I imagine that the average user might have an easier time using it now, especially if they had no prior experience with an older version, but I find the lack of choice somewhat disturbing. It's good to know there are sane replacement options, like [BusyCal](http://www.busymac.com/).
Address Book, on the other hand, has never been as intuitive as it could be, and it's just terrible now. It works, and it has all the features I want, but the UI is so cumbersome that it feels like a sick joke. There are and have been some serious functionality issues that go deeper than the visible UI, particularly if you use Exchange or any other service and what that to be your sole contact repository, but at least the basics do work. | null | 0 | 1317057548 | False | 0 | c2mprej | t3_krv1k | null | t1_c2mprej | t1_c2mp5bz | null | 1427649306 | 16 | t5_2fwo | null | null | null |
True | dnew | null | That is the other drawback. It's a good idea to choose those boundaries carefully. I'd rather live with the bugs in GCC and MySql than try to roll my own on every application. | null | 0 | 1317057577 | False | 0 | c2mprkl | t3_krklz | null | t1_c2mprkl | t1_c2mmx1l | null | 1427649309 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317057684 | False | 0 | c2mps6r | t3_krv1k | null | t1_c2mps6r | t1_c2mpo4u | null | 1427649316 | 19 | t5_2fwo | null | null | null |
True | agbullet | null | I'm one such engineer.
If I had to guess, people don't actually hate *the ribbon*. They hate having something familiar taken away from them, and the idea of having to get used to something new. | null | 0 | 1317057791 | False | 0 | c2mpssz | t3_krv1k | null | t1_c2mpssz | t1_c2mpr3j | null | 1427649324 | 39 | t5_2fwo | null | null | null |
True | LenHolgate | null | True, the COM required for things like CLR hosting and whatever is strangely reminiscent of the early days of COM... | null | 0 | 1317057920 | False | 0 | c2mptkw | t3_krouy | null | t1_c2mptkw | t1_c2mpfe8 | null | 1427649334 | 1 | t5_2fwo | null | null | null |
True | rzwitserloot | null | First things first: Title is a little misleading. The conclusion can be reversed, too. When adding a secondary variable (an aggregate of indent depth, size of methods, hierarchy depth, etc), the effect of code length on bugs disappears. The real find (which is quite interesting) is that non-raw-code-size metrics often touted as presumably better indicators are in fact strongly correlated to code length; in effect they measure mostly the same thing, roughly. As SquashMonster's excellent comment already covers, kloc without something to compare it to is mostly useless, whereas some of these other metrics could at least in theory attempt to aspire to be independent. This paper seems to indicate they just aren't, which is very interesting.
But, more importantly, this result also does **NOT IMPLY** that the right answer is put reduced code length before other concerns at all. Here's an example. The basic suggestion of the paper is that bugs are effectively on a per line of code basis, so regardless of a program's complexity, method depth, etc, etc, the number of bugs in it will be linear to the lines of code in it.
Let's say we have project X, which is written as if code golfing is a way of life. Every line is analysed, reanalysed, refactored, and possibly even obfuscated to keep kloc as small as is humanly possible. This project has 50k lines of code and has 2 bugs per kloc. (It has 100 bugs).
In another part of the world, another team is working on the same thing. This is project Y. They write code to put readability first, and they don't golf it very much. This exact same project has 83kloc, and has 1.2 bugs per kloc. (it has 100 bugs).
Both projects have about equal bug counts, both projects adhere to the results of the paper (When these teams add more code, then bug counts go up). Which team is doing it right? Well, depends on other factors. Which code is more flexible? Which team spent less time writing and thus has more time / budget for writing more integration tests and hiring testers, or take more time to add features without as much deadline stress? Presumably project Y would actually win on that count, but that's not the point of this thought exercise.
Another strange and IMO bullshit conclusion we can draw from this paper is that splitting a large application up into multiple completely independent bits is _WRONG_. Yes, each individual unit would have far less bugs, but the entire app will undoubtedly consist of a few more kloc than if it was a mess-o-spaghetti due to the need to write some connecting interfaces and other module glue. The sum of all bugs across all modules would be higher, at least if this paper is to be taken out of context, then if it was just a single big ball. I'm pretty sure that's not right at all, and it is in fact quite good for bug counts, code quality and flexibility, etc, to split up where possible.
| null | 0 | 1317057926 | False | 0 | c2mptlu | t3_krklz | null | t1_c2mptlu | t3_krklz | null | 1427649334 | 1 | t5_2fwo | null | null | null |
True | spirit_of_radio | null | Just as developers often claim to "know their users", designers do the same (imho, they are even more guilty of this). In neither case does that mean the person actually does know anything about the user. | null | 0 | 1317057961 | False | 0 | c2mptsr | t3_krv1k | null | t1_c2mptsr | t1_c2mpnw7 | null | 1427649337 | 5 | t5_2fwo | null | null | null |
True | matthieum | null | Actually, using a code coverage report you should be able to isolate paths within the code that are rarely (if ever) taken. Those are prime candidates for a good pair of eyes, since they are lightly/not tested. Bearing in mind, of course, that some code is not covered (`catch(...)`) | null | 0 | 1317057995 | False | 0 | c2mptzl | t3_krklz | null | t1_c2mptzl | t1_c2mnlo1 | null | 1427649339 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317058066 | False | 0 | c2mpue0 | t3_krrz1 | null | t1_c2mpue0 | t1_c2moj16 | null | 1427649344 | 1 | t5_2fwo | null | null | null |
True | Iggyhopper | null | I think I'm going to like this part of the future of the web. | null | 0 | 1317058082 | False | 0 | c2mpuh7 | t3_krzdn | null | t1_c2mpuh7 | t3_krzdn | null | 1427649345 | 22 | t5_2fwo | null | null | null |
True | mikaelhg | null | ``com.google.common.io.Closeables.closeQuietly(closeable);`` | null | 0 | 1317058082 | False | 0 | c2mpuh9 | t3_krrz1 | null | t1_c2mpuh9 | t1_c2mo8kp | null | 1427649345 | 2 | t5_2fwo | null | null | null |
True | JavaLSU | null | We are programmers, we are not end users. This is our biggest flaw.
The address book change is something my wife pointed out to me as something she likes. It's a simple little UI change that adds a perceived level of depth and comfort. It doesn't need to be changed, it just needs to exist.
She's the end user, and she like little details like that. That's why Apple has gained so much in popularity. It's the little touches that they add that Microsoft doesn't really have a hold of yet.
Take the swipe back and forward in safari (lion). It's so freaking elegant, but unnecessary. Elegance matters more the functionality to many people.
Know your end user. | null | 0 | 1317058088 | False | 0 | c2mpuie | t3_krv1k | null | t1_c2mpuie | t3_krv1k | null | 1427649346 | 42 | t5_2fwo | null | null | null |
True | deoxxa | null | I'm reading http://nlp.stanford.edu/IR-book/html/htmledition/irbook.html and it's really good, but I'd very much welcome any other good reading material on the IR subject. I've never been to university, so anything that involves a lot of math will go right over my head, but I'm happy to give it a go anyway, if it's good reading!
Also any pointers (pun intended (and another)) on the code itself would be great; I'm not exactly a C++ ninja. | null | 0 | 1317058099 | False | 0 | c2mpukq | t3_krzys | null | t1_c2mpukq | t3_krzys | null | 1427649347 | 3 | t5_2fwo | null | null | null |
True | DavidM01 | null | If you understand the flow of data in an application, then you understand the application. If you don't, then you don't.
How we handle that flow is why OOP, Procedural, Logic, Functional, etc methodologies. | null | 0 | 1317058105 | False | 0 | c2mpulk | t3_krzdp | null | t1_c2mpulk | t3_krzdp | null | 1427649347 | 4 | t5_2fwo | null | null | null |
True | rzwitserloot | null | I don't think the bolder implementation (_language choice matters_) works. In fact, it may well imply the opposite. Language choice doesn't matter.
The paper implies that bug count <-> code length are correlated. There are constants involved with correlation: BUGCOUNT(proj_X) ~= CODELENGTH(proj_X) * C.
I would think it rather obvious that 'C' is dependent on a few factors, it's not a universal constant. Programming language must play a large part in it, because some languages express in multiple lines / tokens what others do with less, but clearly complexity of "!!?" is no different from some keyword or other.
Programming languages like Scala that tout support of a lot more paradigms will usually be able to massively decrease the things OO metrics tend to measure, but if that doesn't matter, then this paper doesn't mean anything in regards to _language choice matters_ unless we know the values of C.
| null | 0 | 1317058149 | False | 0 | c2mpuu4 | t3_krklz | null | t1_c2mpuu4 | t1_c2mna5f | null | 1427649350 | 2 | t5_2fwo | null | null | null |
True | tangra_and_tma | null | partial application, lambda lifting & moving free variables to lambda parameters are ways I got around this when writing a Scheme compiler, so I presume you could do something similar in a VM whilst compiling (haven't tried it though; my VM produces LAP, and that's just interpreted directly). | null | 0 | 1317058160 | False | 0 | c2mpuw7 | t3_kroia | null | t1_c2mpuw7 | t1_c2mpgdq | null | 1427649351 | 3 | t5_2fwo | null | null | null |
True | pnpbios | null | Sounds like you can have the html5 back-end without X if they are putting unity support in. Looking forward to this. | null | 0 | 1317058194 | False | 0 | c2mpv1z | t3_krzdn | null | t1_c2mpv1z | t3_krzdn | null | 1427649353 | -3 | t5_2fwo | null | null | null |
True | nealibob | null | Makes sense. I do think, however, that the smaller the project, the more it makes sense for the engineer to work directly with the user as much as possible. Having someone who is not skilled in software development project management collect requirements and convey them to the engineer is going to result in sadness. | null | 0 | 1317058230 | False | 0 | c2mpv8i | t3_krv1k | null | t1_c2mpv8i | t1_c2mps6r | null | 1427649355 | 9 | t5_2fwo | null | null | null |
True | mariox19 | null | Easily, if you don't follow the adage. | null | 0 | 1317058251 | False | 0 | c2mpvce | t3_krklz | null | t1_c2mpvce | t1_c2mnlo1 | null | 1427649361 | 1 | t5_2fwo | null | null | null |
True | QuestionMarker | null | Absolutely. Code modularity *in itself* doesn't imply any of that, though. Code reuse does. | null | 0 | 1317058260 | False | 0 | c2mpve7 | t3_krklz | null | t1_c2mpve7 | t1_c2mpr4x | null | 1427649361 | 1 | t5_2fwo | null | null | null |
True | spirit_of_radio | null | Of course, you're right. The reality is a tiny percentage of software development has any formal UX person involved. Often that's just a scale thing (if the entire development team is 1 person, it's hard to get a UXer in there).
But just because there's no formal UXer on the project, doesn't mean UX work can't happen. A Developer pretending to be a UXer is better than nothing, at the very least if forces them to "think about the users" in a bit of a more formal way.
You're 100% right; of all the tools a UXer has in their bag, nothing beats watching someone work. It's my favourite part of my job. You never fail to learn something interesting (even if it has nothing to do with the product you're working on) | null | 0 | 1317058336 | False | 0 | c2mpvrt | t3_krv1k | null | t1_c2mpvrt | t1_c2mpo4u | null | 1427649362 | 9 | t5_2fwo | null | null | null |
True | wurzelg | null | Have been meaning to try Sencha Touch, to see how performance compares. | null | 0 | 1317058371 | False | 0 | c2mpvzy | t3_kpgmn | null | t1_c2mpvzy | t1_c2m7ns3 | null | 1427649365 | 1 | t5_2fwo | null | null | null |
True | JL235 | null | Agreed, and I also don't believe that you should always rolling your own is always the best idea.
It's about finding a balance, and using good judgement, to decide when to do what. | null | 0 | 1317058455 | False | 0 | c2mpwij | t3_krklz | null | t1_c2mpwij | t1_c2mprkl | null | 1427649372 | 2 | t5_2fwo | null | null | null |
True | comment-dwim | null | I've never understood the appeal of closures as objects when there is a more fitting data structure that mimics objects in most languages: environments (except for the problem that they aren't exposed or manipulable in most cases). | null | 0 | 1317058477 | False | 0 | c2mpwmk | t3_kroia | null | t1_c2mpwmk | t3_kroia | null | 1427649373 | 2 | t5_2fwo | null | null | null |
True | matthieum | null | People fear change. Change breaks habits, and you need to craft new ones. Change gets you out of your comfort zone, and unfortunately at the worst of times (say, when you try to print your document just before this important meeting and there is no "Print" on the f*cking ribbon).
Fortunately, being humans, once we get past our fear, we realize that we adapt quite fast :) | null | 0 | 1317058525 | False | 0 | c2mpwvb | t3_krv1k | null | t1_c2mpwvb | t1_c2mpssz | null | 1427649376 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317058537 | False | 0 | c2mpwxi | t3_kogj4 | null | t1_c2mpwxi | t1_c2m2s4j | null | 1427649377 | 1 | t5_2fwo | null | null | null |
True | spirit_of_radio | null | You're right. Developing a usable product is all about a culture of usability so that everyone realizes the up front work that has to be done.
But, if that ends up front, and the developers don't understand the users, all the up front work in the world won't help. Everyone on the project needs to share the same understanding of the users, their goals, project goals... Even in great organizations, this is the hardest part of a UXers job. | null | 0 | 1317058549 | False | 0 | c2mpwzs | t3_krv1k | null | t1_c2mpwzs | t1_c2mps6r | null | 1427649378 | 3 | t5_2fwo | null | null | null |
True | axilmar | null | > Let me try this again, the problem you had in your example, and the issue you have with D's struct vs classes is not resolved by the solution you describe. It stems from switching from value types to reference types, and if value type classes had a switch to turn them into reference types, the result would be the same.
But I wouldn't have to switch from value types to reference types in C++. I would use reference types without sacrificing performance in C++.
I.e. I wouldn't choose to change from value types to reference types in C++, because I'd use reference types right from the start.
> Why would you?
Because I don't want to use the collector.
Because I want my objects to be deleted as soon as they go out of scope.
> will be collected when all references to it no longer exist.
Nope. It will be collected when the collector decides to run, and if there are no references to it.
> D has choose that struct and class are different, and so they are.
Which is problematic, unlike "between a for loop and a while, foreach and until, a jmp and a if, an array and a linked list", which are more beneficial to separate than to not separate.
> To continue to argue this is an issue without present actual issues is of no benefit to your self or the design of the language.
Well, it seems to me that you just want to justify D's choices, no matter what the cost. You deliberately not see the issues.
Here is another issue then: I would like to be able to allocate my objects either in the heap or as part of aggregates.
I.e. I'd like to do:
class MyDialog : Dialog {
Button button;
};
and
class MyDialog : Dialog {
Button *button;
MyDialog() : button(new Button) {}
};
I cannot do that with D.
Are you going to side step this issue as well?
| null | 0 | 1317058573 | False | 0 | c2mpx4k | t3_kljc0 | null | t1_c2mpx4k | t1_c2mpnkc | null | 1427649380 | 1 | t5_2fwo | null | null | null |
True | pavel_lishin | null | Mine generates a .bmp, and it's not empty, but neither will OS X preview show me the image, nor will imagemagick's convert accept it as valid. | null | 0 | 1317058628 | False | 0 | c2mpxfb | t3_krpem | null | t1_c2mpxfb | t1_c2momgt | null | 1427649384 | 2 | t5_2fwo | null | null | null |
True | kamishizuka | null | Bug #1: Program doesn't work! | null | 0 | 1317058713 | False | 0 | c2mpxxi | t3_krklz | null | t1_c2mpxxi | t1_c2mopvn | null | 1427649390 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317058888 | True | 0 | c2mpz0g | t3_krv1k | null | t1_c2mpz0g | t1_c2mpv8i | null | 1427649405 | 24 | t5_2fwo | null | null | null |
True | djgrave | null | Article describes How to Restore a SharePoint Site from a Database Backup | null | 0 | 1317058892 | False | 0 | c2mpz15 | t3_ks0j6 | null | t1_c2mpz15 | t3_ks0j6 | null | 1427649405 | -2 | t5_2fwo | null | null | null |
True | Gh0stRAT | null | >The recommended books are ~$100.
Welcome to college... | null | 0 | 1317058931 | False | 0 | c2mpz95 | t3_kqucu | null | t1_c2mpz95 | t1_c2mmgd6 | null | 1427649408 | 3 | t5_2fwo | null | null | null |
True | Tommelot | null | Wow, I think that image has been on [wikipedia](http://en.wikipedia.org/wiki/Mandelbrot_set) since the website first went up.
That said, chaos theory was one of my favourite MSc subjects! | null | 0 | 1317058940 | False | 0 | c2mpzas | t3_krpem | null | t1_c2mpzas | t3_krpem | null | 1427649409 | 1 | t5_2fwo | null | null | null |
True | ItsAPuppeh | null | Perhaps it would be better to summarize with:
Class names should be nouns, and not verbs. Focus on the data first, and and the functionality to apply to the data second. | null | 0 | 1317058960 | False | 0 | c2mpzf9 | t3_krzdp | null | t1_c2mpzf9 | t3_krzdp | null | 1427649410 | 39 | t5_2fwo | null | null | null |
True | killerstorm | null | From time to time you have a function which is fucking long and breaking it into smaller pieces makes no sense at all. | null | 0 | 1317058977 | False | 0 | c2mpzir | t3_krklz | null | t1_c2mpzir | t1_c2mohfy | null | 1427649413 | 1 | t5_2fwo | null | null | null |
True | HaywoodMullendore | null | I agree that MS Word is a horrible example for that survey. I tweak almost all software that I use, but I don't remember a single time I would have needed to change MS Word settings (I'm probably forgetting something, but anyways..).
And settings shouldn't be removed.
The blog post was basically just really annoying in lots of different ways. :) | null | 0 | 1317059006 | False | 0 | c2mpzof | t3_krv1k | null | t1_c2mpzof | t1_c2mp5bz | null | 1427649413 | 31 | t5_2fwo | null | null | null |
True | s73v3r | null | Apparently you've never worked outside of Windows. | null | 0 | 1317059047 | False | 0 | c2mpzwu | t3_kr2x5 | null | t1_c2mpzwu | t1_c2mpqpo | null | 1427649418 | 3 | t5_2fwo | null | null | null |
True | s73v3r | null | Yeah, no. That works ok while you have only a couple of files, maybe a class or two. As the project gets larger, it's far, far more difficult to actually keep those things straight in your head. | null | 0 | 1317059103 | False | 0 | c2mq099 | t3_kr2x5 | null | t1_c2mq099 | t1_c2mjgag | null | 1427649422 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317059141 | False | 0 | c2mq0gc | t3_krzdn | null | t1_c2mq0gc | t1_c2mpv1z | null | 1427649424 | 9 | t5_2fwo | null | null | null |
True | s73v3r | null | >If I don't remember where something is supposed to be, I go trace through the execution and find it. Novel concept, I suppose.
It's an awful concept, considering you have to break your concentration on what you're doing, search through the code base for what you think is the name of something, and then try and go back to where you were. Especially considering that with code completion, the computer is doing these things for you. | null | 0 | 1317059208 | False | 0 | c2mq0ur | t3_kr2x5 | null | t1_c2mq0ur | t1_c2mnkqo | null | 1427649429 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | This is a good point. Theoretically, the data doesn't actually *do* anything, it just *is*; Nouns are appropriate. | null | 0 | 1317059234 | False | 0 | c2mq10m | t3_krzdp | null | t1_c2mq10m | t1_c2mpzf9 | null | 1427649432 | 2 | t5_2fwo | null | null | null |
True | StrangeWill | null | >Just as developers often claim to "know their users"
The more you know your software the less you know your users. ;)
Every time someone speaks up about how something _might_ be "confusing" it's bloody UI design gold to me (being as most people I talk with aren't super familiar with the UI), being as I'm practically blind to all of this. | null | 0 | 1317059249 | False | 0 | c2mq12t | t3_krv1k | null | t1_c2mq12t | t1_c2mptsr | null | 1427649433 | 8 | t5_2fwo | null | null | null |
True | s73v3r | null | I would love to use that, but I'm working on Windows, and my stuff is compiled with Visual C++. | null | 0 | 1317059259 | False | 0 | c2mq15z | t3_kr2x5 | null | t1_c2mq15z | t1_c2mkfl8 | null | 1427649434 | 1 | t5_2fwo | null | null | null |
True | I_TYPE_IN_ALL_CAPS | null | > Don't make objects that end with 'er'.
EXCEPT FOR WHEN IT MAKES SENSE TO.
DON'T TREAT CRAFT AS RELIGION. | null | 0 | 1317059260 | False | 0 | c2mq165 | t3_krzdp | null | t1_c2mq165 | t3_krzdp | null | 1427649434 | 9 | t5_2fwo | null | null | null |
True | __j_random_hacker | null | That's true, but I don't think it's important. The functions are structurally identical in precisely the way that ordinary methods are now. If a method can use the same internal representation despite managing to operate on different objects, is there any reason why two different closures can't do the same?
The fact that compiled languages like C++0x permit closures tells me that it's enough to have one internal representation per closure type signature. If per-closure-instance internal representations were really necessary, that would imply that functions would need to get compiled at runtime!
EDIT: Changed "If two different methods..." to "If a method..." -- sorry for any confusion. | null | 0 | 1317059273 | True | 0 | c2mq18u | t3_kroia | null | t1_c2mq18u | t1_c2mpgdq | null | 1427649435 | 4 | t5_2fwo | null | null | null |
True | dnew | null | But reusing code that isn't modular leads to more bugs than just writing it again. Modularity is a prerequisite for reuse, pretty much by definition. | null | 0 | 1317059305 | False | 0 | c2mq1fs | t3_krklz | null | t1_c2mq1fs | t1_c2mpve7 | null | 1427649437 | 1 | t5_2fwo | null | null | null |
True | nirolo | null | It's a UI change that implies functionality that doesn't exist. The Address Book now looks like a book, but in no way behaves like a book. You can't turn pages, you can't bookmark anything. Your contact list is a scrollable list of people that no book can do.
To make it worse it has a UI mode that is completely unusable. If you look at the bottom there is a button that switches off "book mode" and removes the list of contacts leaving you with just a single contact sheet. What for? In this mode the only way to get to other contacts is to use the arrows at the bottom, but who searches through contacts like this?
So considering all of this why does it look like a book?
EDIT: In addition to all of that
Look at this one:
http://www.mac-guides-and-solutions.com/image-files/mac-os-x-snow-leopard-address-book-large.jpg
Now look at this one:
http://ryanmckern.com/wp-content/uploads/2011/07/Mac-OSX-Lion-Address-book.png
Now quickly tell me where are the contact groups in each one? Does the Lion version even support contact groups? Well it turns out the red bookmark thing is a button and not just decoration, there goes familiar UI elements. Because it has to look like a book you cannot display your contact groups, so you have to hide functionality from your user, which means they may never learn about it. | null | 0 | 1317059337 | True | 0 | c2mq1mt | t3_krv1k | null | t1_c2mq1mt | t1_c2mpuie | null | 1427649439 | 59 | t5_2fwo | null | null | null |
True | StrangeWill | null | >They hate having something familiar taken away from them
Yep that's me here, I'm _still_ familiarizing myself with where some things are (I obviously don't use Office that much, heh).
I've gotten used to it in Outlook through, so maybe I'll warm up and stop digging for simple things on Word/Excel. | null | 0 | 1317059402 | False | 0 | c2mq20m | t3_krv1k | null | t1_c2mq20m | t1_c2mpssz | null | 1427649444 | 3 | t5_2fwo | null | null | null |
True | majeric | null | Code Obfuscation is just *stupid*. "Let's celebrate making it harder to read code! YAY!" :P | null | 0 | 1317059419 | False | 0 | c2mq24t | t3_krpem | null | t1_c2mq24t | t3_krpem | null | 1427649447 | -9 | t5_2fwo | null | null | null |
True | omnilynx | null | None of those details is necessary to understand pointers, though. You could teach pointers by thinking of memory as a single flat array and ignoring the stack and program code data. All you really have to know is that all your data is stored in this memory array and a pointer is just a piece of data (and like all pieces of data, it's just a number) that represents the location within the array of another set of data. | null | 0 | 1317059429 | False | 0 | c2mq271 | t3_kogj4 | null | t1_c2mq271 | t1_c2m8jkn | null | 1427649447 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317059431 | False | 0 | c2mq27f | t3_ks0s7 | null | t1_c2mq27f | t3_ks0s7 | null | 1427649448 | 3 | t5_2fwo | null | null | null |
True | [deleted] | null | > But, you can't do this. You would have to be able to resolve infinitely to get a correct "%wrong"
I can't get the correct "%wrong" because it's a real number, and I don't have infinite memory to store all its digits.
But I can get correct bounds like "between 7% and 9% wrong". Which is bigger than "between 0.001% and 0.002% wrong".
> I'm pretty sure it doesn't work like that. We can all agree that .01 is smaller than .02 , but they are both the same distance from infinity
They are not the same distance from zero, which is what I'm measuring. I projected the interval `[1, +inf)` (resolution in pixels) to the interval `(0, 1]` (size of a pixel), and now I can easily measure and compare "distances to infinity".
Of course if you _don't want_ to compare different resolutions, nobody can force you to. But when you do want, that's quite easy to do and get meaningful results. | null | 0 | 1317059568 | False | 0 | c2mq2zr | t3_krpem | null | t1_c2mq2zr | t1_c2mpb44 | null | 1427649458 | 3 | t5_2fwo | null | null | null |
True | JavaLSU | null | See, this is the disconnect.
My wife didn't expect any change. She just said "Hey look, it looks like a notebook now. That's nice."
It's just more elegant with a silly little UI change. The average user doesn't actually expect a book. The see the spirals and think "That's neat".
You're giving them way to much credit for what they expect functionality wise. Programmers are not end users and have a hard time with this.
| null | 0 | 1317059594 | False | 0 | c2mq34t | t3_krv1k | null | t1_c2mq34t | t1_c2mq1mt | null | 1427649460 | 8 | t5_2fwo | null | null | null |
True | [deleted] | null | That's what she said. | null | 0 | 1317059675 | False | 0 | c2mq3ku | t3_krklz | null | t1_c2mq3ku | t3_krklz | null | 1427649465 | 1 | t5_2fwo | null | null | null |
True | notfancy | null | Thanks for the links! As promised, [my take](http://alaska-kamtchatka.blogspot.com/2011/09/yield-continue.html). | null | 0 | 1317059826 | False | 0 | c2mq4id | t3_kqi1v | null | t1_c2mq4id | t1_c2mgp7z | null | 1427649480 | 1 | t5_2fwo | null | null | null |
True | baddox | null | You can't have a programming language without syntax, and that's all "the idea that the format of the code is also code" is. In Java, you have to put a space between "public" and "static," or else the parser won't know what you're talking about. | null | 0 | 1317059903 | False | 0 | c2mq4y1 | t3_krpem | null | t1_c2mq4y1 | t1_c2mnmz8 | null | 1427649483 | 1 | t5_2fwo | null | null | null |
True | IRBMe | null | Once again, that's why it's a *heuristic*, not a *rule*, and why I said that having a method which is very long is an *indication* that the method is *possibly* too complex. | null | 0 | 1317059960 | False | 0 | c2mq59m | t3_krklz | null | t1_c2mq59m | t1_c2mpzir | null | 1427649487 | 1 | t5_2fwo | null | null | null |
True | baddox | null | Have you ever seen any halfway competent code in any programming language that's not indented? Everyone agrees you have to indent your code to make it readable, so why not let the compiler/interpreter use that indentation as real information? | null | 0 | 1317059967 | False | 0 | c2mq5az | t3_krpem | null | t1_c2mq5az | t1_c2mnysf | null | 1427649488 | 1 | t5_2fwo | null | null | null |
True | gregK | null | I prefer the more evocative class names TheOneThatManages, TheOneThatIsManaged and TheOneWeDoNotSpeakOf (it was a big hack). | null | 0 | 1317060055 | False | 0 | c2mq5so | t3_krzdp | null | t1_c2mq5so | t3_krzdp | null | 1427649494 | 57 | t5_2fwo | null | null | null |
True | baddox | null | Are you running Windows? TFA says it outputs a Windows format bitmap, which perhaps is incompatible with bitmap viewers in other operating systems. | null | 0 | 1317060075 | False | 0 | c2mq5ws | t3_krpem | null | t1_c2mq5ws | t1_c2momgt | null | 1427649497 | 0 | t5_2fwo | null | null | null |
True | djork | null | It's actually not "exactly" what Apple did. It's *not at all* what Apple did.
The OS X address book *looks* a bit like a book, but it has search, scrolling selection lists, various buttons, etc., that extend it so that it is not really a *book metaphor*, but just a book *style*. Same goes for the calendar app.
If you had no search, and no list of people, and had to turn pages to find contacts, then you'd have a book metaphor like Dick in the OP described. | null | 0 | 1317060115 | False | 0 | c2mq64v | t3_krv1k | null | t1_c2mq64v | t1_c2mpmsa | null | 1427649499 | 17 | t5_2fwo | null | null | null |
True | thecapitalc | null | So, who wants to run this for me so that I can print it our on a really large printer at work?
Like I am talking in the range of 30k pixels wide so I can print it 4 feet wide on a printer ~600 DPI. Actually, fuck it, we'll go higher DPI.
Or instruct me how I can run this to do it myself.
Edit: I figured it out. It is now generating a 15,000 x 10,000 pixel image. When I tried 30k x 15x it generated an error on me. | null | 0 | 1317060124 | True | 0 | c2mq675 | t3_krpem | null | t1_c2mq675 | t3_krpem | null | 1427649500 | 2 | t5_2fwo | null | null | null |
True | pnpbios | null | you should be able to run headless gtk applications with this, yes? | null | 0 | 1317060132 | False | 0 | c2mq68t | t3_krzdn | null | t1_c2mq68t | t1_c2mq0gc | null | 1427649500 | -1 | t5_2fwo | null | null | null |
True | pavel_lishin | null | It's a *game*. http://en.wikipedia.org/wiki/Code_golf | null | 0 | 1317060138 | False | 0 | c2mq69u | t3_krpem | null | t1_c2mq69u | t1_c2mq24t | null | 1427649500 | 10 | t5_2fwo | null | null | null |
True | JavaLSU | null | I'm not here trying to defend the new address book. I've never used it and it's not the point. My point is perceived value vs functionality.
The article makes fun of the fact that the notes font looks like a sharpie. That's genius. To make fun of that means that the author doesn't understand what end users want.
Create two exact same notes apps, one with a "sharpie" font and one with "arial".
See which one people like. Hell for arial, you can even select any font out of 100.
People don't want choice. They want a product that will work awesome right out the box. For everyone else, there's android. | null | 0 | 1317060168 | False | 0 | c2mq6e3 | t3_krv1k | null | t1_c2mq6e3 | t1_c2mq1mt | null | 1427649502 | 12 | t5_2fwo | null | null | null |
True | GreySim | null | There's also an [/r/vim](http://www.reddit.com/r/vim) if you wanted to cross-post this there. | null | 0 | 1317060170 | False | 0 | c2mq6ep | t3_kravz | null | t1_c2mq6ep | t3_kravz | null | 1427649502 | 1 | t5_2fwo | null | null | null |
True | [deleted] | null | Code golf (i.e. minimizing code size) is usually not the point of obfuscation. Look at the *shape* of the code in this instance. | null | 0 | 1317060197 | False | 0 | c2mq6jq | t3_krpem | null | t1_c2mq6jq | t1_c2mnsh1 | null | 1427649504 | 9 | t5_2fwo | null | null | null |
True | haskell_rules | null | One of the dominant technologies in Google PageRank is related to finding the eigenvector of a stochastic matrix which models links between pages. You aren't going to replicate this kind of thing efficiently unless you take the time to understand the mathematical concepts behind it.
Once you understand the concepts, you will see that the implementation is pretty hairy. You need to have a crawler following links and building your adjacency matrix, and an indexer to allow for quick, comprehensive substring search. In other words, you need to know how to code.
I'm wondering why someone that doesn't know math, and doesn't know how to program, would want to try to tackle this endeavor? | null | 0 | 1317060233 | False | 0 | c2mq6re | t3_krzys | null | t1_c2mq6re | t3_krzys | null | 1427649507 | -5 | t5_2fwo | null | null | null |
True | djork | null | > Developers certainly don't, because it's not (generally) their jobs. Who does have time for it? The UX folks, because that is (or should be) their job.
Why set the bar so low? Why can't we ask programmers to give a shit about (visual) design and UX?
Design is something that can be learned and improved with study and practice. We should be encouraging developers to figure this stuff out so we don't have all of these Dicks from special "UX firms" running that side of the show.
| null | 0 | 1317060326 | True | 0 | c2mq7aa | t3_krv1k | null | t1_c2mq7aa | t1_c2mpk0d | null | 1427649514 | 2 | t5_2fwo | null | null | null |
True | genpfault | null | And that is Programming...how? | null | 0 | 1317060330 | False | 0 | c2mq7bd | t3_ks0j6 | null | t1_c2mq7bd | t1_c2mpz15 | null | 1427649514 | 3 | t5_2fwo | null | null | null |
True | nirolo | null | But did the UI change make things easier for her or was it just "Oh that looks pretty"?
The thing that Apple had always been good before was making sure their UI conveyed information in a fast minimal way. Animations have a purpose as well as making stuff look pretty and shiny.
The genie effect on windows for example shows you where your window went.
The zoom effect on the dock shows you which icon your mouse is currently hovering over, the bouncing icon shows the app is starting.
These new interfaces immediately disconnect the App from the rest of the system forcing the user to think about where things are. Never make the user think, not even for a split second.
| null | 0 | 1317060341 | False | 0 | c2mq7df | t3_krv1k | null | t1_c2mq7df | t1_c2mq34t | null | 1427649514 | 23 | t5_2fwo | null | null | null |
True | jsproat | null | # generates mandelbrot set
_ = (255,
lambda V,B,c:
c and Y(V*V+B,B, c-1)if(abs(V)<6)else(2+c-4*abs(V)**-0.4)/i)
v,x=1500,1000;
C=range(v*x);
import struct;
P=struct.pack;
M,j ='<QIIHHHH',open('M.bmp','wb').write
for X in j('BM'+P(M,v*x*3+26,26,12,v,x,1,24)) or C:
i,Y=_
j(P('BBB',
*(lambda T:(T*80+T**9*i-950*T**99,
T*70-880*T**18+701*T**9,
T*i**(1-T**45*2)))
(sum([Y(0,(A%3/3.+X%v+(X/v+A/3/3.-x/2)/1j)*2.5/x-2.7,i)**2
for A in C[:9]])/9))) | null | 0 | 1317060366 | False | 0 | c2mq7ii | t3_krpem | null | t1_c2mq7ii | t1_c2mpnbz | null | 1427649516 | 33 | t5_2fwo | null | null | null |
True | kraln | null | It happens maybe once every three months, when I'm going after a part of the system I haven't visited in a while. | null | 0 | 1317060404 | False | 0 | c2mq7qy | t3_kr2x5 | null | t1_c2mq7qy | t1_c2mq0ur | null | 1427649519 | 0 | t5_2fwo | null | null | null |
True | [deleted] | null | For some people it's fun. It also gives you a better understanding of the language as you find quirks that assist with obfuscating. | null | 0 | 1317060509 | False | 0 | c2mq8c7 | t3_krpem | null | t1_c2mq8c7 | t1_c2mq24t | null | 1427649528 | 4 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317060544 | False | 0 | c2mq8kt | t3_krpem | null | t1_c2mq8kt | t1_c2moj8s | null | 1427649531 | 1 | t5_2fwo | null | null | null |
True | Campers | null | How far are we from implementing web apps in GTK and putting them online for anyone to use?
With something akin to a chroot environment would there be any technical problems in doing it? Aside from memory consumption, of course.
| null | 0 | 1317060637 | False | 0 | c2mq95e | t3_krzdn | null | t1_c2mq95e | t3_krzdn | null | 1427649538 | 10 | t5_2fwo | null | null | null |
True | makaferri | null | it's an incredible tutorial!! | null | 0 | 1317060706 | False | 0 | c2mq9ko | t3_krzd8 | null | t1_c2mq9ko | t3_krzd8 | null | 1427649547 | 9 | t5_2fwo | null | null | null |
True | nirolo | null | I just posted this, but it seems to have disappeared. Reddit is acting strange, so I apologise if it is a duplicate
But did the UI change make things easier for her or was it just "Oh that looks pretty"?
The thing that Apple had always been good before was making sure their UI conveyed information in a fast minimal way. Animations have a purpose as well as making stuff look pretty and shiny.
The genie effect on windows for example shows you where your window went.
The zoom effect on the dock shows you which icon your mouse is currently hovering over, the bouncing icon shows the app is starting.
These new interfaces immediately disconnect the App from the rest of the system forcing the user to think about where things are. Never make the user think, not even for a split second.
| null | 0 | 1317060805 | False | 0 | c2mqa3n | t3_krv1k | null | t1_c2mqa3n | t1_c2mq34t | null | 1427649550 | 2 | t5_2fwo | null | null | null |
True | [deleted] | null | [deleted] | null | 0 | 1317060872 | True | 0 | c2mqahc | t3_krzdp | null | t1_c2mqahc | t3_krzdp | null | 1427649556 | 34 | t5_2fwo | null | null | null |
True | frezik | null | Except that it's not always clear when people use tabs instead of spaces, which can foul Python/Ruby up very badly. So then you go and make policy to enforce the use of one or the other, and set your editor to make the difference obvious (perhaps spaces show as a dot that's smaller than a period). Except, I could have just as easily enforced an indentation style with policy in a curly-brace language, and set my editor to indent to that style for me.
The argument ends up being a wash in the end.
Curly-brace blocks are also a bit easier to parse. Python's tokenizes the whitespace into INDENT symbols, which can then be handled by the grammar in a similar way that curly braces are. In a curly-brace language, the tokenizer doesn't have to do anything and the grammar works on its own.
In the end, whitespace indentation is a feature I can tolerate, but don't necessarily like. | null | 0 | 1317061023 | False | 0 | c2mqbcp | t3_krpem | null | t1_c2mqbcp | t1_c2mo1k4 | null | 1427649566 | 1 | t5_2fwo | null | null | null |
True | KPexEA | null | I wrote one in javascript using the HTML5 canvas, you can play with it [here](http://www.scale18.com/canvas2.html) | null | 0 | 1317061122 | False | 0 | c2mqbut | t3_krpem | null | t1_c2mqbut | t3_krpem | null | 1427649574 | 3 | t5_2fwo | null | null | null |
True | bcain | null | > Bearing in mind, of course, that some code is not covered (catch(...))
Done correctly, you should be able to create tests or scenarios which execute those catch blocks and add to the coverage metric. | null | 0 | 1317061227 | False | 0 | c2mqcdl | t3_krklz | null | t1_c2mqcdl | t1_c2mptzl | null | 1427649580 | 1 | t5_2fwo | null | null | null |
True | jmdavis | null | An array in D is essentially a struct with a ptr and a length. In the first case, you're just decrementing the length. In the second case, you're creating a new array struct with the same ptr and a length which is one shorter and then assigning that to the original array struct. The compiler will optimize out the temporary and the result will be exactly the same.
If you want to better understand how arrays and slicing work in D, then read [this article](http://www.dsource.org/projects/dcollections/wiki/ArrayArticle). | null | 0 | 1317061289 | False | 0 | c2mqcpo | t3_kqoz2 | null | t1_c2mqcpo | t1_c2mnzx0 | null | 1427649585 | 2 | t5_2fwo | null | null | null |
True | nirolo | null | See you are putting the choice in the wrong place. You are now saying "Here you go developers, make things how you like", and as you have pointed out, developers don't know Jack about their users.
So the Address Book now looks like a book, iCal looks like a note pad, your notes app can look like post-it notes, maybe we can make the browser look like a TV. Lets just give every app its own unique personality and try and make it look like a real world object.
Can you see what happens if you continue this trend? Sure, everything looks like its real world counterpart, but now stuff either has to be limited to real world functionality, or you have to fudge it and break your "real world" interface. On top of that everything now works differently. Let's just turn OS X into the MySpace of operating systems.
There is a reason why UI guidelines exist. It's not for the developer to change them unless there is a very good reason for it.
| null | 0 | 1317061421 | False | 0 | c2mqdhh | t3_krv1k | null | t1_c2mqdhh | t1_c2mq6e3 | null | 1427649595 | 21 | t5_2fwo | null | null | null |
True | tiftik | null | I use clang_complete with Vim, which is on par with (if not better than) Intellisense. | null | 0 | 1317061430 | False | 0 | c2mqdjc | t3_kr2x5 | null | t1_c2mqdjc | t1_c2mpqpo | null | 1427649595 | 2 | 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.