COMP 762 Fall 2008 - Project 1: Program Analysis
You must do the project individually. Please see the course
schedule for the deadline.
The objective of this project is to give you experience with the
analysis of large software systems and insights into potential
issues regarding the evolution of a concrete software system. This
project will serve as a foundation for Project 2: Prototype
development, so make sure to manage your project in a way that will
facilitate the reuse of the artifacts you download and produce, and
of the knowledge you acquire. Tip: do not be mislead by the
relatively low percentage attributed to project 1 in the overall
grade. This percentage does not reflect the true importance of
project 1 as a lot of the work you do in project 1 will impact your
- Find and install a target system. The target system is
the software system you will analyze as part of this project. You
can use any system you like as long as it meets the following two
The most obvious way to find a target system is to download the
source code of an open-source project. There exists many source
code repositories for countless projects (e.g., SourceForge). There are also
large open-source projects such as Eclipse, JBoss, Apache, and OpenOffice. You may know of
others, and you can of course search the web. Use anything you find
interesting for the project and you feel comfortable downloading,
installing, and running. If a system interests you but looks too
big for your comfort level, there might be a way to hack off a
- You have not developed it yourself;
- It comprises at least 10,000 LOC (not including comments);
- At the date indicated on the course schedule, email a brief
description of your system to me. Please use "(762) Project 1
Description" as the subject of your email. Your description should
include the name of the system, what it does, the main programming
language, the size of the system, and how you obtained it (with URL
if open source).
- Define a concern of interest on your
target system. We have discussed what concerns are in detail in
class. Think about different features, non-functional requirements,
or design decision present in the system. Choose one you find
particularly interesting or important.
- Using one program
analysis tool of your choice, analyze the implementation of your
concern of interest. Imagine that your analysis is intended to help
a team leader or technical manager assess the cost and risk of
performing a change to the concern. Explore, experiment, play
around. There are no official procedures to follow or right answers
to discover. Example of questions to investigate include:
- How many modules (classes, files, methods, whatever) are
involved in the implementation of the concern? Which ones?
- Does the implementation of the concerns interact with any other
- Does the implementation of the concern rely on any architectural
- Evaluate the evolvability of the concern you analyze. It it
evolvable? Why? Why not? In which circumstances? What can be
done to improve the evolvability?
To perform your assessment you must use a program analysis tool.
Again, you have free reign to experiment and choose whatever tool
you like best. A few tool collections:
Note that you do not have to restrict yourself to freeware: many
commercial tools have a free evaluation period.
You should hand in a single PDF document meeting the following
Between three and four pages using the IEEE Computer Society format
for conference publications (use the two-column format
templates). Email your report directly to the instructor, using the
following file name "YourLastName-report1.pdf" with the obvious expansion.
You should use the following section breakdown (respecting the
The report is the only deliverable for this project, so please pay
special attention to the quality of the writing. In particular, use
a precise, concise, and focused style. Avoid vagueness and
repetitions, and do not state the obvious (in the context of the
course). Check the grammar and spelling. If you can, ask a
colleague to review it.
- Introduction A very brief introduction giving a
high-level overview of your project.
- Target System What system you used, how big it is, where
you found it, why you picked it, and anything else that might be of
- Concern of Interest What concern you analyzed, including
it's description from a stakeholder's perspective. Why you chose
that concern, why it's interesting.
- Methodology What you chose to analyze, why you chose to
analyze what you did, the tool you used, how you used it, etc.
- Results A summary of the results of your analysis,
including aggregated data supporting your claims.
- Conclusion A brief summary of the important points of
your points of your project, of the significant results, and the
general conclusion of your analysis.
Important Tip: Although the report is the only deliverable for
project 1, keep everything you used and produced as you will need it
for project 2!
In evaluating your project I will be looking for the following main
- That you have though about what a software concern is, how it
translates to code, and what this means in the context of software evolution.
- That you spent a reasonable amount of effort installing and
understanding a software engineering tool.
- That you have been rigorous in devising and following a
methodology to analyze your system.
- That you have displayed creativity and thoughtfulness in synthesizing the results
of your analysis.
- That your have spent the time and effort to produce a quality report.
Going Further (Optional)
If you really get into this project and would like to push it
further, here are a few possibilities. If you choose any of these,
you can get extra space for your project report. Contact me if you would like to
discuss such possibilities.
- Concern traceability Find a concern that is formally
documented (i.e., in a user manual, a requirements manual, etc.),
and document the links between the external documentation and the
implementation of the concern.
- Tool evaluation Perform a systematic evaluation of the
tool you have used.
- Literature survey Survey the literature for case studies
and experiments involving concerns similar to the one you are
- Evolution analysis Using data obtained from the source
code repository, analyze how the implementation of your concern of
interest has evolved over time.
- Your idea here Other avenues are always possible...