up one level
---


w̶i̶e̶l̶d̶l̶i̶n̶u̶x̶.̶c̶o̶m̶

35-Year-old Developer Learns To Bullshit

Note: I wrote this some months ago. Shout out to supportdriven.com slack chat community for motivating me to write more during the blog #challenge.

Today I turn 35. That’s not the point of this blog post, but it puts this blog post in perspective. The point is that as a 35-year-old Software Development and Support Engineer, I don’t know how to bullshit, but am now learning about it.

I don’t know how to recognize bullshit. But I’m learning.

Here’s what I’ve learned.

A Software Development and Support Engineer is being bullshitted when the other person talks a lot but doesn’t answer the Software Development and Support Engineer’s question. There are other forms of bullshit too but this pattern particularly comes to mind. On a high level what it comes down to is, spending effort on something unimportant is bullshitting. In that sense I can bullshit myself too — if I spend too long trying to do some unimportant task. But between two people, it can take the form of one person wasting the other person’s time by purposely saying something misleading to them. In professional software engineering setting, between two people it can also take the form of Person A talking at length about something non-work-related like a hobby or like their personal life, *and*/*or* Person B listening to be polite.

I’m learning how to recognize bullshit, bullshitters, when I’m being bullshitted, and when someone’s bullshitting me.

I truly believe that by 10 years old, many people were expert bullshitters.

I think that by some time in their teens or twenties, most people can bullshit and/or recognize bullshit. Furthermore by that age, most people assume that everyone else can also bullshit. Thus by getting older than that, and still being bad at bullshitting, there’s a sort of double-tough barrier to cross.

For me to a large extent what I’ve done over the past two or so decades, is that when a person bullshitted me I would tend to not my head, smile, and then from then on avoid that person. From my point of view, it alienated me from a person when I realized that they had bullshitted me — I treated it as them lying to me, and I took it very personally, didn’t bring it up to them (didn’t confront them), internalized it, and tended to avoid conversations with that person from then on. Where has this gotten me? To be honest, now looking back on it, it’s alienated me from a lot of people.

Looking back, but more recently, this is what I was trying to figure out in this previous blog post “For an IT professional it’s a Skill to get an Answer” ( http://wieldlinux.com/2014-12-17-IT-professional-skill-answer.php ). In that post in hindsight I was writing that as a Software Development and Support Engineer it is important to realize when someone’s bullshitting me.

However. This blog post is not supposed to be *all* a rant. Moving on.

I’m moving forward and getting better at bullshitting later-in-life.

In fact I will be as bold as to say that without knowing how to bullshit, a Software Development and Support Engineer won’t be able to do their job! It’s that important. Every day, every conversation, every message exchanged, needs to be quickly analyzed for what level of bullshit it contains. If the bullshit gets in the way of a Software Development and Support Engineer’s important goal, then it must be addressed and either worked through, or else worked around.

Where to go from here? As a Software Development and Support Engineer, once I get good at identifying when someone is bullshitting me, the next step will be to call the person out. When the bullshit gets in the way of my goal I need to every time call the person out — I need to every time confront them and let them know that I’m going to treat their bullshit response as bullshit, and adjust my actions accordingly to continue towards my goal.

Where to go from here in terms of being alienated or not-being-alienated? Looking back in hindsight, now I realize that some degree of bullshit is normal, and the normal thing to do is to evaluate the degree of bullshit vs. the level of importance of the goal that is being impacted/hindered by the bullshit, and then either let it go or confront it *but (and indeed this helps with this) don’t let it negatively affect* my relationship with the other person. Don’t take it personally when it’s not.

Indeed, it turns out that when used with each other between two experienced bullshitters, some bullshit is an effective tool to soften conversations and as a “meta” (alternate/indirect) way of communicating what’s important vs. what’s not important.

What’s a high-level, overall conclusion here? For a Software Development and Support Engineer, no matter what point in one’s life one learns to recognize and properly react to being-bullshitted, knowing how to bullshit is a valuable skill.

( This post is somewhat of a follow-up on my previous post “As a Software Support and Development Engineer I am Bullshitted” ( https://investorworker.com/2016/2016-05-18-engineer-i-am-bullshitted.html h̶t̶t̶p̶:̶/̶/̶w̶i̶e̶l̶d̶l̶i̶n̶u̶x̶.̶c̶o̶m̶/̶2̶0̶1̶6̶-̶0̶5̶-̶1̶8̶-̶s̶o̶f̶t̶w̶a̶r̶e̶-̶e̶n̶g̶i̶n̶e̶e̶r̶-̶b̶e̶i̶n̶g̶-̶b̶u̶l̶l̶s̶h̶i̶t̶t̶e̶d̶.̶p̶h̶p̶) )

Edit: This post was previously published at: w̶i̶e̶l̶d̶l̶i̶n̶u̶x̶.̶c̶o̶m̶/2016-06-28-engineer-35-learning-bullshit.php



[2019 edit: Moved to: https://investorworker.com/2016/... .html.]