DOCSEARCHbyAlgolia
Submit Docs

NUS CS2113 Software Engineering Course

website·Indexed 29 days ago

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

Course materials for CS2113, featuring a weekly schedule and an adapted software engineering textbook. Topics include software reuse, error handling, design approaches, testing (unit, integration, and UAT), quality assurance, debugging via the TRAFFIC method, refactoring, and transitioning from C++ to Java.

Tokens
155.7K
Snippets
321
Records
1.1K
Agent score
68%

What's inside CS2113

  1. Overview of the Individual Project (iP)

    The Individual Project (iP) is designed to help students learn or refresh fundamental skills in Java, Object-Oriented Programming (OOP), IDEs, Git/GitHub, project automation tools, code quality, and AI coding tools. The iP is based on a generic project called 'Project Duke' and is completed during the first half of the semester. Skills and code developed during the iP are intended to be leveraged later in the Team Project (tP).

  2. 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 provides the following core components:

    • Source Code Editor: Features syntax coloring, auto-completion, code navigation, error highlighting, and snippet generation.
    • Build Tools: Integrated compilers, interpreters, and build automation to handle compilation, linking, running, and deployment.
    • Debugger: Tools to execute programs step-by-step to observe runtime behavior and locate bugs.
    • Additional Utilities: Support for automated testing, UI component construction, version control, platform simulation, 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 text editors with scripting capabilities, such as Vim or NeoVim, as alternatives to full IDEs.

  3. Overview of Java Collection Interfaces

    Java provides a hierarchy of interfaces to handle groups of objects. The core interfaces include:

    • Collection: The root interface for all collections; used for maximum generality.
    • Set: A collection that cannot contain duplicate elements (models mathematical sets).
    • List: An ordered sequence that allows duplicate elements; elements are accessible by 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 maps to at most one value.
    • Other specialized interfaces include Deque, SortedSet, and SortedMap.

  4. 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 may result in a loss of participation marks. A critical course policy prohibits asking team members to reveal the feedback they submitted for you, regardless of the motive.

  5. Overview of CS2113 Software Engineering Course

    CS2113 is an introductory Software Engineering course that balances basic SE theory with practical skills. The course introduces the Java programming language, the Object-Oriented Programming (OOP) paradigm, and basic UML models. Learning is split into two main components: theory, supported by the 'Software Engineering for Self-Directed Learners' online textbook, and practice, which consists of an individual project (developing a chatbot named 'Duke') followed by a collaborative team project.

  6. Overview of the Java Collections Framework

    The Java Collections Framework is a unified architecture for representing and manipulating collections (objects that group multiple elements into a single unit). It consists of three main components:

    1. Interfaces: Abstract data types that represent collections (e.g., List<E>, Map<K, V>). These allow collections to be manipulated independently of their internal representation.
    2. Implementations: Concrete, reusable data structures that implement the interfaces (e.g., ArrayList<E> implements List<E>, HashMap<K, V> implements Map<K, V>).
    3. Algorithms: Polymorphic methods that perform computations like searching and sorting on objects implementing collection interfaces (e.g., sort(List<E>)).

  7. Introduction to the Software Development Lifecycle (SDLC)

    The Software Development Lifecycle (SDLC) is a framework describing the stages of software development. Common stages include requirements, analysis, design, implementation, and testing. The lifecycle extends beyond initial release to include deployment, operation, and maintenance. Feedback from the operation and maintenance phase (such as user-reported defects and feature requests) serves as input for future development cycles.

  8. Overview of Software Engineering Principles

    Software engineering is the application of a systematic, disciplined, and quantifiable approach to the development, operation, and maintenance of software. Its primary goal is to transform human needs into dependable software while operating within real-world constraints such as time, budget, personnel, and incomplete information. It encompasses more than just programming; it includes requirements definition, verification (testing), and long-term maintenance.

  9. Overview of Team Project (tP) Grading Scheme

    Project grading is non-competitive (not bell-curved). The total score is 45 marks, consisting of 40 individual marks and 5 team marks. The grading is divided into five main components: Product Design (5 marks), Implementation (10 marks), QA (10 marks), Documentation (10 marks), and Project Management (10 marks).

  10. Overview of Integrated Development Environments (IDEs)

    Integrated Development Environments (IDEs) are tools used by professional software engineers to consolidate most development-related tasks within 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 Automation: Includes compilers and/or interpreters to handle compilation, linking, running, and deployment.
    • Debugger: Enables step-by-step program execution to observe run-time behavior and locate bugs.
    • Additional Tooling: May include automated testing support, UI component builders, version control integration, runtime simulation, AI-assisted coding, and collaboration tools.

  11. Introduction to Software Modeling and UML

    A model is an abstraction that provides a simplified representation of a complex entity by capturing only selected aspects. In software development, models serve three primary purposes:

    1. Analysis: Understanding problem domains or planning software architecture.
    2. Communication: Acting as visual aids for stakeholders (e.g., using use case diagrams for customers or architecture diagrams for developers).
    3. Blueprints: Providing instructions for implementation, where a design (like a class diagram) is used by programmers to write code, or used by Model Driven Development tools to generate code automatically.

    Unified Modeling Language (UML) is the industry-standard graphical notation used to describe these various aspects of software systems.

  12. Understand the fundamentals of Software Engineering

    Software engineering is the application of a systematic, disciplined, and quantifiable approach to the development, operation, and maintenance of software. Its primary goal is to turn human needs into dependable software while managing real-world constraints such as time, budget, personnel, and incomplete information. It encompasses not only programming but also requirements analysis, verification (testing), and long-term maintenance.