DOCSEARCHbyAlgolia
Submit Docs

CS2100 Public Resources

website·Indexed 30 days ago

https://neu-pdi.github.io/cs3100-public-resources

Lecture notes and resources for CS2100, covering Python programming, object-oriented design (inheritance, composition, interfaces), design patterns (Observer, Strategy, MVC), data structures, and algorithms such as Minimum Spanning Trees and Kruskal's algorithm. Includes materials on data science with pandas and numpy, Value-Sensitive Design (VSD) ethics, and software testing practices like mutation testing.

Tokens
464.1K
Snippets
1.6K
Records
2.8K
Agent score
73%

What's inside CS2100

  1. Overview of Hexagonal Architecture Refactoring Lab

    The goal of this lab is to refactor a monolithic codebase into a hexagonal architecture. The primary focus is on two feature areas: Device Management and Automation Rules. The objective is to untangle infrastructure (like database connections and IoT network requirements) from business logic to improve testability and maintainability. Key concepts applied include identifying domain vs. infrastructure, designing port interfaces, and replacing the DatabaseConnection singleton with dependency injection.

  2. Overview of the CookYourBooks Semester Project

    The semester project is a comprehensive recipe management application. It is developed incrementally across multiple assignments. Key technical components include:

    • Domain Model: Modeling ingredients, quantities, and recipes.
    • Persistence: Implementing JSON serialization and file storage.
    • Testing: Utilizing unit tests and mutation testing.
    • Architecture: Implementing service layers and clean separation of concerns.
    • OCR Integration: Importing recipes from photos.
    • GUI: Building a graphical user interface using JavaFX.

  3. Overview of common structural design patterns

    Key patterns for managing changeability and class structure include:

    • Strategy: Swap algorithms at runtime via a common interface.
    • Decorator: Wrap objects to dynamically add behavior using composition.
    • Template Method: Enable subclasses to customize specific steps of a predefined algorithm skeleton.

  4. Introduction to Domain Modeling

    Domain modeling is the process of transforming real-world requirements (gathered via stakeholder interviews, user stories, and acceptance criteria) into a structured understanding that guides software design. The primary goal is understandability, ensuring that code is easy for humans to navigate, predict, and change by aligning the implementation with the business process and vocabulary of the problem domain.

  5. Overview of Google File System (GFS)

    The Google File System (GFS) is a distributed file system designed to store data across thousands of commodity machines. It separates metadata management from actual data storage to solve large-scale storage problems.

    Key components include:

    • NameNode (GFS Master): Manages metadata, specifically tracking which machines hold which data chunks.
    • DataNodes (GFS Chunkservers): Store the actual data chunks.

  6. Overview of the CookYourBooks Semester Project

    The semester project is a recipe management application. It is built incrementally across several assignments and covers the following technical areas:

    • Domain Model: Ingredients, quantities, and recipes.
    • Persistence: File storage using JSON serialization.
    • Testing: Unit tests and mutation testing.
    • Architecture: Service layers and clean separation of concerns.
    • OCR Integration: Importing recipes from photos.
    • GUI: A graphical user interface built with JavaFX.

  7. Overview of Lab 14: The Future of Programming

    Lab 14 is a non-coding, discussion-based lab designed to prepare students for lecture L38: The Future of Programming. The lab follows a 'read → pair → share → discuss' workflow where students evaluate claims about AI's impact on software development, synthesize perspectives from multiple sources, and practice technical discussion skills.

  8. Overview of the MapReduce Programming Model

    MapReduce is a system for distributing computation across thousands of machines to process massive datasets. It solves the computation problem by breaking tasks into smaller units executed in parallel.

    Key components include:

    • Coordinator: Assigns tasks to workers and handles failure recovery.
    • Workers: Execute user-defined functions to process data.

  9. Overview of Lab 5: Requirements Engineering

    Lab 5 is a requirements analysis exercise where students interpret an intentionally ambiguous project brief for an 'Office Hours System'. The goal is to demonstrate how the same text can lead to different interpretations and to practice building a shared understanding through negotiation. This lab contains no coding exercises; all work is documented in REFLECTION.md.

  10. Overview of the cyb3-json-serialization assignment

    The assignment focuses on expanding the CookYourBooks application through domain modeling and persistence architecture. Key tasks include organizing recipes into collections (published cookbooks, personal recipe boxes, web imports), managing a user's library, and implementing persistence via JSON serialization and Markdown export. The core objective is to separate domain logic from external concerns (storage and file formats) using repository interfaces.

  11. Introduction to Domain Modeling

    Domain modeling is the process of transforming real-world requirements (gathered via stakeholder interviews, user stories, and acceptance criteria) into a structured understanding that guides software design. The primary goal is understandability, ensuring that code is written for humans to read and trust, making it easier to navigate, predict, and change. A domain-aligned design uses the same concepts, relationships, and vocabulary as the business process, effectively bridging the gap between non-technical stakeholders and the implementation.

  12. Overview of Kotlin and JVM Interoperability

    Kotlin is a modern language developed by JetBrains that is fully interoperable with Java and runs on the Java Virtual Machine (JVM). It is designed to reduce Java's verbosity and boilerplate code, providing features like null-safety and top-level functions. Both Java and Kotlin source code are compiled into the same JVM bytecode, allowing them to coexist in the same project.