5 ms·
The nihilist and optimist programmers (2015)
- kough 9y agoAn example of in the middle: realize things have flaws, but work to improve them. Realize that perfection cannot be achieved, so work with the stakeholders to come up with something acceptable. Programming here is just one other set of tasks that has to be done. Check out http://meaningness.com http://meaningness.com for deeper insight on the philosophical side.
- kerkeslager 9y agoThat's basically the optimist view in the article, I think. Optimism in this case isn't about pretending the thing is good, it's about believing it can be good.
- jacquesm 9y agoOr even simply about believing that it can be better than it is right now. That may eventually lead to it being good but that's not a given.
- lomnakkus 9y agoIt's not even that, I think. It's just a... "Trade-offs exist: Deal with it." type thing? If I can offer an anecdote which is tangential: I like to say that I'm actually an Optimist, but it's just that I've been disappointed so many times that I may sound like a Pessimist. Honestly, I think it requires a certain amount of optimism/hope for the future to keep working in this industry. The people are usually great, but the systems (both technological and organizational) are mostly just awful. Awful, awful, awful. I take a little solace in the fact that I can (most of the time) fix the technical systems.
- kough 9y agoI read the optimist view as more idealistic – "not rock forever on a sea of changing assumptions", "the thing out rightly be defined", "shouldn't contain compromise".
- lmm 9y ago> If a thing is undefinable, you will naturally resist efforts to define it. If a thing is forever in flux, you will resist efforts to freeze it. If a thing is composed exclusively of compromise, you will resist efforts to make decisive decisions. And if a thing will never be good, you will resist efforts to make it good. Isn't that a good way to approach software development? You probably shouldn't make decisive decisions, you probably shouldn't freeze your project, and if you define it you risk missing opportunities outside that definition.
- pdonis 9y ago> Isn't that a good way to approach software development? Not if your software needs to actually meet users' needs--in other words, not if you want to make a living at it. To meet users' needs, your software has to ship, which means you need to make decisive decisions, you need to freeze your product, and you need to define what it does. What you don't need to do is stop doing those things once you've done them once. You can always update your software, you can always make new decisions, and you can always redefine what your software does, in response to changing user needs or changing understanding on your part of what user needs actually are. But the only way to do that is to do it, which means you have to start somewhere. And never making decisions, never freezing anything, and never defining anything means never starting anywhere.
- whimatthew 9y agoAs I was reading the post, I kept thinking that the nihilist sounds like they're following the recommendations set in "The Pragmatic Programmer." If you make decisions reversible or abstract away the interface from the implementation, you may be doing it for nihilistic reasons, but still a decent idea. Also, "good enough" is underrated.
- partycoder 9y agoThe "nihilist" described here is a person that sees implementation as means towards an end, and in this perspective, functional requirements are at the center. Because of this, for these people software is a black box where the only important things are the touching surfaces. The "optimist" described here is a person that sees software in a more broader sense: functional AND non-functional requirements. Non-functional requirements include maintainability, scalability, performance, security, configuration, etc. and will strive to implement them. -- Now, my opinion: My name for the "nihilist" programmer are "feature fairies" or "duct tape programmers". The problem with feature fairies are that they create more problems than they solve, and never volunteer to fix them. Feature fairies like to get credited with completed features, but never with the defects associated with their contributions. Therefore they will usually play dumb when a bug happens, or an incident is declared, and make someone else clean up after them while they implement the next feature. So after a couple of years, you have someone credited with a lot of features, and a team of people that have been cleaning up after such person. The duct tape fairy is now a 10xer, a rockstar whose time is very valuable therefore needs to be paid more, even promoted, even though this person is responsible for wasting 90% of the engineering payroll in fixing trivially avoidable defects. The way to prevent that is to leave a trail of evidence that can link commits to bugs. When an incident happens, make sure to identify the commit id causing the problem and put it directly in the ticket. Make it very clear where the defects are coming from and who they're coming from. Never volunteer to clean up after a feature fairy. By the time you do this, the feature fairy marked their task as complete and from the eyes of management you would be wasting your time working on a completed task. Rather than doing that: - When the feature fairy wants to take on the next task, ask if they have fixed one of the defects caused by them as per evidenced in the commit id. - Rather than opening a new ticket, reopen the original ticket. This better reflects the situation: you are completing the work the duct taper failed to complete, you are not adding new work. This also denies the duct taper of their prized fake task completion. When a feature fairy volunteers to be in a hiring committee, prevent it at all costs. They last thing you need is having to clean up after more people. Be careful while doing this to not be perceived as negative.
- scribu 9y ago> The way to prevent that is to leave a trail of evidence that can link commits to bugs. Or have a code review step in the workflow, so that the buggy commits don't get merged in the first place?
- faragon 9y agoTL;DR: nihilist programmers should be fired as soon as possible.
- Slackwise 9y agoAnd then there is being the nihilist because the company and project managers won't allow you to improve or fix anything anyway.
- devoply 9y agoWell I was thinking the nihilist programmer gets fired a lot less often than an optimist programmer does. Mainly because he gets the job done, while the optimist programmer often finds he's bit off more than he can chew and is choking on it... and the company is not happy because they are not getting RESULTS, which is all that they care about.
- tempodox 9y agoThis may seem logical, but in practise it doesn't work that way. Optimists make for a better mood in the workplace, which interestingly is more important on a day-to-day basis than achieving results (barring any obvious negligence).
- kmicklas 9y agoSometimes I wish I was a nihilist programmer. They seem much happier, and in my experience optimist programmers slowly get all the life sucked out of them when on a team of mostly nihilist programmers (which seems to be most in the industry).
- theclaw 9y agoI learned not to be overly optimistic, but that doesn't make me a nihilist. I think most experienced programmers are pragmatists.
- franciscop 9y agoThis is so well written, I just wish it expanded a bit more in the end. I'll tell my experience rocking from one side to the other: When I started as a self-taught programmer I was basically fighting the code all the time and reading about these better practices and all. I followed a top-to-down learning focusing first on the deliverables. As I started learning more and more and constantly struggling with my own code, the ideal implementation (of course involving OOP) seemed further and further far off, always elusive. You could always add an extra layer, an extra abstraction here and there. At some point I realized I was lost in an abstraction sea and not getting anything done. I abandoned some of the projects at mid-size and made https://picnicss.com/ https://picnicss.com/ as an example of the opposite. Oh boy, what a difference. A single stylesheet made in few days with great adoption and feedback from the community. I just saw a video of Google IO 2017 and they used it there in a demo! It also helped that I switched from PHP to Node.js around that time. So I kind of got hooked to that. I have made quite a few tiny-sized, one-off projects ( https://github.com/franciscop/ https://github.com/franciscop/ ) and learned a lot about this quick-iteration coding. I wouldn't say it's the same as the OP's description of nihilist since that seems to be based on a large codebase. What I made was nihilist in the sense that some projects superseeded the previous ones. Example: first I made https://umbrellajs.com/ https://umbrellajs.com/ , then decided to re-implement it all and created https://superdom.site/ https://superdom.site/ with an alternative syntax. Now I think I've found a balance in the middle as I'm finishing https://serverjs.io/ https://serverjs.io/ ; the library's public API should be fairly stable, but the implementation details can have their shortcomings and be kind of messy at places. To finish off with a great saying for the situation: Perfect is the enemy of good.
- dwaltrip 9y agoI enjoyed your comment, and just want to point out that there are two separate issues at play here: 1) The quality of the end product (what the target audience sees and interacts with) 2) The quality of the underlying implementation (the hidden stuff that makes it work) They are not completely independent (e.g. uncertainty in the product design has strong implications about time spent polishing the code). But the distinction is important, and it can be worthwhile to analyze them separately.
- 9y ago
- Iv 9y agoThe thing is that the nihilist and optimist are not different persons but different mindsets and that in some circumstances, one or the other is right. Sometimes, management dooms a project and as a programmer there is only so much you can do to make it forward. Interestingly, poor technical quality does not prevent a project from being commercially successful. Other times, especially at the start of a project, or as a project manager, you have the ability of making it right. Do not pass on it! Have some realistic expectations about how far people will go with recommendations and best practices, but recognize opportunities to improve a design, as they are rare and valuable. tl;dr: be the nihilist 95% of the time, but do not miss the optimist's opportunity that will happen 5% of the time!
- Jach 9y ago> The nihilist programmer starts from these axioms and then decides what to do. What to do? The least amount of change possible. I don't think there's a deductive chain from those axioms to that choice of action. If you're a "nihilist programmer" (not a fan of this usage of nihilist/optimist) in this sense, there's nothing in your ethos that says it can't be better. Sure, it will always be crap, but you can make it better crap. You can do that in small bits or big bits. The analogy I use for legacy production software is that it's a tire fire, one should endeavor not to make it worse (by unnecessarily adding more tires or fanning the flames), and if possible make it better (spray water on the thing), but it's never going to be an Eden even if you managed to put out the fire since you've still got a stack of tires that could reignite at any moment. If you start out with an Eden in the beginning, maybe you can preserve that, but even if it's ever been done it's not done most of the time. The best is the enemy of the good, but the good is the enemy of the better. There are few things more irritating to someone with a "nihilistic programmer" mindset as seeing some self-satisfied "optimistic programmer" with their Good crap, that's still crap and could be made better. Not seeing any chance or value of improvement from good is the inverse to seeing no chance or value of improvement from broken, the problem with either view is that doing better isn't tried.
- z5h 9y agoWe need both.
- deleted 9y ago[deleted]
- jasonkostempski 9y agoI'm either a nihilistic optimist, or an optimistic nihilist depending on what and how much I consumed the day before.
- YeGoblynQueenne 9y agoWhat's being missed here is that it's perfectly possible to be an optimist that delivers, and does so reasonably fast. The problem is that it takes an excruciatingly long time to understand how to do this and most people simply don't have the patience to get there, so they get stuck in one of the two camps - do the right thing slowly, or do the wrong thing fast. Or perhaps it's a luxury- you have to make the right career moves and only allow yourself to work for organisations and people who actively support you while you develop your skills. You need to convince people to really invest in you, that is. And that's hard to do. Think though- what's the alternative? If you work for employers who believe that everything you do is always going to be a bit shit, what can you expect from them? You can certainly expect your pay to be a bit shit also, and then your say in anything that matters. Way to go to become a useless, incompetent, irrelevant, cost-center drone, there, buddy! I'm not saying you should strive to be a rockstar. But you can get better at what you do, and one day, even get to be good at it. Like, really good. People do that in every craft, in every trade, in every art, even. Why is programming any different? Well, it ain't. The "nihilist" programmer in the article is really a pessimist programmer. The stack is always half full for them (get it?). But if it wasn't for "optimists" we'd never have tail-call optimisation. See? It gets better.
- wcummings 9y ago>What to do? The least amount of change possible. Limit exposure, limit effect. Get to the next checkpoint. If it ain't broke, don't fix it.