Ancient coding ideas finally in English - Part 1

1. 
   Each great programmer learned programming from the master before him.
   Be precise in writing code.
   Teach programming to others, as you'll understand how things work better yourself when you're forced to explain it.
   Put safety in your code, don't just look at what minimally works, protect yourself from careless mistakes.
   


2. 
   Good programs depend on 3 things:
   The code.
   The hardware.
   The presentation.
   


3. 
   Don't write a program to get bare minimum done, and be over with it.
   Rather do it for the sake of the program itself, and try to get the most out of the program.
   


4. 
   Your code should be welcome to other good programmers.
   You should pay attention to minor details of their code.
   Pay attention to their ideas.
   


5. 
   Your code should be open for improvements.
   Let even simple programmers review it for mistakes.
   Be minimalistic on communication layers in your code.
   [The previous] refers to communicating with your own code, this applies even more so when your code has to communicate across a network or other external dependencies.
   Excessive external dependencies or communication across a network only hurts your program, and worsens code quality, and you'll end up with an unmanageable program.
   


6. 
   Declare over yourself a coding standard.
   Buy yourself friends to bounce ideas off of.
   Accept every new idea for consideration, no matter how ridiculous it might seem at first glance.
   


7. 
   Stay away from bad libraries.
   Don't statically link to them.
   Don't give up when it's a disaster out there.
   


8. 
   Don't make yourself a sole reviewer of large amounts of code.
   When presented with two implementations, assume both of them are complete garbage until convinced otherwise.
   When having to decide between two implementations you are presented with, examine the pros and cons of the situation, and what improvements can be done, and be happy when proponents of each were able to walk away being able to accept the pros and cons and reach the best implementation.
   


9. 
   Review code in depth, and have ever changing methods to do so, otherwise a severe bug can slip by you.
   


10. 
    Love writing code.
    Hate bureaucracy.
    Don't give in to status quo.
    


11. 
    Be careful in what you to say to others, or you may create a rift in your community, the outcome of the current work will fail, and your program will be for naught.
    


12. 
    Love peace and run after it.
    Love the other programmers, and show them how to write better code.
    One who only seeks to advance his own self will end up destroying himself.
    One who doesn't learn what's new will end up not being able to write code with what he currently knows.
    One who doesn't learn at all shouldn't be writing code.
    One who doesn't use libraries the way they're supposed to be used will be lost in the end.
    


13. 
    If you don't write the code, who is going to write it for you?
    If you're always writing all the libraries yourself, what's the point?
    If you don't write it today, then when exactly?
    


14. 
    Take programming seriously.
    Optimize the little bits which do the most.
    Welcome all patches with a smile (even if you don't commit them all).
    


15. 
    Make for yourself a system, and stay away from assumptions, learn about it if you're not sure.
    Don't write a program based on rough estimates.
    


16. 
    I've spent a lot of time with those who know only theory. Don't argue with them, just pay attention.
    The theory isn't the main thing, but the practical. If you dwell on the theory, you'll end up being repetitious with your code.
    


17. 
    On three things a good program depends on:
    Meeting Requirements.
    Correctness.
    Peace with the community.