Saltar al contingut Menu
  • Home
  • Information
  • Contact
  • Map

Programming Project (PROP)

Credits Dept.
6.0 (4.8 ECTS) CS


Person in charge:  (-)

General goals

Once students have learnt the techniques and methods needed to build programs in earlier subjects, they must be able to synthesise this knowledge and use it to develop a programming project of medium complexity. The teaching objectives of this subject strive to do just this, and are divided into three levels:
-  Putting into practice and synthesising students' knowledge of programming, algorithms and data structures.
-  Introducing students to the process of developing software projects through an intensive use of this knowledge to meet strict functionality and operational demands. The focus will be both on those aspects related to the software being designed (requirements for quality, correction, reusability of components, etc.) and on the development process itself (organising the work group, documentation, interaction with the user, prototyping, etc.).
-  Completing students' training in these fields, basically as far as concerns the requirements of large-scale programming, which are not covered in earlier programming subjects.

Specific goals


  1. The stages of a programming project (specification, analysis, design, implementation, testing, and maintenance). The kind of decisions taken in each stage. The need to document each stage.
  2. The main internal and external requirements regarding programme quality (minimum requirements are that they be correct, efficient, robust, understandable, re-usable, and fit for use) and the compromises that need to be struck between these requirements.
  3. Design principles, object-oriented programming, and their justification. The advantages and drawbacks of adopting this paradigm in a programming project.
  4. The use of object classes and inheritance to prevent redundancy and to capture specification, design and implementation abstractions. The advantages of an object-oriented approach with regard to reliability, modification, portability, re-use, and productivity.
  5. The main software engineering problems (the solutions to which will be dealt with in other subjects).


  1. Development of a medium-sized project on a group basis (depending on the predefined development plan and architecture).
  2. Invoke the programming knowledge acquired in previous courses during the development of a medium-sized programming project. The task involves choosing algorithms and data structures to build a programme that is efficient and functions properly.
  3. Organise the design and implementation work of medium-sized team (3- 10 people) in accordance with a predetermined schedule. This organisation includes overall planning and the allocation of tasks between group members.
  4. Identify all those potentially common factors in the specification, design and implementation of a programme in order to deal with them in one fell swoop. Use object-oriented techniques effectively in order to perform this factorisation.
  5. Deal with programme anomalies by using the exceptions mechanism provided by the programming language.
  6. Design an effective user-friendly interface for the programme, employing a GUI library for this purpose.


  1. Ability to create and use models of reality.
  2. Ability to design systems, components and processes meeting certain needs, using the most appropriate methods, techniques and tools in each case.
  3. Ability to solve poorly-structured problems.
  4. Ability to logically argue the decisions taken, work done, or a given viewpoint. Ability to give well-reasoned opinions and reasons with a view to convincing others.
  5. Initiative: Resolution, knowing how to take decisions and how to act in order to solve a problem.
  6. Ability to learn on one's own.
  7. Ability to work effectively in small groups to solve problems of middling difficulty.
  8. Ability to integrate: Seek and propose tasks for developing one's own competencies and skills.
  9. Ability to set up and organise either a uni- or multi-disciplinary group to tackle a complex project.
  10. Ability to present a well-written report setting out one's results (in order to document the submission of practical work).
  11. Ability to relate to others. Receptiveness to the ideas of others.
  12. Assume responsibility for one's own work.


Estimated time (hours):

T P L Alt Ext. L Stu A. time
Theory Problems Laboratory Other activities External Laboratory Study Additional time

1. Introduction
T      P      L      Alt    Ext. L Stu    A. time Total 
2,0 0 0 0 0 2,0 0 4,0
Small and large-scale programming. Internal and external criteria regarding software quality. Life-cycles.

2. Object orientation
T      P      L      Alt    Ext. L Stu    A. time Total 
2,0 0 0 0 0 2,0 0 4,0
Object-oriented specification, design and programming (OO). Objects, classes, attributes, and methods. Relationship between object classes and ADTs. Inheritance, polymorphism, and genericity as programming and design tools. Relationship between object orientation and criteria regarding software quality.

3. Specification
T      P      L      Alt    Ext. L Stu    A. time Total 
4,0 0 0 0 0 2,0 0 6,0
project definition. Requirements. Functional specification. First, model the domain. Case study.

4. Design
T      P      L      Alt    Ext. L Stu    A. time Total 
4,0 0 0 0 0 2,0 0 6,0
Programme architecture. Design levels. Communication between modules. Three-layer architectures. Examples.

5. Object-oriented programming
T      P      L      Alt    Ext. L Stu    A. time Total 
4,0 0 0 0 0 1,0 0 5,0
Review of the object-oriented programming concept. Given the ground covered in previous courses, this will stress how to implement the programming language used in the course.

Inheritance, polymorphism, and genericity as programming tools. Execution mechanisms. Object creation/destruction. Method calls and passing parameters. Static and dynamic binding. Garbage collection. Exceptions.

6. Programme testing
T      P      L      Alt    Ext. L Stu    A. time Total 
2,0 0 0 0 0 1,0 0 3,0
Component testing. Optimising components.

Component integration.

Testing and integration strategies. Planning tests.

Scaffolding and regression tests.

Putting help tools to the test: "Debuggers", "profilers", test automation.

7. Programme interfaces
T      P      L      Alt    Ext. L Stu    A. time Total 
2,0 0 0 0 0 0 0 2,0
Input and output types. Communication between programmes.

Principles of human communication. Information presentation, data entry and validation, navigation, help levels, user models.

8. Documentation
T      P      L      Alt    Ext. L Stu    A. time Total 
2,0 0 0 0 0 0 0 2,0
Technical and user information. Documentation standards. Documentation help tools.

9. Programme quality
T      P      L      Alt    Ext. L Stu    A. time Total 
2,0 0 0 0 0 0 0 2,0
Defining software quality. The factors involved in quality. Measuring the quality of programmes. Validation and testing. - Software quality standards.

10. Explanation of the project to be developed
T      P      L      Alt    Ext. L Stu    A. time Total 
5,0 0 0 0 0 0 0 5,0
The project outlines and discussion of the alternatives.

Explanation of the development plan, the objectives in each stage, and the methodology to be followed.

Explanation of the content of each assignment submission and the assessment criteria employed.

  • Laboratory
    Scheduling requirements may entail some of these explanations being given in the lab classes instead of in the theory classes.

11. Learning of the notations and the tools to be used.
T      P      L      Alt    Ext. L Stu    A. time Total 
0 0 3,0 0 6,0 0 0 9,0
  • Laboratory
    The professor will explain:
    - The basic elements to be used in the specification and design stages. A highly reduced sub-set of UML is currently being used.
    - The components of the programming language which are not fully covered in the theory classes. This course will preferentially use Java.
    - An introduction to the libraries available (when necessary) and in particular, to the libraries used to build a user interface.
    - An introduction to development tools, and testing and optimisation tools not covered in previous courses.
    In all cases, the explanations given will be brief and students will have to round off their learning through private study.

  • Additional laboratory activities:
    Complete the learning of the notation and tools presented by the teacher in the lab classes.

12. Project development
T      P      L      Alt    Ext. L Stu    A. time Total 
0 0 5,0 0 70,0 0 0 75,0
This is described in the following sections.

  • Laboratory
    Interviews with the project tutor to discuss alternatives, resolve questions, receive comments on submissions, and in general, monitor project progress.
  • Additional laboratory activities:
    Work on project development outside class hours. This includes time spent with other members of the group and in off-line interaction (for example, by e-mail) with them and with the tutor.

Total per kind T      P      L      Alt    Ext. L Stu    A. time Total 
29,0 0 8,0 0 76,0 10,0 0 123,0
Avaluation additional hours 1,0
Total work hours for student 124,0



The project proposed to students will exhibit the following characteristics:

- A small problem will provide the starting point, allowing the to interpret what his or her programme should do.

- The project is sufficiently large to ensure that a "direct" approach to the solution is not viable.

- The project has a strong algorithmic and data structuring component.

- Students must submit their completed programmes within a reasonable time frame. The objective is therefore to submit a finished product and should not be seen as merely an exercise.

- Project implementation will draw on components created by others, and elements from other projects.

The approach adopted for implementing the project will be as follows:

- Students will be organised in groups of 3, which in turn will form clusters comprising 3 groups (i.e. 9 students).

Each cluster will be assigned a tutor.

- There will be 3 problems each term for solution by each cluster (i.e. one problem per group. Although the problems are different, there are sufficient similarities between them to allow identification of common elements that can be developed just once and re-used by the whole cluster.

- Each student will have his/her exclusive responsibilities within the group to programme and test each class.

Development plan

Students will be given the problems at the beginning of the course and will then have a week to organise themselves in groups and clusters.

Three submissions will be made during the course at roughly 4-5 week intervals. The submission schedule will be as follows:

- First submission: specification and analysis. This covers a problem in Natural Language, a detailed description of the functions to be developed, a model of the problem domain, and a list of the non-functional requirements for the programme.

- Second submission: design and initial implementation. This submission includes the design of any common parts shared with other groups in the cluster, and the implementation of those components. These components must implemented completely within the domain model.

- Third submission: fully-functioning final programme, operating in accordance with the specifications set out in the first submission, accompanied by the programme technical and user information.

The first two submissions are asynchronous. The final submission consists of an interview with each member of the group lasting roughly an hour, during which students demonstrate their system and respond to the tutor"s questions.

Docent Methodolgy

Theory classes:

These present the most general contents of the course (which bear little relation to the specific practical problem set each term). These classes are generally concentrated towards the beginning of the course.

However, general theory, practical project work, and information on the materials to be included in each submission are interleaved when deemed appropriate.

Lab classes in scheduled hours:

The teacher uses some of these classes (normally at the beginning of the course) to briefly present notation schemes, languages, libraries and tools. Students take the initiative in most of the lab classes. Groups devote their time in these classes to working together, asking the teacher questions, and receiving his/her comments on previously submitted work.

Independent work:

Most of the course hours cover work outside class. Students use this time to work on their projects, whether on their own or with their work groups.

Evaluation Methodgy

Students will be assessed on three submissions (documentation and/or software), distributed throughout the course. The submission deadlines will be announced during the first month of the course.

Submission 1 (Specification and Analysis): 10%
Submission 2 (Design and beginning programming): 25%
Submission 3 (Final): 65%

Assessment will take into account students' individual contributions and the results attained by their respective groups. This means that not all group members will necessarily be given the same grade. Each member of the group must program aproximately one third of the program. In the case of an important deviation, the student in question might me awarded a "not presented" grade.

Submissions 1 an 2 will be assessed on the extent to which the objectives agreed with the tutor are met. Submission 3 will be of a more general nature, evaluating the quality of the project and its state of completion (however, both aspects have much to do with the work contained in the previous submissions). Specifically, the assessment will be based on the following three groups of characteristics:

1. Achievement of objectives: The reports submitted, the completeness of the programmes submitted and the extent to which they operate properly and in accordance with the agreed specifications.
2. Internal factors:
- Design quality
- Quality of the coding
- Re-usability and maintainability
- The way the group and cluster work; includes the extent to which designs and code are shared, and the effective use of of shared code.
- Submitted tests.
3. External factors:
- Correctness, efficiency and robustness.
- Interface quality and user-friendliness.
- User documentation.

The tutor will not accept any submissions that are clearly incomplete. Students might be awarded a "not presented" grade for incomplete submissions.

If the project is not reasonably operational by the third submission (ex. if its basic functions are not properly finished), this last grade will be the one determining the extent to which the agreed objectives have been met. In this case, the final grade for the course will be the minimum between 4 and the grade obtained by applying the weighting scheme.

Basic Bibliography

  • Bertrand Meyer Construcción de software orientado a objetos, Prentice Hall, 1998.
  • Timothy Budd An Introduction to object-oriented programming, Addison-Wesley, 2002.
  • Robert V. Binder Testing object-oriented systems : models, patterns, and tools, Addison-Wesley, 1999.
  • Ken Arnold, James Gosling, David Holmes The Java programming language, Addison-Wesley, 2000.
  • Allen J. Peralta Giménez, Horacio Rodríguez Hontoria Enginyeria del software : programació orientada a objectes, Edicions UPC, 1994.

Complementary Bibliography

  • Bertrand Meyer Object-oriented software construction, Prentice Hall, 1997.
  • Grady Booch, James Rumbaugh, Ivar Jacobson The Unified modeling language user guide, Addison-Wesley, 1999.
  • James Rumbaugh, Ivar Jacobson, Grady Booch El Lenguaje unificado de modelado : manual de referencia, Addison-Wesley, 2000.
  • James Rumbaugh, Ivar Jacobson, Grady Booch The Unified modeling language reference manual, Addison-Wesley, 2005.
  • Grady Booch, James Rumbaugh, Ivar Jacobson El Lenguaje unificado de modelado, Addison-Wesley, 1999.
  • Richard C. Lee, William M. Tepfenhart UML and C++ : a practical guide to object-oriented development, Prentice Hall, 1997.
  • Roger S. Pressman Software engineering : a practitioner's approach, McGraw Hill, 2005.
  • Ron Jeffries, Ann Anderson, Chet Hendrickson Extreme programming installed, Addison-Wesley, 2001.
  • Alan Cooper and Robert Reimann About face 2.0 : the essentials of interaction design, Wiley, 2003.

Web links





Previous capacities

- Ability to solve algorithmic problems of middling difficulty and based on a clear specification, and to implement solutions in an imperative programming language.

- Familiarisation with the basic mechanisms for structuring programmes (modularisation, encapsulation, abstract data types, classes) and ability to apply them to small to medium-sized problems (i.e. comprising few modules).

- Knowledge of object-oriented programme elements (classes, objects, inheritance, execution methods).

- Familiarity with an imperative language, preferably of an object-oriented nature.

- Ability to use and programme simple data structures (tables, linear structures, dictionaries, etc.) in this language.

- Ability to use libraries in this language.

- Mastery of basic strategies for finding and correcting errors in simple modules.


logo FIB © Barcelona school of informatics - Contact - RSS
This website uses cookies to offer you the best experience and service. If you continue browsing, it is understood that you accept our cookies policy.
Classic version Mobile version