Sample Projects
- Do a comparative analysis of two similar specification languages,
such as Z and VDM.
- Do a specification of a system of significant size in a
specification language such as Z, Statecharts, or Larch.
- Report on the state-of-the-art of the use of a given style of
formal specification language.
- Report on the state-of-the-art of requirements elicitation.
- Report on the state-of-the-art on execution (animation) of a formal
specification language.
- Generate initial specifications for a software system using
learning techniques.
- Find, install, and perform a significant exercise with a public
domain specification tool (for instance, a theorem prover or proof
assistant for Z-like or algebraic specifications).
- Report on the state-of-the-art in handling time as part of a formal
specification.
- Do a critical analysis of several of the reported success stories
in formal specification.
- Do a critical analysis of the object-oriented versions of a
well-known formal specification language.
- Do a comparative analysis of two similar design methodologies, such
as Shlaer-Mellor and OMT.
- Report on the state-of-the-art in producing designs for (a)
concurrent, (b) real-time, or (d) distributed systems.
- Do a critical analysis of the role of source code in several recent
efforts in software architecture.
- Report on the state-of-the-art in symbolic model checking as
applied to software.
- Extend Murphy, Notkin and Lan's analysis of call graph generators
for C by: (a) considering other extractors, in particular commercial
ones or (b) considering another language.
- Produce a reasonable dynamic call graph extractor for C (that is,
one that extracts calls during program execution); if such an
extractor is found publicly, then perform experiments to compare the
results to the Murphy, Notkin, Lan results.
- Design and implement a set of regression tests and a supporting
testing harness for the CSE401 compiler.
- For a complex abstract data structure, define the formal
specification and show that a given implementation satisfies that
specification.
- Find a publicly available test coverage tool and apply it
aggressively to several systems, reporting on the strengths and
weaknesses of the tool.
- Report on the state-of-the-art of testing object-oriented
programs.
- Build a version of grep and use it to analyze various usage
patterns of different users of grep.
- Use reflexion models and a repository of versions to track the
evolutionary history of a software system.
- Produce a report on the current understanding of the costs of the
software lifecycle (percentages for testing, design, etc.); perhaps
determine whether or not these are stable across different kinds of
software (e.g., real-time, contract, shrinkwrap, etc.)
- Produce a report on the state-of-the-art in software walkthroughs,
inspections, etc.
- Provide an in-depth analysis of the version history of one or more
public domain pieces of software. You might focus on issues such as
the "shape" of the version history (if a tree-structured history is
kept), on an analysis of the kinds of changes applied, etc.
- Report on the state-of-the-art in 3D visualization of software.
- Report on the state-of-the-art in software configuration management
tools.
- Read "Microsoft Secrets" by Cusumano and Selby and evaluate some
aspects of it in terms of published material in software engineering.
- Do a comparative analysis of OLE, OpenDoc, and CORBA. (Or perhaps
two of the three.)
- Determine the state-of-the-art in technical solutions to the Year
2000 program, as an example of a form of software evolution.
- Analyze and report on the definition and use of PCTE, the Portable
Common Tool Environment.
- Analyze and report on the definition and use of CDIF, a common
interface definition for CASE tools.
- Clearly characterize several forms of software reuse and report on
the state-of-the-art technology for those approaches.
- Peform your own analysis of the software-related issues of the
Denver Airport problems.
- Analyze one or more years of RISKS Digest looking for situations
in which the proper application of software engineering principles
still led to system failures.