I think mine would be the "Getting Real" concept by 37Signals.com
Basically this is based largely on the same-old-same-old KISS principle, but that simply proves how valid this principle is in many working environments and certainly in IT. I still benefit from this basic principle in my day-to-day programming.
What was your "eye opener" at the time?
The Long Tail . This is a very interesting concept to describe the niche strategy of businesses, such as Amazon.com or Netflix, that sell a large number of unique items in relatively small quantities.
The original wired article by Chris Anderson will certainly give a different perspective on business on web.
The fact that it does not matter that the platform you are working on has been developed by some evil corporation. What matters is how much value you are adding to YOUR company by developing in it.
Eeek.... You want me to pick just one?
I was very resistant to "Structured Programming" but finally came around to seeing the light (yeah, I'm old -- I've been doing this a while).
On the other hand, I caught on to "Object-Oriented Programming" right away (I'd been programming 10 years by that time, but it would be another 5 before someone would pay me to write C++ code). That was probably the brightest lightbulb going on over my head.
Now, I'm picking up the MVP pattern and Dependency Injection.
Discovering Boost, and finally working with someone who's relentless about writing exception-safe code.
The idea that there are jobs out there that don't suck, and that you shouldn't stay in a horrible shop out of loyalty or out of the faulty idea that "everywhere out there is just as bad as this place is." It's not a programming idea, I admit, but it certainly fits the criteria of this question -- it has helped me in my career immensely. It's also helped my mental health immensely! :-)
Design patterns which are my secret weapon in writing code sometimes
Code generation. We consistently cut about 30% off of our projects by generating robust business objects automagically, and working on an ORM tool pushed me to a new level as a developer.
Tools like CodeSmith are absolutely invaluable.
The idea that code and data can be interchangeable. Functional style programming has helped me more than any other concepts.
Besides that, it would have to be iterative development. I feel a lot better when I know I can create the most basic, simple program, then expand it to fill its required needs.
Alex
Learning that it is important to try and see things from the perspective of others.
Using different frameworks and working on different technology stacks has helped a lot. You see the advantages and disadvantages of different solutions. In general, it makes you less religious.
MindMapping - which are like Hierarchy Chart but allow for easier discovery and thought logging
One of the biggest aha moments Ive had was when I started using Lua from C and started seeing how high level languages are constructed. Most of my professional work is done in high level languages so seeing how something like a Lua table is constructed out of basic c primitives was a real eye opener and helped me understand what is actually happening under the hood in a scripting language.
An eyeopener for me was when a coworker reduced a work of mine that was several hundred lines long into something that was only about 100. I learned that I needed to remember KISS and that if it's getting too convoluted, there is most likely a better way.
Design Principles articles from Object Mentor site. especially
Check the articles on http://www.objectmentor.com/resources/publishedArticles.html. Look for 'Design Principle'.
It changed my vocabulary and gave better foundation for any design reviews that I do.
Not listening to any rule-book and coding daily for years and years :)
Mine was definately continuous building and automated testing. I'm still early on in my career so these are quite new to me. We setup a integrated SVN, CruiseControl build system very early on in our project and we've seen the benefit through not wasting anytime in manually maiking releases at the end of each sprint.
Automated refactoring support. Once you internalize it, automated refactoring totally changes the way you work -- the way you approach legacy code, the way you design new code, even the way you type.
Of course, once you're sufficiently addicted, it leaves you screwed for languages and environments that don't have it. :)