bguthrie

It means that a bunch of people who once thought they were somehow above or apart from politics find that they are not, and that the things that happen in the world constitute news of real interest to hackers. That's growth.

It's also misleading to talk about this as an issue of ideological purity. People talk about purity when the politics of the public figure in question are not extreme enough. The problem is that she helped start a war that killed rather a lot of people, none of whom are now able to lend their voices to the discussion, and those who wish to remember those people are obliged to speak on their behalf. You don't mind her politics, and that's cool. But no one's forcing me to pay Dropbox anything. So I won't anymore.

    As a Rails developer, I've become tired of messing with
    ruby versions, gem dependencies, bundle installations,
    deploy-time asset precompilation on my servers,
    etc. ... Basically, what I wanted was a Heroku-like 
    workflow that generates and hosts debian packages, 
    which is what  exactly what PKGR provides.

But finding bugs like the above is TDD's bread and butter. TDD dictates specifically that the test must be written first, that it must be isolated to a particular spot as much as possible, and the dumbest piece of code possible must be written in order to allow the author to move on to writing the next test. Someone TDDing this method would stub out any required external state in order to focus only on the piece of code in front of them.

The final system may not be correct––you must still perform high-level testing as you always would, and you must understand the rules of the system you're building. But you're apt to avoid the simple stuff.

I agree that Java has its uses, but I've always thought that this was one of the weaker ones. Java's poor syntactical support for clarifying abstractions like lambdas or rich data structures like hashmaps makes small projects larger than they need to be. The answer isn't to find a way to manage large projects; it's to find a way to make them smaller. Size is poison, and automated refactoring is no cure.

Edit: Asymmetric, not asynchronous.

    I've had to quit a couple of jobs due to the fact that 
    staying there maintaining the same old code base ... 
    would have been what resulted in my burnout.

And believe it or not, legislators do watch those calls and emails––especially calls. All of them of them will tell you that the perception of a groundswell of support or opposition to an issue is enough to start to sway minds on Capitol Hill. Don't give in to cynicism.

Every system is built on abstractions. You can argue about the value of understanding particular systems, but we are well past the point when any one person can or should understand them all. No one is arguing that it's acceptable to learn only the highest-level abstractions. But it is acceptable to let somebody else worry about some of the lower-level ones.

People who don't focus on understanding engineering systems often focus on understanding other systems––team dynamics, for example, or business needs. I've met a lot of developers who only cared about learning the technical side, and were happy to look down on developers who didn't feel the same. Is that wiser, somehow?

"The Scunthorpe problem occurs when a spam filter or search engine blocks e-mails, forum posts or search results because their text contains a string of letters that are shared with an obscene word. While computers can easily identify strings of text within a document, broad blocking rules may result in false positives, causing innocent phrases to be blocked."

As for the article, I'm thankful. If my relatives won't listen to me, maybe they'll listen to the New York Times editorial board.

And no, people didn't "just do their jobs." Management methodology isn't a new idea.

There is no hiding from a pair.

If the problem domain you're trying to grapple with is dominated by algorithms, an idiom that prefers verbs to nouns may be helpful.

If you're working in a very complex business domain, where the algorithms aren't especially interesting but the relationships between entities are, nouns are helpful.

Clojure and Haskell programs often utilize named types. Several OO languages have recognize the need for first(ish)-class function management. Ruby, Python, and Javascript are all good examples of languages that have attempted some compromise between the two. They are justifiably popular.

Good OO code isn't as different from good FP code as most partisans imagine. Remember that all good code has to satisfy at least three audiences: the computer, fellow programmers, and third-party consumers (who may or may not be either of the above). They all have different needs. Don't discount the importance of nouns for that third category.

The ads are ridiculous because no one wants to have to work at their kid's soccer game. But there are, I'd suggest, a fair number of people who'd like to attend the game but don't have that choice. Framed that way, remote work is freeing. The trouble with the ads is that they frame that work as some kind of virtuous shackle-extension rather than an arguably-necessary evil. That's a frame well worth pushing back on.

My primary way of achieving reuse, as a developer, is through templating and partials and helpers; they're what I use to avoid runaway repetition of styles, which means that redundant Bootstrap class usage isn't often a pain point. But keeping classes inline does make it easier for me to debug layout problems at a glance, where relationships between elements are clear. Those classes might not have semantic value to the consumer of the page, but they certainly have semantic value to me. And most of the time, I care more.

Large CSS files, even semantic ones, are difficult to maintain, and often give you little feedback on the meaningful relationships that elements have with each other. Pure semantic markup is a myth: web pages are structured documents, and that structure has an impact on style, which is constrained by the limited descriptive power of CSS itself.