Software is Evolutionary and Revolutionary
Of all the engineering disciplines, programming is the most malleable. Virtually anything you can imagine can be built in software, assuming enough hardware is available; however, the sad truth is that most programming is so constrained by convention, standards, enterpriseness and a major lack of imagination that it rarely lives up to its potential.
In the Star Trek universe, the Vulcans followed a philosophy called IDIC, infinite diversity in infinite combination, which celebrated the incredible variety of possibilities in the universe that Vulcans could put their mind to. Likewise in software the possible ways to solve problems, provide service, create new opportunities and change the world are also infinite.
Unlike physical engineering software is not constrained by physics or chemistry (things like gravity and rust). Writing a piece of software does have constraints of course such as time, money and hardware. Writing complex software is still hard. The difference is that given a freedom to choose the tools, languages and techniques and assuming you are smart and clever enough anything is possible.
In the real world an infinite set of ways to build software is considered highly impractical. What if I solved every programming problem with a different language? Maintenance would be a nightmare. Hiring additional programmers would be tough (do you know these 12 languages?). Management would be unable to understand what anyone is doing or why.
So companies seek to restrain software development, to choose a set of acceptable tools, languages, standards and methodologies and make changing them difficult. The way to restrain jello is to freeze it in a cup. Now you have control but at the cost of software's ultimate advantage: the flexibility to do anything.
Of course there are different degrees of "anything goes". There may be infinite ways to write software but only a small number actually make sense (otherwise 1000 monkeys could be your IT staff). The real issue is so artificially restricting your ability to find the best solution that the only result is ... not much better than the monkey's work.
What people who manage software development often don't realize is that programming is evolutionary and revolutionary. The adage "the only thing that doesn't change is change itself" is the world our code, business and the programmers themselves life in. Viewing a program or problem or programmer as a static unchanging thing is really a death knell but sadly a common theme.
Software is evolutionary in that the languages, tools and processes are constantly changing, almost on a daily basis. My friends in the civil, structural and architectural worlds deal with principles and solutions that may be hundreds or even thousands of years old. Changes happen for them but usually only in terms of new materials or techniques. In software change happens every day. In order to keep up you as a programmer have to change almost daily. The application you are writing must change to meet new requirements and demands in a world that never stands still. What today was state of the art is tomorrow's garbage heap content. You have to have a plan to deal with how you, your project and company will somehow survive the ever moving ground underneath you.
Imagine designing a building where the force of gravity is changing every day. That's what we have to deal with. It's so scary people react by nailing everything down and stomping on anything that changes. Of course that's one of the IDIC options, but the one that in the long run results in failure, coprolitic projects, burned out programmers and IT departments no one likes.
Software is also revolutionary. Unlike physical engineering we can invent our own gravity, even our own physics. Change happens suddenly or slowly but something new comes along that radically provides new solutions, new opportunities and a whole new viewpoint. The GUI and mouse, OO programming, the personal computer and the Web are all examples of major changes that enabled all sorts of new ways of doing things (some for the worse depending on who you are). Those who watch for evolutionary changes usually will notice and "get" the revolutionary changes as well. Yet the majority of people in our industry fear changes, learning new ways of programming, and planning projects with an eye on a changing landscape.
So software being evolutionary and revolutionary is a scary thing. What you know today might be useless tomorrow and that's not fun to contemplate. It's equally as frustrating to be evolving and being radical as a programmer and find yourself in a static, almost luddite workplace.
Yet software is still the most exciting, changing, moving form of engineering there is. We can do anything. We can be stupid. We can get silly. We can create something that no one ever contemplated before. Given enough freedom and creative license to try anything we can solve almost any programming problem. Maybe we will fail miserably but that's change and evolution, not everything works, but when it does it's pretty amazing.
So go out and be radical today!