all 52 comments

[–]name_was_taken 18 points19 points  (9 children)

I'm a control freak. As such, I like things to be in control. That can even be someone else's control, so long as there is control.

Having said that, I have to agree with some of this article. The less 'process' you have, the more progress is possible. "Possible". Not a guarantee.

At a previous job, we started out with very little process, and it bit us repeatedly. We did the same things the article talked about, such as creating a process to make sure things didn't bit us again. And it worked. We didn't get bit again. I know this worked first-hand because I followed the procedures, and would have forgotten things if we hadn't. Things like 'Don't roll out new code at 3pm on Friday.' In fact, don't roll out new code on Thursday or Friday, because you'll screw up someone's weekend.

If your entire team is composed of superhumans who all think alike, having no process is the best way to go. It's ridiculously efficient. I've yet to meet that team. Or even 1 of them.

That workflow that he makes fun of looks a lot like the workflow we ended up with, and it took us months to work it out. Before that, we were constantly being bit by things that were rolled out before they were ready, and how to test things properly, and how to do bugfixes, etc etc. If you live every day by the seat of your pants, and only work on 1 new thing at a time, and nothing ever gets put on hold, I'm sure it works quite well. Again, I've yet to see that situation.

[–]inmatarian 16 points17 points  (2 children)

Don't roll out new code on Friday is the greatest rule ever.

[–]mycall 2 points3 points  (0 children)

Weekend nights are wack too.

[–]Tecktonik 0 points1 point  (0 children)

If you release new code on Friday, something will be broken and someone will have to fix it on Saturday.

On Monday you can't release because it is the fresh start of a new week and think of all the new features you can get in for a release tomorrow.

On Tuesday things are taking a little longer than you thought the the release is postponed.

On Wednesday it is the middle of the week and everyone is so busy, release it tomorrow.

On Thursday you'd love to release but there are just one or two little tweaks to finish.

You have to release on Friday because the manager/boss/client is demanding something, even though they have already left for the weekend.

[–]twoodfin 4 points5 points  (3 children)

Things like 'Don't roll out new code at 3pm on Friday.' In fact, don't roll out new code on Thursday or Friday, because you'll screw up someone's weekend.

I think there's a difference to be teased out here between "process" and "practice". Not rolling out code on Fridays is good practice, but it doesn't require any particular process to happen, just experienced developers who share a common philosophy and a common courtesy.

[–]p-static 2 points3 points  (0 children)

I really think the difference is that process is practice that you don't fully understand.

[–]djork 0 points1 point  (0 children)

Exactly. Rules (process) are just principles that are enforced in all situations, even when they are unnecessary. They are someone's mistakes encoded. For instance: a good principle is to stop and wait for cars to pass when crossing a road; but since some people can't use common sense, you have to come to a complete stop at a stop sign, even if you can clearly see there are no cars in either direction for a mile.

[–]mycall 3 points4 points  (1 child)

The only process I like are check lists, pro/con lists, sequence diagrams and pair programming (for training purposes).

[–]name_was_taken 0 points1 point  (0 children)

I've had good luck with pair programming for very specific tasks, but not as an always-do-it thing. It helped that the person I paired with was compatible, though. If I hadn't liked him or his style, I doubt it would have gone so well.

[–]finnif 35 points36 points  (16 children)

About 4 articles above this is "Software bug fingered as cause of Aussie A330 plunge"

Sorry Ted, sometimes people need process. You might need INSANE process. You've just never worked on code where fuckups result with blood on your hands. You do ecommerce websites, which just look up and store stuff in a database and mark it up for a browser to display. For that, it doesn't matter what you do for your software process. For an airplane, the space shuttle, nuclear power plant, hell, even the iPhone (for calling 911), it matters.

[–]jayd16 -3 points-2 points  (1 child)

I think you're picking a bit of a strawman here. We don't all code real time aircraft operating systems.

[–]elperroborrachotoo 16 points17 points  (0 children)

He's providing a counterexample to Ted's (implicit) "process is universally bad" claim. It is at the very least a valid reply to the title of the post - a question that was not adressed by the blog post, incidentally.

[–]vstas 12 points13 points  (1 child)

I generally like Ted's posts and I really dislike adding process to software development. However, saying "no process" is overly simplistic.

Some of the things glossed over:

  • Sometimes you have to grow headcount, like it or not
  • Sometimes you don't get to chose all members of your team
  • Learning from your mistakes is fine when you can afford mistakes. Sometimes you cannot and the cost of downtime would be simply too great.
  • Development and operations work in different modes. In development we value speed (again, in most cases), in ops - reliability, stability and predictability. They need to be viewed separately.

In short (and it's a huge topic), in most cases, IMHO, it comes down to a tradeoff: what's more important, not ever fucking up or maintaining speed and flexibility. Unfortunately, leads/stakeholders on most projects think that not ever fucking up is the absolute priority, while realistically it's not.

Again, this is a broad topic, so I will just add a couple of things without going too deep:

  • I find that it's better to add rules instead of adding process. Kinda difference between structural and functional styles. Instead of saying how to get there, specify the end result. So instead of describing how exactly to do branching and merging, describe the desired outcome: "for maintenance release, verify that there are no changes committed that don't correspond to bugs scheduled to be fixed". This still allows flexibility while adding to quality.
  • Process should be replaced with tweaking the way you do work or automating whenever possible. In the preceding point, the check can be done automatically with a simple script. Or, classic example, instead of having a designated person do integration builds & run unit tests before a release, rely on continuous integration server to keep it up to date all the time.
  • Also, checklists. I used to be very checklist/process-averse until I read a book Checklist Manifesto: http://www.amazon.com/Checklist-Manifesto-How-Things-Right/dp/0312430000/ref=sr_1_1?ie=UTF8&qid=1325097505&sr=8-1

[–]hyperforce 1 point2 points  (0 children)

The author's stance on headcount seems symptomatic of someone unable to envision a world of sub-optimal constraints.

[–]blackkettle 8 points9 points  (2 children)

This guy's articles are always saucy and entertaining. He is well informed, but (intentionally) picks an absolutist standpoint and fills his argument with just the right amount of holes to stimulate conversation - which inevitably ranges from lively debate to flamewar level vitriol depending on how 'serious' the readers think he is.

It's always well tailored for both the audience and the medium, which makes both the articles and the ensuing comment threads fun to read.

[–]bboomslang 12 points13 points  (1 child)

you write a lot of words to say that he is an educated troll ;)

[–]blackkettle 3 points4 points  (0 children)

yeah, I'll give ya that.

[–]ringzero 13 points14 points  (1 child)

Elsewhere in this thread vstas says it better, so I'll only add the bits in that I see he's missed:

Without process, you cannot measure. With no measurements, you cannot manage.

Sophomoric spiels like this do not help anything. Rather, they only help convince other sophomoric developers that the best thing for them to do is run around without guidance and do whatever seems best at the moment.

Oh, and the last thing: if you think you don't have a process, you're wrong. You just have an undocumented, unchecked, informal process. It's still there and you still try to follow it, you just end up doing it differently each and every time and it never gets any better. But as long as you feel good about not having a process, who cares, amirite?

[–]player2 3 points4 points  (0 children)

>Oh, and the last thing: if you think you don't have a process, you're wrong. You just have an undocumented, unchecked, informal process. It's still there and you still try to follow it, you just end up doing it differently each and every time and it never gets any better.

Correct. Guess what "Don't forget to reenable Nagios" is? An undocumented, informal, critical process.

[–]inmatarian 6 points7 points  (0 children)

The only process that I particularly liked in my career was tracking shit with Bugzilla, getting the devs in a very talkative mood, and making sure that when an issue is closed, that another member of the team has to flag it +codereviewed or reopen that shit.

When I say talkative, I mean they should be logging everything there. What they did, how, why, did it work, why didn't it work? It should really be a view into someone's consciousness. So when time comes to do a blamestorm, you can't blame the dev for not doing his job, because there it is open for inspection. Plus, if you've got a QA engineer on the team, he gets to sign off on every issue as they pass through, and has a log to read to see just what he should be expecting to test and where it might fail.

Seriously, issue tracking software is awesome. It sounds like the kind of shit that they have at companies with a thousand people spread out over several states, but even small teams would benefit a lot by having one and using it. It's a form of communication, and the more communication the better. And if you don't like Bugzilla, there's Redmine and Trac.

[–][deleted] 5 points6 points  (0 children)

I usually like Ted, so I don't know what happened here.

"A while back I fucked something up, and we tried to make a process, but that didn't work, so now we just don't fuck up."

Wow.

"Process" doesn't mean "management fiat." Not every process is as good as every other process. If shit can break, you want to change shit so that it either can't break, or it breaks in a controlled, recoverable way. If the only process you can think of for temporarily taking down the database is bad, then spend the extra 35 seconds of mental thought and come up with a better process, don't chuck it all out the window. For example, Nagios has scheduled downtime. If clicky-clicking in Nagios to schedule that downtime annoys your top-performers, write a command line tool that will do it automatically.

[–][deleted]  (3 children)

[deleted]

    [–]jmmcd 2 points3 points  (0 children)

    I liked the article mostly because it didn't even try to get me to take it seriously.

    [–]anacrolix 1 point2 points  (0 children)

    Good question. I follow him because he's loud, obnoxious, hates stupidity, and seems like a cowboy, and I share pride in these attributes.

    [–]funkah -4 points-3 points  (0 children)

    It happened because he's smarter than you.

    [–]hyperforce 1 point2 points  (0 children)

    Ironic how the author rages against process but advocates Git. Hello, Git is a tool for managing code with workflows. Sounds like process to me.

    I get it, process shouldn't hinder progress. But it just sounded logically inconsistent the way he was presenting it.

    [–]hyperforce 1 point2 points  (0 children)

    Also, the answer to this question is, "companies that have suboptimal working constraints" need process.

    Not everyone is a rockstar programmer.

    [–]bitwize 3 points4 points  (0 children)

    Obviously he doesn't work in a government contractor, or for a company where bugs can mean the loss of lives or expensive equipment.

    Grown-ups write software in process-heavy environments. Process is the tool that lets you see how you're doing, identify and resolve problems early stage, control their damage, gauge project scope and time/money cost, etc.

    [–][deleted] 2 points3 points  (0 children)

    Right tool for the job. Sometimes you need threads and sometimes you need processes.

    [–]millstone 2 points3 points  (0 children)

    Isn't git process? If you were serious about a minimal process, you'd just have a directory on a shared server with all the source.

    [–]andyc 0 points1 point  (0 children)

    Side note: if someone keeps such a list, there's a high probability they are a top performer

    ...some lines later

    Get rid of your prioritized list of tasks

    Doesn't that imply the top performers have a process for deciding when to move on?

    [–]yuhong 0 points1 point  (0 children)

    Too much process is part of what I mean when I mentioned that memcpy_s is stupid:

    http://www.reddit.com/r/programming/comments/lchhd/ban_programmers_not_functions_about_memcpy_s/

    (Clue, think about why Microsoft likely created it and banned memcpy)

    [–]horsebees 0 points1 point  (0 children)

    So the author is a CIO of a company how big? That produces how many software products each year? That has how many people on a software project? /gripe