DOCSEARCHbyAlgolia
Submit Docs

CS2113/T: Software Engineering & Object-Oriented Programming

website·Indexed 30 days ago

https://nus-cs2113-ay2122s1.github.io/website/schedule/

Course materials for CS2113/T, covering software engineering and object-oriented programming. The curriculum includes Java casting, OOP fundamentals (classes, objects, abstraction, encapsulation), intermediate class diagrams, software architecture (n-Tier, Client-Server), quality assurance (Boundary Value Analysis, validation vs verification), and code quality guidelines. It also details project deliverables, sequence diagrams, and testing strategies including unit and API/CLI testing.

Tokens
146.9K
Snippets
374
Records
1.1K
Agent score
70%

What's inside CS2113/T

  1. Overview of the Individual Project (iP) objectives

    The Individual Project (iP) is designed to teach or refresh fundamental software development skills that are essential for the subsequent team project (tP). The core learning objectives include Java programming, Object-Oriented Programming (OOP), using Integrated Development Environments (IDEs), version control with Git and GitHub, project automation tools, and maintaining code quality. The project is based on a generic project called 'Project Duke'.

  2. Overview of Software Quality Assurance (QA) techniques

    Software Quality Assurance (QA) is the process of ensuring software meets required quality levels. While testing is the most common QA activity, it is complemented by other techniques including:

    • Static Analysis: Analyzing code without executing it.
    • Code Reviews: Peer examination of source code.
    • Formal Verification: Using mathematical proofs to ensure correctness.

  3. Overview of Peer Evaluation Sessions

    Peer evaluations are conducted in multiple rounds using the TEAMMATES tool (accessible via Admin Tools → TEAMMATES). Submitting evaluations is compulsory; failure to do so may result in loss of participation marks. There are three primary sessions:

    1. Practice Peer Evaluation: Held early in the semester to familiarize students with the tool. Compulsory, but not used for grading.
    2. Midterm Peer Evaluation: Held approximately two weeks into the tP coding phase.
    3. Final Peer Evaluation: Held at the end of the tP. Compulsory for participation marks and a prerequisite for the ability to rebut received evaluations.

  4. Overview of CS2113/T Software Engineering Module

    CS2113/T is an introductory Software Engineering module that balances basic SE theory with practical skills. It introduces the Java programming language, the Object-Oriented Programming (OOP) paradigm, and basic UML models. The module uses an iterative approach to teaching, meaning it covers multiple SE aspects (requirements, design, testing, project management) in small increments and revisits them with increasing depth throughout the semester, rather than teaching them in a strict sequential order.

  5. Overview of CS2113T Project Grading Scheme

    Project grading is non-competitive (not bell-curved) and assessed separately for CS2113T and CS2113 projects. The total score is 45 marks, consisting of 40 individual marks and 5 team marks, divided across four main categories: Product Design, Implementation, QA, and Documentation.

  7. Overview of Java Collection Interfaces

    The Java Collections Framework provides several core interfaces for grouping objects. The root of the hierarchy is the Collection interface, which represents a group of elements. Key sub-interfaces include:

    • Set: A collection that cannot contain duplicate elements (models a mathematical set).
    • List: An ordered collection (sequence) that allows duplicate elements and provides precise control over insertion points and index-based access.
    • Queue: A collection used to hold elements prior to processing, offering specialized insertion, extraction, and inspection operations.
    • Map: An object that maps unique keys to values; each key can map to at most one value.

  8. Introduction to the Object-Oriented Programming (OOP) paradigm

    Object-Oriented Programming (OOP) is a programming paradigm that structures solutions by grouping operations and data into modular units called objects. Unlike procedural programming (e.g., C), which divides the world into static data and functions that operate on that data, OOP treats objects and their interactions as the basic elements of design. Java is primarily an OOP language, though it supports limited functional programming and can be used for procedural code.

  9. Overview of Project Duke development levels

    Project Duke is an incremental software project to build a Personal Assistant Chatbot. The development is structured into levels of increasing complexity:

    • Level 0: Basic greeting and exit.
    • Level 1: Greeting, echoing user input, and exiting via 'bye'.
    • Level 2: Ability to add and list text-based tasks.
    • Level 3: Ability to mark tasks as done.
    • Level 4: Support for specific task types: ToDos (no date), Deadlines (due by date), and Events (start/end time).
    • Level 5: Implementation of error handling for incorrect user inputs.
    • Level 6: Task deletion.
    • Level 7: Data persistence (saving).
    • Level 8: Proper Date and Time handling.
    • Level 9: Search/Find functionality.
    • Level 10: Graphical User Interface (GUI).

  10. Understand Objects as Abstractions and Encapsulations

    In OOP, objects serve as an abstraction mechanism by hiding lower-level implementation details (like data formats or specific algorithms) and allowing developers to interact with higher-granularity entities.

    Encapsulation in objects consists of two primary aspects:

    1. Packaging: Grouping data and related behaviors into a single self-contained unit.
    2. Information Hiding: Restricting direct access to an object's internal data, making it accessible only through the object's defined interface to protect the implementation from unintended actions.

  12. Understand and apply Abstraction in software design

    Abstraction is a technique for managing complexity by establishing a specific level of interest and suppressing more complex details below that level. The guiding principle is that only details relevant to the current perspective or task should be considered.

    There are two primary types of abstraction:

    • Data Abstraction: Abstracting lower-level data items into larger entities (e.g., treating a User object as a single entity while ignoring specific fields like name or date of birth).
    • Control Abstraction: Abstracting the actual control flow to focus on high-level tasks (e.g., using print("Hello") instead of managing the computer's low-level output mechanisms).

    Abstraction can be applied hierarchically to create higher levels of abstraction (e.g., Bit $\rightarrow$ Array $\rightarrow$ File). General examples include OOP classes, software architectures, and UML models.