Skip to content

GDSC-FSC/gdg-fsc-weekly-technical-24-25

BranchesTags

Repository files navigation

GDSC-FSC Weekly Technical Challenges 2024-2025

License: MIT GitHub Stars Contributor Covenant Maintained by GDSC-FSC

🚀 Dive Deep, Build from Scratch! Embark on a hands-on journey to engineer foundational systems like Kafka, DNS, Git, and more, understanding their core mechanics from first principles.

🧭 Table of Contents

✨ Overview & Introduction

Welcome to the GDSC-FSC Weekly Technical Challenges 2024-2025 repository! This project serves as a structured learning platform for students and enthusiasts to understand the fundamental mechanics behind complex software systems. Inspired by platforms like CodeCrafters.io, this repository guides you through building simplified versions of real-world applications and protocols from the ground up.

What is this application? This repository is a curated collection of independent coding challenges, each focused on recreating a core component of a widely used system. From crafting your own Kafka broker to implementing a DNS server, a shell, or even Git, each "week" presents a new challenge designed to deepen your understanding of computer science fundamentals and system design.

Purpose & Goals:

  • Hands-on Learning: Provide practical experience in system-level programming.
  • Conceptual Mastery: Demystify how foundational software like databases, networking protocols, and version control systems work.
  • Skill Development: Enhance problem-solving, debugging, and coding skills in various programming languages.
  • Community Engagement: Foster collaborative learning and knowledge sharing within the GDSC-FSC community.

Why it matters / Problem it solves: Many developers use high-level abstractions without truly understanding the underlying mechanisms. This repository tackles that gap by offering challenges that force you to confront and solve the low-level problems that these systems address. This deep understanding is invaluable for writing more efficient code, debugging complex issues, and designing robust systems.

Target Audience:

  • Members of GDSC-FSC (Google Developer Student Clubs - Florida Southwestern State College).
  • Computer Science students looking for hands-on experience.
  • Aspiring software engineers preparing for technical interviews.
  • Anyone curious about the internals of popular software systems.

⬆️ Back to Top

🌟 Feature Highlights

This repository is a collection of "features," where each feature is a weekly coding challenge. Here are some of the exciting systems you'll get to build:

  • ✅ Week 1: Build Your Own Kafka
    • 🔍 Implement a toy Kafka clone.
    • 💡 Learn about the Kafka wire protocol, network handling, TCP sockets, and event loops.
    • ⚙️ Language: JavaScript
  • 🌐 Week 2: Build Your Own DNS Server
    • 🔍 Create a basic DNS resolver.
    • 💡 Understand DNS query/response formats, UDP sockets, and recursive lookups.
    • ⚙️ Language: Java
  • ✍️ Week 3: Build Your Own Interpreter
    • 🔍 Develop an interpreter for a simple programming language.
    • 💡 Explore lexical analysis (scanning), parsing (AST creation), and execution.
    • ⚙️ Language: Rust
  • 💾 Week 4: Build Your Own SQLite
    • 🔍 Implement a subset of SQLite functionality.
    • 💡 Dive into database file formats, B-trees, and SQL parsing.
    • ⚙️ Language: Go
  • 🌳 Week 5: Build Your Own Git
    • 🔍 Recreate core Git commands like init, cat-file, hash-object, ls-tree, commit-tree, write-tree.
    • 💡 Grasp the concepts of content-addressable storage, Git object model (blobs, trees, commits), and the DAG structure.
    • ⚙️ Language: Rust
  • 🐚 Week 6: Build Your Own Shell
    • 🔍 Craft a basic command-line interpreter.
    • 💡 Learn about process creation (fork, exec), I/O redirection, and environment variables.
    • ⚙️ Language: Python
  • ⚡ Week 7: Build Your Own Redis
    • 🔍 Construct a simple in-memory key-value store.
    • 💡 Understand the Redis wire protocol (RESP), TCP servers, and basic data structures.
    • ⚙️ Language: TypeScript / Node.js
  • torrent Week 8: Build Your Own BitTorrent Client - 🔍 Develop a basic BitTorrent client to download files. - 💡 Explore peer-to-peer networking, BitTorrent protocol, Bencoding, and torrent file structure. - ⚙️ Language: Go
  • 🌍 Week 9: Build Your Own HTTP Server
    • 🔍 Implement a minimal HTTP/1.1 server.
    • 💡 Learn about HTTP request/response parsing, TCP sockets, and handling various HTTP methods.
    • ⚙️ Language: TypeScript / Node.js
  • 🔎 Week 10: Build Your Own Grep
    • 🔍 Create a command-line utility similar to grep.
    • 💡 Deep dive into regular expressions, pattern matching algorithms, and file I/O.
    • ⚙️ Language: Rust

⬆️ Back to Top

🏛️ Architecture & Repository Structure

This repository is organized as a monorepo, where each "week" constitutes an independent project or challenge. While each challenge has its own internal architecture (specific to the system being built), the overall repository structure is designed for modularity and easy navigation.

The core idea is: gdsc-fsc-gdg-fsc-weekly-technical-24-25/ ├── week-X-byo-system-name/ (e.g., week-1-byo-kafka/) │ ├── README.md (Challenge-specific instructions) │ ├── codecrafters.yml (Configuration for CodeCrafters platform) │ ├── your_program.sh (Local execution script) │ ├── app/ or src/ (Your solution code) │ └── ... (Language-specific files like package.json, Cargo.toml, pom.xml, go.mod, etc.)

graph TD
    A[GDSC-FSC Weekly Technical 24-25 Repository] --> B(Common Scripts & Docs);
    A --> C1(Week 1: BYO Kafka);
    A --> C2(Week 2: BYO DNS Server);
    A --> C3(Week 3: BYO Interpreter);
    A --> C4(Week 4: BYO SQLite);
    A --> C5(Week 5: BYO Git);
    A --> C6(Week 6: BYO Shell);
    A --> C7(Week 7: BYO Redis);
    A --> C8(Week 8: BYO BitTorrent);
    A --> C9(Week 9: BYO HTTP Server);
    A --> C10(Week 10: BYO Grep);

    B --> B1[README.md];
    B --> B2[LICENSE];
    B --> B3[setup.sh];
    B --> B4[count.py];

    C1 --> C1a[week-1-byo-kafka/];
    C2 --> C2a[week-2-byo-dns-server/];
    C3 --> C3a[week-3-byo-interpreter/];
    C4 --> C4a[week-4-byo-sqlite/];
    C5 --> C5a[week-5-byo-git/];
    C6 --> C6a[week-6-byo-shell/];
    C7 --> C7a[week-7-byo-redis/];
    C8 --> C8a[week-8-byo-bit-torrent/];
    C9 --> C9a[week-9-byo-http-server/];
    C10 --> C10a[week-10-byo-grep/];

    C1a --> C1b[README.md (Challenge)];
    C1a --> C1c[your_program.sh];
    C1a --> C1d[app/main.js (Solution)];
    C1a --> C1e[codecrafters.yml];

    style A fill:#f9f,stroke:#333,stroke-width:2px;
    style B fill:#ccf,stroke:#333,stroke-width:1px;
    style C1 fill:#dcf,stroke:#333,stroke-width:1px;
    style C2 fill:#dcf,stroke:#333,stroke-width:1px;
    style C3 fill:#dcf,stroke:#333,stroke-width:1px;
    style C4 fill:#dcf,stroke:#333,stroke-width:1px;
    style C5 fill:#dcf,stroke:#333,stroke-width:1px;
    style C6 fill:#dcf,stroke:#333,stroke-width:1px;
    style C7 fill:#dcf,stroke:#333,stroke-width:1px;
    style C8 fill:#dcf,stroke:#333,stroke-width:1px;
    style C9 fill:#dcf,stroke:#333,stroke-width:1px;
    style C10 fill:#dcf,stroke:#333,stroke-width:1px;
Loading

High-level overview of the repository structure.

High-Level Challenge Workflow

The general workflow for engaging with any challenge follows a consistent pattern, designed for iterative development and testing:

graph TD
    A[Start: Select a Weekly Challenge] --> B{Navigate to `week-X-byo-challenge`};
    B --> C[Read Challenge `README.md`];
    C --> D[Install Language-Specific Prerequisites];
    D --> E[Implement Solution in `app/` or `src/`];
    E --> F[Test Locally with `./your_program.sh`];
    F -- Tests Pass? --> G{Yes};
    F -- Tests Fail? --> H{No, Debug & Refine};
    H --> E;
    G --> I[Commit Changes];
    I --> J[Push to CodeCrafters (or your fork)];
    J --> K[Review Automated Feedback];
    K -- Needs Improvement? --> E;
    K -- Complete? --> L[End: Challenge Solved!];
Loading

General workflow for tackling a challenge.

Technology Stack

Given the diverse nature of the challenges, this repository leverages a variety of programming languages and ecosystems:

  • JavaScript/TypeScript (Node.js): For BYO Kafka, BYO Redis, BYO HTTP Server.
  • Java (Maven): For BYO DNS Server.
  • Rust (Cargo): For BYO Interpreter, BYO Git, BYO Grep.
  • Go: For BYO SQLite, BYO BitTorrent.
  • Python (Pipenv/pip): For BYO Shell.

Each challenge directory contains the necessary configuration files (e.g., package.json, pom.xml, Cargo.toml, go.mod, Pipfile) to manage dependencies specific to its language and project.

⬆️ Back to Top

🚀 Getting Started & Setup

To get started with the challenges, you'll first need to clone the repository and ensure you have the necessary development tools installed.

Prerequisites

You'll need git to clone the repository. Beyond that, the required tools vary by challenge. We recommend installing the following:

  • Git: Latest version.
  • Node.js: v21+ (for JavaScript/TypeScript challenges). 
    # Example for NVM (Node Version Manager)
nvm install 21
nvm use 21
  • Java Development Kit (JDK): v17+ (for Java challenges). 
    # Example for Ubuntu
sudo apt update
sudo apt install openjdk-17-jdk
  • Maven: Latest version (for Java challenges). 
    # Example for Ubuntu
sudo apt install maven
  • Rustup: Latest stable Rust toolchain (for Rust challenges). 
    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  • Go: v1.21+ (for Go challenges). 
    # Follow instructions on official Go website: https://go.dev/doc/install
  • Python: v3.9+ (for Python challenges). 
    # Ensure you have Python 3 installed
python3 --version
  • Pipenv (recommended for Python challenges): 
    pip install pipenv
  • TypeScript: Global installation if not handled by Node.js project setup. 
    npm install -g typescript
💡 **Tip: Managing Multiple Language Runtimes**

For managing different versions of programming languages, consider using:

  • nvm for Node.js
  • rustup for Rust
  • goenv or gvm for Go
  • pyenv or conda for Python

These tools help avoid conflicts and keep your development environment clean.

⬆️ Back to Top

Initial Repository Setup

  1. Clone the Repository:

    git clone https://github.com/GDSC-FSC/gdg-fsc-weekly-technical-24-25.git
cd gdg-fsc-weekly-technical-24-25

  2. Generate Challenge Directories (Optional for Contributors): The setup.sh script is primarily for maintainers to create the initial empty challenge directories. If you just cloned, these directories should already exist.

    ./setup.sh

    This script will create directories like week-1-byo-kafka, week-2-byo-dns-server, etc.

⬆️ Back to Top

Installation for a Specific Challenge

Each challenge requires its own language-specific dependencies. Navigate into the desired challenge directory and install its dependencies.

📦 **Example: Installing dependencies for Week 1 (BYO Kafka - JavaScript)** 
cd week-1-byo-kafka
npm install
📦 **Example: Installing dependencies for Week 2 (BYO DNS Server - Java)** 
cd week-2-byo-dns-server
mvn clean install # This will download dependencies and compile the project
📦 **Example: Installing dependencies for Week 3 (BYO Interpreter - Rust)** 
cd week-3-byo-interpreter
cargo build # This will download dependencies and compile the project
📦 **Example: Installing dependencies for Week 6 (BYO Shell - Python)** 
cd week-6-byo-shell
pipenv install # Or pip install -r requirements.txt if a requirements file exists

⬆️ Back to Top

Running a Challenge Locally

Each challenge directory contains a your_program.sh (or your_server.sh, spawn_redis_server.sh, your_sqlite3.sh, your_git.sh, your_bittorrent.sh) script. This script is the entry point for running your solution locally and testing it against the challenge's requirements.

⚙️ **Example: Running Week 1 (BYO Kafka) locally** 
cd week-1-byo-kafka
./your_program.sh

This will typically start your Kafka broker. You might then need another terminal to send requests to it (e.g., using netcat or a Kafka client).

⚙️ **Example: Running Week 2 (BYO DNS Server) locally** 
cd week-2-byo-dns-server
./your_server.sh

This will start your DNS server, often listening on port 2053 or 53.

⚙️ **Example: Running Week 5 (BYO Git) locally** 
cd week-5-byo-git
./your_git.sh init # Initializes a new Git repository
./your_git.sh hash-object my_file.txt # Hashes a file

⬆️ Back to Top

💡 Usage & Challenge Workflows

The primary usage of this repository is to engage with and complete the coding challenges. This involves understanding the problem, implementing a solution, testing it locally, and then pushing it for automated validation (often via CodeCrafters.io).

General Challenge Flow

  1. Select a Challenge: Choose a week-X-byo-challenge that interests you.
  2. Read the Challenge README.md: Each challenge directory has its own README.md which contains specific instructions, requirements, and background information. This is your primary guide.
  3. Set Up Environment: Ensure you have the correct language runtime and dependencies installed for that specific challenge (refer to Installation for a Specific Challenge).
  4. Implement Your Solution:
    • Locate the main entry point file (e.g., app/main.js, src/main.rs, src/main/java/com/dnsserver/Main.java).
    • Start by uncommenting or adding code for the first stage, as per the challenge's README.md.
    • Iteratively build out the functionality, tackling one stage at a time.
  5. Test Locally: Use the provided ./your_program.sh (or similar) script to run your solution and test it against local test cases or manual inputs. 
    # Example: Run your Kafka program
cd week-1-byo-kafka
./your_program.sh
  6. Commit & Push: Once your local tests pass, commit your changes. If you are participating via CodeCrafters.io, pushing to master (or your configured branch) will trigger automated tests. 
    git add .
git commit -m "feat: Completed Stage 1 of BYO Kafka"
git push origin master
  7. Review Feedback: Check the output from the automated tests. If there are failures, debug your code, make adjustments, and repeat steps 5-7.

⬆️ Back to Top

Example: Tackling the "Build Your Own Kafka" Challenge

Let's walk through a typical interaction with the week-1-byo-kafka challenge.

  1. Navigate to the Challenge:

    cd gdsc-fsc-weekly-technical-24-25/week-1-byo-kafka

  2. Read Challenge Instructions: Open README.md inside week-1-byo-kafka. It will guide you on setting up Node.js, the purpose of the challenge (implementing Kafka's APIVersions & Fetch API), and how to pass the first stage.

  3. Install Dependencies:

    npm install

    This downloads any required Node.js packages, as defined in package.json.

  4. Implement Stage 1: Open app/main.js. The README.md usually instructs you to uncomment a specific line or add minimal code to handle the initial connection or a simple request.

    // app/main.js
import net from "net";

const server = net.createServer((socket) => {
  socket.on("data", (data) => {
    // Example: Just acknowledge receipt for stage 1
    console.log("Received data:", data.toString());
    // For actual Kafka, you'd parse the request and send a specific response.
    // For stage 1, this might be a simple "OK" or a fixed response.
    socket.write("PONG\r\n"); // Placeholder, actual response would be Kafka protocol
  });
  socket.on("close", () => {
    console.log("Client disconnected.");
  });
  socket.on("error", (err) => {
    console.error("Socket error:", err);
  });
});

server.listen(9092, "localhost", () => {
  console.log("Server listening on port 9092");
});

  5. Run Locally:

    ./your_program.sh

    You'll see output like Server listening on port 9092. Now, from another terminal, you can test it:

    # Try connecting with netcat (or telnet)
nc localhost 9092
# Type something and press Enter (e.g., "Hello Kafka!")
# You should see "PONG" if your server sends it.

  6. Commit and Push: If local testing looks good, commit your changes.

    git add week-1-byo-kafka/app/main.js
git commit -m "feat(kafka): Pass Stage 1 - Basic server setup"
git push origin master

    CodeCrafters.io will then run its automated tests against your pushed solution and provide feedback. You will then iterate, implementing Stage 2, and so on, until the challenge is complete.

⬆️ Back to Top

⚠️ Limitations, Known Issues & Future Roadmap

This section outlines the current state, known quirks, and future direction of the GDSC-FSC Weekly Technical Challenges repository.

Current Limitations

  • Educational Scope: The challenges aim to teach core concepts, not to build production-ready, highly optimized, or fully compliant systems. Implementations are often simplified.
  • Platform Dependency: The challenges are designed with CodeCrafters.io in mind for automated testing and progression. While solutions can be run locally, the full validation experience is on that platform.
  • Language Specificity: Each challenge typically focuses on one primary programming language, limiting exposure to multi-language implementations within a single challenge.
  • Resource Intensiveness: Some challenges (e.g., BitTorrent, Kafka) might require significant system resources or network bandwidth for local testing beyond basic functionality.

⬆️ Back to Top

Known Issues

  • Setup Script Limitations: The setup.sh script currently only creates empty directories. It does not populate them with initial template files for CodeCrafters.io (e.g., codecrafters.yml, starter code). These need to be manually added by a contributor or fetched from CodeCrafters.io.
  • Version Skew: Specific language or toolchain versions might evolve, potentially leading to compatibility issues if not updated in the README.md files or codecrafters.yml. Please report if you encounter such issues.
  • Incomplete Local Test Suites: While ./your_program.sh allows local execution, a comprehensive local test suite mirroring CodeCrafters.io's environment might not always be available, making local debugging challenging before pushing.

⬆️ Back to Top

Future Roadmap & Planned Enhancements

We are continuously working to improve this repository and the learning experience it offers. Here are some planned enhancements:

  • Expand Challenge Library: Introduce new "Build Your Own" challenges covering areas like databases (SQL parser, B-tree), compilers, distributed systems, and more.
  • Enhanced Local Testing: Provide more robust local testing frameworks or scripts within each challenge to better mirror the CodeCrafters.io environment, reducing iteration time.
  • Starter Templates: Develop scaffolding tools or templates for new challenges to streamline contributor setup.
  • Advanced Stages: Potentially add "advanced" stages to existing challenges for those who want to dive even deeper (e.g., adding replication to Kafka, more complex Git commands).
  • Community Showcase: A dedicated section or external platform to showcase successful implementations and solutions from the GDSC-FSC community.
  • Accessibility Improvements: Ensure all README.md files are clear, concise, and easy to follow for all skill levels.

⬆️ Back to Top

Feature Requests

Have an idea for a new "Build Your Own" challenge? Or a suggestion to improve an existing one? We'd love to hear from you!

  • Open an issue on GitHub with the tag feature-request.
  • Clearly describe your proposed challenge or enhancement.
  • If possible, include links to resources or existing challenges for inspiration.

⬆️ Back to Top

🤝 Contributing & Development Guidelines

We welcome contributions from everyone in the GDSC-FSC community and beyond! Whether it's fixing a typo, improving documentation, or adding a brand new challenge, your help is valuable.

How to Contribute

  1. Fork the Repository: Start by forking gdsc-fsc/gdg-fsc-weekly-technical-24-25 to your personal GitHub account.
  2. Clone Your Fork: 
    git clone https://github.com/YOUR_USERNAME/gdg-fsc-weekly-technical-24-25.git
cd gdg-fsc-weekly-technical-24-25
  3. Create a New Branch: For new features or challenges, branch off main. For bug fixes, branch off main. 
    git checkout -b feature/your-awesome-contribution # or bugfix/fix-issue-xyz
  4. Make Your Changes: Implement your new challenge, fix a bug, or improve documentation. Ensure your changes adhere to the Code Style & Linting guidelines.
  5. Test Your Changes: If you're working on a challenge, ensure it runs locally with ./your_program.sh and ideally passes all CodeCrafters.io stages. If you're adding a new challenge, make sure its your_program.sh works.
  6. Commit Your Changes: Write clear, concise commit messages. 
    git add .
git commit -m "feat(new-challenge): Add BYO Blockchain challenge scaffolding"
  7. Push to Your Fork: 
    git push origin feature/your-awesome-contribution
  8. Open a Pull Request (PR): Go to the original repository on GitHub and open a new pull request from your branch to the main branch. Provide a detailed description of your changes.

⬆️ Back to Top

Setting up a New Challenge

If you're contributing a new "Build Your Own" challenge:

  1. Create a New Directory: Name it week-X-byo-system-name (e.g., week-11-byo-blockchain). Use count.py to identify the next available week number if needed.
  2. Add a Challenge README.md: This is crucial. It should explain the challenge, its stages, and instructions for implementation.
  3. Include codecrafters.yml: This file defines the language pack and debug settings for CodeCrafters.io.
  4. Provide your_program.sh: The executable script that CodeCrafters.io (and local users) will use to run your solution.
  5. Add Initial Code: Provide a barebones app/main.ext or src/main.ext file with basic setup, often with commented-out sections for stages.
  6. Include Language-Specific Config: package.json, Cargo.toml, pom.xml, go.mod, Pipfile, etc., along with their respective .lock files.
  7. Update Main README.md: Add your new challenge to the Feature Highlights and, if applicable, to the Architecture Diagram or Changelog.

⬆️ Back to Top

Branching and Pull Request Guidelines

  • Main Branch: The main branch is considered stable and contains the latest released version of the challenges.
  • Feature Branches: All new development, including new challenges or significant enhancements, should be done in feature branches (e.g., feature/new-challenge-name).
  • Bugfix Branches: For bug fixes, use bugfix branches (e.g., bugfix/fix-dns-bug).
  • Pull Request Titles: Use conventional commits (e.g., feat(kafka): Implement stage 2 of APIVersions, docs: Update getting started guide).
  • Pull Request Description: Clearly explain what your PR does, why it's needed, and any specific areas for review. Link to relevant issues.

⬆️ Back to Top

Code Style & Linting

While each language ecosystem has its own style conventions, we encourage:

  • Readability: Clear, well-commented code.
  • Consistency: Adhere to the style already present in the specific challenge's language.
  • Automated Formatting: Use tools like Prettier (JS/TS), Black (Python), cargo fmt (Rust), go fmt (Go) where applicable.

Testing

  • Local Testing: Always use the your_program.sh script within the challenge directory to verify your solution locally before pushing.
  • CodeCrafters.io: The ultimate test for each challenge. Pushing to your configured branch will trigger their automated tests. Ensure your solution passes all stages.

⬆️ Back to Top

©️ License, Credits & Contact

License

This project is licensed under the MIT License. See the LICENSE file for details.

MIT License

Copyright (c) 2024 Google Developer Student Clubs | FSC

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

⬆️ Back to Top

Acknowledgements

  • Google Developer Student Clubs | FSC: For organizing and promoting technical growth within the community.
  • CodeCrafters.io: The primary inspiration and platform for these challenges, providing invaluable learning resources and automated testing.
  • Open-source Community: To all the creators of the programming languages, tools, and libraries that make this project possible.

⬆️ Back to Top

Maintainers & Contact

This repository is maintained by the GDSC-FSC team.

⬆️ Back to Top

📚 Appendix

Changelog

This section records significant updates and new challenges added to the repository.

  • 2024-08-01: Initial repository setup with 10 core "Build Your Own" challenges.
    • Week 1: BYO Kafka (JS)
    • Week 2: BYO DNS Server (Java)
    • Week 3: BYO Interpreter (Rust)
    • Week 4: BYO SQLite (Go)
    • Week 5: BYO Git (Rust)
    • Week 6: BYO Shell (Python)
    • Week 7: BYO Redis (TS/JS)
    • Week 8: BYO BitTorrent (Go)
    • Week 9: BYO HTTP Server (TS/JS)
    • Week 10: BYO Grep (Rust)
  • 2024-08-15: Updated main README for comprehensive documentation.

⬆️ Back to Top

FAQ

❓ **Q: Do I have to use CodeCrafters.io to participate?**
**A:** While the challenges are inspired by and designed to be compatible with CodeCrafters.io's automated testing, you can certainly attempt and complete them by running your solutions locally. However, the full progression and automated feedback experience is best achieved through the platform.
❓ **Q: Can I use a different programming language for a challenge?**
**A:** Each challenge typically has a designated primary language (`app/main.js`, `src/main.rs`, etc.). While you are free to explore solutions in other languages in your *personal fork*, the official challenge submissions (especially for CodeCrafters.io) will expect the specified language. For new challenges, feel free to propose a language.
❓ **Q: I'm stuck on a stage. Where can I get help?**
**A:** 1. **Re-read the `README.md`:** Ensure you haven't missed any subtle instructions or hints. 2. **Review CodeCrafters.io Logs:** The error messages from the automated tests are often very helpful. 3. **Debug Locally:** Use print statements, a debugger, or specific test cases to narrow down the issue. 4. **Community Support:** Ask for help in the GDSC-FSC Discord channel or during technical sessions. 5. **GitHub Issues:** If you suspect an issue with the challenge description or tests, open a GitHub issue.
❓ **Q: How are the "week" numbers determined?**
**A:** The `week-X` prefix simply indicates the sequential order in which challenges are introduced or tackled by the GDSC-FSC community. It helps organize the repository but doesn't necessarily mean you have to complete them in that exact order.

⬆️ Back to Top

Troubleshooting

  • "Permission denied" when running ./your_program.sh:
    • Ensure the script is executable: chmod +x your_program.sh
  • Language-specific errors (e.g., command not found, module not found):
    • Verify that the correct language runtime and its package manager are installed and added to your system's PATH.
    • Double-check the project's dependency installation steps (npm install, cargo build, mvn install, etc.).
  • Network-related issues (e.g., Address already in use):
    • Ensure no other program is running on the same port your challenge application is trying to bind to. You might need to kill the conflicting process or change the port.
  • CodeCrafters.io tests fail but local tests pass:
    • The local test might be insufficient, or there's a subtle difference in the CodeCrafters.io environment. Review their detailed logs carefully.
    • Ensure all necessary files are committed and pushed. Sometimes local changes aren't tracked.

⬆️ Back to Top

About

Fall 2024 weekly technical meetings, a project each week

Topics

javascript python java rust golang typescript

Resources

Readme

License

MIT license

Code of conduct

Code of conduct
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages