Please create an account to participate in the Slashdot moderation system


Forgot your password?
Programming IT

How 'DevOps' Is Killing the Developer 226

An anonymous reader writes "Python guru Jeff Knupp writes about his frustration with the so-called 'DevOps' movement, an effort to blend development jobs with operations positions. It's an artifact of startup culture, and while it might make sense when you only have a few employees and a focus on simply getting it running rather than getting it running right, Knupp feels it has no place in bigger, more established companies. He says, 'Somewhere along the way, however, we tricked ourselves into thinking that because, at any one time, a start-up developer had to take on different roles he or she should actually be all those things at once. If such people even existed, "full-stack" developers still wouldn't be used as they should. Rather than temporarily taking on a single role for a short period of time, then transitioning into the next role, they are meant to be performing all the roles, all the time. And here's what really sucks: most good developers can almost pull this off.' Knupp adds, 'The effect of all of this is to destroy the role of "developer" and replace it with a sort of "technology utility-player". Every developer I know got into programming because they actually enjoyed doing it (at one point). You do a disservice to everyone involved when you force your brightest people to take on additional roles.'"
This discussion has been archived. No new comments can be posted.

How 'DevOps' Is Killing the Developer

Comments Filter:
  • whine (Score:4, Insightful)

    by phantomfive ( 622387 ) on Tuesday April 15, 2014 @10:08PM (#46763355) Journal
    Python guru Jeff Knupp should go find a job where he can program, and not worry about ops. Simple solution.
  • Re:whine (Score:5, Insightful)

    by Anonymous Coward on Tuesday April 15, 2014 @10:13PM (#46763389)

    100% inclined to agree. DevOps is not really about your best and brightest pure programmers, but taking all of your jack-of-all-trades guys who specialize in "making shit work" and allowing them to keep things working.

  • by fractoid ( 1076465 ) on Tuesday April 15, 2014 @10:20PM (#46763417) Homepage
    This sysadmin/scripter/system architect/DBA role exists in virtually every company that has a core business other than IT or software development. Even in a very large multinational, there's more utility in having one "Mr Wizard" in each business unit than there is in having a room full of software developers somewhere far away from the rest of the business.

    It really is a support role and it's more an outgrowth of system administration than it is saddling your brightest software guy with managing the mail server. Of course, it's possible to get stuck in that role because there's nowhere to go from there, but it's a niche that suits some people. If it doesn't suit you, then move.

    It's also a distinct role from the "do everything guy" at a startup, because at a startup everyone is multitasking and as the startup expands, new people are hired to take on some of these roles. DevOps is a role in itself.
  • Nothing new here (Score:5, Insightful)

    by nitehawk214 ( 222219 ) on Tuesday April 15, 2014 @10:20PM (#46763427)

    Seen this many many times before. Cheap companies that have lots of developers and are too cheap to hire experienced admins... or an IT shop that thinks they can have the IT guys program instead of hiring proper developers. "hey, you work with computers, you guys can all do the same stuff, right?" Wrong.

    While I have known developers that can sysadmin, and admins that can program... they are the exception not the rule. Quality suffers when you force people into jobs they are not qualified for. Companies know this, and they simply don't care as long as the managers think they are saving money.

  • Oh please... (Score:4, Insightful)

    by acroyear ( 5882 ) <> on Tuesday April 15, 2014 @10:28PM (#46763471) Homepage Journal

    You don't force your brightest people to take on additional roles - that is the whole point of a devops team in the first place. Making developers argue about deployments and sending builds to QA and managing your GIT server and development and QA databases and managing your bug tracker is exactly what your developers should *not* be doing, especially if those scripts necessarily have to be in a different language than your application. Sure, your lead developers and architects work with the devops team to support them so they can in turn support you, but that's as far as the relationship goes.

    The way we used to do it, where every senior architect is also responsible for all of those other functions (and has to take the time from his team members below him to help build all that out), is exactly how you stop architecting your software: your leads spend so much time trying to automate the drudgery they aren't improving the app.

    They aren't improving the app because all of their brainpower is no longer focused on the *customers'* problems, but rather their own and their teams. That isn't a good use of their time. Hiring smart people who need to understand the application and its environment, but are good at scripting these other languages of automation, frees up your team leads to doing what they did before and do best: focus on the application and getting the team to produce the code that serves the customers' needs.

  • by putaro ( 235078 ) on Tuesday April 15, 2014 @10:29PM (#46763475) Journal

    There's definitely truth to what he's saying but it cuts the other direction as well. Having your lead guru developer swapping disk drives on a machine isn't the best use of his time. However, I've also seen environments where the developers can't/won't/aren't allow to do the system admin tasks and wind up waiting around or being frustrated when their development systems have a problem. Likewise, with QA - I've seen developers that will just toss any old crap over the wall and expect QA to catch all of their bugs. And, developing tests is often software engineering, often complex software engineering that needs an experienced developer to establish at least the outline of how everything works.

    Personally, I expect any developers I'm working with to have at least basic sys admin abilities and know how to setup/fix any other part of the stack they might touch. Those skills should be used when working with the dev systems and in establishing the base line for production. I would then expect that someone who is more specialized in those other roles to actually setup and run production and also be available when the developers get in over their heads on system admin, hardware troubleshooting, etc. In the same way I would expect a systems admin to at least be able to write a script to automate something and not go running to the developers for everything.

    For test development, I always like to set groups against each other and develop the test suite for each other's code. Most people are a lot more comfortable and eager to break someone else's code than they are their own.

  • Re:whine (Score:5, Insightful)

    by Ice Station Zebra ( 18124 ) on Tuesday April 15, 2014 @10:38PM (#46763523) Homepage Journal

    You forget about the ops part of devops. A lot of ops people need to be made to care about what is running on the boxes they are supporting. By knowing more about what is going on it can help then priortize the work which they are most experienced at, along with helping the "brightest pure programmers" understand why the cool solution they developed is a POS in production.

  • Re:whine (Score:5, Insightful)

    by mlts ( 1038732 ) on Tuesday April 15, 2014 @10:58PM (#46763661)

    I have seen some companies have their developers given autonomy, with their own DevOps, mainly because it allows for what is needed to get granted. New subnet for lab testing? It is a lot easier to get a DevOp guy to configure the VLAN for it than to submit a ticket to a different organization that isn't connected at all, nor knows what needs done.

    Of all the organizations in a company, dev needs the loosest reins (while still keeping separation so that the loosened policies don't allow for a security breach to compromise other departments.) The other department that needs autonomy is QA, because $DEITY knows what needs to be tested against.

    So, having an autonomous DevOps means that the dedicated programmers have people that know what they want/need, and have the ability to get that.

    In my experience, this does seem to work and work well in SMBs that are not just hiring H-1Bs or offshoring their entire dev department in toto. Larger companies, depending on corporate culture, not so much. Dev and QA should be autonomous. They have to be because that is where things get invented and bugs get squashed.

  • DevOps (Score:1, Insightful)

    by ShaunC ( 203807 ) on Tuesday April 15, 2014 @11:07PM (#46763701)

    Yet another buzzword invented by some CIO/CTO somewhere in an effort to consolidate multiple job roles and eliminate warm chairs. No surprise that its genesis seems to be in the startup world.

    "DevOps" is a fucked up amalgam of the developers, the DBAs, the system admins, the mail admins, the storage and backup admins, and sometimes the field techs... All to extract more work from fewer people for less money.

  • Re:Author is dumb (Score:5, Insightful)

    by fractoid ( 1076465 ) on Tuesday April 15, 2014 @11:19PM (#46763785) Homepage

    I'm a senior developer at a 21 year old startup that does C# thick clients over Microsoft SQL back ends.

    At a what? Are you at a 21-year-old company or are you at a startup?

    Or are you at a 21-year-old company that pretends to be a startup when they say things like "hey guys we're a startup so can you work this weekend?"

  • Re:Oh please... (Score:5, Insightful)

    by dnavid ( 2842431 ) on Tuesday April 15, 2014 @11:25PM (#46763819)

    The problem that others are having with DevOps is that they seem to be defining it differently than you are. What you wrote makes sense but the scenarios people are complaining about don't sound at all like your definition.

    That's part of the problem, yes. DevOps started off with reasonably laudable goals: to promote a methodology whereby development teams and operational teams were tightly integrated in a way that made operational and deployment issues part of the development process: development would be driven by the need to deploy useful functionality, not just create it. That way, you didn't have a discontinuity where things were programmed, then someone would have to figure out how to actually deliver that bunch of code.

    The problem which the author of the article references is that this often gets perverted from the original laudable idea of teams of developers and operations people working together, to requiring every single DevOps person being equally qualified to do everything, and then from there pushed even further to many companies creating DevOps positions where those DevOps people are literally doing everything, and not just knowledgeable at those things.

    There is no question that a programmer that understands SQL or database architecture or storage systems or high performance networking or internetworking or virtual hypervisors is a more valuable programmer. They can use that knowledge to guide their development, write better code, and communicate better with the actual DBAs and network engineers and sysops and hypervisor admins. But when management types start to think that the best way to do things is to hire DevOps qualified people to just randomly do everything without any focus or specialization, that's when the myth of DevOps overtakes the reality of DevOps and begins to create real problems.

    I don't honestly know to what degree that is pervasive in the industry: I haven't seen too many examples of it myself outside of certain high profile ones (the author mentions Facebook). If it is trending upward, I think its a bad trend. But to the extent that I see companies use DevOps correctly, as the glue-people to interconnect individual development, operational/deployment, and quality assurance teams, I think its a positive. But I agree with the article author that actually *replacing* developers, QA people, and operational people with DevOps people universally would be a Bad Thing. I just don't know if its actually really happening

  • Re:whine (Score:5, Insightful)

    by Penguinisto ( 415985 ) on Wednesday April 16, 2014 @12:12AM (#46764029) Journal

    100% inclined to agree. DevOps is not really about your best and brightest pure programmers, but taking all of your jack-of-all-trades guys who specialize in "making shit work" and allowing them to keep things working.

    This, right here. I inherited the DevOps job title, even though it is exactly what I've been doing for years now. I can go in, find a problem, test a simple fix, turn QA loose on that fix, and even with change management, I can have it implemented far faster than the devs, who might fit it into their next sprint if you're lucky. They naturally get informed and fit a more elegant solution in for the next release (and sometimes they leave my fix checked-in just as it is).

    Meanwhile, while yeah in a start-up company the developer(s) had to play sysadmin too, all-too-often they don't really know much beyond the basics, and so you really don't want one, say, tweaking HugePages in sysctl.conf, or planning SAN or VM Farm expansion for the next web project, or lots of other things. Similarly, I refuse to dig any deeper in code beyond the simply Python tweak or the obvious fix/workaround, since I only know enough to be dangerous when it comes to all of the dependency chains, not to mention all of the subtle gotchas in all of the codebases I work with (why? Because while a given developer may only need to dork around with (or even just only a part of) one codebase, I have to wrangle multiple projects - time demands that I prioritize what I know about them all).

    It bears a lot of responsibility - you have to know what the frig you're doing, because downtime==money, and stakeholders will have none of it. On the flip-side, you're given a lot of leeway when it comes to what you're allowed to do in order to keep the uptime flowing. For instance, I get priority, where I can call up a network admin, security admin, or whoever I need to put through a change as soon as safely possible. I can order-up (within reason) whatever CapEx I need to build up for the next release, project, or what-have-you. Of course, you have to justify what you do, and if you do something stupid it's your nuts on the chopping block, but overall it balances out.

    IMHO (and little else), I've seen a lot of sysadmins able to step up to the DevOps plate, but very few developers that would be willing, let alone capable (most that I know prefer to write code, and not get their hands dirty with the business of playing server-monkey or wire-monkey.)

  • Re:whine (Score:4, Insightful)

    by huge ( 52607 ) on Wednesday April 16, 2014 @02:19AM (#46764507)

    My experience on this is that you need 'DevOps' to run the development environments but you need production ops to run, eh, production.

    DevOps people don't necessarily have good understanding of the underlying issues of the production environment. There are several issues revolving around this: Security, availability, scalability, etc. As an example is dev who can secure the application but not the platform (database, web servers and so on).

    Good handovers between the two are the key for success. If 'DevOps' changes the development environment in a significant way this needs to be taken into account when moving the version to production. Oh, you upgraded the database in development environment? I guess that explains why RTP failed and we had to roll back.

    Some changes may be very simple to do in development environment, while difficult in production environment. Need some extra disk and upgrade your database backend? Sure, just get it done in the development environment but there may some issues when doing that in production environment; you may need unacceptable amount of downtime, etc...

  • Re:whine (Score:5, Insightful)

    by Anonymous Coward on Wednesday April 16, 2014 @07:11AM (#46765615)

    No, the point of "devops" is getting your employees to do two jobs.

  • Re:whine (Score:4, Insightful)

    by Raenex ( 947668 ) on Wednesday April 16, 2014 @07:26AM (#46765665)

    helping the "brightest pure programmers" understand why the cool solution they developed is a POS in production

    Absolutely. I was in a startup as a dev, and by necessity we were the operations guys early on. It was a financial service that needed to be running 24/7, and having to deal with "oh shit" moments while under the gun instilled the importance of writing software that was built for reliability, graceful failures, recovery, and error reporting.

    None of this "brogrammer" shit or programmer "cowboys" or any of that other nonsense.

  • Re:whine (Score:5, Insightful)

    by RabidReindeer ( 2625839 ) on Wednesday April 16, 2014 @10:47AM (#46767577)

    21st Century Business Logic:

    1. Multi-task. Never devote your entire attention to one task when you could be juggling 7.

    2. Run Lean. Why hire a dedicated expert developer, a dedicated sysadmin, a dedicated DBA and a dedicated network engineer? Make one person do all those things (see #1, above).

    3. Run 100% and demand 110. Who needs expansion room for when things inevitably go pear-shaped? Which Murphy guarantees even when you don't tempt him with #1 and #2.

    4. Run cheap. Demand maximum expertise from the lowest bidder. There's always someone in a third-world country who'd be GLAD to do items #1, #2 and #3 for pennies a day!

    5. Use easily measured things to determine employee effectiveness. Lines of Code, Time on Phone, stuff that's easily objectively measured, unlike less tangible things like customer satisfaction (what, you think we bother to ANSWER those silly surveys?), externals (like poisoning 6 downwind countries) or time to do the job right the first time. Use these as weapons to demand more of #1, #2, #3 and #4.

    6. Subscribe to overpriced buzzword-laden management fads to assist in accomplishing all of the above.

  • by asysarchitect ( 3618765 ) on Wednesday April 16, 2014 @11:46AM (#46768637) Homepage
    Several problems with the original article. Jeff makes the assumption that Developers are at the top of a totem pole and all others are below this developer hierarchy. This is the problem with a lot of younger developers, most who are jumping into development with no structural background in the operating system or real production operations. This premise leads developers to think they are superior to everyone, rather than focusing on building applications that must run in an operational context of being well-behaved in the environment they run, and allow for maintenance work of the operations environment. This is why you see anecdotal articles coming out that talk about the frustration and friction between developers and operations people. The truth is, most developers will be better developers if they learn a little more about how their app will work in a production environment. They will build better applications because they understand the environment better. Your architecture should be loosely coupled, that is, it should not stack up on a single server but rather be broken up into smaller components that can be built for scale across multiple machines and be able to fail over to redundant systems. Ops people will be more than happy to help get you there, but you need to think about how your app will fail as much as how it will work properly. The developer also needs to stay away from dictating specific languages -must- be used to run operations. Rather, they need to understand that operations is best suited to a polyglot of different kinds of tools and languages, using the right tools and wares for the job, not being dictated in some kind of nanny state that says you must use this language or that for operations and all others are to be thrown out. All too frequently startups get hung up on dictating operations people must use Python or Ruby or the ops dude is a total loser. This is the kind of arrogance that shows how little most developers really know about operations. Any of the more popular tools should be available to the DevOps person so they can get things done, and developers should stay away from being nannies. In classic UNIX operating environments the system administrator is/was god, followed by an allowance to use the system granted to developers, database admins, etc. Applications have always been guests inside most Linux/UNUX-based systems, even Windows treats applications for what they are, programs that run inside the operating system. This has always been the premise of modern UNIX-based and even Windows-based environments. Ops people follow this naturally, but typically run into developers that don't want to follow the rules. Ops people expect you to write a well-behaved application. Developers expect an operations environment that runs their application without getting in the way. These two goals can be easily met if both sides work together and allow each side to exploit the system, but everybody has to allow the freedom to make things work best for the goal of building better systems.

UNIX is many things to many people, but it's never been everything to anybody.