Programming Projects

Credits
6
Types
Compulsory
Requirements
  • Prerequisite: EDA
  • Precorequisite: IDI
  • Precorequisite: IES
Department
CS
Make a programming project related to the life cycle of a software application, emphasizing the implementation step.

Teachers

Person in charge

  • Alicia Maria Ageno Pulido ( )

Others

  • Borja Valles Fuente ( )
  • Elvira Pino Blanco ( )
  • Jordi Turmo Borrás ( )
  • Jose Miguel Rivero Almeida ( )
  • Maria Angela Nebot Castells ( )
  • Miquel Sanchez Marre ( )
  • Ramon Sangüesa Sole ( )

Weekly hours

Theory
2
Problems
0
Laboratory
2
Guided learning
0.4
Autonomous learning
5.75

Competences

Transversal Competences

Teamwork

  • G5 - To be capable to work as a team member, being just one more member or performing management tasks, with the finality of contributing to develop projects in a pragmatic way and with responsibility sense; to assume compromises taking into account the available resources.
    • G5.2 - To plan the objectives, operation rules, responsibilities, agenda and review procedure of the work. To identify conflicts, negotiate and solve them in a effective way. To adapt oneself to different kinds of groups (big/small, technical/mixed, same space/at distance). To interact efficiently and promote the participation with other group members.

Entrepreneurship and innovation

  • G1 - To know and understand the organization of a company and the sciences which govern its activity; capacity to understand the labour rules and the relation between planning, industrial and business strategies, quality and benefit. To develop creativity, entrepreneur spirit and innovation tendency.
    • G1.2 - To have initiatives which generate opportunities, new objects or solutions, with a process and market implementation vision, and to imply other team members in projects which have to be developed (capacity to perform autonomously).

Technical Competences

Common technical competencies

  • CT2 - To use properly theories, procedures and tools in the professional development of the informatics engineering in all its fields (specification, design, implementation, deployment and products evaluation) demonstrating the comprehension of the adopted compromises in the design decisions.
    • CT2.3 - To design, develop, select and evaluate computer applications, systems and services and, at the same time, ensure its reliability, security and quality in function of ethical principles and the current legislation and normative.
    • CT2.4 - To demonstrate knowledge and capacity to apply the needed tools for storage, processing and access to the information system, even if they are web-based systems.
    • CT2.5 - To design and evaluate person-computer interfaces which guarantee the accessibility and usability of computer systems, services and applications.
  • CT3 - To demonstrate knowledge and comprehension of the organizational, economic and legal context where her work is developed (proper knowledge about the company concept, the institutional and legal framework of the company and its organization and management)
    • CT3.6 - To demonstrate knowledge about the ethical dimension of the company: in general, the social and corporative responsibility and, concretely, the civil and professional responsibilities of the informatics engineer.
  • CT4 - To demonstrate knowledge and capacity to apply the basic algorithmic procedures of the computer science technologies to design solutions for problems, analysing the suitability and complexity of the algorithms.
    • CT4.1 - To identify the most adequate algorithmic solutions to solve medium difficulty problems.
    • CT4.2 - To reason about the correction and efficiency of an algorithmic solution.
    • CT4.3 - To demonstrate knowledge and capacity to apply the fundamental principles and the basic techniques of the intelligent systems and its practical application.
  • CT5 - To analyse, design, build and maintain applications in a robust, secure and efficient way, choosing the most adequate paradigm and programming languages.
    • CT5.1 - To choose, combine and exploit different programming paradigms, at the moment of building software, taking into account criteria like ease of development, efficiency, portability and maintainability.
    • CT5.2 - To know, design and use efficiently the most adequate data types and data structures to solve a problem.
    • CT5.3 - To design, write, test, refine, document and maintain code in an high level programming language to solve programming problems applying algorithmic schemas and using data structures.
    • CT5.4 - To design the programs¿ architecture using techniques of object orientation, modularization and specification and implementation of abstract data types.
    • CT5.5 - To use the tools of a software development environment to create and develop applications.
    • CT5.6 - To demonstrate knowledge and capacity to apply the fundamental principles and basic techniques of parallel, concurrent, distributed and real-time programming.
  • CT6 - To demonstrate knowledge and comprehension about the internal operation of a computer and about the operation of communications between computers.
    • CT6.1 - To demonstrate knowledge and capacity to manage and maintain computer systems, services and applications.
  • CT8 - To plan, conceive, deploy and manage computer projects, services and systems in every field, to lead the start-up, the continuous improvement and to value the economical and social impact.
    • CT8.6 - To demonstrate the comprehension of the importance of the negotiation, effective working habits, leadership and communication skills in all the software development environments.
    • CT8.7 - To control project versions and configurations.

Objectives

  1. Use previously acquired programming skills to develop a medium-sized programming project, select appropriate algorithms and data structures and build a program correctly and efficiently.
    Related competences: CT4.1, CT4.2, CT5.2,
  2. Organize the design and implementation work of a medium-sized team (three to four people) according to a predetermined schedule. This organization includes both the overall planning and the allocation of tasks between group members.
    Related competences: CT6.1, CT8.6, G5.2, CT8.7,
  3. Identify program specification, design and implementation components that can be factorised and immediately resolved and use object-orientation (OO) mechanisms for effective factorisation.
    Related competences: CT5.4, CT5.5, CT5.1, CT2.3,
  4. Understand object-oriented design and programming principles and the advantages and disadvantages of adopting this programming paradigm.
    Related competences: CT5.4, CT5.1,
  5. Use class and inheritance mechanisms to avoid redundancy and capture specification, design and implementation abstractions. They should also understand the advantages of this use of object orientation in terms of reliability, modifiability, portability, reusability and productivity.
    Related competences: CT4.2, CT5.2, CT5.3, CT2.3,
  6. Deal effectively with anomalous program situations using, if necessary, the exception mechanism provided by the programming language.
    Related competences: CT5.1, CT5.3,
  7. Design a reasonably usable and effective user interface for a program using a GUI library.
    Related competences: CT2.5, CT5.6,
  8. Develop (in groups) a medium-sized programming project, according to a pre-defined development plan and architecture.
    Related competences: G5.2, CT3.6, CT4.1, CT4.2, CT5.2, CT5.4, CT5.5, G1.2, CT2.4, CT4.3, CT5.3, CT2.3,

Contents

  1. ISE review: Specification, class diagrams and use cases.
    Life cycles. Project definition. Requirements. Functional specification. Initial domain modelling. UML class (domain) diagram. Use case diagram. Textual explanation. Case study.
  2. Introduction to Java and OO concepts in Java.
    Object-oriented (OO) specification, design and programming. Classes, objects, attributes, methods and relationships. Encapsulation and hiding, abstraction and classification, inheritance. Polymorphism, static and dynamic binding. Other relationships: association, aggregation, dependency.
  3. Design and implementation in Java of the Three-tier architecture
    The three-tier architecture design paradigm and its Java implementation
  4. Program debugging
    Verification. Program testing and debugging. Component testing. Testing and integration strategies. Test planning. Scaffolding and regression tests. Testing help tools (junit). Handling errors and exceptions.
  5. Design patterns in Java
    Some of the classical design patterns will be explained and implemented in Java (decorator, state, singleton, etc)
  6. Basic interface design concepts
    Input and output types. Principles of communication with humans. Information presentation, data entry and validation, navigation, support levels and user models.
  7. Software development toolchain
    There will be an overview of the typical toolchain to develop software: version control (git), testing integration (junit)

Activities

Activity Evaluation act


Project description and group creation

Description of project deliveries. Group creation for practical sessions.
Objectives: 8 2
Theory
1h
Problems
0h
Laboratory
2h
Guided learning
0h
Autonomous learning
0h

Introduction to Java and Basic OO concepts in Java

Topic 2 development.
Objectives: 8 4 5
Contents:
Theory
8h
Problems
0h
Laboratory
0h
Guided learning
0h
Autonomous learning
8h

Theory
4h
Problems
0h
Laboratory
0h
Guided learning
0h
Autonomous learning
2h

Program debugging

Topic 4 development.
Objectives: 8 6
Contents:
Theory
4h
Problems
0h
Laboratory
0h
Guided learning
0h
Autonomous learning
6h

Design patterns in Java

Some classic design patterns will be introduced (or reviewed if already known from the ISE course) and implemented in Java
Objectives: 4 5
Contents:
Theory
4h
Problems
0h
Laboratory
0h
Guided learning
0h
Autonomous learning
4h

Theory
4h
Problems
0h
Laboratory
0h
Guided learning
0h
Autonomous learning
4h

First delivery of the project

Implementation principles and design.Students will fully implement the domain model and the basic algorithmic kernel for the project, provide test suites for the implemented part and provide a preliminary design of the displays configuring the application interface.
Objectives: 8 1 2 3 6 4 5
Week: 9
Type: assigment
Theory
0h
Problems
0h
Laboratory
0h
Guided learning
0h
Autonomous learning
0h

Theory Test

This exam will assess the theory content.
Objectives: 1 4 5
Week: 12 (Outside class hours)
Type: final exam
Theory
0h
Problems
0h
Laboratory
0h
Guided learning
2h
Autonomous learning
15h

Second delivery of the project

Final project delivery. The documentation should include the diagram of classes (UML), full implementation of the project and the test suites as appropriate, and the user manual. Each group will also give a presentation of their project.
Objectives: 8 1 2 3 6 7 4 5
Week: 15 (Outside class hours)
Type: assigment
Theory
0h
Problems
0h
Laboratory
0h
Guided learning
2h
Autonomous learning
0h

Theory
0h
Problems
0h
Laboratory
10h
Guided learning
0h
Autonomous learning
20h

Theory
0h
Problems
0h
Laboratory
12h
Guided learning
0h
Autonomous learning
28h

Theory
0h
Problems
0h
Laboratory
0h
Guided learning
7.5h
Autonomous learning
0h

Teaching methodology

Topics will be explained in a practical way through the use of numerous examples.

The theory lessons will introduce the necessary knowledge, techniques and concepts for the course project.
Some of the laboratory classes (probably towards the beginning of the course) will be used to briefly present notations, languages, libraries and tools. In most laboratory classes, however, students take the initiative. A number of hours are available for project groups to work together and to discuss any doubts they have with the lecturer.

The two-hour theory classes and two-hour laboratory classes will take place once a week, except for the last two weeks (laboratory classes only). First week there are no laboratory classes.

The bulk of work on the subject will be on the project, which will have a strong algorithmic and data structure component.

The approach to implementing this project will be as follows:
- Students (12-15) will form five groups of three, called a cluster.
- Each cluster will be assigned a tutor.
- Within each group, a single student will be responsible for class programming and testing.

The programming language used will be Java.

Evaluation methodology

Final mark: 0.20 * Theory_Exam_Mark + 0.80 * Project_Mark

Project mark: (0.40 * Delivery1 + 0.60 * Delivery2) * FT

Given that the project is team work in which all group members (and only group members) must participate, the final project mark will be weighted according to a work factor (FT). This work factor is a score (0 <= FT <= 1) representing the work of each group member. The work factor will be determined on the basis of task distribution within the group (first and second delivery) and the final presentation of the group. Work factors will be published together with the second project delivery marks.

Transversal competency in teamwork: Assessment will be based on a simple formula, with the group tutor scoring competency aspects for each group member.

Transversal competency in entrepreneurship and innovation: Assessment will be based on a simple formula, with the group tutor scoring competency aspects for each group member.

Bibliography

Basic:

Complementary:

Web links

Previous capacities

Students are expected to be able to:
- Solve medium-difficulty algorithmic problems from clear specifications and implement their solutions in an imperative programming language.

- Understand basic program structuring mechanisms (modularisation, encapsulation, abstract data types, classes) and apply them to small and medium-sized tasks (a small number of modules).

- Understand object-oriented programming elements (classes, objects, execution mechanisms).

- Use an imperative object-oriented language.

- Use and program data structured in this language.

- Use libraries in this language.

- Master basic error location and correction strategies for simple modules.