I'm a computer science student in Nigeria who writes smart contracts for fun and the longer I do both, the more I realize my university and my terminal are living in different decades.
It is 7:48am on a Tuesday. The harmattan dust is already in the air. Somewhere on campus, a generator coughs to life. I am sitting in a lecture hall that fits two hundred people, watching a lecturer write pseudocode on a whiteboard, a pseudocode for a linked list implementation that was first taught in this exact format in 1987.
I do not say this with contempt. I say it with the specific frustration of someone who went home the night before, opened his laptop, and debugged a smart contract that, if deployed wrong, could drain thousands of dollars from real users in under a minute. Two different worlds. Same brain. Almost no overlap.
My name doesn't matter. What matters is this: I am a computer science student at a Nigerian university, and I am also, somehow, a Solidity developer. I write smart contracts. I use Foundry to test them. I have read audit reports the way other students read past questions. I have lost sleep over reentrancy bugs the way others lose sleep over exams.
And the longer I do both things simultaneously, sit in lectures, then go home and write production grade code for decentralized protocols, the more a particular worry grows in me. A worry I can't shake, even when I try.
Nigerian universities are producing computer scientists who cannot build. And almost nobody in the system seems bothered enough to change it.
The lecture hall and the lies we tell ourselves about it
Let me be specific, because vague complaints are easy to dismiss.
In four semesters of CS coursework, I have written code that runs on a machine I can see, that does exactly what the marking scheme expects, that gets submitted as a PDF — sometimes a PDF and is never deployed anywhere real. I have implemented sorting algorithms. I have drawn entity relationship diagrams. I have written python programs whose entire purpose is to demonstrate that I understand polymorphism.
None of this is useless. I want to be clear about that. The fundamentals are real. Knowing how memory works, how algorithms scale, how compilers think to be honest that knowledge is quietly useful in ways I didn't appreciate until I needed it. When I reason about gas optimization in Solidity, I am drawing on a mental model of computation that my systems architecture course helped build.
But here is the thing about fundamentals: they are the floor, not the ceiling. And in many Nigerian university CS programmes, the fundamentals have become the entire building.
We study data structures without building anything with them. We learn networking theory without configuring anything real. We write operating systems code in sandboxed environments and submit it before it has ever been tested under actual load. The course is not designed to make builders. It is designed to make people who can pass examinations about building.
There is a difference. A significant one. And I notice it every single time I sit down at my laptop after a lecture.
What writing smart contracts actually taught me
Nobody assigned me Solidity. Nobody put Foundry on any syllabus I have ever seen. I found my way into smart contract development the way most self taught developers in this country find anything — YouTube, GitHub, Discord servers at midnight, documentation read on a phone because the laptop battery had died again.
And what I discovered, once I was deep enough in, was not just a new programming language. It was a completely different philosophy of software.
In traditional development, the kind my university teaches, the assumption underneath everything is that you can fix things. You push a bug to production, you patch it. You design a system poorly, you refactor it. You make a mistake, you roll back. The entire culture of modern software engineering is built on the premise that code is malleable, that errors are recoverable, that the system has a human being behind it who can intervene.
Smart contracts have no such mercy!!!.
When you deploy a contract to the blockchain, it is there. Permanently. Immutably. Every mistake you made, every edge case you didn't consider, every assumption you baked in, all of it is now running on a public network, visible to every developer and every attacker on earth, and you cannot touch it. You cannot patch it in the night when nobody is looking. You cannot quietly fix the bug and pretend it never happened.
"The blockchain does not forgive carelessness. It just waits sometimes for months until the right conditions arrive to punish it."
This reality changes how you write code. It has to. You stop thinking about what your code does and start thinking about what your code allows. You stop asking "does this work?" and start asking "can this be broken?" You write tests not to prove correctness but to try, genuinely and aggressively, to destroy your own logic before someone else does it for you.
That mental shift from builder to adversary of your own work is something no lecture ever gave me. I had to find it myself, at 1am, reading a post mortem of a protocol that lost eighty million dollars because one developer forgot to consider a particular sequence of function calls.
The uncomfortable conversation about Nigerian tech education
I have had this conversation in different forms with classmates, with seniors who graduated and work in tech, with one or two lecturers who are honest enough to admit the problem exists. It always follows the same shape.
Someone says: the curriculum is outdated. Someone else says: we don't have the infrastructure. A third person says: the lecturers themselves were trained in systems that didn't value practice. Then everyone goes quiet, because all of it is true, and none of it is anyone's specific fault, and somehow that makes it worse.
The honest diagnosis, as I understand it from inside the system, is this: Nigerian university CS programmes were designed to produce graduates who could get jobs in an era when "getting a job" meant joining a large organisation and maintaining existing systems. They were not designed to produce people who could build new things from scratch, compete globally, or engage with technologies that didn't exist when the curriculum was written.
That era is over. The world has moved. The curriculum, largely, has not.
I think about this when I see my colleagues spending weeks preparing for theory examinations, memorising definitions, learning to write structured answers, practising past questions while the actual skill that will determine whether they can build a product, get a remote job, or compete with developers anywhere in the world goes entirely untrained. The irony is almost too neat: we are in computer science, the most practice driven field in the world, learning it almost entirely through abstraction.
The real cost:
The gap isn't just academic. Remote developer salaries for Web3 engineers are among the highest in the industry. Nigerian developers have every cognitive tool needed to compete for those roles. What many lack is not intelligence, it is structured exposure to real problems, real codebases, and real consequences for bad code. That gap is manufactured by the system, not by the students.
What I wish someone had told me in year one
The first thing I wish I had known: your degree will teach you to think, and thinking is genuinely valuable. Don't skip it, don't resent it, don't spend four years wishing you were somewhere else. The abstract reasoning, the mathematical foundations, the discipline of structured problem solving that is real, and it will serve you.
But it will not be enough. It was never going to be enough. The gap between knowing computer science and being able to build software that works in the real world — software that handles money, that gets attacked, that runs without supervision is a gap you will have to close yourself. Your programme will not close it for you.
The second thing: the most important skill in Web3 development is not knowing Solidity syntax. It is learning to read other people's code specifically, code that failed. Every major protocol exploit is a free masterclass in what happens when smart, experienced engineers make a particular kind of mistake under real conditions. The Euler Finance hack. The Poly Network attack. The Nomad bridge exploit. These are not horror stories. They are syllabi. Read them the way your lecturers wish you'd read the textbooks.
The third thing, and the one I feel most strongly about: find the discomfort of real deployment as soon as you can. Not a sandbox. Not a tutorial that ends with "congratulations, you've completed the module." Something real, something that could fail, something that another human being will actually use. That experience, the specific anxiety of knowing that your code is running somewhere you can't control is the education that no classroom can manufacture. It is also the one that matters most.
A worry, and a quiet hope:
My worry is not about myself. I found my way into a practice that keeps me honest, a community that is brutally unforgiving of bad code, a set of tools that forces me to improve. I am, in spite of my university and partly because of it, building real things.
My worry is about the students who don't find that path. Who graduate with a CS degree having never deployed anything real, never debugged something with actual stakes, never experienced the specific education that comes from writing code that can be attacked. There are thousands of them graduating every year across this country, technically educated and practically underprepared, entering a job market that increasingly does not forgive the gap.
The hope and I hold it carefully, because hope is not a plan is that things are shifting. The bootcamp culture is growing. Remote work has made it possible for developers in Lagos, in Enugu, in Kaduna, to work on products used by people in London and San Francisco. The Web3 ecosystem, for all its chaos and noise, has created genuine economic opportunity for developers who can write secure, efficient, on chain code. The incentives to self educate have never been stronger.
But incentives are not enough. The system needs to change. Courses need to involve real projects with real stakes. Lecturers need both the space and the support to teach tools that were invented after 2010. Students need to be evaluated on what they can build, not just on what they can recall.
Until that happens, the most honest advice I can give to any CS student in a Nigerian university or anywhere, really is this: your education is a starting point. What you do with it, after the lecture ends, after the exam is written, after the generator goes off and the hall empties out, is entirely up to you.
The blockchain does not care where you studied. It only cares what you built.
Written by a CS student navigating theory and terminals somewhere in Nigeria. If this resonated with you, you already know why.
Top comments (0)