DOCSEARCHbyAlgolia
Submit Docs

TIC2002 Software Engineering Course Materials

website·Indexed 29 days ago

https://nus-tic2002-ay2526S1.github.io/website/

Course documentation and learning materials for TIC2002, covering software engineering fundamentals. The content includes a transition guide from C++ to Java (recommending Java 17), comprehensive tutorials on revision control using Git and GitHub (including staging, commits, branching, merging, rebasing, and cherry-picking), and weekly course schedules.

Tokens
137.9K
Snippets
545
Records
1.1K
Agent score
69%

What's inside TIC2002

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

    The Software Development Lifecycle (SDLC) consists of several stages: requirements, analysis, design, implementation, and testing. SDLC process models (or software process models) provide a 'roadmap' for developers to manage this effort, defining the aims of each stage, the expected outcomes (artifacts), and the workflow between stages.

  2. Overview of Git Learning Trail Tours

    The Git Learning Trail is a structured curriculum divided into 'tours', each focusing on a specific Git usage scenario. The tours are organized as follows:

    • Tour 1: Recording the History of a Folder: Systematically recording folder history and saving snapshots on a local computer.
    • Tour 2: Backing up a Repo on the Cloud: Backing up a local Git repository to a cloud-based service like GitHub.
    • Tour 3: Working Off a Remote Repo: Interacting with and utilizing an existing remote repository.
    • Tour 4: Using the Revision History of a Repo: Leveraging the stored revision history for development tasks.
    • Tour 5: Fine-Tuning the Revision History: Maintaining a clean and meaningful commit history.
    • Tour 6: Branching Locally: Managing multiple timelines of work within a local repository.
    • Tour 7: Keeping Branches in Sync: Synchronizing different local branches.
    • Tour 8: Working with Remote Branches: Synchronizing local branches with branches on a remote repository.

  4. Overview of the Java Collections Framework hierarchy

    The Java Collections Framework provides a set of interfaces and classes to represent groups of objects. The core interfaces include:

    • Collection: The root interface for most collections. It represents a group of elements and is used for maximum generality.
    • Set: A collection that cannot contain duplicate elements (models a mathematical set).
    • List: An ordered sequence that allows duplicate elements. Elements can be accessed by their integer index.
    • Queue: Used to hold elements prior to processing, providing specific insertion, extraction, and inspection operations.
    • Map: An object that maps unique keys to values. Each key can map to at most one value.
    • Other specialized interfaces include Deque, SortedSet, and SortedMap.

  5. Introduction to Revision Control (VCS)

    Revision control (also known as Version Control Software or VCS) is the process of managing multiple versions of information. It automates the tracking of a project's evolution, allowing developers to:

    • Track history: Maintain a log of who made changes, when, and why.
    • Collaborate: Identify and resolve conflicts when multiple people make incompatible changes.
    • Recover from mistakes: Revert files to earlier versions.
    • Manage drift: Work on multiple versions of a project simultaneously.

    Git is currently the most widely used RCS, and GitHub is a web-based hosting platform specifically for projects using Git.

  7. Overview of the Git workflow for recording folder history

    To systematically record the history of a local folder and save snapshots at specific points in time, follow these sequential steps:

    1. Initialize a Repository: Put the folder under Git's control by initializing a Git repository.
    2. Staging: Specify which files or changes should be included in the next snapshot.
    3. Commit: Save the snapshot to the version control system.
    4. Examine History: Visualize the timeline of commits using the revision graph.

  9. 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:

    1. 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 when they are not relevant to the current task).
    2. Control Abstraction: Abstracting the details of control flow to focus on higher-level tasks (e.g., using a print("Hello") function instead of managing the computer's actual output mechanism).

    Abstraction can be applied repeatedly to create higher levels of abstraction (e.g., Bit $\rightarrow$ Array $\rightarrow$ File). It also applies to OOP classes, software architectures, and UML models.

  10. Understand the two main aspects of software design

    Software design is the creative process of transforming a problem into a solution. It is divided into two primary perspectives:

    1. Product/External Design: Focuses on designing the external behavior of the product to ensure it meets user requirements. This process typically involves product designers, business analysts, UX experts, and user representatives.
    2. Implementation/Internal Design: Focuses on how the product will be technically implemented to achieve the required external behavior. This process is typically handled by software architects and software engineers.

  11. Understand software integration and build automation

    Integration is the process of combining individual parts of a software product to form a complete whole. To manage the complexity of this process, build automation tools are used to automate steps such as pulling code from revision control, compiling, linking, running automated tests, packaging, and deployment.

    Common build tools include:

    • Java: Gradle, Maven, Apache Ant, GNU Make
    • JavaScript: Grunt
    • Ruby: Rake

    Many of these tools (like Maven and Gradle) also function as dependency management tools, automating the downloading and updating of third-party libraries.