Recent Changes - Search:
ECG Home

GitHub

People

Publications

Calendar

Projects

Fall 2017

Older Courses

Spring 2017

Fall 2016

Spring 2016

Fall 2015

Spring 2015

Fall 2014

Spring 2014

Fall 2013

Spring 2013

Fall 2012

Spring 2012

Fall 2011

Spring 2011

Fall 2010

Spring 2010

Fall 2009

Spring 2009

Fall 2008

Spring 2008

Fall 2007

HOWTOs

edit SideBar

TheRGSE

AICG Syllabus Lecture Blog Discussion Documentation The RGSE Assignments

Attributes of the Really Good Software Engineer (RGSE)

During the semester, we'll be discussing various attributes that seem to be common among many "really good" software engineers. These are concepts you can be considering about yourself. How well do you match the attributes of the RGSE?

The really good software engineer:

  • Writes code to be proud of.
    • When someone sees the RGSE's code, he says, "I want this author working for/with me!"
    • A RGSE's code is clean-looking
    • It is extensively documented
      • high-level (API documentation on functions)
      • low-level (the purpose of each small section of code is described)
    • The RGSE assumes someone else will need to read, understand, and possibly maintain his code
  • Is a Team Player
    • Most projects are not completed “solo”. The RGSE works with team members (other developers, quality assurance engineers, managers, etc.), to complete the project.
    • Frequently merges and incorporates own code with the code of other developers, to quickly ascertain and correct conflicts and problems.
    • Understands and meets team deadlines
    • Respects other team members.
  • Designs for the future
    • The RGSE thinks, "How else might this code be used? Does my design allow for it?"
    • Code written by a RGSE is designed to be extensible to those areas not initially considered.
  • Thinks broadly (overlaps with "Designs for the future")
    • The RGSE considers the "big picture" when writing code. The RGSE knows that where and how the code will be used affects how he does his implementation
    • When a bug is found in one section of code, the RGSE searches for other, similar sections of code which may contain the same bug/issue.
    • What are the interactions of this code with users (people), and with libraries and other code that it uses or that use it? The RGSE considers how might changes he makes affect them.
  • Thinks and designs modularly
    • An RGSE recognizes that it is easier to understand cohesive works than works that cover many conceptual areas, and designs modular code with one primary feature or function per modular unit.
    • Simple functions handle one thing well. More sophisticated functions can call a series of the simple functions to accomplish their task.
  • Has good communication skills
    • Not only does the RGSE document well, but he also is able to explain an idea or design to others in such a way that they easily comprehend it.
    • The RGSE knows how to “talk to the audience”, whether the audience is highly technical, management, or lay folk.
    • Everyone can get behind on a schedule. The RGSE ensures that if conflicting priorities prevent a task from being completed on time, other team members and managers are informed early enough of the delay that alternative plans can be made.
  • Manages his time efficiently and properly
    • There are many tasks that must be prioritized (sometimes having conflicting or interacting priorities) and completed. The RGSE has learned to manage his time and spend appropriate amounts of it on tasks depending on their priorities.
    • The RGSE knows to do his homework when learning something new, and spend an appropriate amount of time researching an answer. The RGSE also knows when it’s time to ask for help, rather than spinning his wheels. Tasks get accomplished much more quickly (for all involved) when questions are asked before too much time is wasted.
Edit - History - Print - Recent Changes - Search
Page last modified on September 04, 2011, at 01:06 PM