Programming Projects

Credits
6
Types
Compulsory
Requirements
Department
CS
Web
http://www.cs.upc.edu/~prop
Make a programming project related to the life cycle of a software application, emphasizing the implementation step.

Teachers

Person in charge

Others

Weekly hours

Theory
2
Problems
0
Laboratory
2
Guided learning
0.28
Autonomous learning
5.72

Competences

Transversal Competences

Teamwork

  • G5 [Avaluable] - 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 [Avaluable] - 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. Test the program systematically and exhaustively.
      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 testing
      Verification. Program testing and debugging. Component testing. Testing and integration strategies. Drivers and stubs/mocks. 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 Concepts of Interface design in Java
      How to design a simple graphical user interface using Java standard libraries and applying the principles of 3-layer arquitecture
    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


    Software life cycle review

    Review of software engineering concepts and UML. Practical example of (part of) a first delivery.
    Objectives: 3 4 5
    Contents:
    Theory
    4h
    Problems
    0h
    Laboratory
    0h
    Guided learning
    0h
    Autonomous learning
    3h

    Project description and team creation

    Description of project deliveries. Team creation for practical sessions.
    Objectives: 8 2
    Theory
    0h
    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

    Design and implementation in Java of the Three-tier architecture

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

    Program debugging

    Topic 4 development.
    Objectives: 8 6
    Contents:
    Theory
    6h
    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

    Java: implementing interfaces

    Topic 6 development.
    Objectives: 8 7
    Contents:
    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 and provide test suites for the implemented part.
    Objectives: 8 1 2 3 6 4 5
    Week: 10
    Theory
    0h
    Problems
    0h
    Laboratory
    0h
    Guided learning
    0h
    Autonomous learning
    0h

    Second delivery of the project

    Intermediate project delivery. The documentation should include the complete diagram of classes (UML) of the project.
    Objectives: 8 1 2 3 7 4 5
    Week: 14
    Theory
    0h
    Problems
    0h
    Laboratory
    0h
    Guided learning
    0h
    Autonomous learning
    0h

    Third delivery of the project

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

    Supervision of first assignment

    Laboratory classes related to the first assignment.
    Objectives: 8 1 2 3 6 4 5
    Contents:
    Theory
    0h
    Problems
    0h
    Laboratory
    16h
    Guided learning
    0h
    Autonomous learning
    29h

    Supervision of second and third assignments

    Laboratory classes related to the second and third assignments.
    Objectives: 8 1 2 3 6 7 4 5
    Contents:
    Theory
    0h
    Problems
    0h
    Laboratory
    12h
    Guided learning
    0h
    Autonomous learning
    29.8h

    Third assignment presentation

    Presentation of the third assignment and interview.
    Objectives: 8
    Contents:
    Theory
    0h
    Problems
    0h
    Laboratory
    0h
    Guided learning
    2.2h
    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 (and there are two theory sessions).

    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 (15-20) from a laboratory group will form teams of four.
    - Each laboratory group will be assigned a tutor.
    - Within each team, a single student will be responsible for class programming and testing.

    The programming language used will be Java.

    Evaluation methodology

    Final mark: Project_Mark

    Project mark: (0.40 * Delivery1 + 0.15 * Delivery2 + 0.45 * Delivery3) * FT

    Given that the project is team work in which all team members (and only team 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 team member. The work factor will be determined on the basis of task distribution within the team (provided at the first and third deliveries) and the final presentation of the team. Work factors will be published together with the last project delivery marks.

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

    Transversal competency in entrepreneurship and innovation: Assessment is performed considering the initiative of the team in the two moments in which they have to make their own decisions, not predetermined in the subject: the extra functionalities of the project and the algorithms and data structures with which the main functionality is going to be solved. Therefore, the evaluation is a combination of two criteria:
    1) Depending on the optional functionalities proposed versus the optional functionalities implemented
    2) Depending on the initiative of the team when choosing algorithms and DSs to implement the main functionalities

    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.