Accessibility
ISEL

Modeling and Design Patterns-LEIC

Course: BSc in Computer Science and Computer Engineering
Curricular Unit (UC)

Modeling and Design Patterns

Mandatory  
Optional  x
Scientific Area IC
Year: 2nd Semester: 2nd ECTS: 6 Total Hours: 160
Contact Hours T: TP: 67.5 PL: S: OT:
Professor in charge

 Fernando Miguel Gamboa de Carvalho

T - Theoretical; TP - Theory and practice; PL - Laboratory; S - Seminar; OT - Tutorial.

  • Intended learning outcomes

    Students who successfully complete this course unit will be able to:

    (1) Describe the main object oriented design patterns.

    (2) Understand the asynchronous programming model and use asynchronous APIs.

    (3) Use higher order abstractions that represent effects or control flow, such as: Streams, Futures, Promises, and Continuations

    (4) Develop software components based on non-blocking asynchronous approaches with asynchronous APIs.

  • Syllabus

    1. Introduction to object oriented (OO) design patterns.

    2. Behavior parametrization and first-class functions.

    3. Higher order functions (e.g. andThen, memoize, etc) and functions composition.

    4. Simplifying OO design patterns.

    5. Fluent APis (e.g. comparing, reversed, thenComparing, etc)

    6. Default methods and their use in design patterns and interface composition.

    7. Introduction to Streams as sequences of items with on-demand processing.

    8. Chaining, immutable and mutable reduction operations.

    9. Streams Generators.

    10. Asynchronous programming model.

    11. Programming essential effects and their relation between the synchronous and asynchronous model.

    12. Designing asynchronous APIs with Futures, Promises and Continuations.

  • Evidence of the syllabus coherence with the curricular unit’s intended learning outcomes

    This course main goal is the introduction to advanced programming techniques, which combine the object oriented programing paradigm with functional reactive programming approaches (https://en.wikipedia.org/wiki/Functional_reactive_programming).

    Functional reactive programming is a programming paradigm oriented by data flows and the propagation of changes that uses building blocks of functional programming.

    These approaches offer a development idiom that aims scalability, maintainability and evolvable systems

  • Teaching methodologies (including evaluation)

    Theoretical and practical teaching is planned during the semester in 30 lectures that correspond to 67.5 of contact hours (15 lessons of 3 hours and 15 1.5 hours). The total student working hours is 160. The lectures are intended for presentation and explanation of the topics and their practical application demonstration.

    Lessons embrace the presentation of problems and discussion of different solutions through the discussion and design of conceptual models.

    The core subjects are still extended in assessments and workouts. The curricular unit's goals are evaluated through: (1) test (T), (2) assessment forms (F) and (3) projects argumentation (P). The final grade is the result of the following formula: 40% [T] + 20%[F] + 40% [P].

     

  • Evidence of the teaching methodologies coherence with the curricular unit’s intended learning outcomes

    The concepts are introduced through the presentation of issues that are discussed with the students, under the teacher guidance and solved through the development of models in the whiteboard, which reflect the suggestions from the audience. Finally we implemented the solution that best meets the requirements of efficiency, flexibility and extensibility.

    The assessment forms replicate the same kind of problems presented in the classroom, but applied in a new context, and should be resolved independently by the student and with the support of teachers.

    The projects include a set of challenges that must be solved through the application of acquired knowledge. The projects evaluation is based on an argumentation which discusses the solutions developed by the student.

  • Main Bibliography:

    R.Urma, M. Fusco, A. Mycroft, Modern Java in Action - Lambdas, streams, functional and reactive programming, Manning Publications, 2018, ISBN 9781617293566