University Talk · Keynote recap
Insights on Computer Engineering
A reflective session for the students who are where I once was — on falling for code before university, what a degree truly gives you, the fundamentals that never expire, and the open source, competitions and teamwork that turn a student into an engineer.
Watch the talkThe full session
Watch the talk — 35 minutes
The complete recording, in Persian, captures the whole conversation — the stories, the questions from the room, and the asides that don't fit on a page. Then read on for the recap below.
About the talk
This wasn't a lecture about a framework or an algorithm. It was an honest conversation about the journey itself — the messy, non-linear path from a curious student into a working software engineer.
Standing in front of Computer Engineering students at Amirkabir University of Technology, the aim was simple: to hand over the map I wished I'd had. Not a list of answers, but a way of thinking about university, industry, and the years where the two overlap.
What follows is a recap of that session — the story, the ideas, and the advice, in the order they unfolded.
The heart of it
Six ideas worth carrying out the door
Fundamentals endure
Data structures, algorithms, operating systems and architecture outlast every framework that will come and go. They're the ground you stand on.
Build in public
Your GitHub and personal projects are the résumé that speaks before you do. Real, finished work matters more than a perfect transcript.
Learn beyond the syllabus
The classroom is a starting line, not a finish line. The most valuable skills are the ones you go and teach yourself.
Quality over quantity
A few projects you genuinely care about, built well, beat a long list of half-finished ones. Depth signals far more than volume.
Teamwork is technical
No real software is built alone. Communication and collaboration are engineering skills — practise them as deliberately as you practise code.
Don't fear the gap
The distance between theory and practice isn't a flaw in your education. It's the space where engineers are actually made. Grow into it gradually.
University gives you the foundations. What you build on top of them is entirely up to you.
The academic journey
A path that started before the first lecture
The story doesn't begin at university — it begins years earlier, with a teenager learning to code for the joy of it. Here's the arc, from first curiosity to standing back at the front of a classroom.
- Before university
Falling for code
Learning to program years before any lecture hall — building Android apps out of pure curiosity, long before it was a career plan.
- First steps
Into the industry early
Finding the first professional opportunities while still a student — discovering that real products teach what no course can.
- University
Amirkabir Polytechnic
Studying Computer Engineering at one of Iran's leading technical universities — and learning to balance it against real work.
- Sharpening
ICPC & competitive programming
Training the muscle of thinking clearly and quickly — algorithms under a clock, with a team depending on you.
- Industry
Cafe Bazaar
Growing into an Android engineer and chapter lead — shipping software used by millions, and mentoring others along the way.
- Giving back
This talk
Returning to campus to share the map — so the next cohort can navigate the same terrain with a little more confidence.
University & industry
Two teachers, one engineer
What university gives you
- The deep fundamentals that don't change with trends.
- A way of thinking rigorously about problems.
- Time, peers, and permission to explore.
- A shared language with other engineers.
What only industry teaches
- Shipping real things to real users.
- Working within constraints, deadlines and teams.
- Reading, maintaining and improving others' code.
- That ‘good enough, shipped’ often beats ‘perfect, someday’.
The mistake is treating them as rivals. The students who grow fastest let each one do what it does best — and start bridging the gap themselves, early.
Courses that matter
The subjects that pay off for a whole career
Whatever you specialise in later — mobile, backend, ML, systems — these courses keep paying dividends. They're worth your full attention while you have them.
Data Structures
The vocabulary of every program you'll ever write. Choosing the right structure is half of writing efficient software.
Algorithms
Teaches you to reason about cost and correctness — the habit of asking not just “does it work?” but “how well?”
Computer Architecture
Demystifies the machine underneath. Understanding caches, memory and the CPU makes you faster everywhere above it.
Operating Systems
Processes, threads, scheduling and memory — the concepts behind every concurrency bug and performance win you'll meet.
Database Systems
Almost every product stores and queries data. Knowing how databases really work pays off for an entire career.
Computer Networks
Modern software is distributed by default. The network is no longer optional knowledge — it's foundational.
Your GitHub is the résumé that speaks before you do.
Beyond the classroom
Where the real growth happens
Open source & personal projects
The most formative work rarely comes from assignments. Releasing a library, maintaining a repo people actually use, finishing a project you cared about — that's where you learn to write software others can depend on. It's also the most honest portfolio you'll ever have.
Competitions & practical experience
ICPC sharpened how I think under pressure; the Telegram Android contests taught me to ship polished, performant UI against the clock. Competitions compress a great deal of growth into a short time — and they're some of the most fun you'll have as a student.
Self-learning, deliberately
The half-life of any specific technology is short; the ability to teach yourself the next one is permanent. Treat self-learning as the core skill it is, and the curriculum becomes a launchpad rather than a ceiling.
Balancing work & university
Doing both at once is hard, and it's a skill in itself. The trick isn't doing everything — it's choosing deliberately, protecting your energy, and letting work and study feed each other instead of competing.
You don't need to know everything before you start. You need to start — and then keep learning.
For students, specifically
Practical advice you can act on this week
Build a real GitHub
Treat it as a portfolio, not a dumping ground. A handful of thoughtful repos says more than a hundred forks.
Make personal projects
Pick problems you actually want solved. Motivation carries projects to completion — and finished work is what counts.
Learn independently
Don't wait for a course to cover something. The ability to teach yourself is the single highest-leverage skill you have.
Choose quality over quantity
Go deep on a few things rather than skimming many. Depth is what employers and collaborators can actually feel.
Join competitions
ICPC, hackathons, UI contests — they compress years of pressure-tested learning into days. Use them.
Practise communication
Write clearly, explain your reasoning, review others' work kindly. Teamwork is an engineering discipline.
Drop the internship anxiety
You don't need to have it all figured out by second year. Build steadily; the opportunities follow the skills.
Separate two kinds of success
Academic success and professional success overlap but aren't the same. Aim deliberately for the one you actually want.
Final thoughts
The map is yours now
No two journeys into software look the same, and that's the point. University and industry are not a fixed track but a pair of tools — use them on your own terms. Build things you care about, learn relentlessly, be generous with your teammates, and don't let anxiety rush a process that rewards patience.
If a single student left that room a little more confident about the road ahead, the talk did its job.
Thank you.