1) DRY, don't repeat yourself, write reusable code, it's not just helpful for the next project, code can also be reused in the same project, less code is easier to maintain.

2) Prefer data over code, a simple example: if you are calling the same function over and over, with just different parameters, write a loop and get the values from data.

3) write small functions, rarely more than what fits on a screen, a function should do ONE thing, if you want to do multiple "things" write more functions, then write one function that controls the flow and uses those functions as building blocks.

I follow this routine:

• read (other's code, books, articles etc)
• have a side project to learn (it is not a product you develop, or your main job)
• share and engage

Over period you will identify a pattern. Then go full steam on it.

I wrote about it here: Become a better programmer

1. Learn from others' code (at every opportunity. Whey you see something working, dig deep and find out what makes it work)
2. Learn from your bugs (be humble, yes, even you can make mistakes. Analyse why it happened, what habits you want to form to prevent it in the future)
3. Learn to question status quo (don't be afraid to ask why things are the way they are, try to come up with how things should be instead)

Focus on the fundamentals

.....................

Focus on the fundamentals

..............

Focus on the Fundamentals

.........

Feel free to read the programming language books, learn some frameworks, and etc... But at the end of the day, the reality is, in order to be a good, smart, engineer, you must master the fundamentals. I'm sure you've heard the lore: Algorithms and Data structures can get you very far with the tech giants, right? Well, why is this? What are these things? They're the fundamentals! Instead of just using other people's code, you actually understand how to implement these things from scratch! Do not ever underestimate this power... Just as it is easy for people to get on YouTube and blurt out obscenities to one another and it requires much more discipline to hold our tongues back when we are challenged, it also requires much more discipline to stop worrying about throwing a product together fast and truly understand the fundamentals of programming. Doing so will cause you to realize there's no such thing as a "hard" problem anymore: Just ones that needs to be broken down, divided, or reduced more.

Take AES-256 Rijndael encryption algorithm for example... At first, you may look at the process of creating this and be scared or intimidated. "I'm no security expert or mathematician." However, when AES-256 becomes:

A couple of lookup tables with:

AddRoundKey(); SubBytes(); ShiftRows(); MixColumns();

rinse, dry, repeat a few times... It becomes much easier to take in... Now, you take those 4 functions and you create sub-problems where you write down the steps you need in order to AddRoundKeys, in order to SubBytes, etc..., Then you go read up on whatever you need, and/or get to work... Next thing you know, Rijndael, something that was "extremely complicated" isn't hard or intimidating at all anymore. This can be applied to all programming and even other life problems. If for example you are breaking those steps down further, now you hear about something called a Galois Finite Field, and you get scared again... Do the same thing with that... Keep breaking things to the atomic level... Ask yourself this question: How did Physicists create a nuclear bomb? By stressing out about "complex problems?" No! They get down to the atomic/nuclear level and played with the basics! That's why it was literally called an atomic/nuclear bomb.

IMO, this is the most important part of programming and something that is overlooked and undertaught like absolute madness... You go to the bookstore and you find 100 syntax books, and these may give hints to the problem-solving aspect, but rarely do books tackle this head-on. If you read the book Cracking the Coding Interview by Gayle Laakman McDowell even, you will notice that she tells Google, Facebook, Microsoft, etc... To look for problem solvers, because most people can learn the knowledge. This is not to say knowledge isn't powerful, because it is, but definitely focus on problem solving via the fundamentals!

PS: Do not actually use your own Rijndael algorithm in a production environment due to the possibility of side-channel attacks. But it's a fun algorithm to write just to learn and challenge yourself! If you want to implement this algorithm, make sure you use the built-in AES-256 capability of your Intel processor because it will be more efficient and also not susceptible to side-channels.

I guess it depends what level you are as to what you need to focus on, but these should be good overall goals for anyone:

1. Learn lots of languages, but learn one really well. Learning lots of languages goes without saying, but getting to the nitty gritty of a language and understanding how it works at a lower level than the code you write and learning to take advantage of it to solve different problems and becoming comfortable enough with a platform that it feels natural to you will teach you an awful lot about programming in general, and having a "go to" tool that you can whip out and solve a problem without thinking about it will only add to the cycle, giving you more problems to solve in ever different ways.
2. Learn to identify and replicate patterns. The usual buzzwords do apply, such as MVC and Observer/Observable, Inversion of Control, Separation of Concerns, but don't focus too hard on being too "correct" and applying patterns too rigidly (a common mistake). The most important thing is to learn to identify parts of your own programs that are in themselves patterns and the problems that they solve, and learn to apply them in new and existing projects. You'll soon build up a toolbox of paradigms and patterns in your head that allow you to approach problems with a much more top level point of view, which means you can spend more time and effort designing the parts of your programs that need the most attention and not have to think too hard about the plumbing.
3. Be a good house keeper. Comments are so important, as is neat and tidy code. Everything is nice and fresh in your mind when you're working on it and many things seem obvious, but 6-12+ months later you'll have a fresh pair of eyes and you'll have to re-read and comprehend your own code from scratch. Reading other people's code (including your own later!) is a constant source of education - don't make it harder for yourself ;-)

1. make mistakes. the best way to learn coding os to make mistakes, and then fix them. Make sure you know WHY the mistake was caused, so that you can avoid that in the future,

2. once you got the basics down, go try to help others on Q&A sites. This'll help you realize what you know, and what you need to work on

3. have fun! if you're not having fun most of the time, then maybe it's time to find something else that you will enjoy.

• Get involved emotionally. Create programs you need and want. If you don't, you will never become engaged enough to write good code
• Learn the basics first, which means, learn a bit about how processors tick, leave out all those frameworks in the beginning, just write vanilla code to get the practice and understanding for what you are doing
• Be open and open-minded. Tell other people about what you are working on. Share your code. Accept what others have to say and try to improve! You can never be the master of everything, so networking will help you master all situations nevertheless :)

• "Write code that is easy to delete, not to extend." This'll help with developing maintainability in one's code.
• Contribute to any open source project. This'll help with style and best practices.
• Solve programming puzzles. This'll help with keeping in mind performance and economy.

1. Single responsibility for each function
2. Unit testing
3. Helping other

==> Write a code which handles worst case input as well. - You have to take care before you start writing code

==> Handle unexpected situation in proper way ( ie. many tutorials of php to mysql - if db connection fails then they write die(), this is very bad - PFA ) You can redirect user to some page instead of calling die() & terminating page and give shocking surprise to your end user

==> If you need to repeat a code, never do it. Create separate user defined functions and then call them - In case in future you get to know that something makes your logic more correct - making that change will be very easy

1. Never repeat same code again.
2. Try to find out lots of method for single tasks.
3. Self broke and made again.

And never give up. Enjoy the coding.

1. Keep learning things every day, try lerning new frameworks, libraries and languages and try to figure the place of everything.
2. Keep your code clean, follow the SOLID principles and good practices and make your code reusable and adaptable to future changes
3. Share knowledgement and learn from others. Try to keep in touch to other developers and learn from them, follow some blogs about coding and the last news of the development market :)

• Practice is not enough, keep reading and learning.
• If you can write code that works, this doesn't necessarily mean that you are doing it right, there might always be a better way to do it, try to discover and learn that.
• Don't isolate yourself, keep up with latest technologies, user feedback, design trends, the programmers' community talk..

Oh, there are many! Here are the top three according to me:

1. Make a habit of testing your code properly from the very beginning. It doesn't matter how good you are at a particular technology. Care for the edge cases. Learn some testing techniques.
2. Don't love your stack! Don't be someone who says "JavaScript is bad" or "NodeJS can't scale." Keep an attitude to learn something new every day.
3. Manage distractions! Find out how to prioritize things and manage your time properly.