What things didn't you know you needed but are now very glad you have?Take a programmer that has never used source control, show them what it does, and their eyes light up... the benefits are obvious but until they actually see it most people had never considered the existence of such a tool.
What other such things exist? Tools or approaches or techniques that aren't obvious before you encounter them, but once seen have obvious value. Things that are likely so ingrained in the way you work that it's hard to think of working without them, things almost embarrassing to bring up because you expect the other person to say "duh, that's obvious!"
No matter how petty something seems there is a chance that other people don't know about it yet; I'd like to get an idea on what things I'm missing simply because I never thought of them.
A second monitor. One to hold the programming environment, the other to hold either the documentation or to hold the program under testing.
Vacations. Evenings. Weekends. It can be fun to pull all-night sessions and code really cool programs, but in the end family time is what counts.
Learn to say NO.
The Internet.
The amount of information at my fingertips is mind boggling.
stackoverflow.com
An IDE!
Seriously some people still just dont know "why" they should use one...
A profiler. A good one will tell you more about what is going on inside your code, than you could have ever dreamed.
Holding down alt + dragging, in certain text editors, to select not only lines of code but also columns. This has definitely saved me hours of time.
Something we all take for-granted now, but I remember when I first got a mouse with a scroll wheel, and then had to go back to one without.
Source control. I'm amazed at how many people don't use any.
Touch typing.
Don't laugh, I've personally known several programmer who "hunted-and-pecked", claiming that they could do so just as quick as a touch typer. I say, BS. If you can't touch-type, you're gimping yourself.
There are some good free online typing programs. An hour a day for a couple weeks can double your typing speed, and nobody has to know you were ever a hunt-and-pecker.
Debugger. I deal with so many computer science students who have not really used a good, GUI-driven debugger.
I hold up Visual Studio as a great debugger (or at least the best I've ever seen).
Of course, I've debugged on a system where the only debug output I had was one LED, initially. That was not terribly pleasant. You don't need a GUI. But it sure helps at times!
printf you mean log4cpp.sourceforge.net - bcml
cdb (not gdb) and WinDbg are more suitable. - Alex
A good file comparison application, like BeyondCompare.
http://www.scootersoftware.com/moreinfo.php
It is the most useful tool in my toolkit and has saved my hide many times.
Fiddler - HTTP debugger, essential for REST development, link [1]
FireBug - javascript/css debugging used to be torcher, FireBug + jQuery make AJAX development fun. link [2]
[1] http://www.fiddlertool.com/code & syntax highlighting and coloring in modern text editors and IDEs
Automated refactoring tools. Mostly Rename, Extract Method, and Introduce Explaining Variable.
Red squiggly lines under my syntax errors so I don't need to hit compile.
It's saved days of my life.
VMWare or other virtualization system. Being able to test cross-platform code on 6 or 7 different OS configurations without having to have a mess of spaghetti cabling and KVM switches is great.
Here's one that I don't have yet... but I SHOULD. A reversable debugger. That is, you just run your program until the error, then tell it to BACK UP one step at a time until you figure out what's going on. I have seen academic examples [1], so tell me: why don't I have one built into IntelliJ or Eclipse?
[1] http://homepages.inf.ed.ac.uk/jcook/bdbj/bdbj-1.2.1/dl.htmlA unit testing framework like JUnit [1], and a Continuous Integration (CI) [2] server. Also, some kind of build system like make, Ant, or Maven.
Maybe also a team coding standard, to avoid wasting time over arguing with coworkers about tabs vs. spaces and brace styles.
[1] http://www.junit.org/A family. My baby daughter rocks! And shes a good sleeper too!
Another important concept is ORM and using tools like NHibernate..
Mastery of a text editor (whether it be VIM, Emacs, etc). At least one that supports replacing with Regular Expressions, macros, and all the shortcuts that allow me to type and edit at the speed my brain sometimes thinks. Learning an editor inside and out is one of the best pieces of advice I ever got from an instructor in Com sci at university.
Firebug: didn't know I needed it, and sometimes wish I didn't need it anymore.
Generics - I love you.
Google
so that all that I need to know is just a URL away
On a group level, continuous integration.
If an automated build runs per commit, people will no longer freak out when the build breaks because they know exactly which commit broke it.
If the build also runs unit tests, people will smile.
If the build also deploys to test environments and runs acceptance tests, group zen may be on its way.
For .Net Lutz Roeder's Reflector [1] for being able dive into the code of some DLL when source code is not available.
Open source Javascript frameworks like Prototype [2] and JQuery [3] that finally make it easy to get a rich clientside experience.
And Tortoise SVN [4] for saving me from my Visual Source [un]Safe nightmares!
[1] http://www.red-gate.com/products/reflector/A nightly build.
A large, widescreen monitor. Being able to see two (or more) files for editing at one time is huge.
Regular Expressions. Many people don't know them.
Coworkers!
I left my job to do a solo software startup project and by far, by a million miles, the thing that I miss most is having smart people around me. This is not only true in the sense that our coworkers make us smarter, but they also help us stay sane.
twitch twitch
So next time you think you can do it better by yourself, really examine all of the benefits of being surrounded by smart folks. I don't regret my decision, but I can't wait to hire someone!
Understanding the end user.
There is no substitute for understanding.
Cygwin [1]. All the power of the Linux command prompt and associated tools for your Windows systems. If you know some basic bash commands there are a lot of things you can do with a one-line command that would be a real pain to do manually in the GUI.
[1] http://www.cygwin.com/Launchy [1]: The Open Source Keystroke Launcher
I can never go back to using the Start menu again...
[1] http://www.launchy.net/A girlfriend that cooks for me while I am at stackoverflow.
Assertions. After I started adding them to my own code during development, I was astonished to find how many times they were triggered. When I started adding them to other people's production code, they were astonished by the number of bugs that the assertions uncovered. It was a tipping point in my software development career.
Learning about advanced algorithms.
For example, spending the time to read about all the different ways data can be sorted teaches you a lot about manipulating data. Even if you never do anything but call the library's QuickSort. Ditto about how compilers work. Or how to store tree-oriented data in a relational database.
A memory stick
Intellisense
I keep coding notes. A library of code snippets + text about coding minutiae.
As a senior .Net web developer, I just have too many details to remember in too many languages -- C#, VB, HTML, CSS, SQL, JavaScript and on and on.
I can instantly find the SQL using ROW_NUMBER for paging data, the syntax for applying a regex in JavaScript, or the steps for deploying a web app to IIS, along with my own comments and troubleshooting tips.
Since I've been keeping notes for a decade now, I can find information about older technologies like classic ASP, SQL Server 7, or VB6 -- handy when you're called in to read the old code for an upgrade.
I refer to my own dogpile of notes before going to Google. The particular software I use is InfoSelect (www.miclog.com, I have no affiliation with them). It's like writing everything you know on 3x5 index cards and then being able to search their text. I believe you can also use OneNote for this; no doubt there are many others.
A coffee grinder
Learn the keyboard short-cuts of your IDE and ditch the mouse whenever possible. It'll not only make you faster, but also force you think more of keyboard oriented users in your own apps!
Oh, and ReSharper [1] of course! :)
[1] http://jetbrains.comA great revolution for me was the discovery of delicious.com
It has become an every day tool, completely integrated in my browsers as plug-ins, through which I discover and find pertinent techniques, white papers, tutorials, tools for subjects I'm interested in. The fact, that you can also browse bookmarks saved by other people on subjects of your interest is a related amazing technology-watch feature that I discovered by acccident.
I guess you can't really understand the power of this social bookmarking features as implemented by delicious until you start using them. That's why I think delicious is a good candidate as an answer for the current question.
Code Complete. Absolutely the best book on software development.
Test driven development
IM and IRC. At this moment there are 207 people in the ##CSharp chat room in FreeNode, always about ten who are active at any time, and always two or three who are willing to help or discuss technical issues and ideas with you about C#.
Design patterns
wiki - collaboration on the web
MacBook's touchpad.
Learning how to take heap dumps of running processes, then using WinDbg + SOS to troubleshoot them for memory leaks and deadlocks. Priceless with large scale web applications!
[1] http://www.eggheadcafe.com/articles/20060114.aspAgile and SCRUM Methodology changed everything
My wife and son :-)
No interruptions would also be high up my list. Often hard to achieve but makes the world of difference
wget - is there a better way to download things from the net?
Automated regression testing, preferably run nightly after the nightly build on the nightly build. Huge time saver and confidence booster.
It will sound corny, but.... a co-worker. I freelanced for a long time, doing contract work for small businesses where I was pretty much the only developer, brought in for small projects, often working remotely from my house, then moving on to something else.
A couple of years ago, I started working with someone on a daily basis, and improved efficiency aside, it's amazing how much more fun and rewarding work has become. Even the bad stuff is so much easier to get through.
Spider Robinson had it right.
vim, find and grep
Static source code analysis in the editor.
This has already caught many silly mistakes I made after I got distracted by a phone call or something. For example I seem to often create a while loop with a condition that does a variable != null check, but then forget to update the variable inside the loop (thus creating an infinite loop). IntelliJ IDEA warns me about this before I try and run the code.
A Laptop! Finally I don't have to walk 5 minutes to a warehouse, then back to my desk, then back to the warehouse......
WinMerge for comparing the differences in content of two files similar files
Life, mate. It's short and it's out there, so don't spend yours in front of a monitor (says the wise guy who's mostly done that).
Virtual Desktops.
Being able to have "groups" of windows (say, a browser window for testing and two code windows on desktop, then a browser window and a PDF viewer for docs on another, and then a group of email/calendaring apps...) is really damn useful.
It's like having an extra dimension; you can alt-tab to switch within the windows on one desktop, and then hit another key combo to switch to another desktop with its own self-contained group of apps.
Issue/Bug tracking systems like Fogbugz and Bugzilla.
Funky things like Dependency Inject or Test Driven Development.
Teach him Test Driven Development way of developing software.
Backups. Automated, versioned, tested, and useable backups.
A programmers notepad (such as TextPad or Notepad++). Sometimes a full IDE isn't needed and it' nice to have someting light to do quick things.
Emacs - Before using it I didn't imagine I could so easily automate all those everyday routines. Now I can't imagine my life without it.
Scripting I mean scripting in "scripting" languages. I used to write my scripts in C, and only realised the true power of scripting when a colleague introduced me to Python.
Since, then I have moved on to Scala, but the Python experience was an eye opener.
Lint [1], pylint [2], JSLint [3], etc. You don't know just how ugly your code is until an automated procedure goes out of its way to badger you about it.
[1] http://en.wikipedia.org/wiki/Lint_programming_toolSystem level debugging and monitoring tools:
Software Development (some were already mentioned): Unit Testing frameworks, JUnit, etc., especially when combined with code coverage tools: Devel::Cover [3] (Perl), Cobertura [4] (Java), rcov [5] (Ruby), sb-cover [6] (SBCL) and Devel::NYTProf [7] (Perl).
Profiling tools: Devel::Prof (Perl), Devel::NYTProf (Perl), YourKit [8] (Java) and ruby-prof [9].
Oracle's EXPLAIN PLAN [10] for helping to tune SQL.
[1] http://www.ibm.com/developerworks/aix/library/au-unix-perfmonsar.htmlReflector!!!!!!!
A mocking framework, like Rhino Mocks [1], which allows you to work with mocked or stubbed instances while testing.
Without it Test First Development just wouldn't be the same.
[1] http://ayende.com/projects/rhino-mocks.aspxUnix CLI tools like find, awk, sed, make. They come handy in all kinds of situations.
GNU Screen [1]. I don't know how I worked without it before I found it. It allows me to use all the other suggestions that were made here in one screen session.
[1] http://www.gnu.org/software/screen/Reflection. Definately reflection. There is just no way I could do my current work without it.
Without a doubt, it's the Internet. Those who have always known it have no idea what an impact this has made on everything.
If you haven't really "got" the object oriented paradigm, your eyes will light up when you finally grasp it. OO is a way to think about the "middle chunks" of a complex system and lets you make progress even when you don't understand the whole solution yet.
stackoverflow :)
Cheat sheets!
Command-line access to cheat sheets using a Ruby gem: http://cheat.errtheblog.com/
Heck, you can even do cheat cheat.
Here are some awesome networking cheat sheets from Packetlife: http://packetlife.net/cheatsheets/
I'm currently in the process of collecting all the best sheets and printing them into a binder format.
A Staging Server: I can't imaging working on a web app then deploying into production without staging it first in the same environment as the production server.
Scott Hanselman has put together and maintained an excellent list of tools and utilities, many of which I now find indispensable.
The list is here:
Scott Hanselman's 2007 Ultimate Developer and Power Users Tool List for Windows [1]
My personal favourite: slickrun [2], an indescribably smart and effective utility to launch anything.
[1] http://www.hanselman.com/blog/ScottHanselmans2007UltimateDeveloperAndPowerUsersToolListForWindows.aspxBoost [1]
C++ is as bad as all the Java programmers claim without it.
Google.
Before trying to solve any problem, use Google to see if (and how) any one has done it first.*
*Although the answer to who's done it first might well be Google.
Domain Driven Design
Basecamp Project Management Software because no one really wants to take the role of the project manager, but this helps everyone become more accountable for what they are doing. Especially in small companies, I think most programmers fret at the thought of using such software because they complain it makes more work for them, but when you are working with programmers who are both on-site and remote, things can get messy. Basecamp helps to keep everyone on the same page. For our team, we use it as a calendar, task list and sometimes a wiki for documentation.
Bazaar. Definitely the best source-control software I've ever worked with. First you discover source-control, then you discover bazaar [1].
[1] http://bazaar-vcs.org/strace and ltrace on Unix. I have no idea how other programmers get along without them! The output of these tools can take some getting used to, but once you do get used to it, its hard to imagine not having!
Synergy, without a doubt. 3 seperate OS's all controlled by one mouse and one keyboard? Magic.
(java) In the last few days, I've also discovered the joys of Spring Workflow. There are other frameworks out there but this is the one I discovered. Re-implementing our core Webservices has not only been a joy, but maintenance and performance have been hugely improved.
Ctrl+F5
CruiseControl or any continuous integration tool, and lots of Unit Tests.
Good people in Test.
And "eat your own dog food" use your software every day you'll know the problems earlier.
I've found that having one vertical monitor and one horizontal monitor is very useful. E-books, web browsing and some code (long functions) are better on the vertical one. Mail and wide code are better on the horizontal one.
for me also...
EDIT
forgot one
EDIT 2
some tools I place on my USB stick. ( link [7] / link [8])
always my mindmaps with me...
[1] http://www.jetbrains.com/A "visual" editor. When I first started programming, I learned to use a line editor (think interactive sed... a big step up from punch cards) and got pretty good at working with it. Then some other students started using and bragging about a new "visual" editor (think vi). I tried it, but couldn't see the point; I could edit code faster with the line editor which I had spent a great deal of effort mastering. Finally, after some time, after admitting my stupidity, I switched to the more modern editor and never looked back. Hopefully that experience has made me a better judge of the value of change. In our industry, more often than not the new way of doing things is worse than the old one. But sometimes the new way is in fact an improvement.
ClipX - A Clipboard extender that lets you access your 20 most recent "Ctrl-C copies". How many times you whished, you had that "second-to-last" copy handy.
Set the shortcut to Ctrl+Alt-V, and you will get used to it quickly.
People skills. Now I can talk my managers out of doing thing(s) that make absolutely no sense without having to write a single line of code, and that saves me a huge amount of time.
Git. I didn't have any idea how bad svn was until I came to know the powerful ways of git. (though I think any -distributed- version control system might work).
IntelliSense, or any similar auto-completion mechanism.
It is absolutely staggering how many IDEs don't have this, even though Visual Studio demonstrates really nicely how useful it is and how much time it can save.
Unfortunately you can't have IntelliSense in a dynamically-typed language.
Resharper [1] Proberbly one of the most useful tools I have ever used. Makes my coding experience in Visual Studio so much more pleasent.
[1] http://www.jetbrains.comA mock object tool. Specificaly Moq for .Net.
two monitors. definitely two monitors.
Google, absolutely that best thing ever happened.
Using a language that supports closures and functions as first class objects, if you've never used anything but a C derivative. These two language features make your code orders of magnitude more elegant. It can take a while to catch on to why they are nice, but much like source control, it's hard to go back once you have them.
Cell phone.
Tools like CodeRush & Refactor Pro
Coffee
A comfortable chair (seriously)
Productivity enhancing tools (not programming specific) like Launchy and Ultramon
Someone to bounce questions off of
Silent time
Code Complete 2
Virtual Machines
just to name a few.. but all of these are very very important to me.
Debugger. I deal with so many comp sci students who have not really used a good, GUI-driven debugger.
I hold up Visual Studio as a great debugger.(Or at least the best I've ever seen).
printf debugging. I've seen so many CS students who have struggled with good GUI-driven debuggers when they could have simply added a few lines to their code and found their mistake.
(Both methods have their moments, I guess)
Coding standards checkers like JTest [1] are capable of giving good advice on programming techniques that you might not be aware of, and they can give you something to think about. Also, any unit testing framework that calculates statement coverage is useful to see what you overlooked in your tests.
[1] http://www.parasoft.com/jtesta KVM switch for handling 2 computers or more at the same time.
3 monitors. A large widescreen monitor for Eclipse (or any other IDE). A second monitor for the documentation/API/tutorials/references/spec stuff and a small third monitor for my entertainment (tv, watching movies, watching series like 24, big bang theory and so on, listen to music,...).
Sounds weird, but if you don't think very hard but just have to code your already thought about solution, its very relaxing to code while wathcing tv or series.
Microsoft. If it wasn't for Mr. Gates, I'd be schleping at Radio Shack !!
ReSharper. Enough said.
File and directory comparison tools.
My two favourites:
WinDirStat. Shows a graphical representation of files and folders taking up space on your hard drive. Great for spotting files which can be deleted or moved. Has saved an old tiny server from certain death for the last 5 years!
Logging. I cannot count the number of times that a customer has reported an issue in an environment where there is no possible way to get a debugger in, and it has been solved simply through examining clear, verbose logs to figure out what's going on.
I find a lot of the time people rely on a debugger to step through and see what's going on, and that's how the causes of problems are found. However, you'll end up with customers that have boxes that you're not allowed to access at all, let alone use a debugger.
"Here's the log file. Tell me what's wrong."
I am thankful to the spotlight on my Mac! and Launchy on my PC!
without it, i would waste a lot of time searching for my programs!
Latin
Learning Latin at school.
Its difficult to quantify the benefits... but every so often I find myself understanding words that I have never seen before and being able to remember them more easily by understanding their derivation rather than simply learning their meaning 'parrot fashion'.
Also being able to pick good names for classes, methods and variables by building them up from smaller blocks like inter-, intra-, ex-, in-, pre-,post-.
Dunno - waddya think?
Conditions [1]. (Also: Seibel [2], Pitman [3].)
Before using them, I had no idea they existed; after learning about them, I find it amazing that most people and systems still get by with exceptions or (gasp) error codes. (In fact, from up here, exceptions look pretty much like a tiny amount of syntactic sugar for "error codes + early return + a struct".) We generally recognize the value of separation of policy and mechanism in other contexts, yet exceptions still violate this horribly. Even in languages that seem otherwise enlightened compared to the old C++/Java way (like Python and Ruby), nobody seems to care that their error reporting and handling facility is pretty much exactly as wimpy as C++/Java's.
[1] http://www.lispworks.com/documentation/HyperSpec/Body/09_a.htmMonadic query comprehensions (i.e. LINQ)
Portable apps; really helps when your shifting from one environment to the next.
That totally happened to me with source control! Why they never taught me that in college is beyond me! Actually they started teaching it the year after me.
Similar to the question, but on a little different plane...
i told my co-worker that i hated the second or two it takes for new tabs to load in IE and that was the biggest reason why i preferred Firefox. He said now that i've said that he's started to notice it and it bugs him too.
App Verifier [1]. It rocks your world.
[1] http://www.microsoft.com/downloads/details.aspx?familyid=c4a25ab9-649d-4a1b-b4a7-c9d8b095df18&displaylang=enI notice that almost all answers are centered on tools.
Things that I miss most in projects where they don't exist are:
It really makes a difference if you work in a project which starts out with a set of specifications and requirements, or whether it's just "an idea" which needs to be implemented.
Same is valid for documentation (and I don't restrict this to source code documentation): Consider which documentation is required for whom (technical, setup, maintenance, user; users of different areas of expertise). Also estimate the time required to create this documentation, and plan this as active development time (rather than an afterthought after the "real work" is done).
Portable Apps, Linux Live CDs, and classes in C++ have all vastly improved my life.
Separate compilation. Gone are the days of when I used a BASIC compiler which took several minutes to re-parse a large program after editing one line of code.
By the way, I'm not answering this question per se, but for anyone that doesn't know about source control (as mentioned in the post), here is a great introduction: http://www.ericsink.com/scm/source_control.html
Two tools:
Make-file or now it is Ant-files i will have to learn by heart
my six monitors [1], .NET, Edit and Continue, unit tests, and a STOP button that actually stops the page loading (Thanks, IE8!).
[1] http://www.realtimesoft.com/multimon/gallery_browse.asp?ID=934&date=desc&nummon=false&mon=descSwitching to the Dvorak keyboard layout. It increased my typing speed, and decreased my fatigue.
A (dual) monitor that can be rotated by 90deg
No longer scrolling like crazy all over the source code, and can see a reasonable number of lines at a time
In Visual Studio, I use code snippets all the time. For example, typing "mbox" then Tab, will auto-complete a MessageBox.Show() for you. There are several others, and it's easy to create your own.
Also, I use the right-click "Surround with" option to surround a block of code in a try-catch block or something similar.
I also use the "Extract method" on a block of code to create a private method and enhance the readability of the code.
I know a lot of programmers that aren't aware of them, or are aware of them, but just never used or got used to them. They're a great time-saver!
Unit Tests and Lean software practices generally.
Knowing I have comprehensive automated test coverage lets me sleep at night.
Development, integration and test environments that are identical in software configuration to the live environment to which code will be deploy, as well as a database with a large enough dataset to be representative of the live environnment.
Versioning file system. Having worked on a VAX many years ago I'm still somewhat surprised that it's not a standard feature of modern operating systems.
Assembler.
A complete continuous integration environment that performs a rich set unit and system tests.
Those 'quick fixes' can cause significant damage if there's only quick testing.
A living ornitorynx. I am sure none of you is able to realise the amazing benefit of coding near this incredible gift of god. No ?
In all honesty, DIV-Based CSS Layouts. I fought tooth-and-nail for years, and continued to tell myself "It's okay, tables work with little effort, nothing wrong with using them."
I am so thankful I stopped being so apathetic and lazy.
WinGrep for searching quickly and efficiently through a codebase.
http://www.wingrep.com/download.htm
Continious integration...CC.NET
GoF [1] book and the concept of design patterns as such. I think I never really understood OOP until I read this book. Patterns helped me to take a broader look at my programs.
When you start programming, you think of your code in terms of really low-level things, such as vars and loops. Then you learn functions and start using them (I can remember times when I was about 10 and was eager to write my next BASIC program with subroutine). Even later you meet the classes — and at first it seemes to be the highest level of abstraction. And then you meet the patterns.
For me it was like driving to the top of the hill — when you reach it thinking the road is just over, you suddenly see the whole world ahead.
[1] http://en.wikipedia.org/wiki/Design_PatternsA second screen
For developping and testing and read the documentation, plus check e-mails once a while...
For anyone with multiple monitors or widescreens, a window management program is a must. Try WinSplit Revolution [1] for starters.
[1] http://www.winsplit-revolution.com/Automated nightly build system, saved us the time of a 6+ hour manual build process down to a 15min automated build
Going backwards in time:
CruiseControl.NET... Resharper... NUnit... Reflector... Intellisense... Struts... Debuggable JSP's... Java... an IDE... Windows... XWindows...
Maven. It makes integrating the use of various tools into the build process so easy.
Code Coverage Reports (cobertura).
A tool to check memory usage (like valgrind, purify or bounds checker). These have been the key to solving some pretty nasty bugs in the past. Because reading through thousands of lines of code looking for that wretched memory corrupting code is not my idea of fun.
Capistrano. Knowing that I can run deploy:rollback if anything fails and also forcing tests to run before deployment is extremely useful. It also means no matter how complicated deployment of a project is, anyone is able to do it since it only requires a single command.
A laptop, Intellisense, dual monitors, teammates, my local developer community, Resharper, Firebug, WinMerge, Subversion, Google, ice cream, and beer.
And the minute I can't add to this list is the minute I've lost the will to live.
Great question.
ORM tools. I remember going into a project (early days) thinking I would have to write classes for all entities manually, and then finding out about code generating ORM tools. Needless to say, it saved considerable time and effort.
Object Oriented Programming for code reuse!
in VIm you can apply a regexp or any command based on another regexp.
e.g.
:/head/,/\/head/s/google.com/yahoo.com/
^^^^^^ first regexp. start
^ separator
^^^^^^^^ second regexp, ends here
^ command. substitute.
^^^^^^^^^^^^^^^^^^^^^^ the regexp.
EJB3...
Death to deployment descriptors! Long live annotations!
Oh, and Java annotations, too. Never saw the need until EJB3 showed me the light. Of course, having done EJB3 annotations for a while, I still see the need for deployment descriptors (don't put host names in source code - that's bad 'um kay?). But the annotations sure makes ORM constructs easier to deal with.
lex and yacc for skimming through context free data (of any type, be it languages or structured data)
Third party tools that make your job easier / more productive.
For example I work with sql server a lot and there are some great intelli-sense and comparison tools out there. I can compare and sync schemas and data. When I show these to other developers they often turn green with envy.
The tools alone save me hours upon hours a week.
Textmate bundles. E uses them now too, so I can develop on Mac and PC using relatively light-weight and easy-to-understand IDEs that are very versatile.
Finger-Print reader for authentication on a notebook ! Wow !!
FullShot9 for putting screen shots of only the areas on code and forms that I am referring to into my documentation and bug reports.
I second the suggestion of a Continuous Integration server. Particularly if you use something like Hudson [1], since you can graph all sorts of interesting data (test numbers, code coverage scores, static analysis) over time.
[1] https://hudson.dev.java.netperl and regex(unseparatable I guess), GUI diff/merge tool, mercurial. That's about it that I can think of for now.
Taskbar Shuffle
On Windows "It allows you to drag-and-drop programs on your taskbar for quick reorganization"
Until I had it installed, during long work sessions I used to spend 10 to 15 minutes closing down all my apps and re-opening them again purely to re-order the tabs on my taskbar. With shuffle it takes a second.
See: http://download.cnet.com/Taskbar-Shuffle/3000-2072_4-10531265.html
Onenote for keeping track of information while writing code and it syncs with the cloud FTW
It's another tool, and typically one a programmer encounters early in their life, but one that I've learnt to love in all its simplicity (and that makes me retrospectively curse the fortunately fairly little time I spent without it):
less
Oh, the sweet times I've spent piping svn diffs and large grep results into it. The beauty of console buffer restoration after a simple q. The finesse of navigating through just about any input that can be piped.
Godsent.
So simple it's brilliant.
Snoop! for debugging WPF apps FTW!
