1,054 karma · joined September 20, 2012
That made the rest of the interview more believable and trustworthy. Fair, balanced and humorous
I agree that it's a fine line between simplifying a topic for "the general masses" and dumbing it down to something out of the movie Idiocracy. However, I think that Oliver has done a fair job of making it easier to relate to topics people otherwise wouldn't.
(He could use a touch less cursing to add some gravitas where needed, but that's a matter of personal taste I guess)
Seems like a very common scenario they don't support any longer, for technical reasons? for not wanting people to listen to music that way?
I did find it odd that "Ruby" (what became VB) was suppose to be the "shell for windows " and allow user to "design their os". Maybe I misunderstood that part because it sounds like a recipe for disaster :)
http://channel9.msdn.com/Series/VisualStudioDocumentary/The-...
I give great kudos to Alan Cooper, his book "The Inmates are running the asylum" was a paradigm shift for me. Once you've read it you have a little Alan inside your head for the rest of your life, telling you how stupid, impolite and lazy most software is. It's annoying but highly effective.
Really recommend it for anyone who hasn't read it. He's a bit rabid in his aversion to developers designing, but if you can look past that it contains many gems
I think its one of those things when Microsoft gets around to focus on it they'll "fix it" but for now, crappola.
To be fair though there are some more subtle accents, like Gray and Blue Gray than can be used
Anyways, highly recommended, if nothing else to get insight in human patterns regarding living spaces and communities
It was good because documentation was tied to the source control and easy to locate and read when you were working on the project.
It's easy that wiki's become neglected and forgotten if there's not someone that "cracks the whip" so to speak so I think any way to lessen the friction and bring it into the coding environment is a good one
http://www.slate.com/articles/double_x/doublex/2010/03/can_y...
That together with the old chestnut "seek first to understand then to be understood" to ensure that you respect and understands their position are real game changers.
Its funny and scary how important these kind of social and interpersonal skills are working in any corporation. Yet often are lacking and leads to a lot of unnecessary friction.
It's something I almost wished was taught in schools, if only so they could recognize the patterns later when they go into working life.
I'm pretty sure there are good objective metrics both for readability and maintainability, they might not be the only aspects but calling it subjective is going too far.
For instance maintainable code could be said to minimize side effects, be somewhat modularized and be as compact as possible while being readable. I find it hard that anyone could claim the opposite and be right "as a matter of taste"
But in all seriousness, projecting issues as character flaws is a really destructive thing to do, not just in programming but in any relationship. It's a really good habit to avoid it whenever possible.
I read somewhere (I think it was Blink) that marriage counselors could tell which marriages would fail by observing those that generalized around their spouses character rather arguing about the issues, ie "You always..."
Often it's also a question of how things are composed, not just how much they're abstracted away. If you're use case dictates that you need to separately control something that's been composed into one thing then you're usually out of luck
Deck construction really is one of the more creative aspects of MtG where you can create new kinds decks or twists on old ones
I think the most infuriating thing about MtG was the obsolation of whole sets, I get that's its' smart business from WoT and there are some tournament forms where you can use different sets... but still, felt a little bit like playing a game you never could win :)
Must give credit to MtG for introducing me to a world of cutthroat deal-making that would give UN a run for their money. Trying to saw together swaps with other collectors could be very challenging and rewarding. You learned the hard way the times you were "scammed" and someone got the better of you.
Some of the "voice" of the author might indeed be lost just because good copy editing normally is about 20% of a draft , but it could be argued that what's left is better for it.
I agree though that one should try to keep the overall tone/style the same
If you think I'm using the term wrong I'd appreciate a reference, thanks
http://en.wikipedia.org/wiki/Entropy_%28information_theory%2...
I actually think you should be verbose to the point of building a DSL-like syntax for your solution to improve readability. Even for instance addint small properties and methods that simplifies reading. It's much easier to read
if (CanWrite && WillFitDisk)
than if (File.Position != File.EOF && Disk.AvailableSpace > Buffer.Size)
Even if reusability of those small methods and properties aren't highSo I see it as "compact" as possible as long as you fulfill understandability and maintainability.
Each part is interconnected to ensure quality and efficiency:
1. Maximum entropy means that your codebase should contain as much concentrated "information" as possible in relation to its size. Free of copy & paste code and repetitions that can be reused in libraries, methods and classes. This ensures less code to maintain , easier to spot bugs and easier to spot patterns.
2. Understandability (that includes readable): That means no blob classes or methods with an infinite number of purposes. Each layer of abstraction simple enough to keep in mind in its entirety.
3. Maintainable: It should be bug resistant, making it hard to do the wrong things and easy to do the right (for example putting required parameters into constructors rather than fields or properties). You should be able to replace and/or modify individual parts without side effects. Having as little code as possible also helps with this.
I think "covered by automated" tests are nice ... in some cases. It is far from a rule that they're a panacea for every kind of project, code and/or situation nor are all kinds of code wort the effort (models & algorithms: yes, UI: usually no). It also depends on the team and methodology.
That good code does what its suppose to do and should be bug free should be a given :)