Hey! Everybody currently in my 2nd year of computer Engineering tier 3 college who wants 75 percent but don't know how to teach. So I am on my own I have learned c language on my own I am pretty good at it I am thinking about dsa in cpp but before cpp I am doing oop in cpp but I am also interested in app development to earn money also wanted to crack gsoc in 2027 also interested in cybersecurity I am also interested in core computer Engineering don't know how to proceed for all of this things but one thing is for sure wanted to create something before 2027 starts and earn money or atleast create something outstanding and also definitely want to crack gsoc. Please guide me how to move further.

Context: Need help fixing logic flow / breadboard circuit for Traffic & Pedestrian Light System (Tinkercad)

Hi everyone, I'm working on a traffic light and pedestrian light simulation project in Tinkercad (using 555 timers, counter ICs, and logic gates like 74HC4017, 74HC32, 74HC08, 74HC86, etc.) and I've run into an issue getting the pedestrian button trigger to work correctly.

The Problem:
The section highlighted in the white circle is for the pedestrian lights, but when I press the push buttons, the circuit doesn't react.

Expected Behavior / Logic Flow

Trigger Condition:

Pressing any of the 4 push buttons should trigger a state change across all LEDs in the system.

Traffic Lights (Upper Module — N, S, E, W):

When a push button is pressed, the active traffic lights should first transition to Yellow, and then turn Red.

Pedestrian Lights (Circled Module):

Default State: Pedestrian lights should stay Red ("Don't Walk").

Triggered State: When a push button is pressed, the pedestrian light should switch to Green ("Walk") for 10 seconds.

Reset State:

After the 10-second timer elapses, the system should automatically revert to its normal traffic light sequence.

Hi everyone, I'm a self-taught female engineer from Vietnam, currently exploring Hardware IP Cores for Edge Robotics.

As my very first step, I wrote a basic C++ algorithmic model for a 3-DOF robot arm's Inverse Kinematics. Please note: This is just a rough, early-stage demo! I know the C++ structure might still be messy, but I wanted to get the math logic right first.

To make it hardware-friendly (preparing for future HLS), I used the Planar Projection (Decoupling) method:

1. Using atan2 to rotate the base (yaw).
2. Collapsing the space into a 2D triangle to solve shoulder/elbow angles using the Law of Cosines.

Here is my GitHub repo: https://github.com/nguyenkhanhvy3131-tech/AuraLogic-IK-Hardware-Model

Since I am learning completely on my own, I would love some gentle feedback. Did I miss any critical edge cases in my math? Any tips for a beginner on how to optimize this further?

Thank you so much for your time and kindness!

I’ve been researching how to build a strong foundation for a software engineering career in India and created the attached roadmap.

My current plan is:

CS fundamentals
→ Java
→ Backend development
→ SQL/RDBMS
→ Data engineering
→ Cloud/DevOps
→ Distributed systems
→ System design

I’m particularly unsure about the middle of the roadmap.

For example, should I learn Data Engineering, Cloud/DevOps and Distributed Systems before specializing in Backend/SDE, or would it be better to focus on backend development first and learn the other areas later?

I’m trying to avoid the common problem of learning many technologies superficially.

For developers who have worked in the industry, how would you restructure this path?

I’ve attached my roadmap for context. I’d especially appreciate feedback on what I should postpone, remove, or study more deeply.

                         ┌─────────────────────┐
                         │   COMPUTER SCIENCE  │
                         └──────────┬──────────┘
                                    │
                ┌───────────────────┴───────────────────┐
                │                                       │
                ▼                                       ▼
     ┌──────────────────────┐                ┌────────────────────────┐
     │  CORE CS FOUNDATION  │                │ ENGINEERING FOUNDATION │
     ├──────────────────────┤                ├────────────────────────┤
     │ Programming          │                │ Software Engineering   │
     │ DSA                  │                │ Git / GitHub           │
     │ OOP                  │                │ Linux                  │
     │ Discrete Mathematics │                │ CLI / Shell            │
     │ Computer Architecture│                │ Debugging              │
     │ Operating Systems    │                │ Testing                │
     │ Computer Networks    │                │ Documentation          │
     │ DBMS                 │                │ Clean Code             │
     │ Security Fundamentals│                │ Design Principles      │
     └──────────┬───────────┘                └───────────┬────────────┘
                │                                        │
                └──────────────────┬─────────────────────┘
                                   ▼
                    ┌──────────────────────────┐
                    │      DEVELOPMENT         │
                    │   Programming Languages  │
                    └────────────┬─────────────┘
                                 │
                 ┌───────────────┴───────────────┐
                 ▼                               ▼
        ┌─────────────────┐             ┌─────────────────────┐
        │      JAVA       │             │       PYTHON        │
        │     Backend     │             │   Data / Automation │
        └────────┬────────┘             └──────────┬──────────┘
                 │                                 │
                 └────────────────┬────────────────┘
                                  ▼
                       ┌─────────────────────┐
                       │    WEB / BACKEND    │
                       └──────────┬──────────┘
                                  │
             ┌────────────────────┼────────────────────┐
             ▼                    ▼                    ▼
      ┌──────────────┐    ┌────────────────┐   ┌──────────────────┐
      │ HTTP         │    │ REST API       │   │ Authentication   │
      │ Web          │    │ Backend        │   │ Authorization    │
      │ JSON         │    │ Frameworks     │   │ API Security     │
      └──────┬───────┘    └───────┬────────┘   └────────┬─────────┘
             │                    │                     │
             └────────────────────┼─────────────────────┘
                                  ▼
                       ┌─────────────────────┐
                       │     DATABASES       │
                       └──────────┬──────────┘
                                  │
                  ┌───────────────┼───────────────┐
                  ▼               ▼               ▼
             ┌─────────┐    ┌──────────┐    ┌──────────┐
             │   SQL   │    │  RDBMS   │    │  NoSQL   │
             └────┬────┘    └────┬─────┘    └────┬─────┘
                  │              │               │
                  └──────────────┼───────────────┘
                                 ▼
                      ┌──────────────────────┐
                      │   DATA ENGINEERING   │
                      └──────────┬───────────┘
                                 │
             ┌───────────────────┼────────────────────┐
             ▼                   ▼                    ▼
   ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
   │ Data Modeling    │  │ ETL / ELT        │  │ Data Pipelines   │
   │ Data Warehousing │  │ Distributed      │  │ Batch / Streaming│
   │                  │  │ Systems          │  │                  │
   └────────┬─────────┘  └────────┬─────────┘  └────────┬─────────┘
            │                     │                     │
            └─────────────────────┼─────────────────────┘
                                  ▼
                       ┌─────────────────────┐
                       │    CLOUD / DEVOPS   │
                       └──────────┬──────────┘
                                  │
              ┌───────────────────┼───────────────────┐
              ▼                   ▼                   ▼
     ┌──────────────────┐  ┌───────────────┐  ┌──────────────────┐
     │ AWS / Azure / GCP│  │ Docker / CI/CD│  │ Kubernetes       │
     │Cloud Architecture│  │               │  │ IaC / Terraform  │
     └─────────┬────────┘  └───────┬───────┘  └────────┬─────────┘
               │                   │                   │
               └───────────────────┼───────────────────┘
                                   ▼
                    ┌────────────────────────────┐
                    │     DISTRIBUTED SYSTEMS    │
                    │   Scalability / Reliability│
                    └─────────────┬──────────────┘
                                  │
                ┌─────────────────┼─────────────────┐
                ▼                 ▼                 ▼
        ┌──────────────┐   ┌──────────────┐  ┌──────────────────┐
        │ Caching      │   │ Messaging    │  │ Load Balancing   │
        │ Redis        │   │ Kafka        │  │ CDN              │
        │ Queues       │   │ Streaming    │  │ Replication      │
        └──────┬───────┘   └──────┬───────┘  └────────┬─────────┘
               │                  │                   │
               └──────────────────┼───────────────────┘
                                  ▼
                       ┌─────────────────────┐
                       │    SYSTEM DESIGN    │
                       ├─────────────────────┤
                       │ Low-Level Design    │
                       │ High-Level Design   │
                       │ Architecture        │
                       │ Scalability         │
                       │ Availability        │
                       │ Reliability         │
                       │ Performance         │
                       │ Security            │
                       └──────────┬──────────┘
                                  │
                                  ▼
                       ┌─────────────────────┐
                       │   SPECIALIZATION    │
                       └──────────┬──────────┘
                                  │
       ┌──────────────┬───────────┼───────────┬──────────────┐
       ▼              ▼           ▼           ▼              ▼
┌──────────────┐ ┌────────────┐ ┌───────────┐ ┌──────────┐ ┌──────────────┐
│ Backend /    │ │    Data    │ │ Cloud /   │ │ ML / AI  │ │Cybersecurity │
│ SDE DEEP     │ │ Engineering│ │ DevOps    │ │ DEEP     │ │ DEEP         │
│              │ │ DEEP       │ │ DEEP      │ │          │ │              │
└──────┬───────┘ └─────┬──────┘ └────┬──────┘ └────┬─────┘ └──────┬───────┘
       │               │             │              │              │
       └───────────────┴─────────────┴──────────────┴──────────────┘
                                      ▼
                         ┌─────────────────────────┐
                         │  ENGINEERING EXCELLENCE │
                         └────────────┬────────────┘
                                      │
                    ┌─────────────────┼─────────────────┐
                    ▼                 ▼                 ▼
             ┌──────────────┐ ┌──────────────┐ ┌────────────────┐
             │ Problem      │ │ Communication│ │ Product        │
             │ Solving      │ │ Teamwork     │ │ Thinking       │
             │ Leadership   │ │              │ │ Business       │
             └──────┬───────┘ └──────┬───────┘ └───────┬────────┘
                    │                │                 │
                    └────────────────┼─────────────────┘
                                     ▼
                         ┌──────────────────────┐
                         │     ELITE ENGINEER   │
                         └──────────────────────┘

Thanks in advance to anyone who takes the time to review it.

i am 4th year computer engineering looking for problem that can be solveable by creating or making with hardware and software component for my capstone. the problem could be nobel and exp with many store (real world problem). message me directly or comment here so i can message you 😄

Are these two streams interesting for someone who enjoys JEE PCM. I would appreciate if you send papers for both branches so I can decide whether my interest lies here or not.

[](https://www.reddit.com/submit/?source_id=t3_1w5zmoz&composer_entry=crosspost_prompt)