I always liked to ask myself "what's the first principle(s) of this?" after I learned the basic stuff of something (e.g. programming). It's an inspiring question, IMO, that can force you to think about the most important principle(s) behind something, especially a skill such as programming.
So, what do you think is the first principle(s) of programming? I'll give my answer below a little later.
Write code like if it was you that would have to maintain that code.
Be as lazy as possible.
Zen, part I: Programming is only the road, not the way.
Programming is only the technique to teach a computer what it's gotta do. To be successful in creating fast, reliable software means to know your algorithms, best-practices and all the other stuff not necessarily connected to your Programming (language).
Zen, part II: If you are in a hurry, stroll along slowly. If you really are in a hurry, make a detour.
Sounds silly, but do not let yourself get into compromises that (really) may trouble you afterwards. I got a rule: If you are at the core of a program, try to be as precise and good as possible. If you are using methods from the core that are deep in your software, try to be faster in coding. If you are coding above these two, you can even get a little bit more sloppy.
Design errors are the hardest to find and/or fix, next step are programming errors in parts everyone relies on, then the "real showing-off software parts". If you need to fix a design error at the end of a project, ummm, that's not good... ;-)
Zen, part III: Know your path, Neo.
Know your environment, tools and the stuff you rely on on a daily basis and get it sorted so that it works for you. Best if you use your programming "environment" so natural that you do not even have to think of it. If you have to get a job done do not introduce "fancy new stuff" but do your work. This stuff can be introduced in a new project, namely then when you have time to prepare and use it.
KISS (keep it simple, stupid).
It does indeed beg the question "How do you define simple?" And also "When is something too simple for the task at hand?" This is why you cannot become a good programmer just by knowing the first principle of programming.
Premature optimization is the root of all evil. -- Donald Knuth
Do not reinvent the wheel.
Understand the problem first!
YAGNI - You Ain't Gonna Need It. The idea behind YAGNI is to program for your requirements, not for prospective, potential features. The premise is that by keeping to what you need to program, you will (among other things) cut code bloat, reduce complexity, avoid feature creep, and reduce the restrictions on what can be done (and how it can be done) in the future.
I suppose it works in tandem with modular design: Future features can be augmented without redesigning existing code.
Knowing when not to program.
Coffee in, code out.
If it wasn't tested, it is broken.
There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.
-- Charles Antony Richard Hoare
Distinguish between cause and effect (working with computers)
Distinguish between fact and opinion (working with people)
As simple as possible, but no simpler (design)
In my opinion, the most important principle is the reduction of complexity by creation of good abstractions.
This includes
but also determination of the point where to stop creating abstractions and get down to the fundamental properties of the implementation technologies (e.g. database system, programming language) to prevent creation of avoidable additional complexity.
Program with an audience in mind. By that, don't assume that anything you write will not be read and maintained by you or someone else.
A corollary to that: Prove that you understand the problem you are trying to solve by naming your variables and functions and classes well!
it doesn't work till you showed it in a test
Think first, code later.
You're nowhere near as smart as you think you are. Ask questions. Learn to value your peers.
When debugging, the first answer will almost always be wrong.
Code you write with the intention of tossing out tends to become a cornerstone of much larger processes. Never leave anything written haphazardly.
Any problem can be solved with another layer of indirection.
Principle: Software is Knowledge Capture.
Consequences: Many techniques for knowledge representation, all founded on Abstraction. Gives us layers, tiers, encapsulation, separation of concerns.
Many techniques for procedure representation, all founded on Sequence, Choice, Repetition.
Always write code as if the person who will be maintaining it is a psychotic serial killer who knows where you live
Also, never think you know everything about programming, keep learning
I got into programming by way of studying digital electronics, so I guess for me the basic logic gates (not, and, or, xor, implies) were the first principles of programming.
Garbage in - Garbage Out It doesn't matter how nice your user interface is if the data is bad.
DRY, pretty much everything else spawns from it. KISS is the other end of the balancing act to make sure you don't pursue software elegance to levels of insanity.