9 ms·
What does it take to be a good programmer?
- abc_lisper 10y ago> I divide and conquer and get things done. I had the same insight after many years like the author - that every problem you do can be broken down into smaller problems, which can be worked independently and tested independently. Why it wasn't obvious to me early-on I have no idea. I guess I never developed the intuition to see the efficiency of the method. Did anyone else among you had the same experience?
- nickff 10y agoYou are essentially describing 'test driven development', and many of us have either been taught the methodology, or stumbled on to it.[1] [1] https://en.wikipedia.org/wiki/Test-driven_development https://en.wikipedia.org/wiki/Test-driven_development
- AnimalMuppet 10y agoNo, abc_lisper is describing decomposition of the problem. That may or may not be implemented in a TDD environment; it may not even involve tests at all.
- nickff 10y agoabc_lisper specifically said: "every problem you do can be broken down into smaller problems, which can be worked independently and tested independently". Unless you delete or ignore "and tested" from that post, abc_lisper's approach definitely involves tests.
- AnimalMuppet 10y agoI stand corrected; what abc_lisper said definitely involves tests. That's not necessarily TDD, though; see my post at https://news.ycombinator.com/item?id=13465459 https://news.ycombinator.com/item?id=13465459 for the difference.
- nickff 10y agoI agree that abc_lisper did not 'exactly' describe test driven development, which is why I said he 'essentially' described test driven development. I am a believer in test driven development, yet I often write a bit of application code before I write the tests; I acknowledge that probably makes me a pariah, but I still keep tests (and TDD) in mind.
- AnimalMuppet 10y agoMeh, I think TDD has value, but I don't think a methodology should become a religion. Write a bit of application before your tests, write most of the tests before the code, you're good to call it TDD in my book. (Of course, being non-religious about methodology may make me a pariah, and not just on TDD; but I can't work up the energy to care...)
- thibauts 10y agoTesting does not automatically imply automated tests. I do break down problems and follow the same kind of process, yet my goal is less automated testing than it is raw flexibility, ability to recombine pieces of code at will and move fast. Chasing automated tests, even if it supposedly yields this kind of composite constructs is in my opinion taking an interesting side-effect of good craft for an end in itself. Then of course, saying the code can be tested in isolation doesn't imply coding is driven by tests. TDD, in my opinion, like all idols in the history of cults is, as an end, the dawn of critical thinking and progress.
- abc_lisper 10y agoI agree decomposing and testing go hand-in-hand, but it wasn't even apparent to me decomposition is the way to go. I guess I didn't know it is possible to design solutions to problems while breaking them down. Btw, I discovered (He hee) testing of modules independently very shortly after I found out about decomposing.
- deleted 10y ago[deleted]
- leshow 10y agoI agree, but I have an alternate intuition. Humans are only able to understand anything through decomposition to smaller problems, working out those problems, then recomposing to a whole again. This is evident not just in software development, but in everything. At some point you have to ask yourself: If this "decomposition" hammer is the only tool we have to use in the world, it's no surprise that everything looks like a nail.
- abc_lisper 10y ago> At some point you have to ask yourself: If this "decomposition" hammer is the only tool we have to use in the world, it's no surprise that everything looks like a nail. Agreed! I think this is why it was not intuitive to me. I was (reasonably) good at math in school, but I never tried to decompose the problem. I always tried to get a feel of the problem by looking at it from various angles and get the crux of the problem. That's the best I can say about my thinking method then.
- kazinator 10y agoThat makes sense. The thing about decomposition is that there is more than one (a toolbox with multiple hammers). So even if you decompose, you have to look at multiple angles before you choose a decomposition.
- khedoros1 10y agoI remember early on in my programming education having subroutines pounded into my head. I learned them grudgingly, because nothing that I'd written so far was complex enough to need them. It was always simpler to just write my <100 line program without any functions/subroutines. Things got more complex. Named subroutines started seeming logical to encapsulate certain behaviors. Eventually, it became natural to think "I wish this part of the program were separated out and implemented elsewhere, so that I could treat it as a solved problem." That's about the point where a divide-and-conquer approach started occurring to me, at least in a limited context. That context expanded over time.
- bpchaps 10y agoI definitely had that same experience. I've been writing code like that for about 15 years now and it's only started changing over the past two years or so. I think it stems from a few reasons - 1. I have a tendency to fix small problems that only need a one-time fix. So, lots of code, but disposable and messy. 2. HS programming classes lacked a lot of the meta stuffs, like refactoring, working in groups, etc. 3. Most of my coding years have been spent in a terminal where a combination of awk, sed, grep, xargs, etc works perfectly fine. A non-trivial number of problems can be solved that way, but it hits a wall pretty quickly. For the past few months, I've been writing a lot of Clojure and have found that it fits my mental model significantly better than Python, C, etc. What's interesting is that all other languages I code in have dramatically improved ever since Clojure "clicked". Hell, even my bash-fu has become cleaner, terser, faster and more bug free. Funny how that works..
- abc_lisper 10y agoHey, I'm currently using Clojure too and I feel the same way! I think the reason it feels more natural is its emphasis on process instead of things. You think of computation as series of transformations, and that makes easy to establish causal relationships among events and thus help reason better about the system. (I think Steve Yegge first complained about Java, that it is a land of nouns) I think the failing of OOP for me is that I never got what an object is! To me, an object always felt like a weird plane in a n-dimensional axes(because an object contains other objects), and it was hard to reason about that. For example, my first (atleast in my latent consciousness) reaction about Abstract classes was, what is it abstract about? If it is abstract about a bunch of things, that are only related because of the flow of code, I guess I wasn't smart enough to crack that effectively.
- antfarm 10y agoThat is only easy if the overall architecture has already been taken care of by someone else.
- awfgylbcxhrey 10y agoIn my opinion, "be humble" isn't a winning strategy. Don't be so arrogant that you stop improving or fail to understand mistakes, but by all means don't be humble. Be proud of who you are and the work you've done. You work in an industry where 90% of people don't understand what you do. Chances are your own boss won't understand the actual value you're providing. So don't be humble. "There's always someone better than you out there" -- sure, but that person's not here, right?
- D_Guidi 10y ago> be kind and realize you might be wrong this is the author mean for "humble", and I think it's damn true
- YCode 10y ago> "There's always someone better than you out there" -- sure, but that person's not here, right? Great response to a devil I've had on my shoulder for a long time.
- tabeth 10y agoFailing to be humble eventually leads to arrogance. This advice is counterproductive. The part regarding being proud of who you are is completely tangential. I also highly doubt that "90% of people" in the tech industry don't understand what a "good programmer" does. The best advice is just to become as best as you can by trying as much as you can: 1. Deliberately working 2. Learning from people you perceive to be better. 3. Keeping up with trends. 4. Mastery of the basics/fundamentals. 5. A razor sharp focus on what really matters -- value in the context of the business/domain.
- TeMPOraL 10y ago> 5. A razor sharp focus on what really matters -- value in the context of the business/domain. This is a tricky part, and you have to ask yourself explicitly - what do you want to work on? Becoming a better programmer, or a better employee/entrepreneur? Because business does not optimize just for good, quality work. It optimizes for earning money. Which involves things like: - doing good, quality work which can be sold - doing good enough work, minding the essential tradeoff between quality and business realities - doing shitty, half-assed work and having a good sales team sell it anyway - doing useless shiny things that don't really help the intended audience, but help your business to get their money If the needs of your business are from the latter two groups, being a good programmer goes directly against your career success in that place. Unfortunately, it is my belief that most of the jobs in our industry fall into those two groups. From the POV of everyone else but programmers, the code is only means to an end. I want to emphasize it, because a lot of advice for programmers tells you about the "razor sharp focus on what really matters -- value in the context of the business/domain", and I found that for some reason, it never resonated with me. It took me a while to understand why - it's because this advice comes from a business mindset, where making money is the goal and the means to it are tangential. I have the opposite mindset - for me, it's the product that matters, not how to make more money off it. Realizing that those are two different worldviews has helped me stop feeling inadequate just because I couldn't bring myself to enjoy the business value. It also helped me understand the POV of management and what they expect from me.
- halis 10y agoIt helps to be obsessive. Program in your spare time. Don't be one of these people that just learns what they need to know to do their job and then stops learning. I've been programming professionally for 6 years and I'm learning as much today as when I started.
- sanderjd 10y agoYou don't need to be obsessive or program in your spare time to be a good programmer. It's great to continue to learn indefinitely. It's also great to leave work at work and build a life rich with a diversity of interest and activity. You can do both.
- Radle 10y ago"Write unit tests, they could prove to be invaluable, especially when you introduce changes to your codebase." I always read this... What exactly is a unit test? What parts of my software should be tested? What are some examples of good unit tests and the code that is tested?
- TeMPOraL 10y agoTDD is like object-oriented programming. Nobody can agree how precisely it should work in real world, but "you'll know it when you'll see it". And you're 50% likely to embrace it, and 50% likely to decide it's utter crap.
- AnimalMuppet 10y agoTDD is more than having unit tests. TDD means that the first thing you write are the tests. Why does that matter? It means that you're writing a user of your class before you write the class. That means that the interface of the class gets designed from the mindset of a user, not an implementor. More: The interface gets designed by someone who wants to be able to test all the externally-visible behavior of the class. If you can't test it, you have to think about re-designing the class interface - often by breaking it up into smaller classes. I've seen this in practice; the net effect of this is better class design (plus thorough tests). That said, I'm considerably stronger of a proponent of tests than I am of TDD. If you don't like the TDD approach, still write tests. Write lots of them. They'll often save you when you make subtle mistakes in your next set of changes. (Nothing like fixing a bug, running the tests, and getting informed of all the implications of your change that you forgot about.)
- TeMPOraL 10y agoYou see, I'm in that 50% of people who don't particularly like TDD. Even though I tried it, honest to god, several times. > That means that the interface of the class gets designed from the mindset of a user, not an implementor. From my experience, something entirely different happens. The class gets designed from the mindset of a third party - the tester. Which is, I believe, a mindset different from the user. If all you're testing is the externally-visible behaviour, fine. You're pretty much treating the class like a library. But if you start injecting stuff into the class to test if some other dependent services got called properly, etc. - and especially if you start designing the interface around such testability, then I believe it'll lead to bad, unreadable code. In particular, I believe adding complexity to the class for the sole purpose of making it easier to test is a code stink. TDD taken to the extreme prescribes that you should only ever write dumbest possible code that makes current tests pass. If you need more complicated behaviour, you first have to write tests for it. But this gets quickly out of hand if your project is meant to do anything more complicated than being a simple CRUD layer, because test complexity rises in lockstep with production code complexity. I've seen cases when people blindly following the test->code->refactor cycle created tests that themselves were isomorphic to the algorithm they were implementing, which makes one ask where did they have the code that tested if tests themselves are implemented correctly? So personally, while I like tests (particularly regression tests), I just can't make myself follow TDD.
- tabeth 10y agoShocking to me that there are so many articles on this. The strategy to becoming a good programmer is the same strategy to become good at anything else. 1. Identify what it means to be good 2. Work endlessly towards that aim 3. Deliberately practice 4. Decide to refine strengths or squash weaknesses. Do this as frequently as possible. Make sure you have an accurate assessment of what your strengths and weaknesses are. (5) and (6) can help with this. 5. Consult the advice of those more experienced. As frequently as possible 6. Allow your work to be publicly scrutinized. Do not work privately, the feedback loop should be as tight as possible to inform (1) 7. Repeat (1) - (6) as frequently as possible Do that and you will become better. Guaranteed. Note, this won't necessarily make you the best. However, it will make you better. Continue this process until you're as good as you desire. There, of course, are diminishing returns after a while.
- JoeAltmaier 10y agoWorks for life, really.
- bluecat 10y agoStep five is, in my experience, one of the fastest ways to get better. Very solid list of steps.
- FLUX-YOU 10y ago>1. Identify what it means to be good You'll never get a solid definition for a good programmer, and that's the problem. If we knew that, we would have a list of things to learn and teach and we could easily make that a standard interview test before giving people a job. And no one would need to write any more "10 things you need to know as a programmer" articles.
- Clubber 10y agoIf you ask other programmers, you will get a bunch of answers. If you ask the guy who cuts your checks, a good programmer is someone who can solve their problems and make their business more efficient.
- lojack 10y ago> never be dogmatic about anything Mostly agree with that with the exception of learning new things. Sometimes it helps to be dogmatic about things if your goal is to learn something new. A prime example is TDD. When my goal is to build a working piece of software, I tend to do TDD for some parts and write tests post facto (or not at all) for other parts. When learning TDD it helped to force myself to be dogmatic. Similarly, if you're learning functional programming in a language that isn't strictly pure, its helpful to be dogmatic about your approach and force yourself to do things the functional way, while in the real world introducing limited impurities may be better.
- TeMPOraL 10y agoMy personal advice would be to follow the Ira Glass quote: > Nobody tells this to people who are beginners, I wish someone told me. All of us who do creative work, we get into it because we have good taste. But there is this gap. For the first couple years you make stuff, it’s just not that good. It’s trying to be good, it has potential, but it’s not. But your taste, the thing that got you into the game, is still killer. And your taste is why your work disappoints you. A lot of people never get past this phase, they quit. Most people I know who do interesting, creative work went through years of this. We know our work doesn’t have this special thing that we want it to have. We all go through this. And if you are just starting out or you are still in this phase, you gotta know its normal and the most important thing you can do is do a lot of work. Put yourself on a deadline so that every week you will finish one story. It is only by going through a volume of work that you will close that gap, and your work will be as good as your ambitions. And I took longer to figure out how to do this than anyone I’ve ever met. It’s gonna take awhile. It’s normal to take awhile. You’ve just gotta fight your way through. That is, code a lot of stuff. And, while doing so, pay attention to how you feel. Sometimes it'll be exhilarating, or you'll be proud of what you done. Other times, you'll be confused, or afraid, or pissed off about how something you wrote earlier is now unmaintainable or hard to make work. This is how you actually learn the insights behind all the dogmas, rules of thumbs, heuristics, good practices, etc. That's how you develop taste - that intuition which will help you write good code.
- dullroar 10y agoThat's a great quote. Thanks for that.
- kornish 10y agoA great quote, and a great interpretation at the bottom.
- windlessstorm 10y agoBig smile on face after reading this.
- optimuspaul 10y ago
- slantaclaus 10y agoTime, intelligence, resourcefulness, curiosity, stubbornness, ideally being physically next to programmers more competent than yourself, TIME Adderall or something like that could also be a plus...
- partycoder 10y agoA good programmer is a good problem solver. But it also requires technical knowledge or ability to acquire it, as well as a good ability to communicate ideas. Now, you can solve problems in many ways. They can be solved in the best interest of the programmer, or in the best interest of the company. If I have a sales team, and give them a goal to sell $100, and they make a loan for $100 on behalf of the company and give me $100, that's probably not a good sales team. Let alone a 10x sales team. But in software, technical debt (equivalent to buying with a loan) is something done frequently and some people mistakenly perceive it as being a good programmer. Usually because they cannot perceive the build-up of accrued work.
- keithnz 10y agoWell, I've been programming 30+ years..... I think one of the main things that makes a good programmer is someone who cares about the final product. Ironically this doesn't necessarily mean you have to be super good at writing code. I have seen people with what seems basic coding capability very methodically build some really nice software. This is because they are very focused on the "end" not the "means". You see the thoughtfulness of what has been designed in. Sometimes, in the quest of writing "good code" it interferes with writing good software because the emphasis becomes getting good at the means to an end above the end itself. Not to say improving your coding capability isn't of value, but it's done so you can create even more fantastic things.
- wruza 10y agoUsually they methodically build very nice nightmare, but of course 30+ years is long enough to see a couple of exceptions. I've been there for 15+, and half of that in 'consulting' — it's when you write business code right here, right now after 10m discussion. These are really two different styles, but I feel what you mean. 'Good code' is a hard thing to define, but for me it is the code that fully covers all aspects of the initial set of intents (I intentionally let the purpose and profitability off, because it may be not of value in some cases). If intents are unclear, we can't really evaluate anything in between. If it was a very dirty hack for a hard task, and we intentionally made it, it is still good code. Thus you can't tell good code from bad without knowing its history and the rationale behing it. Code doesn't fail, projects do.
- keithnz 10y agoUsually ... I find many people can make nightmares for all kinds of reasons ... but for me, usually, people who have a strong sense of what they want and they have a strong sense that they want it to be "good" but only have a basic coding skills. They don't end up with nightmares, possibly slightly strange things, but they tend to adopt coding advice in a considered manner and start growing their coding capability. The biggest problems there comes when the person is dealing with frameworks which have concepts beyond their current coding capability. I think we see at the other end of the spectrum with the frameworks, languages and software we really like, they are done by people who really want their end result to have this quality of "good" and are very considered. They leverage their coding ability to great effect. (lua and its implementation is a good example of this ) I think when we see your more run of the mill business app where you spec -> implement, often you don't see good programming, often because no one super cares. It's just average programming. However, when someone starts thinking, well, applications like this should be super easy to put together and really starts to care that they are easy to do, then you'll see some good programming :)
- leshow 10y agoPersonally I think the most important thing is a thirst for knowledge. There are plenty of people I finished school with that were much better engineers than me out of school, but they don't learn in their free time and they've stagnated. If you love to learn and you put your time into it, you will continually improve. With time you will run laps around those who don't.
- passivepinetree 10y agoExactly. If you don't have passion to do something, it's really hard to get better at it. Obligatory Randall Monroe quote that hits the nail on the head: "I never trust anyone who's more excited about success than about doing the thing they want to be successful at." If you're not passionate or enjoying what you're doing, you're probably wasting your time.
- MollyR 10y agoI'm training my nephew, he's living with me while going to college in the philadelphia. He's been getting really frustrated hearing platitudes like this from his professors. I've basically been mentoring him and having him read https://github.com/braydie/HowToBeAProgrammer https://github.com/braydie/HowToBeAProgrammer , Comp Science with Python, and a couple books on linux and C to help with some lower level stuff. He's been struggling a lot with C and Linux concepts. I've been there to help, and now I have strong opinion C and Linux would make a lot of programmers have a better understanding of their programs and computers.
- keyboardhitter 10y agoI agree that it would help with a better understanding. I can't help but wonder why aspiring sysadmins and programmers DO NOT have immediate interest in such things? To me it just 'made sense' and 'clicked' almost immediately. Maybe I learned from a different angle, but it seems obvious to me to want to learn these things (C and Linux fundamentals, I mean).
- MollyR 10y agoI don't know for sure but. I noticed a lot of his class notes were written for windows and mac users. Also a lot of it was focused on java and python. I wonder if C and Linux classes became higher level electives.
- NumberCruncher 10y agoI have read a really good book on this subject: https://www.oreilly.de/buecher/120174/9783897215672-weniger-schlecht-programmieren.html https://www.oreilly.de/buecher/120174/9783897215672-weniger-... I think it is only available in German.
- tenpoundhammer 10y agoI've been programming professionally for the last 6 or so years, I've been in 4 teams across 3 companies. The reason this question generates so many answers with such great diversity is that the answer really depends on where you work and what you consider success to be. At the first company, a good software engineer was a person who could effectively work inside of the team and get through the requirements for code review in a timely manner. While working at another job a good programmer was someone who could figure out the requirements by themselves and have a working product to show the boss in a timely manner. At my current a good software developer is someone who has a strong grasp of their language of choice, can deliver features to a Product Owner, and who can grab a project by the horns and lead from an architectural or design perspective. None of these answers are wrong, they are just reflections of the engineering cultures they are born from. Based on my experience a good programmer is someone that understands what success means in the culture they are currently in and can execute on that. Long term a good programmer is someone that continues to learn popular skills, products, frameworks, tools and can continue to follow the path that best suits them, whether that be a startup, large corp, freelance, or entrepreneurship. It's all about opening doors for yourself to walk through.
- Clubber 10y agoFirst and foremost, add value to business by solving a business problem. Once you can do that, follow the DRY and KISS principles. I've noticed developers who can quote scripture (best practices), but can't solve a non-trivial problem.
- tim333 10y agoI'm reminded of something Splosky wrote: >The difference between a tolerable programmer and a great programmer is not how many programming languages they know, and it’s not whether they prefer Python or Java. It’s whether they can communicate their ideas. By persuading other people, they get leverage. By writing clear comments and technical specs, they let other programmers understand their code, which means other programmers can use and work with their code instead of rewriting it. Absent this, their code is worthless. By writing clear technical documentation for end users, they allow people to figure out what their code is supposed to do, which is the only way those users can see the value in their code. There’s a lot of wonderful, useful code buried on sourceforge somewhere that nobody uses because it was created by programmers who don’t write very well (or don’t write at all), and so nobody knows what they’ve done and their brilliant code languishes.
- duderific 10y agoThis boils down to: write code for your peers, not for yourself. I always try to remember that, and write code that will be easily understood by others, rather than the cleverest possible way.
- jnordwick 10y agoSimplicity. And when you think you have a good simple plan of attack, simplify more. I have rarely had problems from being too simple, and when you do they are easy to fix, but over complication (over generifying) is always a beast to fix.
- keyboardhitter 10y agoI agree with this, the simplest solution is often the best, and then work on it until it is elegant. In the visual arts, i use the same line of thought when i am turning a sketch into a full painting, for comparison.
- YZF 10y agoHere's my take: - You need to think a certain way. You need to be able to see how to translate a problem into something a machine can execute. You need to be able to switch from the macro to the micro smoothly. - You need a certain level of proficiency with the tools you're using. Those can be programming languages/OSes/libraries/other software. - You need experience. Having seen different approaches to solving various problems. Which ones worked. Which didn't. Having tried a few different approaches, different languages. - You need domain knowledge. If you're working in a certain field you need to know the state of the art. You need to be able to read papers in the field. You need to be able to apply whatever techniques are required for the domain. - You need to be a problem solver. These are sort of basic table stakes for being a good "programmer". In most real world settings you need to have some more on top of that: - You'll need to be a good communicator. You will need to interact effectively with many different people, e.g. your boss, a product manager, junior developers. It's a team effort. - You need to understand users/customers. You need to be able to gather requirements, ask the right questions, and deliver something useful. - You need to understand the life-cycle of software. How long will it be in use? What sort of maintenance work will it need. How will it evolve? - You need to have some business understanding. Is what you're doing creating business value? - You need to appreciate the right trade-offs. Sometimes a crappy solution sooner wins over a perfect solution too late. And sometimes you should wait and have a perfect solution. That's just one example of a trade-off but our job is full of them. - You need perseverance. Sometimes things take longer than you think. Some bugs take a lot of work to chase down.
- lightedman 10y agoI wish everyone were forced to program everything on a machine with the resources of a Pentium I-class processor and say 64MB RAM. Learn to conserve your resources, learn to eschew that which is not needed, and for crying out loud learn to not write bloated stuff. Even today, most programs I use on Windows 7 were written back in the days of Windows 95/98 and they still work faster than any current modern implementation you can find, and they're smaller.
- suprfnk 10y agoAnd then we would only have a fraction of the current tools and innovations, because we would all waste an enormous amount of time doing tedious memory and resource management. While modern tools and frameworks may sometimes feel bloated, they allow us to develop and iterate fast. I know I would've finished less projects if I had to be programming with performance and size in mind. For a lot of projects it just doesn't matter that much. It's more important that the job gets done.
- lightedman 10y ago"While modern tools and frameworks may sometimes feel bloated, they allow us to develop and iterate fast" And insecurely, at the same time. The majority of vulnerabilities today come from shoddy programming practices taught by the newest languages and frameworks.
- rumcajz 10y agoEvery programmer should be given ZX81 with 1kB of memory to start with.
- lightedman 10y agoAnd after that, the maximum hardware they should be allowed is what I mentioned. Unless you're crunching massive data sets, you don't need 64-bit (and most programs don't, excepting games and of course databases!)
- diamondo25 10y ago
- doggydogs94 10y agoIf you have a choice between 500 lines of easy to understand, dumb code or 50 lines of abstract elegance, go with the easy to understand, dumb code.
- tellarin 10y agoI call that distinction the difference between an elegant and a clever solution. Clever being what you mention. If the programmer can't tell the difference when implementing, then go for a simpler version, as you suggest. - Elegant: Nice, clean, well thought out. - Clever: Hackish, terse, too hard to understand for whatever benefit it brings.
- collyw 10y agoTen times as many places for bugs to hide.
- elihu 10y agoI think there's a personality trait that's really useful in programming, which is to be pessimistic in the short term and optimistic in the long term. What I mean by that is that you don't expect some thing you just wrote to work the first time, and maybe not the second or third, and so on. But you expect that you'll eventually figure it out and it will work. A short-term optimist would become discouraged by their expectations not being met over and over, while the long-term pessimist would not be sustained through the hard parts by imagining how happy they'll be when they made their thing work. I think programming either repels people who are short term optimists or long term pessimists, or the process of learning to code transforms them into short term pessimists and long term optimists.
- foo101 10y agoThe current state of software development has been bothering me. Having spent several years in the software industry, I don't find the motivation to write good code, or design elegant fixes for bugs. I have worked in large MNCs as well as small companies and I see the same trend every where: The management does not care about code quality or elegance. They just want to ship things ASAP. As a result, even if a few developers care about code quality and elegance, majority of the developers don't. They just want to put together a working software, no matter how it is achieved, and be done with their job. Now, even if the minority of developers have coded a few modules that look absolutely elegant and neat, it interacts with the majority of the software that is complex, ugly and sometimes bloated. On top of that, in many teams, developers often touch each others' code and modules to make bug fixes, enhancements, etc. which means all code (whether currently elegant or not) tends towards ugly. How, under these circumstances, do you maintain your motivation to write good, clean and elegant code after having worked about 10 years in the software industry?