Never underestimate the power of small changes over a longer period of time. This perseverance has the power to make you reach just about any goal. Daunting tasks can usually be broken into small actionable pieces. And from then, it's just a matter of persistence.
I have a small whiteboard next to my desk, which I can see almost all the time. I keep track of my progress of the various long-running tasks I'm currently working on. There are many boxes to tick, and it keeps me accountable. And it also reminds me how far I've gone.
One example related to programming is long-term refactoring. There is no way the development be halted for weeks just to refactor something fundamental. So to keep the project up-to-date, it has to be done in small parts.
The technique I use is to define long-term refactoring goals, along with the changes I need to do to reach them. This practice results in a list of guidelines what to refactor and how. Then when I happen to work on a component that is yet to be refactored, I do the necessary changes according to the guideline. This practice results in small, incremental changes that are almost invisible in isolation, but contribute to the bigger goal.
For example, when I started working with React, mixins were the preferred way to reuse functionality (yeah, that was a legitimate idea back then). Now, mixins are deprecated. What should I do with all the components I've written that rely on them?
Luckily, there was no urgent need to remove all of them at once. They were made deprecated, but continue to work as before. So I made it a task: whenever I work on a component that still uses mixins, I refactor that single component. With time, all mixins will be removed. And if support is eventually removed, I'll be left with a significantly smaller task to refactor all the remaining components.
This is just one example, but longer-term software projects are full of much-needed refactorings. Keep a list of the guidelines, and progress just a little bit every time. This technique is also called the "boy scout rule". Leave a code a little bit better every time you work on it. These efforts add up and result in a maintainable codebase.
But incremental progress is not just for programming. Read a few pages every day, and you'll finish several books each year. This simple daily habit propels you way ahead of the crowd.
Sometimes I hear people say that they don't have that much time. A year seems like an eternity, and they want results sooner. The phrase is usually "I don't have a year to work on this". The sad truth is that more often than not, these people progress very little over time. And this strengthens their feeling of urgency, closing the vicious cycle.
When you need to reach a goal that is so far away you can't even comprehend the path, break it down into smaller steps and guidelines. Keep a list of these, and work on them. Progress just a little bit each time. You'll be amazed how far you've gone in just a few months.
You have the power to reach just about any goal. You can learn a new language, enter a new professional field, or build a following. The key is incremental progress.
Learn this one skill, and it opens the door for all the others.