Programming Project (PROP)

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.

Knowledges

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).

Abilities

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.

Competences

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.

Description

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.

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.

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.

• 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.

• 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.

1. http://java.sun.com/
   



2. http://www-306.ibm.com/software/rational/
   



3. http://argouml.tigris.org/
   



4. http://mat21.etsii.upm.es/ayudainf/aprendainf/programacion.htm
   

- 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.