Back in college, we had a professor whose exams contained some questions that people found to be notoriously difficult compared to others. To get a score higher than “good enough”, we had to solve questions that include problem combinations that we never came close during the lectures. I did not understand why he was doing that back then. What we had seen during the lectures, was enough to cover every piece of knowledge needed to solve those questions, but only few were able to solve all questions. We were never able complain about him for asking something that isn’t possible to solve in our level of knowledge. They were all possible. He just wanted us to apply the knowledge in circumstances we didn’t see before. He was testing whether we really understood or not. He was different, but I didn’t notice back then.

It look me a while to realize that my whole experience in the education system was counter-productive to how software engineering, and even world, actually works. I tend to think that this is a general problem after listening the school life of my friends’ from different countries.

The problem lies in how our expectation about the world is slowly shaped through our classic education system.

My a-ha moment

It was just a year after the graduation, 1999 or 2000. I had come to know a database schema with flat, denormalized design. It felt so wrong. We were taught that we had to reach 4th normal form. That was the goal. We had exams and projects to take raw fields and create schemas like that.

Then I learned that it wasn’t because people didn’t know what I thought I knew. It was done on purpose to overcome severe performance problems. They fixed the problems due to flat schema in other ways. It was working great.

It was that moment I realized I could not blindly trust everything I learned. Apparently there wasn’t just one true way of doing things. I had to look from different directions all the time and always think the end result that we need.

But how did I get there?

Life until graduation

Let’s look back in to our years in higher education.

• At the beginning of the semester, we get the book, the course content, possibly past homework/projects/exams (now thanks to internet). The book + lectures almost always contain everything we need to know and understand to solve the problems within the scope of the topic
• Projects and homeworks have fixed due dates, rarely postponed. Those due dates are always in the future enough to deliver the work in the way asked.
• Projects and homeworks have precise requirements, expectations are set clear, up front and never changes
• Success in the curriculum usually doesn’t require knowledge in other curriculum except for fundamental topics. For example, we don’t have to be good at the chemistry class in order to be successful at physics class. Excelling at data structures and algorithms class doesn’t impact one’s success in network class.
• At any given time, the student knows what’s going to happen or what it takes to reach a certain goal. Ambiguity is non-existent. Everything is crystal clear.
• Lecturers explain often one true way of doing things. Sometimes this is right. For example, we can’t just be ok with an algorithm that works in O(n²) where we can have O(n) for the exact same structure, input, output. But there ara tons of other scenarios where we say it depends. Nevertheless, we had exams where we lost the points because we didn’t do it in the exact same way showed, or exact same way the lecturer belives right. One day after another, this feeds false assumption that there is always one best way of achieving something in software engineering and everything else is wrong.

Essentially, pretty much everything we experience in all those years were quite deterministic. We were used to know what we needed to know, what was expected, when was expected, how to deliver. Nothing unexpected happens, there is no unkown. This might work pretty will with some professions, but not all.

We are evolving as species with an ability to deal with change and disruptions. Yet we spend our early years almost never using those skills.

Living in this environment for 16-17 years early in our development ages leaves an impact that needs to be undone when working in software engineering.

Why ?

Like I mentioned here, our world itself, our business, our economy isn’t a deterministic by nature. The empirical nature of software engineering requires us to continuously navigate in uncharted terrains, to pursue goals that might change, to meet requirements at different levels, to deal with disruptions, unforeseable events.

The role of our education isn’t about giving answers to all possible questions, or it’s not about handing everyone a cookbook. It’s about introducing fundamental knowledge, vision, nurturing skills to ask right questions, to make better judgements, to find the knowledge needed and apply it in our purpose.

Early struggles

Many companies assign buddies when a new graduate joins. Still, the job of the buddy isn’t solving challenges for the new graduate or giving pills for growing pains. Some of the things that happen differently:

• Continuous planning instead of semester curriculums
• Change in directions and plans as new information arrives and reality changes, in contrast to projects and homeworks with fixed goals
• Dealing with the stress of consequence of mistakes and learning to live with them (Instead of mistakes only causing drops in grades)
• Learning to do trade-offs
• Starting the work with input that might be missing infomation and working towards collecting more information, compared to starting projects, homeworks where initial information is thorough.
• Inheriting/maintaining code (including stuff done by others) compared to never maintaining the code written for projects/homeworks
• Working with upstream/downstream/team dependencies compared to working alone or with class mates

The need for mindshift is certain. However there is no pill, no course, no tool exists to make this easy. This can’t happen overnight and this is mostly a path that needs to be walked alone, with some coaching/mentoring along. As we get tenured in the industry, we may forget how difficult this situation is.

Conclusion

Overwhelming part of our life in schools include routines, highly predictable tasks, clear inputs, clear expectations with little to none exposure to volatility. This prevents us from developing natural skills to deal with uncontrollable change. Moreover, this is quite opposite of how the world and software engineering works. This creates struggle for many people since they are used to work in a completely different environment. It may take years to unlearn and overcome this and it can be stressful.