Coding in the Cloud: Diving In with Online IDEs

It seems like everything today is moving to "the cloud," which is that nebulous term for software applications and data storage hosted remotely on some server far across the internet. So if all of our software is moving to the cloud, why not the tools used to create that software? Well, in some cases, those tools are rolling out right now. Heck, even GitHub recently added basic editing capability. This article will look at some of the up-and-coming online IDEs.

Pastebins: The Little Brothers of Online IDEs

The first category of online IDEs that we will explore can't really be called IDEs. These IDE-lite web tools are more like pastebins on steroids. Pastebins provide basic text editing capabilities and features such as syntax highlighting, but not support for version control or deployment. Instead, pastebins allow snippets of code to be saved and shared with other users. The following web tools extend beyond the basic premise of typical pastebins in that they also allow your code to be executed, something vital for testing. This category of IDE-lite is excellent for simple proof of concept work, but not for developing full applications. The main feature that these web tools support is quick and easy tinkering and the ability to share small snippets of code.  The three IDEs is in this space that we will be covering are JS Fiddle, Python Fiddle, and ideone.

JS Fiddle

JS Fiddle

JS Fiddle may not be a fully featured IDE, but for trying out quick ideas with HTML, JavaScript, and CSS it is a great place to start. The web site provides separate windows for HTML, JavaScript, and CSS, and another window that will display the final output. The editors support syntax highlighting. JS Fiddle allows you to choose from multiple versions of each of the major JavaScript libraries like jQuery, Mootools, Prototype, YUI, and Dojo when testing your JavaScript snippets. It even allows you to link in the URL to your own JavaScript and CSS files hosted remotely. Your "fiddles" can also be saved and shared with other users. JSLint is also integrated to ensure your JavaScript code is tip-top.

Python Fiddle

Python Fiddle

Python Fiddle is similar to JS Fiddle except it is focused on Python instead of the HTML/CSS/JavaScript combination. Python Fiddle provides a sandbox to test snippets of Python code, and provides support for many of the popular Python libraries. Like JS Fiddle, Python Fiddle supports syntax highlighting, and your snippets can be saved and shared with other users.

ideone

ideone

ideone is by far the most ambitious of the glorified pastebins. Much like JS Fiddle and Python Fiddle, ideone provides syntax highlighting and the ability to save and share snippets of code. Unlike the other two, however, ideone aims at supporting well over 20 different languages, including C, C++, C#, Java, JavaScript, Go, Groovy, Objective-C, Perl, Python, and Ruby. ideone aims to be a one-stop shop for all of your snippet testing needs.

Will the Real Cloud Based IDEs Please Stand Up

What separates the real cloud based IDE's from their little brothers is that they include support for importing projects, working with version controls systems (primarily Git), and in some cases support deployment. Of the fully-featured online IDEs we will be examining Eclipse Orion, Cloud 9 IDE, and eXo Cloud IDE.

Eclipse Orion

Eclipse Orion

Eclipse Orion is an online IDE effort being led by part of the Eclipse foundation. The IDE is primarily focusing on web development languages such as HTML, JavaScript, and CSS, but includes initial support for Java. Orion differs from the other online IDEs in that it is not necessarily meant as a hosted solution, but actually intended to be deployed into private environments. You can download Orion and host your own instance. For instance, you company might host an Orion instance for all of its developers, or even for specific projects.

Right from the start Orion lets you initialize new projects by cloning from Git (the only supported version control system), uploading a zip file of your project, or by creating a new HTML5 site using initializr.

For my testing I cloned a repository in Git. For some strange reason I had to use HTTP for Git instead of SSH, since I cannot find the SSH key listed anywhere in the IDE. Orion provides a GUI for interacting with Git, but it can be a bit confusing. While I understand it is a good practice to use Git's "status" command before performing a commit, Orion hides the commit interface under the Respository window's "Show Status" option, which is very confusing.

The editor is fairly nice. It supports line numbers and syntax highlighting. Support for outlining and content assistance is very spotty. Currently outlining is only supported for JavaScript and HTML, and content assist is only available for CSS. Basic editing commands such as Alt+Up/Down to move lines, Ctrl+D to delete a line, and Ctrl+L to go to a line number are supported.

For more information you should check out Eclipse's "Getting Started Guide" for Orion.

Cloud9 IDE

Cloud9 IDE

Cloud9 IDE is another web-based IDE specialized towards web development, and is the only one on the list with a paid solution. Cloud9 IDE is free for projects that will be publicly visible, but for private projects the cost is $15 a month. The IDE supports HTML, JavaScript, and CSS, but also includes support for Ruby and PHP. Of the online IDEs, Cloud9 is the only one on this list that supports Mercurial as well as Git. In fact, GitHub and BitBucket support is baked in from the start and you can actually create your Cloud9 IDE account by logging in through one of those services. In fact, when I created my account that was the only way (hopefully something that has been fixed, but I don't want to create another account to test the idea).

Provided you log in through GitHub or BitBucket, importing projects is a breeze. You will need to be familiar with the command line versions of Git and Mercurial though, as all version control support is implemented through a console at the bottom of the screen. The tool does provide an SSH key that you can register with GitHub so you won't be prompted every time you try to push code.

The editor is very responsive and supports some of the niceties I've come to expect from Eclipse (Alt+Up/Down to move lines of code, Ctrl+D to delete a line, Ctrl+L to go to a line). The syntax highlighter is nice, and there is support for code "beautification." The editor will also notify you of code errors as you type.

Your HTML pages can be tested right inside the interface. If you are looking to deploy to an outside host, Cloud9 IDE supports deployment to Joyent and Heroku.

eXo Cloud IDE

eXo Cloud IDE

eXo Cloud IDE is the last online IDE we will be looking at, and probably the most ambitious. eXo Cloud IDE aims to support the three web languages as well as Ruby, Java and JSP, and PHP. It also provides the most deployment options: CloudBees, CloudFoundry, Heroku, and Red Hat OpenShift.

eXo Cloud IDE supports Git for version control, and provides a nice menu at the top of the screen for all of the Git operations. A bit tucked away under the "Window" menu there is an "Ssh Key Manager" utility so you can set up an SSH key to use with your remote Git host (such as Github). Importing a project from Git was a bit more difficult with eXo Cloud IDE in that first you had to create a folder, initialize a repository in the folder, and then perform the clone. Most of the other services let you start with "clone" and took care of the rest for you.

The editor is nice enough. It supports syntax highlighting and line numbers. It doesn't have some of the text editing niceties I mentioned for the others (Alt+Up/Down is absent, but Ctrl+D for delete line and Ctrl+L for navigating to a line do exist). It does support a nice outline view though for navigating your code, which is very helpful. One extremely nice feature that eXo Cloud IDE supports is a minimal form of code completion (with the standard Ctrl+Space command). eXo Cloud IDE provides basic auto-completion for HTML, JavaScript, CSS, and Java, Ruby, and PHP code.

Comparison

The following table provides a comparison of the different features of the online IDE's mentioned:

IDE	Cost	Languages	Version Control	Deployment
JS Fiddle	Free	HTML, JavaScript, CSS	None	None
Python Fiddle	Free	Python	None	None
ideone	Free	20+ Languages	None	None
Eclipse Orion	Free	HTML, JavaScript, CSS, Java	Git	None
Cloud9 IDE	Free (Public), $15/mo (Private)	HTML, JavaScript, CSS, Ruby, PHP	Git, Mercurial	Joyent, Heroku
eXo Cloud IDE	Free	HTML, JavaScript, CSS, Ruby, Java, PHP	Git	CloudBees, CloudFoundry, Heroku, OpenShift

Conclusion

While I don't see the online IDEs taking over for most developer's day-to-day tasks, I think that they are a welcome addition to any developer's toolset. Web developers will benefit the most at the moment, as most of the tools are geared towards HTML, JavaScript, and CSS development. Seeing as how most software is moving into "the cloud" and those are the technologies that are driving new web-based applications, that's not a bad thing. The pastebin style tools are useful for quickly testing new concepts and don't require a lot of the overhead of a full-blown IDE.

Git seems to be the clear winner when it comes to version control support in the online IDEs. GitHub in particular is favored (it is a great service so I can see why). Only one IDE offered support for Mercurial, and Subversion lovers are out of luck going forward into the online world.

Personally, robust code completion and refactoring tools are a must in my world, and support for those features is definitely lacking in the current generation of online IDEs.  I think that as the tools mature support for those features will increase. I could see that several years down the line there will be whole software teams that develop and deploy all of their code right from their web browser.

Dealing With Management Disdain for Refactoring and Unit Testing

Refactoring and unit testing seem to have bad stigmas from upper management. From my experience, most managers see no value in performing either of those tasks. Refactoring (rewriting existing code) and writing unit tests take time, which is time that could be used to add valuable features for the customer. While this is true, I would like to touch on some of my personal experiences with refactoring and unit testing that have proven that there is a value to those tasks.

The Golden Book of Refactoring

First I'd like to cover refactoring. Years ago I read Martin Fowler's excellent book Refactoring: Improving the Design of Existing Code. This is probably the most important book I've read in my programming career. The book covers the process of identifying code to refactor (through the use of "code smells" that are rules of thumb to identify potentially bad code), the different refactoring techniques that can be applied, and how to actually apply the refactoring techniques. While around 50% of the book is obsolete (most modern IDEs provide built-in support for performing the refactoring techniques, which is a large part of the book), the rest of the book is pure gold and still worth the read just to learn how to identify bad code and know which refactoring technique to apply to fix it. After I read this book I completely changed how I view coding. I found myself seeing potential refactorings before I even wrote the code, and I changed the design before even getting started so the code wouldn't need to be rewritten in the future. As soon as I read it I started tearing apart our baseline at work. I found all sorts of places that needed cleaning up. Every month my line of code count was in the negative, which management wasn't too pleased with as that was our main metric at the time (LOCC is a horrible metric).

The Fallacy of "Not Writing New Code is Not Being Productive"

Early on in my refactoring experience I started getting resistance to changing the code base. It was the standard argument about how I could be working on new features instead of rewriting old ones. So why did I persist with my refactoring arguments? Even more importantly, why did management see the light? Well, the project was a Swing GUI with a lot of screens. Most of those screens were very similar or made of similar components. In the original design when I came on, most of that similarity came from copy and pasted code or someone's independent work to make a similar screen. The average time for a team member to create a screen from scratch was about one week.

Duplicated code is one of those code smells I mentioned earlier. I managed to create a framework of superclasses and extracted classes that formed commonly used components. It took me a little over a week to perform all of the refactoring. In that same time, I could have written one screen and added value to our product! What a waste! Well, it turns out not. After the refactoring was complete, the time to create a new screen using the new base classes and refactored components dropped to one screen per day. So for one screen's worth of effort one week, you got five screens worth of effort the next. I also refactored the styles and sizes of screen components into a set of utilities, so that when all screens used that utility they would have a uniform look and feel, which was something that was missing before.

That's not to say that the payoff will always be that big. This was an extreme case, but it makes my point about refactoring having value very well.

You Might Break Something!

I recently completed a major refactoring on a set of EJBs for another project. There were about 8-10 EJBs that each consisted of a single method that was between ~200 and ~500 lines long. The code was a nested mess, and once again it was an example of copy-and-paste happiness. Once again my new boss was totally against the idea of rewriting the code, mostly because of the possibility of me breaking something. His favorite phrase when I mention refactoring is "Don't break anything." So this time I added another best practice to the mix: unit testing. For every block of code that I refactored out of these massive EJBs I created a unit test to ensure that the block worked as expected. Now not only was the code cleaner and better organized, but it was now tested as well.

Testing Takes Too Long and Is More Code to Maintain

I tend to hear this one not just from management but from other team members. On another project separate from the two mentioned above, my team implemented unit testing late in the game. The benefits were still there though. Can you guess the results? We found bugs (which is what unit testing is designed to do), some of which had been in the system for ages. We also tended to break code less, since we ran the unit tests every build to regression test our work. Every time we did discover a bug, we wrote a unit test to expose it and then fixed it. We were lucky on this project that management was supportive of our decision to write unit tests (mostly after we completed another major refactoring effort that improved productivity dramatically).

Unit testing also provides another benefit: improved documentation. If a unit test is well written it can often uncover gaps in the documentation (what happens if I pass null for this parameter? what if I use a negative number for this one?). Many times I ended up rewriting the Javadocs to better reflect what the method was doing after the unit tests exposed its true behavior.

How I've Dealt with Management

So how have I dealt with management pushback? Well, on my first program I had already started the refactoring without permission. Once our team started reviewing the code and realizing how much was changing I started to get heat about it. So I explained my vision about what I was trying to accomplish and how the new code base would be easier to extend and create screens. I quoted a bunch of stuff from Martin Fowler's refactoring book about the problems with the code. I had a plan for my refactoring and by explaining it and the benefits I was able to get buy in from the rest of the team and management. If you plan on making large sweeping changes to code, explain your changes first and explain their benefits (quote Martin if you have to).

The second way I've dealt with it is to do it in minor steps. As I work on a new feature that is similar to and older one, I clean up a bit of the older one and reuse what I can. On the project that added the unit testing the refactorings were done very incrementally, but over time the payoff was huge in productivity gains for adding new features. The general idea is leave the code you touch better than when you started with it. Extract out a method or class here and there that can be reused, or rename or document something that is unclear. Add a unit test for both the older feature and the new one. Little changes over time can add up without causing too many ripples.

Conclusion

So in conclusion, while unit testing and refactoring do take up time that could be spent developing features, they also provide benefits by making software more robust and easier to understand, maintain, and extend, which can make adding those new features much easier going forward. From my experience, refactoring often (but not always) leads to productivity gains over time. Feel free to use my examples next time you have to convince your manager that they are good practices and not wastes of time.

How to Fix a Broken Software Patent System

Oracle vs. Google
Apple vs. HTC
Lodsys vs. App Developers
Microsoft vs. Barnes & Noble


Recent headlines are filled with cases of patent battles between technology and industry titans. It seems like more and more patent cases (and especially software patent cases) make the news every day. NPR recently did a fantastic piece in their This American Life program called When Patents Attack. It is definitely worth the time to listen to or read the transcript.

As a software engineer, I have to agree with many of my colleagues in the field that the patent system is broken. I have actually witnessed it firsthand to a certain extent. Several years ago I worked on a project for what my team thought at the time was a novel idea. After we had a working prototype, our company of course wanted us to look into patenting the idea. So I was tasked with doing some patent research. What I found kind of surprised me. It turns out, our idea wasn't novel. In fact, it had already been patented three times! Two of the patents were for recent years, but one of them was over a decade old. Ours wasn't a new idea, it was just one that hasn't been capitalized on yet.

Now the real question is how did the exact same idea get patented three times in the first place. Well, having read the patent applications in full (and they were quite lengthy) it was kind of easy to understand. Each application was filled with technical terms and legal mumbo-jumbo that made the applications nearly unreadable. Many of the claims in one patent used synonyms for terms in the other. When you boiled it down to layman's terms though, the patents were identical. Heck, with enough big words obfuscating what you really mean, you can patent anything (the When Patents Attack story mentions Patent 6,080,436 titled "Bread Refreshing Method", which is better known to the rest of the world as "toast").

In truth, to find the patents matching our idea it took some searching and using combinations of terms that were similar to the ones we used to describe our "novel idea." I knew which terms to use because I was familiar with the subject matter. In the case of the United States Patent and Trademark Office (USPTO), the patent applicant reviewers probably are not as familiar with the field and will be less likely to make the connection.

Something else I found while Googling for the patents were articles on the subject of our "novel idea." Some of these dated back well beyond a decade when the first patent was filed. Technically, these should have been considered as "prior art" since they described the same concept before the first patent application was filed. In all reality, none of the patents should ever have been valid. It is easy to understand how the first patent could have been granted. Back when it was issued, the USPTO probably didn't have the search capabilities to identify works of prior art (before the days of Google), but the subsequent patent applications should have turned up this prior art when they were being reviewed.

The point is, there are numerous patents that exist that are either identical or similar enough to be considered the same, and many of them probably aren't valid because they weren't novel ideas. These patents slipped through the cracks, but are now valid and are now viable weapons.

Weapons?

The NPR piece describes an arms race among patent holders. Apple and Google and Microsoft are amassing caches of patents to use "for defensive purposes." (updated: such as Google's announcement today to purchase Motorola and its 17,000+ patents). The NPR piece compares it to the term "Mutually Assured Destruction," which in nuclear terms means "if you nuke me then I'll nuke you and we'll both be destroyed." In patent terms it translates to "if you sue me because I infringe on your patent then I'll sue you because you infringe on mine." The idea is that if you hold enough patents that your opponent infringes on then they can't sue you because you can counter-sue them back.

That's not a healthy strategy for innovation and the patent system. One, it means that many patents are being cached not for their innovation value but instead for their litigation value. Sadly, the patents that are worth the most are really the least innovative ones: far reaching, overly vague patents that cover general concepts. Two, it means that smaller players such as small businesses and startups can't participate. Back to the nuclear analogy, it means that a country like San Marino (the startup of countries) better not try to build a weapon (product that may infringe a patent), or better pray it doesn't get noticed, because any of the bigger countries could take it off the map at any point.

There is one more problem with this patent approach: patent trolls (i.e. non-practicing entities). Patent trolls collect patents and use them for litigation or licensing, but do not build any products themselves. Which means all of their patents are offensive. Google can threaten Apple with a patent claim that Apple infringes on if Apple tries to sue Google for one of Apple's patents that Google infringes on. In the end, it could just be a stalemate. That doesn't work with the patent trolls. If a patent troll sues Google for patent infringement, there can be no counter suit since Google can't be holding any patents the troll is infringing.

Some people are calling for software patents to be abolished again (software could originally not be patented until a 1998 ruling, just in time for the original web gold rush). I think that once the software patent genie is out of the bottle, there's no turning back the clock to undo what was done. There are too many big established companies with too many lobbyists to let that happen. So the best we can do is reform the broken system and fix the problem going forward. 

Part of the problem with the patent system seems to be that the USPTO is overworked and underfunded. A recent proposal called the "America Invents Act" helps to push some reform through the senate. One of the benefits is that there will be additional USPTO offices and that the USPTO will get to set its own fees and keep all of those fees (previously it did not set fees and only received a portion of them).

With that in mind, I have a few suggestions for how these fees should be set and how the patent system should be reformed.

First, raise the barrier to entry. It currently costs as low as $110 to file for a patent (non-refundable whether the patent is issued or not), and $755 if the patent is issued. Raise those values to $1,000 to file (non-refundable still) and another $1,000 if the patent is issued. This would probably cause the number of bogus or far-fetched patents to be lowered and improve the quality of the patents that are submitted. This would mean more money for the USPTO and hopefully fewer patents to review (leading to more thorough and better reviews).

Second, reduce the duration of the patents (at least for software and business process patents). Patents currently last 20 years from the date of filing. When the patent system was first formed, technology (like the cotton gin) didn't advance at nearly the rate that it does now. A 20 year monopoly in the software field is well beyond the useful lifetime of most software products. Five years, or at most seven, should be more than sufficient, if not still excessive for software patents. Can you imagine if Apple refused to license their multi-touch patents for 20 years? Only the iPhone would be able to pinch zoom for that long? That number needs to go down.

Third, raise the maintenance fees and make them annual. Currently, at 3 1/2 years it costs $490 to renew a patent. At 7 1/2 years that number goes up to $1,240, and at 11 1/2 it is $2,055. I propose that a more exponential scale be used.

Year 1: $1,000
Year 2: $10,000
Year 3: $50,000
Year 4: $100,000
Year 5: $500,000
Year 6+: $1,000,000

There would be numerous benefits to this approach. First, the smaller values initially would allow startups a few years to cement the patent and get something off the ground. Second, patents with lower value and less utility would probably not be renewed after a few years, making the technology available to other companies sooner. Companies would probably only pay the upkeep on their most valuable patents and the ones that differentiate them from their competition. Third, the patent trolls will have a hell of a time paying for the upkeep on the thousands of patents they are hoarding. Unfortunately, they would probably still pay for the broadest reaching patents they can use to sue with, but it would probably cause them to reduce their patent portfolios and their threat to small companies. Fourth...that would be one well funded USPTO! With that kind of money they could hire field experts to examine patents and have multiple reviewers for patent applications. The best possible solution would be to apply those fees starting when they change (i.e. next year if your patent is 6+ years old then there's a $1M cost to renew, only 2 years then it would be $10,000).

In addition to the pricing changes, the USPTO should provide an easy system for third parties to challenge patents. The America Invents Act actually is looking to implement this by providing a one year post-grant review period where third parties can submit prior art and challenge a patent. There are multiple benefits to this as well. One, it gives competitors a chance to defend themselves against a patent by striking it down early. Additionally, if the fees are upped as I mentioned above, then a lot fewer bogus patents will likely be filed. If an idea is not really new or radical and is likely to be shot down in the post-grant phase, the filer will be less likely to file the patent at all since they will lose out on the non-refundable application fee. This too would likely improve the overall quality of patents that are granted. The hard part on the USPTO is to make this fair for both parties, as large companies could easily file endless reviews against startup competitors and put pressure on them with already granted patents past the review period. The system will need to be affordable so that startups can defend themselves and file reviews as well.

What do you think?

So You Want to be a Programmer

So you want to be a programmer?

That is great! Programming can be very rewarding.

First of all, I'd like to to touch on why I am writing this. I see a lot of blog articles with titles like "10 Things Every Programmer Should Know." When I go to the post, I see a bulleted list of things which only five of which I agree with. There are a lot more things that I think programmers should know. This article is intended for the newbies out there, but I think some experienced programmers may get something out of this.

So you want to be a programmer?

My first question to you is simple: why? Are you doing it because you love computers? Are you doing it because you want to know how software works? Are you doing it because you have this cool idea for an app for your phone? Are you doing it for the money?

Only three of those are good reasons to consider programming. Software engineering and the medical professions are the top growth industries at the moment and also offer some of the best salaries, which is great to those of us in those professions. However, if you don't have any interest in how software works or in helping people, those are two professions you need to steer clear from. The last thing a programming team needs is someone who hates coding and the last thing a hospital needs is someone who hates working with patients. While programming can be very rewarding, it can be a lot of hard and frustrating work as well.

Personally, in my first years of college I was a Psychology major. I played with computers, tried different operating systems, and modded games as hobbies. I also worked as a tutor in the campus computer lab. Just before I graduated with my associate's degree my psychology professor sat me down and recommended I change my major when I go to a university. It's not that I wasn't good at my psychology coursework, but he knew I was better at computers, so he recommended I go into computer science. That was probably the best counseling I ever received at school.

That's enough about me. The point is, you need to be passionate about programming and computers if you want to be really good in the field. You also have to be really passionate about learning. Compared to other fields, the lifespan of programming languages, tools, frameworks, and development methodologies is similar to that of gnats. If you're not constantly learning, you're a dinosaur pretty quickly. Luckily, reading blogs (like this one), is a good way to stay up to date, and there are lots of resources and tutorials on the internet (Google is your friend).

So what is it that you really need to know to be a good programmer. Quite a lot, actually. First, it probably takes learning a programming language.

Learn a Programming Language

So which programming language should you learn first? It really depends on what you want to develop. Want to develop games for the XBOX 360? You should probably learn C# or C++ then. Want to developer enterprise level back end services? Want to develop Android phone applications? You'll probably want to learn Java. Want to develop a quick and dirty content-based web site? You'll want to look into Ruby and Rails. Want to develop iPhone applications? Objective-C is the language for you. Want to develop interactive web pages? The holy trinity of HTML, JavaScript, and CSS will be required.

It turns out learning a language is usually pretty easy. Once you have the concepts of one language down it is not hard to pick up another one (usually). The hard part is learning the libraries of another language. Libraries provide the meat of using a language. Some languages, such as JavaScript, provide very minimal libraries. Others, like Java, have thousands of commands in their standard library. Fortunately, for every language, there's probably only a subset of the libraries that you will be using. One of the best ways to learn a language is to read source code from an existing project. Search Google Code or Github for projects related to your interests and read the code for those projects.

In addition to a bread-and-butter programming language such as the ones mentioned above, you'll probably eventually want to learn a scripting language such as Perl, Python, Ruby, or Groovy as well. Scripting languages are good for small tasks and for performing maintenance, and in many cases for writing full applications (especially for the web: Ruby on Rails is a popular framework for running a website, and Groovy has an equivalent called Grails). For instance, say your program has a configuration file and the format of that file needs to be completely changed. You could manually change every single instance of the file (which would take a lot of time), or you could write an application that would change the file to the new format (which still make take a while to write). The other option is to write a quick script to make the change.

Learn how to Document Code

Another key point when learning a programming language is learning how to document code for that language. Javadoc (for Java), XML Commenting (C#), and Doxygen (C++) are a few ways that you can write documentation for you code so that it can be generated into human-readable documents such as web pages. Documentation is almost as important as the code itself is, especially if you are working in a team environment. While most programmers hate documenting, well documented code can reduce the confusion when reading the code for people who didn't write the code and might not know why it is doing something (or for you many years down the road when you don't know why you were doing something).

Learn how to use an IDE

Once you know the language, you next step is to learn the development environment for it. Modern software is usually developed in an IDE (Integrated Development Environment). For instance, as a Java programmer, I spend most of my day coding in an IDE called Eclipse. For Java there are other options like Netbeans as well. If you plan on writing C# applications, you'll most likely use Microsoft Visual Studio. If you're looking to write iPhone apps, then you'll be using XCode on a Mac. No matter what IDE you use, make sure you learn how to use it well. IDEs offer features like code completion which will show you what commands are available when writing code (great if you're first learning, so you don't have to look up everything on the internet all of the time or wade through gigantic documents). IDEs can also color code your code so you know what are reserved words, what are the variables, function calls, etc.

As well as learning an IDE, it is a good idea to have a good handle on a basic text editor (usually something better than Notepad though). For Windows, this could be Notepad++, TextPad, or e. For the Mac, the most recommended text editor is TextMate. If you're on Linux, welcome to the holy war between vi and emacs (I'm personally a vi guy). These editors are great for when you have to edit config files, HTML or XML documents, or make small code changes.

Learn a Version Control System

Another very important tool that you will need to learn how to use is a version control system. Version control allows you to save snapshots of your programming work at various stages in time. That way, if you break something, you can always revert it. The current top version control systems are subversion, mercurial, and git. Mercurial and git are very similar, but subversion can be quite different from the two. Git seems to be the rising star and the one you should probably pay the most attention to. There are numerous sites that will host your code for free (as long as it is publicly accessible) such as Google Code, BitBucket, and GitHub.

Learn XML

So now that you know you need to learn a programming language and have picked one and its IDE, there are a few technologies that pretty much go hand-in-hand no matter what language you are learning. The best example of this is probably XML (Extensible Markup Language). XML is the lingua franca of the web. It is the basis for XHTML, is used in configuration files, web services, data files, and even in some databases. No matter what language you choose, at some point you will most likely have to interact with XML documents. It is a good idea to at least understand the basics of XML. Another technology called JSON (JavaScript Object Notation) is making inroads on a lot of what XML is used for, so that's another one you should probably look into as well.

Learn Regular Expressions

Regular expressions are another feature that spans all programming languages and you will probably have to use at some point. Regular expressions provide a syntax used for searching text, replacing text, and ensuring that text is in a specific format. For instance, say that a user types in a phone number or credit card number and you need to validate it is formatted properly (has all of of the right digits, parentheses, and dashes in the right places). The easiest way to do this validate the text the user entered against a regular expressions representing a valid phone number or credit card number. Regular expressions are also useful for extracting values out of text, such as pulling just the area code from a phone number.

Learn SQL

Database interaction probably the next important thing you will need to learn. At some point in your career as a programmer you will most likely have to interact with a database. You may not be the one to set it up (there's usually "the database guy" on the team that does that), but you will need to learn how to query it and update it. Most databases today are "relational databases", and luckily there is a standardized query language called SQL (Structured Query Language) used for these interactions. While you might not need to know all of the details of how databases work, at a minimum you should know that basics of SQL (SELECT, UPDATE, etc.). Looking forward, a new breed of databases is emerging that don't use SQL (and are thus referred to as NoSQL databases). These databases don't have a standard query mechanism yet, and often use JSON for storing data.

Learn Web Technologies

Even if you're not working directly with the web, a lot of technology and applications are moving to web-based applications. It will be a good idea going forward to learn the basic web technologies (HTML, JavaScript, and CSS). HTML (Hypertext Markup Language) is a markup language used to display the structure of a web page. JavaScript is a programming language that controls the behavior of a page, and CSS (Cascading Style Sheets) define the style and look and feel of the page. If you will be doing any serious web page work, expect to have to learn additional libraries (such as jQuery or prototype) if you want your page to have any cool effects.

Learn a Unit Testing Framework

Another set of technologies you should learn is the *Unit testing framework that goes with your language of choice. Unit tests are pieces of software that are designed to test units of other pieces of software. Writing test cases for your code ensures that the code that is being tested is well designed and bug free. If you're a Java developer, you'll want to learn how the JUnit library works. For C#, it is called NUnit, and C++ developers will probably use CppUnit.

Conclusion

So that's just a taste of some of the things you will need to learn to be a good programmer. That doesn't even touch on the numerous design philosophies or development cycles that are also involved, but it should be enough to get you started. Pick up a few books on those subjects. Read some blogs. Read some code on GitHub and Google Code. Pick a few small projects for yourself to push your skills. Good luck!