Some programmers enjoy optimizing code to make the implementation as fast as humanly possible; or golfing to make code as compact as possible. Others enjoy metaprogramming to make code generic, or designing algorithms to be asymptotically efficient.
What do you find most interesting and challenging as a programmer?
I like building pleasing-to-use apps that have real-world value.
The area that I like to study most is algorithm design. It's interesting to see how others solve complex problems, and it improves the way I approach new problems myself.
The area that I like to actually program is testing. I love troubleshooting, and finding ways to make software break (so I can then fix it, of course).
I go home happy if I can add functionality, make my code easier to understand, and end up with less code than I had before, all in one day.
That doesn't happen often, but it's a wonderful feeling when it does.
At this moment (I am still a beginner programming-wise) I love to do just the things I can't do yet. To write algorithms that undoubtedly exist somewhere already, but that I don't know of. That basically means that just "programming" is my challenge :)
The mere satisfaction if the code I wrote works is the best motivation a starting software engineer can have I think.
After I've completed a particular module I've been assigned, or when I'm doing a peer review or a code review, or a white-box testing scenario, I like to challenge myself and my co-workers to reduce the number of lines while still maintaining readable, functioning code.
This exercise alone usually increases the performance of the application simply by allowing us to find unnecessary, duplicative, or fluffy code that can be omitted. This is even better when performing the activity against other peoples' code.
I prefer to make code as simple and as clear as possible. After all, I might be the next guy who has to maintain it.
Anything that's not web development!
Aside from that, anything that can stimulate my imagination and exercise a wide range of skills. Game development in particular - as I get to play with graphics, AI, sometimes networking and databases, and all kinds of clever algorithms.
Really, I don't like web development. This may start a flame war, but fighting all day with html, css, ajax, etc... just to make a webpage "look good" doesn't feel like programming. Backend work isn't so boring because that's more algorithms and data manipulation where my computer science studies can shine. Front-end work though is more of a drag because its not about functionality - its about whatever the user thinks is "pretty".
This reminds me of an old codinghorror article:
http://www.codinghorror.com/blog/archives/000734.html
I'm the kind of person that would create a UI like that - efficient for programmers, ugly for non-programmers.
I like working on programs that have to deal with really large datasets. How to make them faster and efficient.
What I enjoy most is solving hard problems in clear, maintainable ways.
What I mean by hard problems:
I like finding and solving scalability problems and cleaning up code. Figuring out a method that is 10-1000 times faster than the original implementation is fun.
I like to look for new ways of doing things. I love to see how other people do things, after all, someone might have a better solution than me. There's always numerous ways of doing things. Algorithm design is always particularly interesting because it makes you look at things in from a different angle and ask yourself "what if?"... it always yields by far the most fascinating results.
Code golf is always amusing - I could spend [waste] hours optimizing code down to the smallest amount of code possible. But if I inherited and had to maintain an application that was written like that I'd most likely freak. The smallest and/or most efficient way of coding something isn't always the best in the real world.
Sometimes it's okay to take a small performance hit in order to make the code more maintainable. If the few extra seconds someone has to waiting for their system means that maintenance time [and costs] is dropped by hours to minutes or weeks to days or hours, then take the performance hit!
I like programs that allow me to stretch and learn new things, in just about any dimension.
New problem domain? New language? New stack? New APIs? New libraries? New operating system? All of these are good things. If I'm not learning something new, I feel like I'm slowly drifting backwards.
This doesn't imply in any way that I object to working with stuff I'm already somewhat expert with, nor that I architect, design, or develop fragile or risk-filled systems. Quite the opposite! It just implies that I prefer to add things to my mental toolbox whenever possible.
I enjoy extracting a reusable library out of the code (or creating one to begin with), so I can solve similar problems in the future with less effort. It also typically makes the code cleaner overall, because it separates the problem into different levels of abstraction.
I like abstract, difficult problems. I also just like to code.
Interface design is one of my strong points, but I've done so many at this point that I enjoy being deeper in the pipes a lot more.
Also... This may be crazy, but I really enjoy managing software projects. It still feels like a fronteir. That's exciting and interesting to me.
Awwwwww cmon man, just one? I love it all.
I love requirements cause there is that hidden window of what the client needs and what they seem to think they need. I like engaging in requirements cause sometimes you can simplify a swathe of complexity by considering other routes to the client's goal.
Design rocks cause you have to additionally think of all those edge cases and consider maintenance, future proofing and performance.
I adore bug fixing because there is some crazy problem and piecing together all the clues and discovering the reason behind the riddle is so rewarding.
Delivery is awesomes because even though there is stress you get to deliver to the client and make a difference. Sometimes you have to make hard choices (cut/defer) and it's interesting to navigate and learn about the potential politics or pragmatism surrounding this.
This might sound a bit masochistic but I also really dig refactoring WTFery code. As I contract a lot I see a lot of this kinda thing and where there is justification to turn a big pile of mess into something coherent its really fun to do.
Oh and race conditions! Ain't they just "fun"? I really like analysing code and detecting race conditions and working out how to mitigate against them effectively.
Don't make me choose, I like it all! :D
At the end of the day, I suppose it boils down to efficiency, for both the code and for myself.
On the primary level, it is important to me that the code operating smoothly, efficiently, and without any bottlenecks. Also, it should be easily readable (so anyone performing maintenance could efficiently make edits and alterations).
Secondary to that, but also important, is any approaches, techniques, or shortcuts that I can use to achieve a goal faster than I could before while also improving or not sacrificing any aforementioned code efficiencies. I'd rather take a bit longer to make it readable and operate properly if necessary, but if I can make it easier on myself and not sacrifice anything out of the system, that is a great feeling.
I've come to love the moments when I write code that speaks to me. Beautiful prose that uses meaningful vocabulary that is all at the same level of abstraction. Every now and then I manage to get it right, express the business needs as pure poetry. Pity I can't do it more often, usually its just the drudgery of getting things done.
I'm a kent beck kind of guy. Ever since I read his book on smalltalk patterns this has been with me in my baggage. Probably like strong opiates, once you taste it you crave for more.
I like making programs run faster with more cores. So, either parallelizing sequential code or finding scalability problems in existing parallel code.
I like to make efficient and well structured programs, with independent, short and generic functions.
I try to make it the more efficient and compact as I can, but also modular and reuseable.
I've always liked pure algorithmic work, particularly optimizing code. The really really fun stuff is trying to make the code super-generic, something like 6th normal form. If you can build an entire system where the data flows from the persistence storage to the interface and then back again without making the interface painfully lame for the users, then well, um, you exceeded the title of 'master' ... and probably 'guru' ...
Paul.
I like to build things for people. Software allows me to simplify complex domains for use by more people. In fact the software I write manages complexity. If I can simplify a developer's or a customers life they will pay me. Its a great life!
I like using algorithms to solve problems that can really use them. Either applying, adapting, or inventing is fine: I like clever, nontrivial stuff that matters.
High-quality system design is a close second. Breaking a project down into the right parts, or building a library the right way for a particular scope and context -- neither overengineered nor underengineered for the job at hand, plus the jobs it's likely to be applied to (often a tough line to walk...).
Performance optimization is third -- not quite as glorious, but satisfying nonetheless. To do the job right, though, you really need to keep it in mind while you're doing the first two, since design choices can severely limit your performance if you're not careful, and algorithms are often the best and most effective performance boost.
The most fun I have programming is to make my code simpler and smaller---and on really good days, do more at the same time. As Chris Fraser said, the best programmers add functionality while removing code. It doesn't happen to me very often.
A design has achieved perfection not when there is nothing left to add, but when there is nothing left to take away. ---Antoine de Saint-Exupery
I enjoy refactoring, coming back to a problem you've solved before with more experience and a fresh perspective.
I enjoy looking at other languages, making the code more generic and more re-usable.
I like writing tools and/or classes for other developers to use. It's enjoyable for me if it makes the other developers tasks easier.
Understanding the domain and making a clean design out of it. Also, I enjoy doing lower level more technical stuff, like communication with new hardware, solving threadings problem. etc...