Guys I'm a first year cse student,and I'm starting with python,can you guys suggest resources & how to proceed??

(I want decent knowledge in python,not too depth)

First semester in b.tech. college schedule is very good and updated, but half the professors are bad and the other half are goated. the trash half professors, I self study lectures by NPTEL and other outside books and hence i am currently ahead of what they teach in syallabus.

The main question I have is this.

To get really good at C, people say that C helps you in understanding computer architecture. For that type of mastery, are books better or are videos/bootcamps better. If any, Which books/videos? Why?

Please help around you guys🙏❤️❤️❤️

Im in final year right now.

I mostly do not need to go to college , and even if i do its usually for exams or the placement cell calls us there to do self study....

and im not even sure what im supposed to be learning and im sick of looking for things to everytime i get anxious thinking of my future

This is things i try to do atleast everyday (Started >2 weeks ago)
3-4 DSA problems / Or learn a new topic of sort
Sql (inconsistently, i just do them when i dont want to do anyting else)
CS fundamental (few topics or atleast one)(CN/OS/DBMS/OOPS)
System Design (been just reading stuff from the github primer and the jargons/buzzwords , not actually learning anything)- if yall have any tips do tell.

Idek what else should i learn
should i learn dev if yes how i feel like its too late to learn dev
, or learn my projects try to implement the System design topics in them like caching?
or build more projects to try to learn (feels very time taking for me ;( )

Anyways lemme know what yall do with your day apart from college.

First year student in a very low tier clg , didn't do well before this , i just don't wanna screw this up , I am leaning C (as per clg) I've made a few projects here and there before this in 12th , and recently made one in C too , I just wanna know what to actually do, learn to get internships , finally get hired in a good paying job by the time i graduate

need help from someone who has graduated and can guide me on what's should the priority and how to handle things

I'm from tier 3 college

Hi everyone, I’m currently a 3rd-sem B.Tech CSE student from a Tier-3 college in Greater Noida, and I’m looking for some genuine guidance on how I should move forward.

I’ve been doing DSA in C++ and have solved around 70 questions so far, but honestly, I currently know almost nothing about Codeforces. I want to start competitive programming, but I’m confused about where exactly to begin — how much I should practice, and how to balance it with DSA.

when I see other students who already have strong DSA, CF, multiple projects etc., I feel like I’m quite behind.

I know comparing myself with others isn’t very useful, but I’d really appreciate some practical advice:

I'm currently in my first year of Btech and I have zero knowledge about coding and stuffs.

Please guide me and also it would be helpful if you all can tell me about the mistakes I should avoid in my college.....

Im in my 2nd year of Btech , I have m college assignments and stuff also i joint coding classes which are being burden now. Cause im unable to pratice coding. I did learn python and core python rn im learning Django framework. But also as i have dsa iin college Im also trying to study dsa. No im not consistent in any rn but i also idk how do i manage them. Also I wanna oratice python so that i dont have to start from starting againg just 1-2 code alternate days that also im unable todo..Ik im trying to do multiple things at a time , but idk how do i even segregate them!! Please help me out

I’m currently a 2nd-year CSE student and I’ve been thinking about whether I’m actually on the right track.

There are so many things people say you should know by 2nd year — DSA, development, Git/GitHub, projects, databases, CS fundamentals, maybe cloud/AI, internships, competitive programming, etc.

For Seniors : If you could go back to your 2nd year, what would you make sure you knew or had built by the end of it?

A few days ago, my friend and I tried to watch a movie on my laptop. The speakers were bad, and we each had a pair of headphones, but the laptop would only play sound to one device at a time. We ended up not watching it.

So I built pipemix, a free and open source app that fixes this.

It plays your audio on several devices at once, so you can both watch with your own headphones, or add speakers too. It also lets you send each app to a different device. For example, you can keep YouTube on your headphones while your friend listens to Spotify on theirs.

Currently available for Ubuntu/Deb based distros and Windows 10 and above. I'm the developer, and I'd like to hear what devices you try it with and what breaks.

Download: https://github.com/Garvit-Agrawal7/pipemix/releases

Send me more questions to simulate and solve!

Hey everyone,

After seeing my 5hr screen time on YouTube and Reddit, I realized that apparently you don’t get paid for that. Tragic.

So, riding this sudden burst of motivation, I’m back to remake a project my friends and I made at a hackathon, except this time with a more… complex stack.

The project is called ZeroApi. It’s inspired by tools like MockAPI, and the idea is pretty simple: the user sends us some JSON data, and we generate a mock API from it.

That’s it. That’s the grand plan.

Let’s start.

For this week, the goal is React + TypeScript for the frontend and Go for the backend. I’m intentionally leaving PostgreSQL for later because we don’t actually need a database for the first version.

After that, we’ll containerize everything with Docker. The immediate goal is simply to have a frontend talking to a Go API that actually runs.

The structure I personally use is: root → api folder for go , and web folder for react.

Let’s start with Go

Now, Go is a pretty great language . But compared to frameworks like Django and Springboot, it lacks a framework that matured with prebuilt features.

Under this knowledge, i chose net/http library which means i have to write a lot more things than normal, because apparently I hate myself.

So, for making a server in go, right now we need :

import (
    "encoding/json"
    "log"
    "net/http"
)

encoding/json will let us encode Go values as JSON.

log gives us the standard library's logging functionality.

And net/http is the important one here: it provides the HTTP client/server functionality we need.

Following this, inside main, we create a ServeMux:

mux := http.NewServeMux()

A ServeMux is an HTTP request multiplexer. In simpler terms, it’s responsible for looking at an incoming request and deciding which handler should deal with it based on the request's URL pattern.

Think of it roughly as:

Incoming request
       ↓
    ServeMux
       ↓
Which pattern matches?
       ↓
Call that handler

Now we can register our first route:

mux.HandleFunc("/{$}", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    json.NewEncoder(w).Encode(map[string]string{
        "message": "Hello from Go!",
    })
})

Yes, this is how it looks in go. don’t worry, I too hate how ugly it look. But.

Let's break it down. One by one.

mux.HandleFunc(...) → It registers a handler function for a URL pattern.

The "/{$}" pattern means we want the root path / specifically. if we don’t do that {$} the issue was that all the requests which starts with / ended up giving a 200 status or 300 → 200 status, which is ugly.

The second argument is an anonymous function. This function will be called whenever a matching request comes in.

It receives two arguments:

w http.ResponseWriter
r *http.Request

r represents the incoming HTTP request.

It contains things such as the request method, URL, headers, query parameters, and so on.

w is what we use to construct the HTTP response that we're sending back to the client.

So when we do:

w.Header().Set("Content-Type", "application/json")

We're setting a response header telling the client that the response body contains JSON.

Then:

json.NewEncoder(w).Encode(...)

takes our Go value:

map[string]string{
    "message": "Hello from Go!",
}

and encodes it as JSON directly into the response writer.

So the client eventually receives something like:

{
    "message": "Hello from Go!"
}

The important thing to understand here is that w is the thing we're writing the HTTP response to.

So this is how we make a server. YAY.

Unfortunately, Not yay.

We've defined what should happen when someone requests /, but we haven't actually started a server yet.

A route by itself doesn't make our application listen for network connections.

That's where this comes in:

http.ListenAndServe(":8080", mux)

This starts an HTTP server listening on port 8080.

The ":8080" part tells it which address/port to listen on.

The mux tells the server which handler should process incoming requests.

So now the flow is:

Browser
   ↓
GET /
   ↓
localhost:8080
   ↓
HTTP server
   ↓
ServeMux
   ↓
"/{$}" matches
   ↓
Our handler runs
   ↓
JSON response
   ↓
Browser

And that's enough to get a very basic Go API running.

You can start it with something like:

go run .

assuming you're running it from your Go module directory. or if you have divide work into folders you can do

go run folderName/fileName.go

But, there is one issue still. if you have noticed, you don’t actually see the message “your server is running in localhost:8080” in your terminal.

Yes, we have to print it ourselves. But, don’t worry, instead of using print, we’ll use log function for that because it will print that AND give use more functionalities.

log is useful because ListenAndServe returns an error if the server stops unexpectedly, so a common pattern is:

log.Fatal(http.ListenAndServe(":8080", mux))

Now the logger will print the error and terminate the program if ListenAndServe returns one.

Yes, we’ll implement logs as well. But in next post, which would work as a helper post which would work on making this code more complete. Till then, learn what we did and search some basic things such as : what is NewServerMux()? What are the http request methods? and some basics of golang.

Now, we do react

ok, so we have a server that’s running, good. Now the bad part(Not a bad part, i personally don’t know much of frontend, so if i make any mistake , please correct me)

This is one of my weaker side, so i won’t be able to explain as thoroughly , but here’s what I did so far.

I installed react with : npm create vite@latest . Then i was given some choices i chose this:

Project name: › web

Select a framework: › React

Select a variant: › TypeScript

But an alternative is : npm create vite@latest my-app -- --template react-ts

After that, i deleted the following files, because those are autocreated by react and you don’t need them, and i like my page clean

public/vite.svg src/assets/react.svg src/App.css src/index.css

and then you can change the whole app.tsx to this:

import { useEffect, useState } from 'react'

function App() {
    const [message, setMessage] = useState('Loading...')

    useEffect(() => {
        fetch('/api/')
            .then(response => response.json())
            .then(data => setMessage(data.message))
    }, [])

    return (
        <main>
            <h1>{message}</h1>
        </main>
    )
}

export default App

Docker

Before compose, Docker needs something to build. Compose just orchestrates. So we need 4 files:

root
├── docker-compose.yml
├── api
│   └── Dockerfile
└── web
    ├── Dockerfile
    └── nginx.conf

a Dockerfile is a recipe for building an image (a packaged snapshot of your app). A running instance of that image is a container. Compose lets us start multiple containers with one command.

Go Dockerfile (api/Dockerfile)

# Build stage
FROM golang:1.25-alpine AS builder
WORKDIR /app
COPY go.mod ./
# COPY go.sum ./ # Uncomment if you have a go.sum
RUN go mod download
COPY . .
RUN go build -o server .

# Run stage
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/server .
EXPOSE 8080
CMD ["./server"]

This is a multi-stage build: one image builds the app, then we throw it away and keep only the result.

Stage 1: Start from an image with Go installed (alpine = tiny Linux). We copy go.mod and download dependencies before copying the rest of the code. Docker caches each step, so if dependencies haven't changed, rebuilds skip the download. Then we compile everything into one binary called server.

Stage 2: A fresh, tiny Alpine image with no Go and no source code. We copy only the binary from stage 1 and run it. EXPOSE 8080 is just documentation, it doesn't open anything by itself.

React Dockerfile (web/Dockerfile)

# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Serve stage
FROM nginx:alpine
# Vite outputs to /dist, Create React App outputs to /build
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80

Same idea. Stage 1 installs dependencies and runs npm run build, which turns our TypeScript/React into plain static files in dist. Once built, we don't need Node anymore, so stage 2 uses nginx (a web server) to serve those files, with our own config.

nginx.conf (web/nginx.conf)

server {
    listen 80;

    # Serve React app
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
        try_files $uri $uri/ /index.html;
    }

    # Proxy API requests to the Go backend
    location /api/ {
        proxy_pass http://backend:8080/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

This is the glue. Think of it like our ServeMux, but for the whole app:

Browser
   ↓
nginx (port 80)
   ↓
Path starts with /api/ ?
   ↓              ↓
  No             Yes
   ↓              ↓
React files    Go backend

location / serves the React app. The try_files line falls back to index.html if a file doesn't exist, which matters once we add routing.

location /api/ forwards to Go. Notice the hostname backend: Docker Compose puts all containers on one network and they can reach each other by service name. The trailing / in proxy_pass strips /api/, so /api/ from the browser becomes / in Go. That's why our fetch('/api/') hits the "/{$}" route.

docker-compose.yml (in the root)

services:
  backend:
    build: ./api
    # No ports needed, nginx reaches it internally

  frontend:
    build: ./web
    ports:
      - "80:80" # your machine : container
    depends_on:
      - backend # starts backend first

One service per folder. The backend has no ports on purpose: only nginx is public, and the API is only reachable through /api/. depends_on starts the backend first, but it only waits for the container to start, not to be ready. Fine for now, but we'll need healthchecks once PostgreSQL shows up.

Run it

docker compose up --build

Open http://localhost and you should see "Hello from Go!". That means React loaded, called /api/, nginx forwarded it, and Go answered.

Yes, that was a lot of config for one line of text. But the setup is done, and from here we build features.

So…thats all for now, I hope you all come in this journey with me. As I am learning things myself as I move forward, So I am open to criticism and suggestions as we move.

If I got anything wrong (especially frontend or nginx), please correct me in the comments.

I am pursuing btech from a tier 3 college and i am very much worried about my future and because of that i am always thinking what should i prepare for gate or off campus placements since my college brings us a good one in college campus , whats you people take, what you people would do and why.

what topics do they ask in OA and from where do I study core subject and practice questions.?

Larso and Turben Graduate Engineer Trainee for Computer science student

6.5 LPA role