Programmer

Definition

Programmer
(a.k.a., Computer Programmer, Programmer Analyst, Coder)

the role that is played when a person produces and tests the source code for new or modified software components

Classification

As illustrated in the preceding figure, Programmer is part of the following inheritance hierarchy:

• Type: Concrete
• Superclass: Engineer
• Subclasses:
  • None

Responsibilities

The typical role-specific responsibilities of a Programmer are to:

• Understand and evaluate the relevant requirements, architecture, and design documentation.
• Reuse software components from the reuse repository.
• Acquire, configure, and extend commercial software components.
• Implement softare components (including prototype code, deliverable new code, and deliverable “glue code” to integrate the software components) in accordance with the:
  • Relevant requirements.
  • System and software architectures.
  • Design.
  • Language specification and idioms.
  • Coding standards.
• Refactor and iterate software components.
• Produce unit test software.
• Perform unit testing of software components including the design, implementation, evaluation, and execution of unit tests.
• Debug the software components:
  • Identify and fix defects.
  • Verify that the defects are infact fixed.
• Write instructions to guide computer operators during production runs.

Programmer typically inherits the general role responsibilities from the Role method component.

Personal Profile

To fulfill these responsibilities, programmers should typically have the following personal characteristics, expertise, training, and experience:

Personal Characteristics

Programmers should typically have the following personal characteristics:

• Strong analytical problem solving skills.
• Able to comfortably multitask (i.e., perform multiple design, implementation, and testing tasks concurrently).
• Solid verbal and written communication skills, and thus able to explain and document the software design, implementation, and testing its diverse audiences.

Expertise

Programmers should typically have the following expertise:

• Expert practical knowledge of the:
  • Programming languages to be used including their idioms.
  • Associated coding standards.
  • Unit (e.g., class-level) testing theory, practice, and tools.
  • One or more of the platforms (e.g., hardware, operating system, browsers) to be used.
  • The theory, practice, and tools of software engineering.
• Solid practical knowledge of:
  • Major object-oriented concepts such as abstraction, encapsulation, inheritance, and polymorphism.
  • Standard modeling languages (e.g., UML or OML) being used to document the design to be implemented including the ability to read both static and dynamic models (diagrams).
  • Major component-based development (CBD) concepts such as components, component models, component infrastructures, and interfaces.
  • Implementing distributed software components.
  • Standard techniques for interfacing with relational and object databases (e.g., wrapper classes, query languages, and stored procedures).
• Basic practical knowledge of:
  • Requirements engineering concepts and techniques.
  • Software architecture patterns, concepts, and techniques.
  • Configuration identification, configuration control, and associated configuration management tools.
  • The application domain.

Training

Programmers should typically have the following training:

• A bachelor’s degree or better in software or systems engineering, computer science, or the equivalent.
• Vendor certifications in the relevant programming languages and lowerCASE tools).
• Practical hands-on training in:
  • The project process, especially in terms of relevant tasks, techniques, and work products.
  • Object and use case modeling concepts, diagrams, and tools.
  • Component models, infrastructures, and interfaces.
  • Programming languages and their idioms.
  • Unit testing tasks, techniques, and tools.
• Reads books, technical journals, and conference proceedings on database design, implementation, and testing.

Experience

Programmers should typically have the following experience:

• Significant actual experience successfully designing and implementing data and software components during similar endeavors.

Tasks

Programmers typically perform the following role-specific tasks in an iterative, incremental, parallel, and time-boxed manner:

• Architecting:
  • Architecture Prototyping
• Software Implementation:
  • Implementation Reuse
  • Programming
  • Data Generation
  • Debugging
• Unit Testing and Software Integration Testing:
  • Test Reuse
  • Test Design
  • Test Implementation
  • Test Execution
  • Test Reporting
• Quality Engineering:
  • Quality Assurance - Software Audit
    
  • Quality Control - Environments Evaluation
    
  • Quality Control - Architecture Evaluation
    
  • Quality Control - Implementation Evaluation
    

Programmers typically inherit common role tasks from the role method component.

Teams

Programmers typically perform these tasks as members of the following teams:

• Software Development Team
• Evaluation Teams:
  • Architecture Evaluation Team
  • Software Evaluation Team
  • Environments Evaluation Team

Work Products

As members of these teams, programmers typically produce all or part of the following work products:

• Software Architecture Prototype
• Software Components
• Unit test level:
  • Test Procedures
  • Test Harnesses
  • Test Scripts
  • Test Suites
  • Test Cases
  • Test Data
• Quality Work Products
  • Inspection Report
  • Inspection Summary Report

Guidelines

• Programmers are only needed as part of the endeavor-specific process if the process involves the production of modification of software components.
• The required expertise, training, and experience may vary depending upon the specific responsibilities and tasks, which in turn may vary depending on the type of software components to be produced. For example, different programmers may:
  • Need to have mastered different programming languages, component infrastructures, and/or platforms.
  • Program prototype vs. deliverable vs. test software components.
• This role combines both unit programming and low-level software testing because the same person typically performs all three in a highly iterative, incremental, and interleaved manner. However, unit testing and/or software integration testing may be instead allocated to the test engineer role during process tailoring, especially if different persons are going to be responsible for unit programming and low-level software testing.
• This role typically inherits the common team guidelines from the roles method component.