DOCSEARCHbyAlgolia
Submit Docs

AddressBook Level 3 (AB3)

website·Indexed 29 days ago

https://nus-cs2103-ay2627-s1.github.io/website/

A desktop address book application used for teaching Software Engineering. The project includes a User Guide, Developer Guide, and implementation details covering UI, Logic, Model, and Storage. It utilizes java.util.logging for logging and JUnit 5 for testing.

Tokens
206.6K
Snippets
388
Records
1.5K
Agent score
73%

What's inside AddressBook Level 3

  1. Introduction to Use Cases for Functional Requirements

    A use case is a description of a set of sequences of actions, including variants, that a system performs to yield an observable result of value to an actor. Use cases are used to capture the functional requirements of a system by describing the interaction between a user (actor) and the system for a specific functionality.

  2. Overview of CS2103/T Software Engineering Course

    CS2103/T is an introductory Software Engineering course that balances core SE theory with practical skills. The course uses an iterative approach, covering topics in small increments and revisiting them as they become relevant to project tasks, rather than following a strict sequential order.

    Key practical components include:

    • A greenfield individual project: Developing a personal assistant chatbot called 'Duke'.
    • A brownfield team project: Taking over and evolving an existing project called 'AddressBook-Level3 (AB3)'.

  3. Overview of Peer Evaluation Process

    The course uses the TEAMMATES tool for multiple rounds of peer evaluations. Submitting these evaluations is compulsory; failure to do so can result in a loss of participation marks. It is strictly against course policy to ask team members to reveal the feedback they submitted for you.

  4. Overview of the Individual Project (iP) - Project Duke

    The Individual Project (iP) is an educational exercise centered around building 'Project Duke', a Personal Assistant Chatbot designed to help users keep track of various tasks and entities. The project is developed incrementally to teach and refresh core software engineering skills, including Java, Object-Oriented Programming (OOP), IDE usage, Git/GitHub, project automation, code quality, and the use of AI coding tools. Developers are encouraged to customize the chatbot's name and personality.

  5. Overview of the Team Project (tP) Timeline

    The Team Project (tP) spans ten weeks and utilizes a breadth-first iterative approach. The project is split into two main phases: a foundational period (Weeks 3-6) and a series of six iterations (Weeks 7-12) where the product is evolved incrementally from version 1.1 to 1.6.

  6. Overview of CS2103/T Software Engineering Course

    CS2103/T is an introductory Software Engineering course that balances core SE theory with practical skills. The course uses an iterative approach, covering topics in a non-sequential order based on their relevance to current project tasks. This allows students to practice SE aspects like testing from the beginning and evolve projects progressively.

    Learning resources include:

    • A customized online textbook: 'Software Engineering for Self-Directed Learners'.
    • A Schedule page for weekly topic progression.
    • A Textbook page for topics in natural sequential order (useful for exam reference).

  7. Overview of Software Development Lifecycle (SDLC) Process Models

    The Software Development Lifecycle (SDLC) consists of stages including requirements, analysis, design, implementation, and testing. Process models provide a 'roadmap' for these stages, defining their aims, outcomes, and relationships. The lifecycle extends beyond initial development to include deployment, operation, and maintenance, where user feedback and defects inform future development cycles.

  8. Overview of Integrated Development Environments (IDEs)

    Integrated Development Environments (IDEs) are tools that consolidate most software development tasks into a single application. A standard IDE typically integrates the following components:

    • Source Code Editor: Provides syntax coloring, auto-completion, code navigation, error highlighting, and snippet generation.
    • Build Tools: Includes compilers, interpreters, and build automation to handle compilation, linking, running, and deployment.
    • Debugger: Enables step-by-step execution of programs to observe runtime behavior and locate bugs.
    • Auxiliary Tools: Support for automated testing, UI construction, version control (Git), platform simulation, modeling, AI-assisted coding, and collaboration.

    Common IDEs by language include:

    • Java: IntelliJ IDEA, Eclipse, NetBeans
    • C# / C++: Visual Studio
    • Swift: Xcode
    • Python: PyCharm
    • Multi-language: VS Code

    Some developers prefer lightweight, scriptable text editors like Vim or NeoVim as alternatives to full-featured IDEs.

  11. Distinguish between Logical and Deployment views

    When documenting software architecture, separate the logical structure from the physical deployment to avoid confusion:

    1. Logical View: Shows the major parts of the system and their dependencies (which part depends on which). It describes the internal organization regardless of where the code runs.
    2. Deployment View: Shows where the parts actually run (e.g., on a user's computer, a specific server, or a cloud environment).

  12. Implement Assertions to verify program assumptions

    Assertions are used to define and verify assumptions about the program state (e.g., ensuring a variable is not null at a specific point). An assertion failure indicates a bug in the code. If an assertion fails, the runtime typically terminates the program to prevent further unsafe execution. Assertions are ideal for verifying internal invariants, control-flow invariants, preconditions, postconditions, and class invariants.
    x = getX();
assert x == 0 : "x should be 0";