When are you happiest as a coder?

ben profile image Ben Halpern ・1 min read

What are the times when you just really really love doing this stuff?


markdown guide

When I feel like what I'm doing matters, either to myself or others. Getting in the 'flow' state is also a pleasant experience.


How much of your work do you typically find "matters"?


That's a tough question, and it really depends on what it is. My current job is actually kind of a struggle for me in that regard. I have no more than a handful of users at any point, though I can at least talk with them directly and see the problems they have and the solutions that we come up to solve them work. But a good portion of the things I'm working on have no users, and instead are optimizations deep in a complex system that no one directly sees.

I also think that feeling that something matters is a difficult thing to apply generally, as it's a mostly subjective experience, especially when you're doing things because they matter to yourself.

I feel this deeply. I don't mind some backend optimization work, and I get that it's important, but man, there's nothing like user-facing development, especially in a situation where you can talk directly to your users and take feedback.


Agree with this. If you can solve a problem that matters to yourself or others then it's worth feeling


I'll agree with all of these and add a nice technology is also great, my personal favourite at the moment is elm.


My favorite time it's when the thing you have been working on for hours, days, weeks, months, finally goes into production and people actually start using it. It's usually the start of a long journey, but it's the best feeling.


Yes! I get to have that on Tuesday. Guess until then, I'll have to live with the nervousness


I hope everything goes well for you! I feel the need to ask what you are deploying, but if it's a stealth release, feel free to tell me no lol.

It is the-network.io, a platform for VC investment funds, and over the past week we had a bunch of calls with clients, showing them a non-permanent version of the platform to get their feedback and maybe have them subscribe to it. I'm happy to say it was received very positively :)


Doing TDD up to the point where the last line of implementation is done and everything works.


Great feeling indeed 😄


When I've finished a thing (feature, a commit, a whole project). Those are the best moments.


A pause for pragmatic celebration.


When I'm working on an interesting, complex problem, but making progress at a steady pace.

It's a balance that's easy to upset in either direction: if the problem is too simple, especially if it's a lot of repetitive, rote work, sure you'll make quick progress, but it can get boring; but if a problem is overly complex, like a caused by subtle, weird race conditions that are hard to reproduce, or if the library you're using has some unexpected behavior and you have to dig through someone else's poorly organized deep class hierarchy to find the bug (this is definitely a hypothetical and not my actual life right now 🙄), it can feel like trudging through deep mud, making frustratingly slow progress.

Both of these are normal parts of software development, but they aren't the parts I love the most. I'm happiest when I'm presented a really interesting, non-trivial challenge, especially one where I have to do some research and learn a new technique, but where I have at least an idea where to go and I consistently make some significant progress daily, check off a subtask each afternoon before I leave.


When I'm working on an interesting, complex problem, but making progress at a steady pace. It's a balance that's easy to upset in either direction: if the problem is too simple, especially if it's a lot of repetitive, rote work, sure you'll make quick progress, but it can get boring;

Wow, you really nailed this!


When I'm actually coding.

So no:

  • useless meetings;
  • calls with the client;
  • asking the designer what the heck is that;
  • writing documentation;
  • bickering with the accounts for the impossible deadlines;
  • pondering estimations (even for things like "how long will it take to fix this bug?"), especially when there's no clue of what the project is meant to achieve in details and the functional analysis is a shape-shifting abomination.

But I understand it's all part of the game and my seniority demands me an important role in all of that, so it's ok. Just let me code once in a while.


I think it is when the focus is on the problem I'm trying to solve rather than on tedious language, framework, or environment quirks. That was the initial appeal of web development for me because I could start a new file and turn a design into code and have something to show for it. When the extraneous setup and prerequisite learning are already taken care of or if a language/framework/environment makes that super easy, then I tend to be happy while coding.



Nothing beats the feeling of transmuting a garbled mess into well-written prose


But first you have to read and understand the garbled mess, even (especially) if it's yours, and I find that part excruciating.
But yes, after it is done, it is really a fantastic feeling of accomplishment. Maybe it is actually proportional ?


You're absolutely right! It's painful to refactor large piles of stinky code. I find it less accomplishing to do manage that since I don't find any joy in doing it. Then again, continuously optimizing/refactoring after every small change in code slows your progress to a crawl.

I think laying down the logic, and THEN ironing out wrinkles afterwards is the sweet spot!

Laying down the logic is the part where you must rethink your logic (why sometimes asking yourself "what the h*** was I thinking ?"). I find its a stimulating time. Most of the time, I use my good old paper and pen to do that, and really like the process.

I totally agree with using pen and paper to map logic! This is where I appreciated my UML diagram lessons back in university. They may seem esoteric, but knowledge of flow charts/activity/sequence diagrams really help clarify your own intentions. Plus, it's a good skill to have if you work with a team.

Indeed! I actually discovered the computer world with flow charts/sequence diagrams first, using them to work with a software that allowed to create new modules without code (a so-called "no-code" platform). You could say that I start with diagrams, before learning to translate it to code


The moment when I had been sitting for hours/days on a complicated task / feature / issue and then had the enlightening breakthrough to solve it! 💡

In this very moment you feel you just understood the whole universe 😁


Honestly, getting paid 😅

Don't get me wrong, it's an incredible feeling working on my own projects and seeing them work. But to be rewarded for what I am passionate about and actually making a living from doing what I love is the greatest high ever.
Keep in mind that I did numerous projects for free just to fill up my portfolio and earn some credit. It was many years down the line when I actually asked for some money.


Getting paid to do something valuable that you also love is the best!


When things are working on the first attempt without having to fix any semicolons errors 😂


I have a confession to make. Because I really like doing those refactors that last intensively for a couple of days. They're not healthy for one to do continuously and generally it is better to improve incrementally in small steps, but just getting yourself lost entirely into some code and complexity for a couple of days is something I love. Even with all the swearing I have to do with the "stupid" existing code that is in the way and doesn't do things the way I want :)


Kinda lame: When I delete more lines than I add in a PR

LoC is an incredibly stupid metric, without a shadow of doubt, but there's something about the joy of making something better than it was by reducing the amount of code needed to make it happen :-)


When I create value for other people creating something that works. It doesn't even have to be coded. Might be no-code, a demo version using a mockup tool, etc.

As long as I'm providing value I'm on the jazz.


At that lovely point when after much trial and error and learning about the problem you are trying to solve, things start to come back together.

You start with an idea or a problem to solve, and things get more and more complex as you try to solve the edge cases, etc. Then there comes a point when the patterns emerge. The refactoring happens. The code gets smaller. Gets simpler. Lines of code get deleted. Things get elegant.

That is when I'm most happy.


During the morning, when I put my coffee on my desk, put on my headphones with some good vibe music and start making my todo list on my scratch pad.


When I work on a new feature or concept that is major and at the heart of the product. When it is done and it actually works and the business actually notices it and the dev team gets a mention in the Company Update meeting and we get to visit the bar like Spartans.


When I am working on a project just the way I like, without any exterior factor (like working just like the old version of the software design, regardless of the logic and the necessity, or using an older technology rather than a newer more efficient one, because nobody else really took the time to learn about it before saying NO, or having the condition on creating a web application to work EXACTLY like its desktop counterpart even if it make no sense)


Believe it or not - it's when I can have good and extensive communication with clients about the pitfalls and obstacles we are BOTH facing, but look at differently, and then I can contribute to their understanding and I'll receive appreciation for those explanations. It is is the best way to find solutions for frustrating aspects, because it is a way to find the compromise we both on our own wouldn't be able to take successfully.


When I struggle with learning some new tool/framework/concept for few hours/days/weeks/months, but then it finally "clicks".


When doing domain modeling and you suddenly "see the matrix". Usually on a walk or in the shower; you're thinking about things as orders and deliveries when a thought punches through. What if you modeled it as a series of composable service provider abstractions? This will create a far more naturally flexible system and significantly collapse the complexity. You run it by the product owner who excitedly validates that yes indeed, this approach works and simplifies things. Then you get to delete tons of code.

I remember the first time this happened to me. It was so profound i had to take my lunch to go sit on the banks of the Mississippi and feel the Zen.


When I am working on things that peak my interest! I come to find that the act of coding inspires more motivation and it becomes a snowball effect. This could even mean learning a new technology, pattern or library.

Generally, I love doing small projects or deep dives into new libraries/projects and having those sweet victories or lightbulb moments. They are moments to savour.

The longer the project (if I am interested), the bigger the payoff too. Similar to training for a big event and finally running the race after all that training.

These are especially true of work projects too. If I am not aligned with what the company wants to do or it doesn't align with what I want out of my future, I can be very flat in my career. Worst-case scenario, I do this "flat" work and then the company project pivots after a few weeks of toiling away. This happened a lot early into isolation and it brings a real feeling of wasted time - not ideal in these trying times!

  1. Find a bug
  2. Write a failing test for it
  3. Fix the bug
  4. Ensure the test is green and open a PR

The fact that I can only follow this pattern for 1/3th of my coding time makes it even more special a treat.


While it sounds egotistical, I like the challenge of doing something others (often the client included) thought was impractical or too intractable to do.


I know the feeling. I'll add that it feels even better to bring someone along (mobbing or pair programming) and witness them realize they did more than they thought possible too.


If I did bring someone along, they'd be refactoring everything in my wake!

I know what you mean. :)

In all seriousness, mobbing and pair programming work best when everyone is contributing real-time organically so there is nothing to refactor when the session is done. It has a productivity potential beyond the capacity of any one of us.


As an Angular developer, I find this too relatable. 😥


When I am slinging sweet, sweet YAML.


Ooh spicy opinion over here 🔥🌶️🔥 haha

I personally like YAML a lot, but it takes a lot of flak for some reason.


When you build stuff that others use to make their life better/easier through feature work and tooling. Its especially nice when you can calculate time saved to do a task for a large group of people.


When I feel that I have accomplished my goal for the day.


When the code I write helps others, to put in simple words when I see my production code in other person desktop/mobile devices it gives immense happiness.


When I understand that my code can help a lot of people.


When I see that my contribution is runing in production


When I make a pretty user interface.


When I am able to put certain addon in my implementation which I never thought of before writing code.


When I learn something different and new 😎🔥


As a coder when I see an opportunity to DELETE code, I do it.

Less Code, Less bugs.

This happens as part of Refactoring process


When I watch some youtube tutorials and learnt something really new to me!
(For ex. Fireship, Coding Garden with cj videos!)
After some eternities, I will try to do those things!😂😂


Pull request approved.. tears of joy


When I'm animating things and it's so cool I can't help myself making sound effects and repeating the animation over and over again.

  • When I'm working on a project I'm really passionate about.
  • When something I worked on gets shipped.
  • When the work I do gives value to other people and communities

When I can determine the application's logic myself while having creative freedom to choose the means to make it so


When you've been writing a complex piece of code for hours then try it and it works on the first go.


After hours of chaos and fixing bugs, finally it is working perfectly. That relaxing moment when I am shuting down all open tabs in my browser. I really like that moment!!...


When something I code is being used by the intended user !


That eureka moment of "It finally worked!"


When i have to make something i have never done and i spend days and days learning and searching until it works. And then you realize 100 better ways of doing it.


Working on a side project with friends.


when everything works smooth and I dont have to worry about errors. LOL


When I'm building brand new features, or brand new applications from scratch.
And secondly, when I figure out the cause of a tricky bug.


When I understand what is going on with my creations!

Nothing is worse than wondering why things are behaving the way they are and you have no idea why


When I'm writing code and learning new things without spending the majority of my day in meetings.