How to Structure Your Programming Work-flow
By: Kevin Sheehan
Tags: Software Development, Code, Coding, Planning, Workflow

For many who are fairly new to programming, like myself, it can be difficult to know where to begin when you are jumping into a new project. I believe that everyone should find a workflow that works for them, because nobody’s is going to be exactly the same. But if there’s anyone who was like me when I first started it can be difficult to even know where to begin.

Today I want to share a some steps i’ve learned to take during my project workflow with the hope that others can use these steps to save them time later debugging, refactoring, and preventing things like having to scrap their entire project.

Step 1: Sketch Out Your Project

The first step to take when you have a new project to work on is to plan & sketch out some design drafts along with your program architecture.

I believe this is the most important step in the entire process, the more detailed you are and the more time you make sure your project idea is properly sketched out, the less time you will have to spend later refactoring, and creating drafts gives you a organized path on what steps you need to work on as you go.

There are many ways to create a draft of your project idea. If you can draw well using hand drawn in a sketchbook, notebook, or a whiteboard(i’d suggest something a little more permanent) might be best for you. But if you’re like me and can’t even draw a proper circle neatly, I suggest learning and using one or a few of web apps that I have listed below to help you plan your projects & make sketching your program architecture & drafts of how you want your project to look much easier.

Web Apps For Project Planning:

The two I use pretty regularly are LucidChart and MockFlow.

I typically draw out my project architecture in LucidChart, like so-

And use MockFlow to draw out a rough design of my project -

These are two pretty simple test examples but I suggest when planning your project to draw out as much as possible, that way if there is an issue with the layout or your models you can adjust accordingly before coding half of your project & having to refactor or start over.

Step 2: Setup & Test Your Environment

This step is one I suggest all programmers do before they dive into their code too much. The last thing you want is to start building out your project and realize a library that you want to use did not install properly. It’s much easier to hash out these issues before building out your code than it is to try and run your program and have to debug the issue afterwards.

Step 3: Step by Step Coding

One of the biggest lessons i’ve learned while working on projects is that spending a minute or two to test your code as you build will save you hours of time debugging later. This means testing & committing your code regularly, preferably between each new task you do (i.e: Did you get what you wanted back on that API request? If not, figure out why not. If yes then commit your code & move on to your next task continuing to test as you go).

No matter how good a coder you are, you will make a mistake at some point & consistent testing takes only a couple minutes at a time to do. Trust me you would much rather want to spend a few minutes testing, over debugging & refactoring your code for hours or days when you run into a bug that you should have tested for days ago.

Step 3.5: Look For Improvements

This step can be done alongside step 3, however I wanted to make it its own step because it is important enough that it deserves its own section.

Once you manage to get a large function in your program working that you take a step back & ask yourself “is this function working as efficiently as I want it to?”. For most applications, the user experience is often one of the most important factors, so before moving on to new functions in your application you should make sure that the ones that you already have are working as efficiently as you would want them to.

To put this is perspective a fast, smooth working, simple application with only a few main functions is often much better perceived than a super complicated, slow, complex application that has many more functions. In other words, prioritize optimizing what you have before you prioritize adding new features.