Embracing Creativity and Unexpected Bugs in Programming

How Mistakes Can Lead to Innovation

Semantic bugs in programming are mistakes that don’t create obvious errors or stop your code from running entirely. Instead, the program behaves in ways you didn’t expect, often leading to strange or unintended results. For example, imagine a program that calculates prices, but due to a semantic bug, it gives the wrong total. The code still runs, but it produces incorrect data. These bugs are tricky because you don’t get error messages or crashes, so finding the problem can take a lot of time and effort. But interestingly, not all of these bugs need fixing. In some cases, a bug might even inspire a new feature or an improvement to the program.

Being creative is one of the most important skills for a programmer. Unlike many jobs where there’s often a standard way of doing things, programming involves a lot of problem-solving, and not every problem has a simple or common answer. While coming up with something entirely new can be rewarding, the real power of creativity comes from how you approach challenges. It's about trying different ways to solve problems, not just focusing on the final product. For instance, experimenting with a new algorithm or structure can lead to discovering better techniques, even if the first attempt doesn’t work perfectly. Plus, when you push yourself to try something new, you’ll likely run into problems or coding errors that will help you improve your skills, learning techniques and tools you didn’t know before. Even if the final code turns out to be unnecessary or doesn’t work as expected, you’ve still grown as a developer.

As Neil Druckmann, one of my favorite game directors, once said (and I’m paraphrasing), “Don’t just take inspiration from other video games; draw ideas from different kinds of media.” If you only look at video games for ideas, you’ll likely end up creating something similar to what already exists. This advice doesn’t just apply to game development but also to computer science in general. Looking at other people's code can help you learn new approaches and strategies, but it’s also important to break away from common patterns. Thinking outside the box allows you to explore new concepts, and asking yourself questions like, “What if I could apply this idea from real life into my code?” might lead to innovative solutions. For example, a developer who is inspired by architecture might design their code in a way that’s highly structured and organized, just like a building blueprint.

In video games, some of the most original and memorable experiences come from combining ideas from other forms of art, like TV, movies, or music. For example, many games borrow cinematic elements like camera angles, dramatic lighting, or storytelling techniques from films to create more immersive worlds. The Uncharted series is a great example of a game that combines action-packed gameplay with cinematic storytelling. These aren’t just copy-paste ideas from movies but are carefully adapted to fit the interactive nature of games. Because players control the characters, they feel more connected to the story and world, something that can’t be easily replicated in movies or TV shows. This is one reason why video game film adaptations often fall flat—they can’t capture the interactive, immersive experience of actually playing the game. As a developer, it’s important to look for unique elements in the world around you and think about how to combine them with the features of your programs. By doing so, you create something fresh and engaging that wouldn’t be possible by following the same old methods.

Now, let’s go back to the question: Can bugs actually be a good thing? Sometimes, the answer is yes. A great example comes from the development of Rocket League, a popular game where players drive cars to play soccer. During development, the creators added a “boost” feature to make the cars move faster. However, there was a bug that allowed players to use the boost while in the air, making it possible for them to fly as long as they had enough boost power. Instead of fixing the bug, the developers realized this mistake added a new layer of strategy and fun to the game. So, they kept the feature, which became a central part of Rocket League’s gameplay. This shows that being flexible and open-minded as a programmer can lead to unexpected but exciting features. While not every bug will be useful, allowing room for experimentation in your code can result in finding unique solutions or mechanics that weren’t planned initially. Many popular features in software started as unintended behaviors or bugs that developers decided to embrace instead of fix.

Creativity isn’t something you turn on and off—it’s always around you, waiting to be used. One way to tap into your creative side is by staying curious and asking questions like, “What if?” or “How can I improve this?” By constantly challenging yourself and your assumptions, you can unlock new ideas. As Neil Druckmann suggested, look beyond the familiar sources of inspiration. You might find creative solutions in unlikely places, like nature, music, or even science. Being open to new experiences and different ways of thinking will help you improve as a programmer. Every new idea brings its own set of challenges, and solving these challenges will help you develop innovative techniques that you might not have thought of before. The key to becoming a better programmer is pushing yourself beyond your comfort zone and exploring new possibilities. Whether it’s experimenting with new coding languages, structures, or designs, this willingness to explore is what drives progress in technology. And ultimately, the goal of programming is to create software that’s not only functional but also innovative, helping to make our lives better or enhancing our experiences in meaningful ways.

Fun fact: Some of the best-loved features in video games and apps today actually started as bugs or accidental discoveries. For example, the “wall jump” in the original Super Mario Bros. was an unintended result of how the game handled character movement. Instead of fixing it, the developers realized it added a fun and challenging gameplay element, and it became a signature move in later Mario games. Similarly, in the game Doom, a bug allowed players to move faster diagonally than they could moving in a straight line. Rather than patch it, players and developers embraced the bug, and it became a core part of speedrunning the game. These examples show that sometimes, the best ideas come from mistakes!