Merriam-Webster defines the aha moment as a moment of sudden realization, inspiration, insight, recognition, or comprehension.
People talk about their AHA! moments a lot. The moment when something clicks. When it finally begins to make sense.
If the aha moment is the moment in time that realization occurs, Eureka! is the sound it makes.
The aha moment and coding
There is a lot of structure to programming. This structure is generally referred to as syntax.
Regardless of the programming language you will use, syntax is something you learn right away. If your code isn’t written in a specific way, it doesn’t compile (or at the very least it results in errors at runtime).
Most students begin by writing code over and over until they start to remember how it should look. But learning syntax through rote exercises doesn’t always result in an understanding of what is actually going on with the code.
There are many programming concepts to learn as a beginning software developer. As each semester goes by these concepts start to take hold. Over time, students begin to have their own aha moments. Moments when the syntax fades away and code starts to make sense all on its own.
Why should we care about aha moments as coders?
What happens when the aha moment doesn’t come?
Does it even matter?
As a coding instructor, I know some students make it through the entire software developer program without achieving a single aha moment. I’ve seen it happen.
Does this mean those students won’t be good software developers? We can’t know for sure until they are put to test, but hopefully not.
Either way, it does mean they don’t fully understand why they are coding things a certain way. Their reasoning for writing code a certain way gravitates to, “Well, that’s how so-and-so did it.”
These students learn to write software by doing the same thing over and over again. If they write this line of code in exactly this way, it works.
Learning by rote may work on some levels, but over time it leads to problems.
When you don’t fully understand the code you write, you will make mistakes, and these mistakes can make it into production code.
Some mistakes will result in software glitches that aren’t that bad and might be caught by proper error handling. Others result in those messy Error 500 pages you see while navigating the world wide web. But the worst of these result in memory leaks and security holes that compromise an entire application.
So, yes, we should care about these moments. Yes, it is important that students have aha moments. It is important they understand how their code actually works, and not just the syntax or how to write it.
How can we make the aha moment happen?
If we know aha moments are important, what next? If comprehension matters, how does a coding student ensure they achieve it?
Can we make aha moments happen?
Our students are largely non-traditional. This means they didn’t enter the college environment right after high school. More often than not, they have families, full-time jobs, and many other responsibilities. They don’t have a lot of time for extra practice let alone to complete the actual homework.
However, aha moments will not come to you in a vacuum. You cannot simply sit idly by hoping for the aha moment to arrive. In order for your aha moment to come you have to become an active learner.
As a software development student you will need to keep coding, often after you’ve submitted your assignments. If you aren’t getting a concept as it is presented, keep trying.
Make time to code. Complete all of the exercises, even those that aren’t required. Spend time coding instead of watching tv, playing video games, or even just surfing the web.
It’s pretty hard to have an aha moment if you aren’t actually coding. It would be like trying to win the lottery without buying a lottery ticket. It’s not going to happen.
Yes, you will need to take a break from coding once in a while to let the learning set in, but don’t stop entirely, and continue to make time for coding.
Here are some ways you might stimulate the aha moment while learning to code:
- Re-read the textbook
- Complete sample problems at the end of each chapter
- Read articles and blog posts on the topic you are learning in class
Re-read the textbook. Reading the textbook is great, but until you write the code for a particular chapter it is very hard to understand the concepts.
Go back to the textbook after you finish the course. Or, return to an earlier chapter once you feel you have a good understanding of what is going on.
By re-reading the material you will have a second opportunity to connect the reading material with the code you write.
Do the homework. Most textbooks have exercises you can complete at the end of every chapter. Oftentimes your instructor will assign homework that is different than these exercises. If you have completed the reading and assigned homework work on these exercises. More practice will help you learn the content while also providing additional chances for aha moments.
If the textbook doesn’t come with sample problems, try to create your own programs that solve a problem you have. Or, use a resource like Exercises for Programmers which contains practice problems for many different real-world scenarios.
Perform your own research. Your instructor puts a lot of work into the course. You will likely have to complete reading assignments, discussions, quizzes, tests, and other projects throughout the course.
If you’ve done all of this already, do your own research and learn through free resources available on the internet. Use search engines to search for articles, blog posts, podcasts, and tutorials that augment your learning as you complete the course.
Whatever you do, don’t stop coding. Keep practicing and the aha moments will come. Remember, they can come anytime.
The timing isn’t as important as what comes next.
Once the aha moment is reached, you will likely be very excited. In fact, you may begin to practice more than you’ve ever practiced before.
However, don’t underestimate the distance between aha! and expertise.
To become an expert at something you need to do it over and over again. Take your newfound knowledge and apply it. Practice. And then practice some more.
Once you’ve had the aha moment, keep coding. Write new code. Re-write code you’ve already written. If you’re still in class, ask your instructor about your code. Validate your understanding with a conversation, and with code.
After achieving expertise you still have to practice.
I’ve been an expert at many things in my life, but this expertise can be lost over time (especially when I stop practicing).
For example, in the Marine Corps, I was a micro/miniature computer technician and was very good at my job. I became proficient as a Collateral Duty Inspector and inspected the work of other technicians in my work center. But today I couldn’t do even a quarter of the tasks I did then. I’d have to go back to the beginning and practice in order to demonstrate basic competence in those tasks.
So even when you think you are done – don’t stop coding. If you want to be a good software developer you can never stop coding.
Aha moments are great. They signify understanding and comprehension. Increase your chances of aha moments by continually practicing whatever it is that you don’t understand. When you have an aha moment, cement your learning through more practice. Don’t let up, even when you reach expert level.