I started programming when I was in high school. I was taught Pascal and HTML among other things. But I was also taking some summer programming classes in an IT institute. That's where I learned Visual Basic and software/database design (during those days, we were using MERISE (Méthode d'Etude et de Réalisation Informatique pour les Systèmes d'Entreprise)). I eventually got Visual Basic installed on my home computer and a book from which I could practice alone, with books.
But, it's only after I graduated from high school, that I started learning and applying C# almost full time during higher studies, and that's what I considered to be my real start into programming and software engineering.
I learned a few lessons over the past decade, and I thought I would take a moment to gather my thoughts on these things. It took me about ten years and a lot of experimentation to figure out some of this.


1. Learning a programming language is the easy part: be aware and beware of the platforms
Take C# for example. Learning the C# language is not difficult. If you already have a good understanding of computer language fundamentals, and if you have some experience in other object-oriented languages, you can become a competent C# programmer within a few days, at least as far as the language itself is concerned. However, the real price to pay is not about the language, it's about the platform. To develop with C# on .NET, you need to know:
   - the .NET framework
   - one or more .NET technologies such as ASP.NET or WPF
   - and the Visual Studio development environment.
The time required to become proficient in .NET development is usually measured in months, even for an experienced developer. Learning a platform is always more expensive than learning a specific language, therefore choosing the platform is the most crucial decision.
Learning always has a cost and this cost is one of the key factors to consider when choosing the technology you want to learn. The real cost of learning is in time, learning always takes time. Since you do not have time to learn everything, it is important to think strategically about what you want to learn. And since the languages are easy, it's the platforms that you have to be careful about: the technologies associated with the language, the development and deployment tools, the operating systems, and other infrastructures.


2. I repeat, learning a programming language is the easy part: meet the underlying concepts of software engineering
The syntax itself, the words you use when applying the language are relatively simple and you can easily pick them up as you go. However, that's far from being enough for producing quality code, which often involve OOP and SOLID principles, unit testing, design patterns, TDD, BDD, and other technical concepts which are beyond the scope of this article. Anyway...


3. Actually writing code is only one (small) part of the job
A software engineer is often expected to be involved into technology research, tools and projects configurations, DevOps and admin tasks, debugging and testing procedures, documentation, and technical debt (fixing and refactoring existing code). Also, they have to be thinking about solutions and designing systems : sometimes the most important work is done away from a keyboard.


4. Tried and true : old and boring is sometimes the best
It's not so much old vs new, or cool vs boring, but rather the thing you are most experienced with. As they say, I trust not the developer who practiced 1000 technologies once, but I trust the developer who practiced the relevant technology 1000 times. If the goal is to build something as efficiently and as quickly as possible, then it would be more productive to use the technologies you master the most.
For example, one of my contacts is making $25,000 per month with a SaaS that was built on boring ASP.NET+SQL Server+Angular 1 because that's what he knew. he hosts it on Windows because he knows how to make it fast and secure. He succeeded by focusing all his time on building the features that clients were asking for, instead of learning fancy tech.
It's important to realise that the technological treadmill never stops. There are always new things to learn. Yet another JavaScript framework could have been launched while you are reading this. Today's cutting edge tech didn't even exist when I was getting started (EF Code First, Xamarin, ASP.NET Core, Razor), and this leads us to the 2 next points.


5. Focus on sustainable technologies
The only constant in the world is change. Actions and time management is an important skill for developers, particularly because we are on a technological treadmill that keeps moving or even accelerating.
For example, Web technologies that were popular around the year 2000 (Flash, ASP Classic and Java Applets) are becoming almost obsolete and decreasingly marketable. Today, we are talking about ASP.NET Core, SignalR, Angular2, React and VueJS. None of these technologies existed in the year 2000, and these new technologies are likely to be obsolete within 10 years.
What hasn't really changed? The fundamentals of languages such as C++/C#, their implementations of algorithms and their principles are still relevant after several decades. If you master the basics of a stable system, you could adapt to change better, you could appreciate it and use it to evolve.


6. Balance between exploration and exploitation
Exploration is about learning new things, studying new techniques, reading books, watching video tutorials, practicing and improving skills. Exploitation however, is to take advantage of what we already know to solve real life issues. It's about thinking creatively about ways to use the knowledge we already have to create value for others.
So yes, both of these tasks are both necessary and important. The risk is to be too focused on either activity.
Too much exploration, and you will never achieve a useful level of expertise in the chosen technology. There is a huge opportunity cost with this kind of light learning, because, although it expands your mind, the time it takes implies that you don't really improve on the skills that you have already acquired.
On the other hand, too much exploitation can keep you from evolving in new technologies, and can limit your employment opportunities.


7. It’s easy to be great... It’s hard to be consistent
It's easy to be great for 2 minutes. It's hard to stay great constantly, every day.
When you have a good idea for a new project, you feel a great desire to start researching, designing and programming. You feel a rush to turn your idea into something real and you become super productive. But the problem is that this motivation fades over time.
Yes, it's fun and it's easy to have new ideas and start working on them. But then there are the efforts to be made, the adjustments, the launch, the maintenance, the corrections, the improvements, and so on. Over several months. This is where it gets hard. It is hard to stay focused on the same idea, on the same project for months and years. It takes a lot of discipline.
It’s easy to be great. It’s hard to be consistent.


8. Diversify your skills
Don't be "just a programmer", become an "Expert Who Programs", an expert in another relevant field that you are passionate about. You can be an entrepreneur, a project manager, a Big Data scientist, a researcher, a security specialist, etc. If you are an Expert Who Programs, in addition to being able to program (maybe full-time), you also have an additional credibility that is related to something other than software engineering.
Hence the importance of getting an education. If you go to university and you already know how to program, you probably won't learn much about programming. That does not mean you should not go to these schools. You will need some culture, and universities are great places to get that. You acquire culture by studying and understanding the world that humans have created, from different angles. It would be difficult to acquire this kind of knowledge if you do nothing but study programming.


9. Pick your niches and stand out
The smaller the niche you choose, the greater your chance of being viewed as a standout in your field. It's very hard for developers to stand out with a title such as "PHP Web Developer". They're competent, versatile, useful, but not noteworthy. One developer who knows how to work with these technologies, feels they are easily replaceable because there are so many out there with a comparable skill set. This area is too broad for you to easily stand out from the crowd. If, on the other hand, you become known for a niche, like Xamarin.Forms or JavaScript Visualisations you're much more likely to be valuable to those looking specifically for that skills set.


10. Age of Skills
Information is the specific knowledge that you need to solve problems. Skills represent the ability to implement solutions using your knowledge.
In a world where most of the knowledge and tools are virtually free, what makes the difference? The skills, of course. We are no longer a knowledge-based society, we are a skills-based society. There was a time when almost all university degrees guaranteed a good job. Now this is no longer the case. Nobody cares about what you know. People care about what you can do. They pay you to do things, not to know things.


Teach yourself programming in 10 years
Researchers have shown it takes about ten years (or 10 000 hours) to develop expertise in a field.
The solution is reflective practice: it's not enough to repeat the same things over and over again, but you should be challenging yourself with a task that exceeds your current ability, trying it, analysing your performance, and correcting all errors. Then repeat. And repeat again. It seems there are no real shortcuts. Learning through reading is good. But getting your hands dirty in practice is better. The best type of learning is learning by doing.
Personally, small projects and prototypes actually helped me improve. But there are still interesting things to master, therefore let's keep learning.