Software Designer
- Software Designer
- the role that is played when a person
designs the
software components
of one or more
systems or
application
As illustrated in the preceding figure, Software Designer is part of the following inheritance hierarchy:
The typical role-specific responsibilities of a Software Designer are to:
- Understand and evaluate the relevant requirements.
- Understand and evaluate the relevant software
architecture.
- Design all or part of the software components.
- Informally evaluate the software design.
- Document the software design.
Software Designer typically inherits the
general role responsibilities from the
role method component.
To fulfill these responsibilities, software designers
typically should have the following personal characteristics,
expertise, training, and experience:
Software designers typically should have the following
personal characteristics:
- An abstract thinker who is comfortable working with
mid-level abstractions.
- Able to perform engineering trade-offs between competing
design decisions.
- Able to identify relevant parts of the requirements,
architectures, and their ramifications on the design.
- Able to clearly grasp the context of the design within
the software architecture.
- Able to comfortably multitask (i.e., perform multiple
design tasks concurrently).
- Relatively self-directed, being able to both manage and
(re)prioritize the multiple concurrent and competing
challenges, issues, ambiguities, and contradictions that
necessarily occur during the prduction of the design.
- Strong analytical problem solving skills.
- Good verbal and written communication skills, and thus
able to document the design and explain it to its diverse
audiences.
- Able to follow the endeavor-specific process and know
when to request a deviation.
- Able to collaborate and work well with others as a member
of one or more teams.
- Able to work independently when necessary.
Software designers typically should have the following
expertise:
- Expert practical knowledge of:
- Software design tasks, techniques, and tools.
- Software design work products including the
corresponding conventions.
- Object-oriented concepts such as abstraction,
encapsulation, inheritance, and polymorphism.
- Object modeling and state modeling.
- Component-based development (CBD) concepts such as
components, component models, component infrastructures,
and interfaces.
- Software design patterns.
- Software design approaches to meet quality requirements
and architecture mechanisms (e.g., assertions, exception
handling, concurrent processes and threading, real-time
issues, etc.).
- Software modeling languages (e.g., UML, OML) including
the ability to create and read the associated
diagrams.
- Software modeling tools.
- Solid practical knowledge of:
- Requirements engineering concepts and techniques.
- Relevant requirements.
- Software architecture patterns, concepts, and
techniques.
- Relevant architectures including physical architecture
and mechanisms.
- The programming languages (e.g., Java, C++, C, HTML,
CSS, XML, JavaScript, assembly languages) and technologies
(e.g., J2EE, EJB) to be used to implement the design.
- The theory, practice, and tools of software
engineering.
- The application domain.
- The application development cycle including relevant
phases and milestones.
- Relevant quality engineering tasks and techniques.
- Model-based testing tasks and techniques.
- Design metrics.
- Basic practical knowledge of:
- Use case modeling.
- Configuration identification, configuration control,
and associated configuration management tools.
- Personal and team scheduling.
Software designers typically should have the following
training:
- A bachelor’s degree or better in software
engineering, computer science, or the equivalent.
- 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.
Software designers typically should have the following
experience:
- Significant actual experience successfully designing and
implementing software components suring similar
endeavors.
Software designers typically perform the following
role-specific tasks in an iterative,
incremental, parallel, and time-boxed manner:
Software Designer typically inherits
common role tasks from the
role method component.
Software Designer typically is a member of the following teams:
As members of these teams, software designers typically
produce all or part of the following work products:
- Software designers are needed on any endeavor in which
new software components are to be developed.
- This role typically inherits the
common team guidelines from the
roles process component.
