We need to produce far more software developers than programmers: How do we change?

May 21, 2012 at 7:48 am 25 comments

At the PACE meeting two weeks ago, we heard a presentation from Lauren Csorny, an economist with the US Bureau of Labor Statistics.  She did a wonderful job, tailoring the results of the recent 10 year predictions to focus on computing.

Here’s the first and most important table: How BLS defines these jobs.  The BLS doesn’t get to actually define the jobs — someone else in the Department of Labor does that.  BLS counts employment within those occupation definitions.

Note carefully the distinction between Programmers and Developers!  That’s a key distinction in terms of the predictions.  Programmers write code that developers design. Software developers are the “creative minds behind computer programs.”

Here are predictions in terms of percentages of job growth:

The market for computer programmers is going to grow more slowly than the rest of the economy.  Software developers (for both systems software and applications) are going to grow enormously fast.  (Yes, grouping “Information security analysts, web developers, and computer network architects” into one job is crazy — they realize that, and that will likely be broken out in the next prediction in 2014.)

The BLS data give us a little more fine-grained view into the job growth vs. replacing existing employees in each of these categories:

Over the next ten years, there will certainly be the need to replace workers (due to age, or moving into a new category of job).  But the greatest growth is in software developers.  Programmers will have more replacement than growth. There will be growth (i.e., new jobs that don’t exist yet) among Software Developers.

I’ve been thinking about what these predictions mean for Computer Science.  Should we be thinking about vocational concerns when considering the content of a degree program?  We need to consider whether we’re preparing students for the future, for their future, and about the needs and opportunities that we can predict.

What do we want computer science graduates to do?  Do we see them as filling the Computer Programmers slot, or the Software Developers slot?  If CS wants to give up on the Software Developers slot, I’ll bet that IS or IT or even these new Information degree graduates would be willing to take those job.

If we in CS want to create Software Developers, how?  What should we do?  And how should educating Software Developers look different than educating Computer Programmers?  Some specific questions:

  • Do we need to teach software developers programming?  I strongly believe that one can’t learn to design without learn something about one’s materials — you can’t learn to design software if you’ve never programmed software.  But I’m willing to admit that I don’t have evidence for this, other than analogy.  Architects learn something about strength of materials and civil engineering, but those are different degrees — the design of buildings versus the construction of buildings.  But it probably depends on the kind of software developer, too.  Systems software developers need to understand lower-level details than application software developers (a distinction in the BLS categories).
  • Do we need to produce expert programmers?  In our program here at Georgia Tech, and at many other degree programs I’ll bet, we have an explicit goal to produce graduates who have some level of expertise in coding.  We teach Java in so many classes, in part, to produce excellent Java programmers.  Is that important, if the programmer job is the one that is going to grow more slowly, and we have such an enormous need for software developers?
  • Do we need to teach how to make data structures, or how to use them?  Is it important to learn how to make linked lists and trees, or just how to use them and what their differences are?  This has been a question for a long time in the SIGCSE community, and these job predictions make an argument that the low-level skills are more specialized and less generally useful now.
  • Do we teach one language/paradigm, or many?  The BLS predictions suggest to me, even more strongly, that we are doing our students harm by only showing them one language or style of language.  “Creative minds” know more than one way to think about a problem.

We might decide that the BLS data are not relevant for us.  Andy Begel and Beth Simon did a really interesting study of new hires at Microsoft, and came away with a picture of what new software engineers do — a picture in sharp contrast with what we teach in our classes.  In the four years since that study came out, I haven’t heard much discussion about changing curricula to address their issues.  CS2013 may have a better chance at shaking up how we think about computer science curricula.

Entry filed under: Uncategorized. Tags: , , .

Visual Programming Languages in the Browser: Scratch and Snap Science of Spatial Learning: Nora Newcombe at NCWIT

25 Comments Add your own

  • 1. Bonnie  |  May 21, 2012 at 8:04 am

    Honestly, I have never seen that distinction when I worked in industry. Software developers and computer programmers were one and the same. Even technical managers have their hands in the code at many companies. My husband has a VP title at a financial company, yet he writes programs every day.

    I think that distinction between people who design systems and people who take the specs and program is a holdover from the 60’s and 70’s, when perhaps companies did work that way.

    • 2. Mark Guzdial  |  May 21, 2012 at 8:32 am

      I raise that question, Bonnie — what about people who program as part of their job? Lauren from BLS said that they talk about “most.” If more than 50% of your time is spent computer programming, then you’re a computer programmer. Less than, then you’re something else.

      • 3. Bonnie  |  May 21, 2012 at 12:18 pm

        But what counts as computer programming? Do they mean the time typing in Java or C#, or does that also include the time spent in endless meeting arguing about the API design, or time spent writing requirements, or time spent conferring with the QA engineer? I have never met anyone in industry who spends more than 50% of their time typing code (well, except for the week before the big milestone), but most software developers, team leads, and architects spend a lot of their time in various activities related to the code.

        The point I am trying to make is that this rigid delineation between people who “design” software and people who “code” software doesn’t exist in the real world. I am not talking about non-software types who happen to write some SQL or a Perl script or two, but who are primarily responsible for something else. I am talking about people whose title and job descriptions are fundamentally related to the production of software. I have long criticized the government’s job classifications because they are out of date.

        • 4. Dennis J Frailey  |  May 21, 2012 at 7:20 pm

          I certainly agree that the government’s job classifications are out of date. They are also influenced more by lobbying and less by reality than one might like. Nonetheless, I have a different perspective on whether these truly are distinct jobs. My background is different, perhaps, from that of others who have commented on this. I just retired after 36 years in industry – a major semiconductor manufacturer and a major defense contractor. In their system of things they did not use the titles “programmer” or “software developer”. However there was a definite distinction in terms of career path for those whose skill consisted mainly of programming and those whose skill went well beyond that to design, software architecture, etc. The latter, for example, tended to be the higher paid and often migrated on to become systems engineers, which meant they might be the chief technical leader on a major project. Another distinction was that the people whose skills focused on programming often tended to have less formal education – technician degrees or else BS in CS – whereas the designer/architects tended to have masters degrees or BS in software engineering. Another distinction was the size of the project. If you were on a small project (10 or fewer software people), the distinction was not very important. But on a major project (50 or more software people) the programmers would have less authority and generally would be working for the designer/architects.

          It is also true that in terms of job growth our experience was consistent with the differences noted in the BLS report. We needed a lot more software designers and architects than programmers.

          • 5. luke  |  March 17, 2016 at 5:17 pm

            >a major semiconductor manufacturer and a major defense contractor.

            > However there was a definite distinction in terms of career path for those whose skill consisted mainly of programming and those whose skill went well beyond that to design, software architecture, etc. The latter, for example, tended to be the higher paid

            Defense is such a different industry, and in my experience, defense pay scales are two decades behind what those people could get in the private sector (and wages for people capable of doing my job have gone up a lot in the last two decades)

            I’m mid-career, working in silicon valley; I have a lot of friends working in defense; people who could do my job easily, many of whom have graduate degrees from places like MIT.

            Now, I’m kind of a marginal guy. I spent a lot of time running my own company (which employers see as barely better than collecting unemployment) and I have no degree whatsoever. I am worth about $100K/yr less (if we are talking about a year with good stock/bonus like this last year was) than someone of my level who has been working at one of the big silicon valley companies full time for the period of time I’ve been working.

            However, when I am working for local big companies like yahoo or google? even though I’m a marginal candidate who spends more time as a contractor than as an employee, I make way more than my highly educated, much smarter friends who work in the defense industry.

    • 6. Dennis J. Frailey  |  January 21, 2014 at 11:51 am

      My experience is more in line with Bonnie’s. I’ve worked mainly with very large efforts that hire dozens if not hundreds of software practitioners – and if you examine actual job openings, this is where the majority of the opportunities lie (don’t believe all the hype about small business creating the new jobs – most of those jobs are minimum wage and don’t last very long). More importantly, I’ve seen that later in life, coding diminishes as part of one’s activity as one progress up the career ladder.

      As I see it, the underlying problem is lack of knowledge on the part of the non-computing-experts who hire others to develop their software. They don’t know what to look for so they end up hiring good programmers. Too often they learn that programming skill is just the first step. The plethora of shoddy software that we experience every day is evidence of this.

      How do we fix this? Perhaps we’ll be like the auto industry when it comes to producing quality – a major competitor will start to succeed because of their quality and the others will have to follow suit. It has always been this way throughout history. People are satisfied with mediocre quality in products that add significant new capabilities until the high quality competitors finally come on the scene. It seems to be part of the maturing process in any technology or business.

  • 7. Bonnie  |  May 21, 2012 at 8:05 am

    And on your first question “Do we need to teach software developers programming? ” – there is no company that I know of that would hire a software developer who couldn’t code.

    • 8. Dennis J Frailey  |  May 21, 2012 at 7:26 pm

      I agree. But to me this is like saying that architects need to know how to lay bricks or frame a house. They would not necessarily spend much time doing those things but they need to know how. In the case of software, my experience has been that by mid-career, many software people don’t do nearly as much programming as they used to. Instead they are designing software or systems or possibly managing teams who do software development or suppliers who are doing the software programming. When recruiting software people for careers in our company (as opposed to jobs on a specific project) we looked for evidence of competence in programming and skill in such areas as leadership, management, design, systems level thinking, etc. An outstanding programmer who lacked those skills would be hired, but with a much more modest career in mind than a competent programmer who had those skills.

      • 9. Bonnie  |  May 22, 2012 at 8:14 am

        I agree that technical managers/architects, etc don’t do as much coding – but at least here in NYC, when they apply for a job they still have to take the programming screening test. I’ve been on both sides of the job search process. At my company,a mid sized software company, everyone who was a candidate for development took the Java screening test. And when I job hunted, for senior positions, I had to do a Java or C++ screen at every place I applied, even at a large, well known financial company. Generally, once you get past the screen, then you get interviewed for the skills appropriate to the job, but you have to get past the screen first.

        The job market in NYC is very different from your world. We don’t have large defense contractors or engineering-oriented companies. Mostly, the jobs are in financial development – everything from traditional banks and investment houses to startups. We also have a lot of web startups and media companies. Software development in these companies, even the large financials, seems to be less stratified. Perhaps defense contractors do things differently because of the role of the government?

        • 10. Dennis J. Frailey  |  January 21, 2014 at 11:56 am

          Interestingly enough, I was hired about 15 years ago to prepare a software engineering education program for a major NYC financial organization because they perceived that the approaches they were using were not good enough for the quality they needed. The techniques I taught (along with several others) were based on what people like NASA use (they have had very few mission problems due to software, although the Europeans have had a few doozies). As a result of this program they changed the way they recruit software developers.

      • 11. Raul Miller  |  February 2, 2016 at 10:19 am

        (I am commenting here, years after this conversation took place. So, quite possibly no one will notice this comment. Nevertheless…)

        It seems to me that that distinction between “software developer” and “programmer” would be more like the distinction between “architect” and “draftsman” than the distinction involving a brick layer. The bricklayer analogy would probably be closer to an analogy with an electronics technician…

        Also, I imagine the software developer, on the job, would be more inclined (than a programmer) to get into the details of how people are using the resulting system – what their problems are, what it is that makes them successful, how they work on a day-to-day basis, what their bosses worry about, that sort of thing. Or, put differently, this might be what some people call a “software architect”.

        (There’s also the job role where people evaluate externally available products, which also sometimes gets called “software architect” but that role is fraught with management difficulty for a variety of “people reasons”.)

  • 12. tdmorley  |  May 21, 2012 at 9:04 am

    In many ways, most current CS curriculula are in the engineering mode, i.e., highly specific and detailed to current technology. But of course, current technology is out of date by the time the students graduate. Better is the science mode, which is much more about general principles and dealing with new ideas

    • 13. Dennis J Frailey  |  May 21, 2012 at 7:28 pm

      I think the unfortunate fact is that most current CS curricula are in the technician mode as opposed to the true engineering mode. True software engineering is seldom taught in CS curricula.

  • 14. Stephen Gilbert  |  May 21, 2012 at 1:20 pm

    I just reread the Begel and Simon article and didn’t come away with the same conclusion that you did–“a picture in sharp contrast with what we teach in our classes.”

    When I read it, I found that the students who they studied were generally well prepared technically; their difficulties fell mainly in the “people skills” areas. While the main recommendation of the article–that the typical single SE course involve more realistic and larger existing code base–might prepare them a little better, it seems like it would come at the expense of seeing the “big picture”, that a green-field project provides.

    Perhaps instead of trying to cram more into an undergraduate degree, we should be following law and medicine, and moving to a post-graduate professional school model where practice is the primary focus.

    • 15. Dennis J Frailey  |  May 21, 2012 at 7:33 pm

      I agree with you in theory but in practice it won’t happen because society does not view high quality software in the same category as high quality medicine or law and, hence, doesn’t make it necessary to have such advanced education for software developers. What I’d propose instead is that we teach more genuine software engineering – along the lines of what ABET would expect in an accredited software engineering curriculum. More specifically, I think we need to clearly delineate computer science from software engineering and teach one or the other well rather than the current model which is to call it computer science but to teach something that seems to straddle both and do justice to neither.

      • 16. Bonnie  |  May 22, 2012 at 8:17 am

        I agree with this to some extent, but a division would be the death knell for many CS departments as students would tend to choose software engineering, seeing it as more “employable”.

        Also, at least here in NYC, most software developers (using the term that is most common in job ads here) do go on to get their masters degree, typically either in CS or in business, depending on where they see their career developing. NYU has a thriving business offering night graduate classes to software developers in Manhattan.

        • 17. Mike Lutz  |  May 22, 2012 at 5:33 pm

          As one teaching in an undergraduate software engineering program, I obviously am in near total agreement with Dennis (hi, Dennis!). Our situation at RIT shows that software engineering and computer science programs can co-exist – but computer science has to actually focus on the science of computing, rather than trying to be all things to all students. And while programming is an important skill for computer scientists and software engineers, curricula which focus on programming to the near-exclusion of broader issues in science, theory and engineering are doing their students no favors.

          From my perspective, competency with different language styles (e.g., Java, Ruby, Erlang, Lisp) is your ticket to get into the game – but it’s not the game itself.

  • 18. Mark Guzdial  |  May 23, 2012 at 11:13 am

    CCC just published a blog post on the BLS data: http://www.cccblog.org/2012/05/23/revisiting-where-the-jobs-are/#more-7838

  • […] liked Alfred’s sentiment in this post: “Be what’s next!” The issues around my BLS post remind me of this idea. We don’t want to give up on what we have always done, because we want […]

  • […] 2012.  Reminds me of Janet Murray’s argument for why designers should learn programming, and about the BLS data saying that we need more program designers. Subramaniam began his talk by extolling the overarching benefits of being able to program in many […]

  • 21. Mark  |  April 2, 2013 at 6:39 pm

    The need for software developers to create computer applications will grow, but the need for programmers to code those applications will diminish?

  • […] do know from studies of real software engineers that they read and debug more than they write code, so it probably would be better for everyone to […]

  • […] the IT industry a growing number of companies are finding they require an increasing amount of tech staff but they just don’t have the […]

  • 24. steve  |  July 6, 2015 at 6:04 pm

    this is NOT a career for creative people anymore.

    modern programming is just glueing together other peoples code, doing boring paper work, attending boring meetings and hunting down a never ending list of bugs.

    why I want out.

  • […] to be clear, there’s a difference between the person who just writes code and the person whose skill set go…. There’s quite a bit of confusion between definitions of developers, engineers, architects, […]


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Trackback this post  |  Subscribe to the comments via RSS Feed

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 10,184 other subscribers


Recent Posts

Blog Stats

  • 2,054,191 hits
May 2012

CS Teaching Tips

%d bloggers like this: