Tips for Beginners Developing Their First Software

In 2013, while working as a nurse, I decided to pursue a Master of Science in Health Informatics at the University of the Philippines. One of the courses in this program covered Internet technologies and computer programming. It was here that I first learned about the origins of the Internet, tracing back to the Cold War. I was also introduced to the key concepts of computers, such as data transmission protocols, data packets, and the OSI (Open Systems Interconnection) model.

As part of the course, we were tasked with creating a health calculator in two different versions: one in Java for a native mobile application and the other in PHP for a web application. This task was my first experience developing healthcare applications. As an acute stroke nurse, I chose to create an electronic version of the National Institutes of Health Stroke Scale (NIHSS), which quantifies stroke severity based on a series of weighted evaluations.

Initially, it seemed like a simple calculator project involving basic arithmetic. However, I quickly found myself overwhelmed, struggling to run the code and not realizing that I was already engaged in debugging. I soon discovered that I needed to learn more than just Java and PHP. I also had to understand XML and HTML for mobile and web interfaces, respectively. On top of that, I needed to design the app's process flow—deciding where the user would go after clicking a button and how to arrange elements correctly within the user interface.

Now, after more than a decade in the digital health space, I'd like to share some reflections on my first software development experience. These tips are intended for those who are new to programming and are about to embark on their first project. Keep in mind that this advice is for learning purposes only—never deploy your first app into a production environment without seeking guidance from experienced colleagues.

1. Your First Goal is to Make Your App Work

Your primary goal when starting out is simply to make your app work. Don't worry about writing clean code or designing a polished user interface just yet—your focus should be on understanding how the code functions. This task will involve a lot of trial and error, and yes, you'll spend a good amount of time debugging.

I'll admit, I once found myself Googling how computers read code. I wondered whether the computer processed my source code from left to right and top to bottom, or if it jumped around unpredictably. It's amusing to realize that computers do read code much like we read books—sequentially from top to bottom.

Also, don't stress if your code is longer or more convoluted than your peers. For instance, I used to write variable names that were far too long. My professor even pointed it out, calling my coding style "weird." I couldn't disagree—it was awkward and inefficient. But at that stage, my goal wasn't to write perfect code; it was to make it work.

2. The next goal is to keep it simple, stupid (KISS).

After your initial coding attempt, you'll likely find that your code is cluttered with unnecessary variables and inefficient processing. This phase is the time to simplify and clean up your code—a process known as code refactoring. Refactoring involves improving the internal structure, readability, and maintainability of your codebase without changing its functionality.

To refactor, I suggest that you adhere to the KISS principle. At this stage, prioritize simplicity over complexity. While advanced programming techniques often showcase elegant one-liners that achieve a lot with little code, you don't need to focus on these at the moment. If breaking your code into multiple, clearer steps makes it easier to understand, then do so. As you progress, you'll have opportunities to use more advanced techniques, but for now, keep your code clean and straightforward so you can easily maintain it.

Additionally, write self-explanatory code that even someone with little knowledge can understand. While comments are helpful, strive to make your code as intuitive as possible. Remember, over time, your own understanding of your code may fade, and others may need to read it, too. Aim to reduce the effort required to decipher your work by making your code as clear and self-documenting as possible.

3. The last step is to thoroughly test your app

At this stage, your focus should be on rigorously testing your app. Start by validating the "happy path," where you input data that your app is designed to handle and follow the intended workflow. Next, test the "unhappy path" by entering invalid data and performing unexpected or erroneous actions that your app might encounter.

As a beginner, don't stress too much about security just yet—this is something you'll address later. However, you should still perform basic data validation to ensure your app handles various inputs appropriately. The main goal now is to ensure your app can support and manage different scenarios effectively. This process will involve writing additional code and may require another round of refactoring to refine your app's functionality.

Conclusion

Overall, developing my first app was a challenging yet invaluable learning experience. Immersing yourself in coding is far more effective than just reading about it. If you find yourself doubting your ability to succeed, remember that I spent over two months working on simple mobile and web applications. It was challenging and often frustrating, but once you get the hang of it, it becomes much more manageable. I hope my experience and these tips provide encouragement for all beginners to dive into programming with confidence.