Description:
The object-oriented programming paradigm is currently one of the most important paradigms in the programming world. Based on this idea, the course aims to teach students how to design and program using this paradigm, employing a modern language used in real-world environments.
The course will emphasize the software design phase and assumes that students have sufficient knowledge and mastery of the imperative and procedural paradigms to understand the imperative functioning of a new programming language.
Given that most software projects are developed by teams of programmers, the course also aims to equip students with the necessary skills to work in such environments.
Type Subject
Tercer - Obligatoria
Semester
Annual
Course
2
Credits
6.00
Titular Professors
Professor
Professors
Previous Knowledge:
Programming Methodology and Technology
Objectives:
The Learning Outcomes of this subject are:
LO.01 - Design of computer solutions to specific problems.
LO.02 - Code structuring and modularization.
LO.03 - Knowledge of a real imperative language.
LO.04 - Knowledge of a real object-oriented language.
LO.05 - Use of a real programming environment
LO.06 - Use of design patterns and class diagrams
LO.07 - Teamwork in the analysis, design, and implementation of software.
LO.08 - Learn software design, implementation, and validation methodologies.
LO.09 - Knowledge of real-time, event-driven, and cooperative programming techniques and languages
The subject, based on these learning outcomes, establishes as goals to ensure that the student, at the end of the subject:
Goal.1 - Demonstrates knowledge of the object-oriented paradigm and all its characteristics.
Goal.2 - Demonstrates knowledge of a real and actual object-oriented language.
Goal.3 - Demonstrates knowledge of using a real development environment.
Goal.4 - Demonstrates the ability to design software from specific specifications.
Goal.5 - Demonstrates knowledge to use software design patterns.
Goal.6 - Demonstrates the ability to work in a team.
Contents:
The detailed contents of the course are (this content is not necessarily given chronologically):
Knowledge of the object-oriented paradigm.
Concept of Class or Prototype
Concept of Object or Instance
Variables
Class Variables
Instance Variables
Concept of Message or Method
Class Methods
Instance Methods
Concept of Encapsulation and Abstraction
Concept of Inheritance
Concept of Polymorphism
Concept of Interface
Knowledge of a real object-oriented language
Introduction to Java
What is Java?
Key features of Java
Introduction to the language
Variables
Instance / class / local / parameter variables
Simple datatypes
Arrays
Operators
Assignment / Arithmetic / Comparisons
Instanceof
Sentences, Expressions and Blocks
Flow Control Statements
If / Switch / While & do-While / For
Break / Continue / Return
Exception Management
Introduction to the mechanism
How to create exceptions (throw /throws)
Try-catch-finally
Introduction to the OO
Class definition
Visibility (private / protected / package / public)
Method definition
Constructor methods
Parameter passing
The ?this? reference
Instantiation and use of objects
Static and Final
Enumerations
Inheritance in Java
Interfaces
Class hierarchy in Java
The Object class
Multiple Inheritance
Method Override
Polymorphism
The "super" reference
Subclass constructor methods
Abstract methods and classes
Numbers, Characters and Strings
Introduction to Generics
Packages
Basic I/O
Collections
AWT / Swing
Concurrence
Use of a real development environment.
Diagramming tool
IntelliJ IDEA as a development environment
Git as a Version Control System
Jira as a project management tool
Ability to design software from specifications.
UML
Class / Object / Message
Encapsulation and Abstraction
Encapsulation vs Visibility
Relationships between classes
Inheritance
Polymorphism
Use of software design patterns.
GRASP guidelines
Layered Architecture
Model-View-Controller pattern
Responsibility-driven design
Object-Orientation and Databases
DAO design pattern
Teamwork in a software development project.
Communication tools
Version Control Systems
Project management tools
The contents of the subject are distributed throughout the subject; the order of teaching does not correspond exactly with the order of the previous listing. During the subject, the concepts are presented and reinforced as the students make progress. The topics of analysis, design and implementation and patterns will be viewed iteratively throughout the subject by introducing the different data structures.
Methodology:
The course is designed so that students take an active role in their own learning. The teaching methodology is intended to make the course dynamic and participatory. Lectures are combined with exercise sessions and in-class activities, as well as guided practical sessions led by the course instructors.
The teaching methodology is clearly divided into two semesters. In the first semester, students acquire the fundamentals of the object-oriented paradigm and Java programming. The teaching approach includes lectures, continuous assessment exercises, and practical sessions. In the second semester, the course adopts a project-based learning methodology. The knowledge gained in the first semester is consolidated through the development of a near-real software development project.
The course content is structured across three levels. First, a theoretical introduction to the concept is provided. Then, software design concepts related to that topic are introduced. Finally, the implementation of these concepts in a programming language is explained.
Evaluation:
To pass the course, students must pass both semesters separately.
Final_Grade = Semester1_Grade * 0.5 + Semester2_Grade * 0.5
First Semester
The first semester is assessed through a set of individual exercises (moderately significant) and a project (highly significant).
The exercises serve a formative purpose, allowing students to individually practice the concepts before applying them in the project. The exercise grade is only considered if the project is passed and it benefits the student.
The semester project evaluates students' design and programming skills. It is divided into 2 design phases and 2 implementation phases. Each phase is assessed independently, and all phases must be passed individually to pass the project. If any phase is not passed, the maximum grade the student can receive for the project is four (4).
Exercise_Grade = Average(Exercise_1, Exercise_2, Exercise_3)
Project_Grade = Average(Phase_1, Phase_2, Phase_3, Phase_4) * 0.8 + Report * 0.2
Semester1_Grade = Project * 0.6 + Exercises * 0.4 (if Exercises > Project)
Semester1_Grade = Project (if Exercises ? Project)
Students must be part of a group, even if submitting the project individually or in pairs.
All phases and the report must be accepted to pass the project.
The evaluation rubric will specify the acceptance criteria.
Students have 3 submission opportunities for the project.
Second Semester
The second semester is assessed through a set of individual exercises (moderately significant) and a group project (highly significant), in teams of 5 students.
The exercises serve a formative purpose, allowing students to individually practice the concepts before applying them in the project. The exercise grade is only considered if the project is passed and it benefits the student.
The semester project is evaluated based on three components: (1) Project execution grade, (2) Mentorship grade, and (3) Peer-to-peer (P2P) evaluation grade.
Project Grade = (Execution * 0.4 + Software Quality * 0.4 + Documentation * 0.2) * Mentorship * P2P
The mentorship grade is a multiplier between 0.5 and 1.5, assigned individually by the project mentor based on weekly meetings and perceived student knowledge.
The P2P grade is a multiplier between 0 and 1.5, assigned by students to their group members via 4 questionnaires.
If a student fails to complete two or more questionnaires, their individual project grade will be marked as NP (Not Presented).
Exercise_Grade = Average(Exercise_4, Exercise_5, Exercise_6)
Semester2_Grade = Project * 0.6 + Exercises * 0.4 (if Exercises > Project)
Semester2_Grade = Project (if Exercises ? Project)
Students may only submit the project during the ordinary call.
Evaluation Criteria:
Basic Bibliography:
[1] C.S.Horstman and G.Cornell, Core Java 2, Vol I. Fundamentos, Septima edición, Prentice Hall, 2006.
[2] K.Arnold, JGosling and D.Holmes, The Java programming language, Boston : Addison-Wesley, 2000
[3] M.Fowler, UML Distilled Third Edition. A brief guide to the standard object modeling language, Addison-Wesley, 2003.
[4] R.Miles and K.Hamilton, Learning UML 2.0, O'Reilly Media Inc, 2006.
[5] C.Larman, Applying UML and patterns : an introduction to object-oriented analysis and design, Prentice Hall PTR, 1998
[6] E.Gamma, R.Helm, R.Johnson and J.Vlissides, Design patterns: elements of reusable object-oriented software, Addison-Wesley Longman Publishing Co., 1995
[7] J.Cooper, Java Design Patterns, Addison Wesley, 2000
[8] D.Lea, Concurrent programming in Java: design principles and patterns, Addison-Wesley, 2000
Additional Material:
[9] M.Fowler, Refactoring: Improving the Design of Existing Code, Addison-Wesley Professional, 2018
[10] R.Martin, Clean Code: A Handbook of Agile Software Craftsmanship, Pearson, 2008
[11] K.Sierra and B.Bates, Head First Java, O'Reilly Media, 2005
[12] E.Freeman, B.Bates, K.Sierra and E.Robson, Head First Design Patterns: A Brain-Friendly Guide, O'Reilly Media, 2004