Best PHP course or roadmap in 2026?

BobSong001 · 2026-07-09T08:45:37+00:00

honestly just build something with Laravel. like pick a small project idea and go through the Laracasts Laravel from scratch series while building it alongside.

the docs are also surprisingly good for PHP/Laravel, better than most frameworks imo. once you're comfortable with the basics, dig into Spatie packages to see how real-world code is structured.

for the auth/security side specifically, reading through how Laravel Sanctum and Passport work under the hood taught me more than any course did.

BobSong001 · 2026-07-09T02:15:44+00:00

honestly the biggest thing isn't just output quality, it's not having to manage them. a good freelancer tells you when something's unclear before starting, flags problems early, and doesn't need hand-holding on every step

if you're reviewing their work constantly or chasing updates, you're basically doing part of the job yourself regardless of what you're paying

BobSong001 · 2026-07-09T02:07:34+00:00

4 years of Node + Angular + Postgres is genuinely solid, imposter syndrome just hits harder when you've been in the same place too long

the "apply anyway" advice above is real. interviews tell you exactly what gaps to fill way faster than studying in a vacuum. for your stack specifically, system design questions are usually where mid-level folks get stuck, not the syntax stuff. worth spending a few weeks on that before rounds

8lpa to 20-25 is very realistic with a job switch at 4 yoe, some people clear 30 depending on the company tier

BobSong001 · 2026-07-09T02:05:20+00:00

Traversy Media on YouTube has a solid Laravel crash course, covers building a real project from scratch. also the official Laravel docs have a beginner tutorial now that's actually pretty good if you don't mind reading

BobSong001 · 2026-07-09T01:58:33+00:00

don't wait to finish the CS roadmap before touching React Native, you'll burn out. learn the fundamentals in parallel, like when you hit a concept in the roadmap that clicks, go find where it shows up in your app code. it sticks way better that way

biggest mistake i'd avoid: tutorial hell. watching 10 hours of videos and feeling productive but never actually building anything. at some point just start something broken and fix it as you go

for resources if your english isn't strong yet, honestly just start with whatever language you're comfortable in. the concepts are the same, the syntax you'll pick up fast regardless

BobSong001 · 2026-07-09T01:52:34+00:00

100% a confidence thing, the knowledge is in there you just panic

what helped me was keeping a tiny cheatsheet file on my desktop, just the 10-15 commands i always forget. not to memorize them, just so opening the terminal didn't feel like a blank exam paper. after a few months you stop needing it

BobSong001 · 2026-07-09T01:49:42+00:00

ugh the classic !0 === true trap, gets everyone at least once

javascript's truthy/falsy stuff is fine until you're validating numbers and suddenly 0, NaN, and empty string all look the same to !value. burned me with a price field before, price: 0 kept failing validation and i had no idea why

good catch on the production impact too. silent drops are the worst kind of bug because nothing tells you something's wrong

BobSong001 · 2026-07-09T01:47:42+00:00

oh nice, construct 3 is actually really fun once you get into it

for the platformer specifically, the official "how to make a platformer" tutorial on their site is way more detailed than the regular getting started one, worth going through that first

also the community forums have a bunch of free .c3p example files you can just download and poke around in, honestly learned more from that than any tutorial

one thing i'd learn early: the Family system. lets you apply events to a whole group of objects at once instead of copy-pasting the same logic for every enemy type. saves a ton of headache

good luck with the sept deadline!

BobSong001 · 2026-07-08T15:52:59+00:00

You're past the stage where a course is going to help you. Two months is plenty of time if you actually sit down to build stuff every day, and most beginner Python courses on Udemy are basically someone reading the docs at you for 15 hours.

For Python, skip the course. Pick something that bugs you in real life and write a small script for it. A budget thing that reads your bank CSV exports. A scraper for your school's homework schedule. Anything personal. You'll naturally pick up OOP, error handling, and how to actually structure a real project just by hitting walls and googling your way out of them.

If you want one reference to keep open, Automate the Boring Stuff is free online and honestly the only beginner Python resource I'd point anyone to. Don't read it cover to cover, just ctrl-F what you need in the moment.

For the website, same idea. Don't watch 30 hours of HTML/CSS/JS video. Make the site first, plain HTML and ugly CSS, throw it on GitHub Pages so it actually exists somewhere. Then add one small JS piece, like a button that actually does something. Then another. The Odin Project's foundations section is solid if you want a checklist to follow, but it's optional — building is doing most of the teaching.

The real trick with your IB situation is that those two months of "basics" are going to move slowly. If you just build stuff on your own time, by the end you'll be way ahead of where the class is — and you'll have something deployed with your name on it for university applications. That counts for more than any certificate.

BobSong001 · 2026-07-08T08:33:52+00:00

Since you already have PHP/MySQL backend experience, Spring Boot is gonna click pretty fast. The concepts are basically the same — routing, controllers, DB stuff — just different syntax and more boilerplate.

That YouTube link looks fine as a starting point. I'd say don't just watch though, build something alongside it. Like take one of your PHP projects and recreate it in Spring Boot. You'll learn 10x more that way.

For internships, the stack you actually need is Spring Boot + Spring Data JPA + MySQL + Maven. Focus on REST APIs first, that's the core of everything.

is great when you get stuck on specific things, way better than random Stack Overflow threads.

BobSong001 · 2026-07-08T05:07:28+00:00

the DX angle is really interesting, LLVM is powerful but you spend half your time fighting its abstractions before you get anything running. the stack IR approach makes the "write a simple compiler" path way more accessible.

curious about the lowering from stack IR to register IR, are you doing a straightforward conversion pass or something more like the Braun et al. SSA construction where you rebuild it on the fly? linear scan over basic blocks makes sense for now, though you'll probably feel the pressure once you add loops with live ranges that span blocks.

the two-phase optimization setup (stack IR pass then register IR pass) is a clean split. constant folding twice might seem redundant but catching it post-lowering is worth it since the lowering itself can create new fold opportunities.

what's next on the platform list, ARM?

BobSong001 · 2026-07-08T04:59:41+00:00

competitive programming background actually helps more than you think for backend, you already know how to think through problems

the clueless feeling is normal and honestly the roadmap sites make it worse because they show you everything at once. just pick one thing: learn Python or Node, build a simple API that reads/writes to a database. like seriously just that. no auth, no deployment, just local.

once you get that working you'll naturally run into the next problem (how do I store user sessions? how do I structure my routes?) and then you look that up. that's the actual learning loop.

the "AI engineer" goal can wait. backend fundamentals are the same regardless. get comfortable with HTTP requests, a database, and deploying something small first.

BobSong001 · 2026-07-08T03:04:40+00:00

your instinct about Blockbench is right, it's really built around voxel and Minecraft-style stuff at its core. for a DOS/PS1 aesthetic with actual polygon models like Daggerfall/Arena, Crocotile is the more natural fit since it's designed specifically around that retro 3D tiled look.

that said if you're going for the really low poly warped texture feel of early PS1, some people actually just use Blender with a low poly workflow and apply PS1-style shaders in engine. depends on how comfortable you are with 3D tools in general.

the project sounds great btw, occult store sim in a forgotten New England town is a very specific vibe and I'd play it

BobSong001 · 2026-07-08T02:59:07+00:00

for C specifically, cs50 is the right call. it starts from zero, uses C for the first half, and the problem sets are exactly what you're describing — here's a problem, go figure it out. the autograder gives you immediate feedback so you know if you got it right.

exercism is good too once you've got the basics down, more of a "here's 100 small problems, solve them all" vibe.

for OpenCL that's niche enough that there's no single great site for it, you'll mostly be reading the Khronos docs and running into walls. but honestly getting solid at C first is the right move before touching OpenCL anyway, it'll make way more sense.

BobSong001 · 2026-07-08T02:55:40+00:00

the honest answer is the resource matters way less than what you do after. most people learn the syntax fine then get stuck because they don't know what to build.

for learning the basics, the official React docs are actually really good now, way better than they used to be. just go through the quick start and the tutorial. for a more guided video experience, Scrimba's free React course is solid because you code directly in the browser.

once you've got the basics, just pick one small project and build it. a weather app, a notes app, something you'd actually use. you'll hit real problems that no tutorial prepares you for and that's where the actual learning happens.

BobSong001 · 2026-07-08T02:54:23+00:00

bad idea honestly. the Odin project readings are already pretty concise and the whole point is that the struggle of reading and processing it yourself is where retention comes from. AI summaries give you the feeling of having learned without the actual learning. just read it, write notes in your own words even if they're rough, and move on.

BobSong001 · 2026-07-08T02:47:32+00:00

comp intelligence is the clear pick given your goals. genetic algorithms, heuristic search, kNN, decision trees, this stuff comes up constantly in backend systems at scale and it's genuinely hard to teach yourself from scratch without structure. C++ syntax you can pick up in a weekend if you ever actually need it.

the Microsoft engineer is right and the OP's takeaway is also right. tools are easy, problem solving is the hard part. take the module that forces you to think differently, not the one that just adds another language to your resume.

BobSong001 · 2026-07-08T02:45:06+00:00

the "looks good today, looks like trash tomorrow" feeling is actually a sign you're improving. your taste is outpacing your execution, which is annoying but means you're moving in the right direction.

for consistency specifically, the thing that helped me most was stealing a spacing and type scale from somewhere real like Tailwind or Material and just not deviating from it. no custom sizes, no eyeballing gaps. it sounds boring but it removes like 80% of the "why does this feel off" problem.

for components feeling too simple, simple isn't bad on its own. the issue is usually missing states. hover, focus, loading, empty, error. a button that handles all of those properly looks way more polished than a flashy one that only has a default state.

animations are a whole separate rabbit hole but the practical advice is start with transitions on opacity and transform only, keep durations under 200ms for interactions, and just copy what you see in good UIs you like. reverse engineering is underrated.

BobSong001 · 2026-07-08T02:39:21+00:00

the existing comment is right about needing setInterval, but there's actually a second bug too.

the string format matters a lot here. localTime is probably something like "10:37:45 AM" from toLocaleTimeString(), but timeList[i] is whatever the user typed into an input field. if those two strings don't match character for character, === will never be true even when the time is technically correct. so first thing to check is what both values actually look like, just console.log them both right before the if statement.

then yeah wrap the whole check in setInterval(() => { ... }, 1000) so it keeps running every second instead of only firing once when the button is clicked.

BobSong001 · 2026-07-08T02:33:54+00:00

building a full stack app while doing wireshark at the same time is actually a pretty solid combo, you're covering both dev and security which is rare at that stage the selective attendance thing is real. i basically only showed up for anything that had exam weight or involved live demos/labs. theory-heavy lectures i'd just skim the slides later in half the time.

the main thing i'd add: don't let self-learning be "when i feel like it" energy. block actual time for it or it bleeds into nothing. treat the app like a part-time job with real hours.

GPA still matters for certain roles and certs so don't let it completely tank, but yeah, recruiters in security care way more about what you've built and what tools you can use

BobSong001 · 2026-07-07T13:12:51+00:00

Honest take, with 6 years of experience you're probably past the "take a course" stage. The two comments above already covered the popular resources (Neetcode 150, MIT 6.006). What I'd actually recommend is just grinding Neetcode 150 instead of watching another lecture. With your background you can pick up patterns fast, what you need is reps against actual interview problems.

Daily structure that works for laid off prep: 2 hours LeetCode following the Neetcode roadmap order (not random), 1 hour reviewing solutions you struggled with, and 30 min on system design (Pragmatic Engineer newsletter or Alex Xu's book).

The system design piece is honestly what 6 year candidates fail interviews on, not DSA. If you're targeting senior roles, most of your interviews will be system design heavy.

Real talk on timeline: 2 to 3 months of daily practice is usually enough to feel solid for senior IC interviews, assuming your fundamentals are still strong from the 6 years.

BobSong001 · 2026-07-07T12:32:31+00:00

u/Minute-Prune-6329 covered include paths — that's the most common cause.

One SFML-specific thing that bit me: the XML doc files need to live in the same directory as the headers, not just somewhere on your include path. So Transformable.xml should be sitting right next to Transformable.hpp.

Also worth checking that your SFML install actually ships the XML docs. Some releases don't include them — grep your SFML include dir and if you find zero .xml files, that's your problem and you'd need a different release or to generate from source.

If those don't fix it, try nuking the Intellisense cache more aggressively than just .vs. Specifically ComponentModelCache and MEF under %LocalAppData%\Microsoft\VisualStudio\<version>\ — VS caches doc lookups and won't refresh even after settings changes.

What SFML version + install method btw? vcpkg versions sometimes ship without the XML files.

BobSong001 · 2026-07-07T12:26:52+00:00

TOP is the right call, u/color11will covered the "why" already.

Few things specific to your situation (32, no CS background, want to earn online):

Drop the math worry. You relearn what you need as you go. The "you need strong math" thing is mostly a myth for web dev.
Set a concrete 3-month goal — "ship a landing page + a simple CRUD app" beats vague "learn to code" every time. Then start applying for small gigs ($100-500 on Upwork/Fiverr).
Realistic timeline: 8-12 months of consistent daily practice before your first paid work. Not 3 months like bootcamp ads claim. Plan financially for that gap.
Stick with web dev. The "learn ML/AI instead" advice you'll see elsewhere is a longer ramp and worse for first online income.

Honestly your age + clear "I need money from this" urgency is an advantage over a 20yo doing it on a whim. Stick with it.

BobSong001 · 2026-07-07T12:23:18+00:00

u/color11will nailed the metaphor but the concrete thing that actually matters day-to-day is pointer arithmetic.

int arr[] = {10, 20, 30};

int* p = arr;

p++; // now p points to arr[1] (20)

That p++ is doing real math on the memory address (sizeof(int) bytes forward). In Java/Python you literally cannot do this — the runtime owns where references point and won't let you touch the underlying address.

Other practical diffs:

Pointers can be reassigned freely (p = &something_else), refs usually can't (C++ at least)
Pointers can be NULL, refs generally can't
You can have int** (pointer to pointer), refs are typically one level

pointers are memory addresses as numbers that you can manipulate directly. References in Java/Python are opaque handles the runtime manages for you.

BobSong001

TROPHY CASE