I'm recently realizing my joy for education and experiencing the glorious “ah-hah” moments. My career goal is to combine this joy with my developer skills. With this in consideration, I decided to build a prototype learning management software (LMS) as my first React-Redux with Rails project. The application would allow users (teachers) to enroll students in courses and then post assignments to those courses.
From my previous developer experiences, I learned the crucial importance of planning a project. Although I definitely find it most exciting and fascinating to swiftly begin coding and see a product dynamically appear on a web screen, I specifically focused more attention on the planning for this project.
My planning phase primarily included whiteboarding the user story, defining the model attributes and relationships, and generally exploring the design of the overall product. Once I had completed that, I eagerly began coding my project.
With React being my most recently developed skill, I figured I should start with the client side of the application and then eventually work on the server side. I followed the general project principle of first focusing on the low-hanging-fruit. I quickly learned that this may not always be the best tactic, especially if focusing on that low-hanging-fruit is simply so that you can avoid the tougher challenges.
As I continued working on the project, and naturally encountered challenges, I typically would spend some time working on a solution and if I wasn't able to find one, I would progress with another branch of the project and return to that challenge later. However, I would now highly advise against this approach, especially if you are unsure what the path will look like once you have found the solution to that challenge. There are so many dependencies in coding projects that it's best to fully know what you are depending on.
In the end, I often had to refactor some of my code to expect a different result from the original challenge than as I had initially assumed.
This definitely comes back to the importance of planning.
No matter how much planning you do, you will naturally encounter unexpected situations once you begin developing. Rather than avoiding those situations, I think it is best to tackle them head on and fully understand how it may effect your plan.
I no longer see planning as simply a phase that comes before coding/developing. It is more likely an ongoing exercise that starts before you begin any building and continues on until the end of the project. It is crucial to consistently reflect on how your current path compares to the planned one. It's absolutely tedious, but it will save so much time and headaches later on.
If you'd like to check out my app, below is the link to the GitHub repo. This is just the base of what is possible after 10 months of software developer experience.