Ask HN: Is programming culture immature? | Hacker News Reader

Ask HN: Is programming culture immature?

140 pointsmattwilsonn888122 comments

I enjoy all facets of using computers, including programming, and am decent at it. I like many others also enjoy the theory crafting aspect which means spending time reading/thinking about programming and technical concepts and engaging with or observing discussions and even debates.

Programming is intellectually challenging, and that seems make insiders and outsiders assume that in order to have some success as a programmer, one must be intelligent, rationale, sensible, or heaven forbid, wise.

Yet in my experience, it doesn't take a lot a long time engaging with the digital-technical community at large to realize there is often a large gap between intelligence and wisdom or even basic sensibilities. A field which has so many tools to objectively quantify their work and the result so often are debates displaying poorly concealed biases and egos.

I was visiting the Star Citizen subreddit where a user posted a readable, short, simple proof of concept to improve a longstanding inelegant UI element.

I read debates about languages and see the most reasonable of authors walking on egg shells and writing caveats like they are commas lest one misstep allows a snowballing tirade of people missing the point.

And more universally, I see people who have acquired anywhere from basic to advanced competency spit jargon of the most specific like it is poetry, in a field where learning specifics on the job is the norm (and not that difficult), it seems people cannot resist using obtuse language to virtue signal their intelligence relative to other people.

There are obviously exemplary members of the outward facing tech community; they often have great success for being the foil to what is above, but more and more I become frustrated and begin to believe that progress in digital technology is greatly hindered by the low quality background of interaction between those who use it.

I say this fully embracing that in a domain like tech where extremely complex and nuanced problems need to be solved that disagreements, sometimes passionate ones, will need to be resolved one way or another - I am not against or complaining about that fact; I am simply growing tired of what I think most reasonable people can identify as basic immaturity and the surprising and disappointing commonplace nature of it.

Do I have to issue any more caveats? I am dead certain their have been numerous and highly successful workplaces which were the anti-thesis to these complaints.

I have less experience in this space and in life than many of you - so please offer your perspectives.

View on HN

I would say a lot of this is just the nature of online discourse that allows the loudmouths, blowhards and nitpickers to have their way while more balanced people disengage because it just isn’t worth it for them. This dynamic can be seen in all online communities that grow large and it’s not specific to technical topics.

That said, I think programmers are prone to some of this simply due to the fact that programming requires a baseline obsessive attention to detail that most people don’t want to think about. Combine this with the fact that businesses need tech and the situation has led to a lot of secure jobs for technical people with poor social skills. This has led to a situation where a lot of people can get by in a sort of comic-book-guy bubble of expertise without having to learn anything about civil discourse.

Now I think it bears repeating, these people are a tiny minority, definitely less than 5% in my experience working with hundreds of engineers over the decades. It’s just the increased size of the community and incentives online that cause them to bubble up without consequence.

I agree with everything you said. Imagine what's going to happen when someone trains an AI model to act like a loudmouth, blowhard nitpicker.

Since this would be done by a programmer, programming communities would be among the first ones targeted.

That already happened. Then, StackOverflow banned ChatGPT.

I wish most software engineers were even half as attentive to detail as most traditional engineers are when it comes to failure modes. The field is obsessed with the happy path which in my opinion separates it from “actual” engineering didciplines.

It’s all about risk profiles. The failure of a bridge or an airplane is catastrophic and people will die. If a SaaS provider is down for awhile, people are frustrated.

You're right, it's just an inconvenience for the users, but a real problem for the developpers.

Some upfront thinking would help us (developers) save a lot of effort and frustration

It’s not just the developers, but the entire organizations they work within that prioritize shipping new features rather than reliability, because that’s generally what’s most profitable (at least in the short term). It’s hard to change those incentives for an entire organization.

The impact, whether economic or QoL or whatever metric you prefer to use, of a million frustrated people and the corresponding loss of productivity may not be insignificant.

And, obviously, software is in charge of actual security in the real world, and the track record there is not exactly flattering! Safety as well, of course, but luckily safety-critical software is a much smaller and usually more rigorous subfield, quite unlike the case with security.

I think this used to be true, but we're not building toys anymore. Whether we like it or not, SaaS products are rapidly becoming transitive dependencies of mission critical, life/death infrastructure.

Last time i had to get roadside assistance, they couldn't use a mile marker / highway location reference. They had to have something to type into google maps in order to dispatch help.

Could they have gotten to me if google maps was down? Probably but i'm not sure. Either way, it wouldn't have been the practiced default and that matters.

I think the perception that programmers are less attentive to failure modes than other engineers is an artifact of two things:

1. Computer programs are far more complex (and complex in a hard to analyze way) than mechanical systems

2. Programming is (still) a relatively immature field, and, and a result, it doesn't have the institutional knowledge and best practices that make certain failure modes highly unlikely

I think (2) is an underappreciated point. If you look at the history of e.g. boilers and steam engines, the early years are absolutely rife with examples of boilers and steam engines exploding in spectacular ways, often killing people in the process. It took years for standards of design and engineering to develop which made those failures exceedingly unlikely. Another example comes from aeronautical engineering. The Comet jetliner, for example, suffered from cracks that developed due to metal fatigue that was exacerbated by the design of the windows. These cracks led to crashes that killed hundreds, and, in response, standards were created and modified to ensure that window frames were properly designed and reinforced to prevent cracks from propagating. Furthermore, Dan Luu has done some work [1] in analyzing how cars fare in accident types that haven't been incorporated into safety standards, and he finds that their performance is often quite bad.

Most "traditional" engineering is like that. It's not that the engineers are personally paying more attention to failure modes. It's that they're following standards, and as long as the standards are followed, the failures that necessitated the creation of those standards are prevented. Programming, unfortunately, is still new enough that many of the standards we need haven't yet been developed, and most practicioners are new enough to the field that what standards do exist haven't really propagated across the field.

[1]: https://danluu.com/car-safety/

Along this theme, Hillel Wayne has a series of blog posts [1] [2] [3], where he argues that programming and engineering aren't really that far removed from each other, and, surprisingly, in some ways programming is more advanced than "traditional" engineering.

[1]: https://www.hillelwayne.com/post/are-we-really-engineers/

[2]: https://www.hillelwayne.com/post/we-are-not-special/

[3]: https://www.hillelwayne.com/post/what-we-can-learn/

Lost count of the number of devs who think a whole function inside a 'try' block with print(e) as the exception handler is the gold standard.

> That said, I think programmers are prone to some of this simply due to the fact that programming requires a baseline obsessive attention to detail that most people don’t want to think about.

It requires some careful attention, planning, and some honed skill, but so does building a bridge that spans a river, so does cooking meals for a party of six on time, so does sewing a shirt, so does composing a piece of music, so does drawing a cartoon or a comic strip.

Programming isn't the first occupation that requires problem solving skills. A tech boom and high salaries have definitely convinced a lot of programmers who haven't had much other world experience that it is. The way we talk about and treat programmers as an elite class has only helped to grow that image even more.

As you said, a lot of highly paid programmers who never cared to learn social skills, or worse, actively despise working with others. However, I don't think this is an accident or a fluke, it's behavior that's been encouraged and reinforced from the bubble. As the tech boom wears off, we might see this change.

> As the tech boom wears off

What could cause this though?

> What could cause this though?

The Fed having a tight-money policy to control inflation leading to widespread layoffs in existing tech firms and less investment in new ones, and what would make it more durable is some breakthrough outside of computing leading investment in a different direction in the next easy-money period.

We’re just trading speculation here but I think the boom and the bubble aren’t quite that relevant once you just look at the profession and not the way it’s been funded by VC.

The field, the industry, the profession… whatever you call it… it’s not even a century old. Cooking, metal work, civil engineering, architecture, etc. etc. go back millennia and transcend civilisations. Humanity has had a hell of a lot of time to get good at those things, each culture throughout history discovering and refining its own methods until now, where we see them fused together in a globally connected world.

Software is not even a century old. We are still in the birth of a new industry, everything is rapidly growing and evolving, and we don’t have any historical context to rely upon except perhaps mathematics.

We might have hit our limit on CPU architecture and how we write software, as far as we know we’re the first to reach this point. But the next generations, the next civilisations, can take our primitive work and discover something we couldn’t.

It’s only going to become more important as time goes on. We all just got in early, in the middle of the chaos. We’re gonna go through this kind of maturity problem quite a lot.

Programming doesn't have the tangible aspect of the examples you provided. If I make a bridge over the river with huge holes in it, you see them. With programming you don't see them until you run into them.

I'd like to fall back on Alan Kay's view on the topic. In his talks, he often considers large parts of computing immature. For instance, in serious disciplines such as Mathematics, there is a great focus on scholarship, and building up on predecessors. In computing, we find it hard to come up with a definition of "progress". There is constant "change", sometimes what looks like "improvements" and "corrections", but it is hard to tell whether stuff is really getting better. At best in software, we find "extensions" of concepts/systems. Contrast with mathematics, where there is a clear mounting to higher concepts over time.

From the above perspective, programming is more like politics/fashion than mathematics. There is in general insufficient respect for scholarship, a lack of universally accepted authorities, a consensus on what's high quality and low quality. There is too much dispute and room for profitless argument.

PS: We got attracted to this field; what does it tell about us? :P

I think I 100% agree with this. There have been threads here about burnout and disillusionment, and I think it kind of feeds into this. There's so much churn and confusion about what is the best way to do things, and there's no real guiding force - everything is still so young.

For me personally, it's frustrating how so many new ideas are really solutions to problems tech itself has caused. I like to say that Docker is great, but really it shouldn't need to exist - packaging complexity is self-inflicted and a sign of an immature discipline.

Also, what other discipline can spend millions of dollars, and 10s of thousands to millions of man hours building a package/framework/language/ecosystem, then decide a few years later that "meh, seems dated", and "look, this new stuff is so refreshing!". Again, the inability to focus is a kind of immaturity.

We are there though. Currently there is no need to use docker to run containers natively in many OS. Systemd nspawn, rocket, cri-o accomplish the same workflows with tight OS integration.

We don’t hear about them that much, but almost anyone using k8s is not using docker at this point.

You’ve completely missed the point. By “docker” they mean the concept of containers, which is only needed because developers are so absolutely awful at keeping track of what libraries they’re using, and completely opposed to using OS packages like rpm/deb, that someone (Docker) finally had to say “screw it, we’re just going to lump everything into this binary blob that includes a whole set of OS libraries because we just give up even trying to get them the play nice with the rest of the IT ecosystem”.

Still the same problem, which is that the OS introduces a bunch of baggage that requires an additional layer of virtualization. To quote Dan Ingalls:

> An operating system is a collection of things that don’t fit into a language. There shouldn’t be one.

Lots of confusion and yet a sense there is a lack of compassion for not knowing optimal solutions in the same wild west environment. Enter imposter syndrome. Enter disillusionment.

It is software engineering. Success is not accumulated on perfecting a formula in a dusty study of an ancient university but in the messy and human business domain. Success almost always has to do with time to market

Almost no other engineering discipline is volatile like that. So why should SE be? There are trends and fashions, of course, and missteps along the way, but the success of building a bridge has nothing to do with time to market. (The success of selling a bridge still might!) Sure, many engineering fields are similarly at the mercy of erratic consumer or business interests, but the fundamentals of what makes a good fridge or camera or building aren’t decided by the marketing department or some yelling contest on the internet where the winner is who has the most Github stars. Real engineering absolutely progresses in universities hand in hand with the real world, or do you think that institutions like the MIT or Caltech or Cambridge’s School of Technology don’t have anything to do with the success of engineering endeavors everywhere?

I know electrical engineers that spend their whole day picking out doors for hydro-electric facilities and chemical engineers whose job is to sell various pipe valves.

The programmer equivalent might be refactoring variable names to "int i_FallDistance_mm" or working in crypto.

If you aren't sure if your current job is one that an engineer would do, you could consult the engineer code of ethics. Broadly:

1. shall, in their areas of practice, hold paramount the health, safety and welfare of the public and have regard for the environment.

2. shall undertake only work that they are competent to perform by virtue of their training and experience.

3. shall conduct themselves with integrity, honesty, fairness, and objectivity in their professional activities.

4. shall comply with applicable statutes, regulations, and bylaws in their professional practices.

5. shall uphold and enhance the honour, dignity, and reputation of their professions and, thus, the ability of the professions to serve the public interest

https://www.apega.ca/docs/default-source/pdfs/standards-guid...

> Almost no other engineering discipline is volatile like that. So why should SE be?

Because it can afford to be like that.

You seem to be treating volatility as something negative. But it's only a side effect of software engineering industries being incredibly cheap to launch and scale.

You can't start a transnational construction company in a garage. But you can start Google.

>For instance, in serious disciplines such as Mathematics, there is a great focus on scholarship, and building up on predecessors. In computing, we find it hard to come up with a definition of "progress". There is constant "change", sometimes what looks like "improvements" and "corrections", but it is hard to tell whether stuff is really getting better. At best in software, we find "extensions" of concepts/systems. Contrast with mathematics, where there is a clear mounting to higher concepts over time.

This is absolutely true.

One real example of this phenomenon in my opinion: the rise of JSON. In the 90's, the XML was invented to be the silver bullet of the myriad of ad-hoc formats for structuring documents that existed in the wild. So in the XML stack you could find the XSL to ensure the validity of an XML document, the XPath to be a querying language, the XSLT to be a language for writing transformations, etc.

I guess that in the 90's many people regarded XML as the dawn of an era of strict correcteness between data exchanges and the elevation of the contract-based design.

At some point though people deemed XML too verbose and started using JSON. Now with JSON there are multiples conflicting implementations of basic things like a schema mechanism and files and API's that rely many times on natural language to be defined, so an obvious retrocess only because of "verbosity".

You can see this random walk in many other places, with frameworks reinventing the same thing over and over and getting traction besides implementing something worse.

I guess that since technology is a field that receives a big influx of people, the dynamic of the field changes to support people who don't understand completely what they are doing, this doesn't happen with mathematics/chemistry/physics because it's you who have to adapt to them.

> In the 90's, the XML was invented to be the silver bullet of the myriad of ad-hoc formats for structuring documents that existed in the wild.

Tangential, but this is seriously uninformed. XML is a subset of SGML, specified by SGML's original creators, implementers, and users (the SGML Extended Review Board at W3C) as a simplified meta markup language for the web. What has been projected into XML beyond this original purpose is truly astonishing, though, and while that's true of the web as a whole, XML has failed this primary purpose, too.

> I was visiting the Star Citizen subreddit where a user posted a readable, short, simple proof of concept to improve a longstanding inelegant UI element.

That's exactly the sort of discussion that encourages what's called "bikeshedding". If someone says "we should fix x because it will be much faster", that tends not to generate rants. If someone says "we should fix x because it would be easier to use", it generates complaints. Mandatory XKCD.[1]

> There is constant "change".

This is especially true in the user interface area. Fussing with user interface elements is a popular way to indicate that the product has a new version. Look up the history of Microsoft Windows screens. There are lots of historical pictures, so you can do this easily.

It's a management problem, too. The head of the Stanford business school once said that the main job of management is "change". Not "improvement". There have been at least 22 versions of Tide, the laundry detergent. A line from a marketing text: "The most effective phrases are FREE and NEW. You can't always use FREE, but you can always use NEW."

[1] https://xkcd.com/1172/

One of Joel Spolsky’s most coherent blog posts was called “Fire and Motion” and talks about how velocity != progress. We are often moving really fast in a big circle.

I think the reality is that programming is not as intellectually challenging as we'd like to think. Maybe we will encounter a hard problem occasionally if we're lucky, but most of them are already solved. As programmers, we just need to pick a solution with good tradeoffs. In fact, understanding the tradeoffs is usually the hardest part.

And yeah, the industry very immature: it is idealistic, hype-driven and full of cargo cults. Which makes perfect sense: when you convinced yourself that you are a great intellectual, but all you do is building REST APIs, this makes you uncomfortable. So the next natural thing to do is join a cult. Maybe even start preaching. This gives you a sense of superiority you've been looking for.

Learning how to program is intellectually challenging actually. Not fully understanding all primitive operations while they teach you to try to execute programs in your mind (rather than using a debugger) is madness. It was to me anyway.

When you get past that point, yea, then I agree. The intellectual challenge for most programs is gone. Not for everyone though, I have a friend working for a HFT firm. The shit he encounters is hardcore.

The biggest obstacle is not grokking that programming is a formal system, just like math - that it is possible to understand programs in your mind in a well-defined way. Much intro-to-coding education tends to leave this unstated, and starting with supposedly "intuitive" but actually very complex, higher-level languages makes it even harder to point out.

Imagine a world where all programming was done via heuristically-derived ChatGPT prompts spelling out what the system has to do in lawyer-like detail. That's what lots of non-coders have in mind when they think of what "coding" must be like. Of course that would be totally unworkable; coding only works because it's formal and 100% reliable.

> coding only works because it's formal and 100% reliable

This is not true for distributed systems: clock skew that is unpredictably different on different devices and networks are inherently unreliable. Real word physics is messy. :)

Even in distributed systems, one usually assumes that there are no Byzantine failures so a kind of reliability is preserved. You need a blockchain to solve the Byzantine fault problem, and that tends to involve a lot of overhead.

Or HFT

> The biggest obstacle is not grokking that programming is a formal system, just like math

I think there's danger in this mindset. Unlike math, programming is always directly tied to real-world problems. And those are defined by humans. Who, as we know, are not very good at being formal.

In my experience, the biggest obstacle is actually not recognizing the informal part. Trying to stay in our own little world of formalities and treating the real world as a nuisance to our grand designs.

Calling yourself a computer scientist might be pleasing to our egos, but at the end of the day most of us are software engineers. We are the conduit between formal and informal. There's no shame in that.

> Unlike math, programming is always directly tied to real-world problems.

Huh? You think that math is not tied to real-world problems? That it's not useful for modeling the real world? It's not like programming is doing something inherently different.

They didn’t say math is never tied. They said programming is always tied. Maybe that in itself is debatable but you’ve changed the argument.

Applying all of that knowledge is emotionally challenging though. On any given day I’m dealing with avoidant behavior. Every time I have to refactor code that shouldn’t have needed it at this point, I’m approaching something that has already been avoided once, by me or usually a few particular coworkers.

Some of us saw a CS degree as a route to living in your own world of imagination and are disillusioned by finding out just how much that is wrong, or defensively cling to that illusion to the point of near fisticuffs if someone tries to burst that bubble.

> understanding the tradeoffs is usually the hardest part

This feels especially true in the front-end. Whenever I try to learn new things I always try to find the online communities, the main books, the podcasts, etc. I try to find the people down to bikeshed about something most wouldn't care about.

I feel like this learning strategy has been especially effective in the front-end world. If you start a new job, chances are you're gonna have a huge chunk of your stack be totally new just because of how many solutions there are for everything out there. I feel like the main value-add I bring a lot of times is just knowing what's out there and what the best tool for the job is. Most of the time I haven't actually used that tool

The hard part is cutting through the bs and knowing what's hyped because of a certain interest group and what's hyped because it's an actual improvement. For that, I find you usually do need to have some hands on experience

I agree. This is why I have a problem with questions like "what project you are most proud of" etc. I have never encountered an interesting project in industry.

In academia, sure. Esp in research.

> I think the reality is that programming is not as intellectually challenging as we'd like to think.

It takes most people thousands of hours of practice to get good at it, and a lifetime to master it. I think most people of average intelligence can get to high levels of competence, but it's definitely not easy.

Yes. It can be truly exhausting, for all the reasons noted.

There's a flip side to providing caveats and walking on egg shells: The culture is terrible at providing feedback. It's given when not requested, it's usually very very pedantic, or possibly delivered with some degree of irritation.

One thing that I find helps: separate things into objective and subjective categories.

code quality, best language, good design, cleanliness -- examples of subjective measures. They're going to vary by person, background and experience, thought processes, etc. They make for entertaining discussion topics, but not usually productive ones.

These generally are also the areas where people's egos and self worth get wrapped up. No one wants to feel like they're producing unclean code.

I try to focus more on objective things: does it produce the correct result? how much time will it take to on board someone to x y or z? It usually helps keep the discussion productive and helps keep egos at bay.

It's difficult though. People have opinions, and they want you to know about them. and they want those opinions to be facts. And it's most likely something we're all guilty of.

This really resonates with me; it makes me realize that I've been too caught up in the subjective things you list here, and not focusing enough on what's more objective.

This applies to conversations about performance a lot, too - so many debates on performance happen without any benchmarking or attempts to measure.

The only way to explore the subjective is through debate. The objective things are neither actually objective, or the most critical aspects of technology choices. Java was marketed as a silver bullet for portability, which appeared an objective fact to encourage adoption at the time; ultimately, this proved to be a red herring, as many other such promises do. If instead the culture had focused on the more subjective aspects of language choice, I think we would be a lot better off.

Debate has its place, that doesn't mean everything needs to be debated at all points in time, or that people shouldn't just accept that they disagree on something and move on.

> If instead the culture had focused on the more subjective aspects of language choice, I think we would be a lot better off.

Maybe? Who's to say what would have happened in some alternate timeline. There's no way to get an actual answer, so there's not much value beyond entertainment in discussion. Perhaps the exercise might provoke thought.

Why did it prove to be a red herring?

I could write a CLI or GUI Java program, that would run on any OS, for which there is a JVM, and that was easier than doing it in C, C++, Delphi or Perl, which were popular at the time.

As far as I know, at the time only TCL/TK offered something remotely comparable in portability for GUI apps.

I may finally have a take worth sharing here:

Yes, I think programming culture is immature as in there is lots that isn't yet well understood. I think the entire industry of software development is the same. But I think this is more a result of how young the field is compared to others. We've been building bridges, roads, etc for hundreds of year, but we're still trying to wrap our heads around software.

I think this is what makes it great. Yes, there are egos, and folks who strongly hold points of view that I'm sure history will prove incorrect, but I think that's what makes this fun.

To give an analogy - I've noticed that when my friends and I all get into a game (dota, back in ~2008, for instance) at roughly the same time, there's this magical period full of fun and discovery where we're all trying new things and exploring how the rules of the new space translate to outcomes. Sometimes we get suck in a local max and then someone dramatically finds a new mechanic that changes everything. This period is the golden period. This tapers off as we start to know which strategies work and we just continuously use those to win.

This is the point where the goals shift from discovery to execution. I've found that playing games past this point is just frustrating for me.

So, yes, I think we're still in the wild west era of software development, but I think it's kind of fun! I don't think it'll last forever and it will probably be better overall when it ends, but I'm here for the ride.

I think this is a good model if perhaps narrow. You mention the lifecycle of a single game. But there are many games released over many years. Software is the same. For example we may have reached some level of maturity for building a CRUD app with RoR. But there are still all kinds of innovations happening at the fore.

I agree with the overall point though, we’ve been making roads, constructing buildings, doing banking for centuries or millennia, compared to a century or less of software. But those fields aren’t 100% mature either — finance cooks up new derivatives, and we find new materials, techniques for constructing things. In some sense I think foundational principles for tech are already there, but not as mature as other industries due to time.

Good point, thanks for your insight.

IMHO the immaturity you're speaking of stems from High Conscientiousness. When conscientiousness becomes obsessive, we worship The Right Way, The Right Tools, The Right Culture. We believe in tools and methods like they have some magical power. We get more concerned about the "how" than the "what" we output. Dogmatism creates immature thinking and debate.

"Woodworking Mindset" is one antidote: https://scottstevenson.substack.com/p/lego-mindset-vs-woodwo...

A lot of the time being too high in conscientiousness actually makes it super hard to be creative: https://scottstevenson.substack.com/p/how-to-finally-make-so...

High conscientiousness correlates with agreeableness; it's rare to have a highly conscientious, highly disagreeable person who would actually go out other way to offend others. So I don't think that's that's the explanation.

Further, commentors on any particular subject are, I think, statistically more likely to be monomaniac obsessives, and that correlates with poor social skills (e.g. truth-seeking at the cost of empathy). In other words, autism.

Fair point, but it correlates more with Neuroticism. Conscientious people could be agreeable because they tend to believe "what's in the water", or the dogma of the place and time. This could cause them to be disagreeable with those outside their tribe.

I doubt that’s what happened at the Star Citizen sub-reddit … Also, this is interesting but there are just a lot of young people in programming forums being a bit immature. If you go to CppCon or GDC or some other tech conference, you don’t get the same discourse as in forums.

ehhh, I think if you watch the cppcon videos, you can get a taste of what the OP is talking about.

The cpp community is possibly the worst offender on some of the points. Speakers walking on eggshells and having to have a laundry list of caveats comes to mind.

It's more mature in the sense that you probably wont see a lot of memes, the insecurity and ego still permeate the venue and community.

Can you link to specific examples please?

I'm electing not to. I don't want to put any one specific persons behavior under a microscope publicly. There are specific examples that I'm thinking of, but linking to a video of them attaches a face, voice, name, etc.

I'd hate to put myself out there doing a talk and be on the receiving end of that sort of indirect criticism. It wouldn't be feedback to the person, it'd just be something for us to argue about whether they're exhibiting a given behavior or not.

Thank you so much for those links. It resonate a lot with a previous experience I had in a company which was so obsessed with doing things "the right way" that they ended up with the most over-engineered abomination I've ever seen*.

They applied all the rules and "best practices" they saw on Medium with maximum strictness (of course) and were very adamant on doing everything now in the "right true way" in the codebase.

I had trouble putting words on that behavior, describing it as "religious fundamentalism, but with code", so I'm glad to finally have a better word for that.

* It was a simple corporate website, with a few, simple forms (though with visuals bells and whistles added), and some semi-customized pages. It could have been a minor project (in term of technical complexity, not business impact), and somehow was so overcomplicated that there was like 5 or 6 front-end dev working full time on useless churn, like adding more configurability to their deployment process, or changing a library with another based on the number of Github stars.

I think programming culture is immature because programmers are often unable to take a step back from the absoluteness of their work and see real life as nuance.

This is also what I think makes for great system architects and really differentiates them from “just” a programmer. The ability to reason about all the trade offs at each point and make that deal with designers+users etc in an amicable way. A good architect understands compromise and nuance whereas many software engineers often see it as a puzzle with one true solution.

So debate often becomes: there is one true way to do this. A difference in opinion is a difference in truth.

When I supervised teams, my favourite moments with junior hires was when they’d hit a problem that they couldn’t reason about without compromising something, and also when they’d invariably break something in the process because “it should work this way”.

It’s the best teaching moment. They can learn that best is relative. What may seem ideal is coloured by so many facets they don’t consider in the limited world view they’ve collected of the systems thus far.

The best are when they put out a UI based internal tool (so no designers involved). They’ll often get responses from users that they can’t figure it out but their own engineering mindset often can’t see past their logical flow and familiarity, to see to the lack of intuitiveness within a greater world view. Again, a really great teaching point about how intuitiveness is often non tangible.

Anyway all this is to say: as programmers we often think in absolutes , in binary so to speak. IMHO that’s one of the biggest issues in our community culture. It’s why we often fail to put ourselves in others shoes or fail to have discourse.

To some degree it’s immaturity of the field as a whole. I think that we accepted some pretty negative behavior as normal and many people still echo it in the way they act if they want to come across as a Smart and Successful Tech Person. We have too many shitty role models in this field still.

Yes, one hundred percent. I work in the intersection of mechanical, electrical and computer engineering and the latter is a toddler compared to older engineering fields.

I think there are several reasons for this: low barrier to entry, short cycle times, almost zero distribution cost. Compare delivering new or updated SW to designing and machining a part or making a PCB.

That's what makes computer engineering so exciting and also sometimes frustrating.

Here's my red hot take on this:

I started programming in my early teenage years, and befriended a bunch of peers, as well as older folks, that were in the same "hobbyist" group. Yes, it intersected with a lot of other "nerd" circles - but what made the programming circle a bit different from the usual nerdy groups, was how passionate and dedicated coders were.

Lots of people made it their identity to be a computer guy, hacker, software developer, etc. and a solid share of them were pretty much hermits in real life - keeping to themselves 24/7, and just communicating with others over IRC or similar.

Then when these folks entered college/workforce/etc. they already had numerous years of experience, and had tied up those formative years with their self-worth. Lots of highly opinionated experts, to put it that way.

Someone presents an alternative way to do things? Or tries to come with constructive feedback? No, that's just stupid. I've been doing this 12 hours a days since I was 10 years old, have red 100s of books on the topic, have done 100s of open source projects, of course I know the optimal way.

My conclusion was that for people like that, the topic of programming is deeply personal. If you abstain from regular social life, "normal" activities and milestones, and put all your money on becoming a rock-star hacker throughout your teens and 20s, I can see why someone is so invested in that idea.

Unfortunately, I've worked with a bunch of guys like that. Many were very competent and smart, pushing out good products - but were a nightmare to work with or manage. Too much ego and not enough soft skills.

This is basically the reply I was gonna write. I might also add that, at least for me personally, the only reason I got into programming was because I didn't have anything better to do in middle/high school. If I had a non-dysfunctional family, a girlfriend, an active social life, or a hobby (like woodworking, cars, reading books, etc) I probably would have focused on those things. But all I did day in and day out was be on the computer, and programming was basically the only productive thing you could do, so I gravitated towards that.

A lot of my programmer peers in high school had the same deal, they couldn't really do anything else other than be on the computer so they got into video games and programming.

> A field which has so many tools to objectively quantify their work

On the contrary, I think the problem is that these tools do not exist.

... and that many of the tools we use are dangerously wrong.

For instance there is the continuous thread about the difficulties hiring and being hired.

There are various snake oil practices such as stack ranking and OKRs (e.g. if you want to drop 20 atom bombs on your startup... OKRs. They are fine for monopolist pyramids that will succeed no matter how much they fail who want to create safe spaces for narcissists while heading off any threats that sensitive and intelligent people might pose to the power structures)

It is very possible for one programmer A to say "programmer B is an idiot" even when programmer B can say "I picked up a project that A was working on and going in circles on for two years and finished it in one year."

One aspect in which one can see that we are still in an immature field is seeing how "the new thing" is always valued more than the stablished one, and how language books are more recommended than works that intend to be foundational (like TAOCP or SWEBOK, disclaimer, I've read neither of them).

> how language books are more recommended than works that intend to be foundational (like TAOCP or SWEBOK, disclaimer, I've read neither of them).

I have read some of the "foundational" works, at least well enough to know roughly what's in them. But I've only had the privilege of applying TAOCP a couple of times in my career. Similarly for other techniques from calculus to dynamic programming algorithms.

99% of the time, I try to focus on the simple solution, one that fits the business needs closely. A few times a year, I encounter a situation where a small amount of cleverness (or deeper theory) has a big payoff for the business. Then I indulge myself carefully. And in those cases where cleverness is actually a win, simplicity becomes even more important.

If I had to make an analogy, programming is a bit like being a fine woodworker with a limited budget. You want to solve the problem, with quality work, at a reasonable price. Finding the right balance can be extremely satisfying, and it can help an organization achieve ambitious goals.

If you've been on a corporate earnings call or watched a presidential speech, I think you'd agree that jargon and statement-couching is the norm when you're addressing a large, potentially hostile group.

It's not necessarily a sign of immaturity, as a consequence of the audience and medium. Text is extra hard to transmit nuance with, and if you just get straight to the point any stakeholders with a side-interest will go go rabid.

You haven’t really provided any examples. You talk about Star Citizen, which is a very controversy laden community and that is mostly composed of non-programmers. It is probably the gaming community I would expect to find the most cynicism. Programming is like many things and online communities are formed of many different personalities. Programming is particularly accessible to younger people in ways other engineering fields are not, or at least as readily. There are also many different skills levels of people that participate in programming communities.

But then you talk about using obtuse terminology as a virtue signal of intelligence or something. Have you read historical, literary, or other analysis / commentary texts? Such terminology abounds in those communities, are they immature?

The Internet is just a weird place, which is just a reflection of how people are.

I believe that a big problem is that there's very little consideration of accomplishment in anonymous online forums. I'd bet that that majority of immature conversation comes teens or young adults who have very little real world software experience.

I do think we're in a weird situation where people with less experience are likely to speak more. I would engage in these online discussions more when I was a teen/YA but I find myself doing it less and less. It's just not worth the effort to try and write something thoughtful when most people won't even bother to read the whole message before replying.

I'm much more interested in hearing the opinions of people who have actually touch most parts of substantially complex software that is delivering value but I don't think that desire is compatible with most social media.

I have a person on my team that does not want to use IntelliJ (we are doing Java), instead it relies on VSCode although the company paid for IJ license. Is this a symptom of strong preferences or being immature? Probably both.

I don't want to use Windows, when I hunt for jobs I avoid jobs that do not offer mac/linux laptop. This is probably immature (or as programmers we are simply spoiled).

There is hype. Some people that for 10+ years where writing Java are jumping ships to learn Go. Go is like Java 1.6, the error handling is cumbersome. Yet all those people say the simpler language is the better. They are the same people that a few years ago were cheering for functional programming in Java and streams...

Finally we have this cult of x10 programmer, being oncall 24/7, macho work ethic (workaholism) and changing the world. Seems like kids gone wild.

I think wanting to avoid Windows or having took preferences is immature. If it is then I don’t know we what “immature” means. There are civil engineers that have tool preferences and also type-of-work preferences, are they immature?

>I don't want to use Windows, when I hunt for jobs I avoid jobs that do not offer mac/linux laptop. This is probably immature.

I don't think that is immature at all. As a professional it is perfectly reasonable to expect to have good tools. If, for what your job involves, Linux / Mac is significantly better (for you) you are right to insist on it.

If you were applying for jobs as a carpenter you'd be right to ignore any that only provided a hammer.

Avoiding jobs that use [this/that os/dx] is not immature at all, it's reasonable. What's immature is joining a [this os] shop and demand to get a machine with [that os] and start to convert the team "to the right path" with a condescending attitude.

Why do you consider it immature to have tooling preferences, in cases where your tooling choices don't affect others?

I see no reason to assume all brains will work equally well with every workflow. The important thing is what gets checked into the repository, not the sequence of keys you pressed to get there.

(I am currently that person, with vscode and emacs. I have better things to do than retrain myself out of a set of keybindings I've become very efficient with.)

I'm not a programmer, but I am an engineer with very strong opinions on, and preferences for, objects/tools I interact with. I don't think your preference for avoiding jobs that would require you to use Windows is immature. The tools we use affect our output. Especially digital tools because they're extensions of how we think.

Some folk view and use cars as A to B transportation, and some care about how wheel camber angles affect driving dynamics. Ultimately, it boils down to taste, knowledge, nuance.

> I don't want to use Windows, when I hunt for jobs I avoid jobs that do not offer mac/linux laptop. This is probably immature

I dont think the windows in itself is the issue here. To my experience, when the employer enforces the use of windows, its because you really cannot use something else to do your work because of some specific network policies which disallow you to connect to the network itself. Also the use of windows goes usually hand in hand with other stupid policies, which forbid you to do anything on your computer which is not part of the job. Sometimes it goes as far as not allowing you to change your wallpaper or restarting your computer in the middle of your work without even warning you every day. I don't blame people for choosing to work in other companies where they don't have to fight the security department when they need to install the basic tools for their job. The tooling you use should be decided on the team level, not the whole company level.

I see it more as a result of the nature of computer intermediated communications.

Most people read something and go on without commenting, it's only when they have something to make it worth the bother of a post that you'll get a response. This is why you'll see disproportional lots of nit-picking in responses here and elsewhere on the internet.

I spend a lot of time and effort in most of my posts here on HN trying to anticipate criticisms and being defensive as a result.

As far as using jargon, it helps remove ambiguity to help ease getting a point across. It's not something that people do to deliberately exclude people, for the most part, though I'm sure there are twits who do otherwise.

I would not use the word immature. I'd say incomplete, or not well rounded. But each culture and profession tends to have blind spots. Some doctors might seem callous and insensitive - so they need to work on "bedside manner". Fashion models might need to adjust their obsession with perfection and physical beauty. Etc. In each case it goes with the territory.

When it comes to hackers, and I would say most academics too, the weakness is a lack of falliblism. It's the tedious, unshakable obsession with being right about everything all the time.

The three words that would massively improve how many of us are perceived are "I don't know".

Perspective: You're observing a few major factors in play.

1. The majority of programmers/IT/Tech-workers are young (<=3 years of work experience). They don't have enough experience to know what's good (or even what matters) for their craft. (i.e. no one should care about programming language because often you don't get to pick it. Your employer does.)

2. The majority of programmers aren't in North America. They're in Europe and Asia. So there is a linguistic barrier. And this linguistic barrier will get hit because the majority of programming work is done in English. So many of these young non-north-american programmers are trying to polish off their English in these online forums. (So expect people to talk past each other or losing things in translation or flat out misreading subtext)

3. The majority of employers of young/non-senior programmers are not product companies. They're services, start-up, IT or financial companies. Services and start-up companies are sales focuses. So a programmers career path will always ultimately lead to sales to some extent. IT and Financial companies have a larger focus on infrastructure or data reporting. (i.e. majority of careers force programmers to become something else, like leaders. So there is a very real brain drain away from the craft)

---

for OP:

The simple solution to what you're observing is to stop reading online forums. Instead watch youtube conference videos, read books, and listen to podcasts. When programmers don't have anonymity, the quality and relevance of the content/discussion go up dramatically.

---

Irrelevant comment:

I think the reason for all this is because anonymity allows insecure/young programmers to test waters before asserting their ideas in the workplace. This is most likely what all the young programmers being pushed towards different careers are doing. They're looking for a magical piece of information that will force a business to align to their own career aspirations rather than changing their own goals to better align with their employer's objectives (i.e. a very uncomfortable sales-oriented self-transformation).

This sounds more like the broad problems with the internet and humanity than with programming. I’d say online programming communities are quite often more mature than <random subreddit>. All these problems you mention do exist in programming communities, even here on HN to some degree, but important to remember these problems exist everywhere, and generally speaking HN is way more civil and reasonable than lots of other forums. People also fight immaturely over car brands and clothing and political opinions and sports teams and you name it… Have you read comments on YouTube? ;)

My personal experience is that inside of tech companies, things are very different than online tech forums. There are still debates, but people’s goals and tech choices are often much more aligned, and there are good reasons not to act immature about things, because everyone knows who you are and your behavior is being noted and recorded in performance reviews.

High quality internet discussions seem to depend on moderation, forum size, and participant reputation (lack of total anonymity). While HN is medium-large, it has very good moderation, and the point system helps with reputation (also the best conversations here I’ve seen tend to happen with people who aren’t anonymous at all, but who’s real-world reputations are known and carried online.)

I think one of the reasons it tends to seem immature is there is a vast delta to what “programming” is.

On the lowest scale you have beginners who are just starting out and learning to code. They tend to be the most arrogant and those are the folks you will find commenting on subreddits like StarCitizen (and other gaming subs).

On the other side of that delta you have complex enterprise software. This stuff takes maturity because programming is just one part of it. It gets past programming and goes into architecture, best practices, culture, etc.

So what you end up with is a community where both the 16 year old who just learned Python and an enterprise SWE with 20 years experience are technically in the same field of “programming”.

I’ve worked mostly with the latter group and can report there is little to no immaturity there. These folks have been around the block, and it always ends up being a very professional environment because of it.

A big reason I feel that the delta is there besides the age and experience difference is where your pride is. If you’re just starting out your pride is in your code, your language, and you defend your choices there. Higher up the totem pole you have pride over a piece of software you delivered, and things like the language you use is just a small part. Tell that 16 year old that Python sucks for the task and they will feel slighted for you saying that. Tell that to someone working on a large software project and they will likely agree or at least hear you out, because their pride is in the entire package, the individual pieces are less important.

Twenty years ago I said yes, and compared it to the amputation era of medicine. Today I think we aren’t just immature but stunted. We are in the grips of the Trough of Disillusionment with Agile, and I blame Scrum as the primary instigator. What was supposed to free us ended up as shackles. We went from a few people talking about test suites and code reviews in 2000 to many of us doing them or at least paying lip service, but testing is still a broken discipline and code reviews miss important bugs too often, which may or may not be the same problem stated twice. And worst of all the world is more full of frameworks than ever before.

The bright spots in the 20’s I’d say are things like elixir and rust, which are bringing some more esoteric development techniques into the light. I don’t know enough about property based testing to say if that’s a way out, but it does point to the possibility that testing is actually NP-complete, which would help explain why decomposition is so damned effective. It reduces the branching factor to something we can manage by hand.

I believe that in tech we value innovations (new ideas) over well established principles. Innovation has a way of increasing value in the short term at the cost of tech debt. The issue is that the debt always come due (esp. when the market is in downturn) and then there is a reckoning which leads us to scramble for a way out of the mess. When the market is in an upturn we forget everything and start the process again.

The problem with this is our industry does not establish firm practices and licenses like in other disciplines like civil engineering, legal, medicine, etc. This causes us to focus on tech luminaries as a guiding post of how to behave in the field, which leads to chaos if the tech luminary is dishonest or unethical. We refuse to learn lessons from the past a repeat failure patterns, over and over again.

As technology starts to eat the world, the people affected won't even have the opportunity to respond with laws or regulation, because we have no insight into what the field is going to do next and no way to control what people do.

> A field which has so many tools to objectively quantify their work and the result so often are debates displaying poorly concealed biases and egos.

This felt wrong when I read it.

I agree we have many, many tools to objectively quantify aspects of our work.

Where I disagree: these tools only measure _some_ aspects. There are many aspects where we don't have good tools for measurement. Some of those aspects are for all practical purposes immeasurable.

For example: measure maintainability.

I think what happens then is the same thing that happens in politics. We take proxy metrics that _are_ measurable, and try to extrapolate over everything. The debates and egos come from arguing which proxy metrics should be weighted which way.

Then I realized I'd propose an alternative hypothesis: programming as a craft is immature.

I could never imagine civil engineers arguing over proxy metrics to the effects of natural forces on a bridge.

Can programming _become_ mature? I don't know. I'm skeptical of any claims that it can be. They all seem rooted in a gut sense of a particular weighting of what we can measure.

Software is both creative and complex. We all muddle through this field.

We've all developed our own biases based on experience and along the way we form a mental model of how "software" should be built. For example, many of us have been burned by some technology or language and we warn people away from it. This isn't a bad thing. It reflects, to an extent, contextual knowledge that isn't really going to be found in a google search or by reading the tutorial. Take it with a grain of salt. That negativity probably harbors some contextual issues that engineer ran into at some point. Noted.

As engineers we take pride in our work. No engineer likes to have his work challenged, so we all become defensive about our way of doing it. Over time, if your not careful, we can get pretty prickly about how to do something. Rather than immaturity I'd call it being resistant to new ideas. Its the old adage about "if you have a hammer...".

In my own experience, yes. Very early in my adulthood I lost interest in working in software design in any conventional capacity entirely because of the kinds of people I was surrounded by and the ludicrous beliefs that they had which led them to where they were and to do what they were doing. There are presuppositions and prejudices that almost everyone coming into this network of industries has that can take years to unlearn (it often depends on the frequency and intensity of self-criticism one can psychically-withstand). One could spend a lot of time spelling all of it out. Probably the big hurdle and one most worth addressing is whiggish attitudes about noetic and moral progress, and the general disdain and disregard for mentality of any ancience beyond that which came about during the "Enlightenment".

I have a feeling that this is just a "quality" (bug?) of people. The technology community is like other communities. Some people have a high sense of emotional intelligence and security/confidence in oneself to entertain ideas and believes they themselves don't hold. They might be able to articulate ideas that are interesting and may contradict assumed norms. Some other people may feel a spike of adrenaline and feel their egos are under attack if another doesn't share their same idea profile and may even try to impose their ideas onto others. It's just people being people, imo.

I think it's up to each of us how we want to relate to various communities of people. For me; I've accepted the chaos of people and try to spend my time wisely.

For bench-marking purposes, which professional culture would you say is "mature"? The professions I'm moderately aware of through friends and family tend to have their own problems, even those that are far older.

You've sort of answered yourself here:

> Yet in my experience, it doesn't take a lot a long time engaging with the digital-technical community at large to realize there is often a large gap between intelligence and wisdom or even basic sensibilities.

The ability to solve problems in one domain does not naturally extend to all domains (or even adjacent domains). I've seen engineers come up write technically impressively code, while concurrently a believer in "Overunity energy" - enough to buy tickets to free energy conferences.

> I am dead certain their have been numerous and highly successful workplaces which were the anti-thesis to these complaints.

Exactly. It's also a matter of choosing the right work environment. I moved from a startup with quite a few junior employees, to a more experienced team in a FAANG. One thing I noticed is that bike shedding was much more limited, and people much more pragmatic. It was quite refreshing. Maybe I'm lucky with my team dynamic, but overall I think that experienced SWEs are less likely to lose time with stupid debates and are more eager to get things done.

I think people who are heavily into technology are generally immature. Technology is one of the most powerful forces that shapes the world in BOTH good and bad ways. Yet, when you actually interact with the majority (not all) of programmers and technology creators, they have no thought about the ethical considerations of what they are doing. To me that shows a basic lack of maturity, and that they never grew out of escaping the world by playing with cool toys.

I know that might sound harsh but I really believe that to be true based on my interactions with tech people.

Given that "ethics" is being actively deployed to neuter or destroy the open source movement, I don't blame them.

Right now, AI art, and it's open source repos that make it possible, are under a sustained attack with the "ethical" banner which seeks to have this technology removed or at least closed sourced so that only Disney can use it.

If that's ethical, than sign me up to be unethical.

I don't believe that only Disney should be able to use AI art. I think it should be destroyed entirely.

What have you created personally, that give you the right to want to destroy the creations of others?

Would you ask the same if I wanted society to get rid of nuclear weapons? In my opinion, AI technology has the potential to significantly make all of society worse by disrupting it in an irrevocable way. Therefore, I think banning and destroying it is not unlike banning toxic substances and destroying stockpiles of weapons.

> I read debates about languages and see the most reasonable of authors walking on egg shells and writing caveats like they are commas lest one misstep allows a snowballing tirade of people missing the point.

I see this a lot right here on hackernews. You could say as an aside "nobody likes getting kicked in the genitals" and you'll have some folks actually-ing about it obnoxiously -- and they'll ignore the real thread of conversation. There are also folks that can't or more likely choose not to understand hyperbole. It's exhausting.

Writing for people and arguing well are separate skills to programming or most other occupations. Competence in one does not imply competence in the other. I find writing a well-formed comment/argument/response to be no easier than programming. It's extremely time consuming (for me, anyway) and this naturally flags the question: why?

Why bother spending time doing this?

Forums with gamified points/award systems encourage people to 'win points'. These systems and their goals are not aligned with humanity, healthy debates or avoiding dogmatism. They don't necessarily preclude the desired behaviour, but they certainly don't incentivise it.

By "debates about languages" do you mean comparing one programming language to another (in full or in part)? I think that sort of discussion has always been problematic -- flamebait. It's not just technology or programming or highly technical topics. It's not just the internet. See vim vs. emacs, Holden vs. Ford (cars in Australia), milk or water first (when making tea).

> authors walking on egg shells and writing caveats [...]

I think this is more common on the internet today, compared to many (maybe 15?) years ago. People weren't arguing better back then, its the eggshells that are new.

The Star Citizen reddit user presumably appeared as an expert in that forum -- who would question them? Does the same thing happen if you make a claim about the viability of some choice in the game, which other users would be likely to have some expertise in? In my experience, disagreeing with a gamer or disputing the dogma (or "meta", perhaps) surrounding a game is a very reliable method of starting a bad argument.

- Programmers are people. People have biases and egos.

- It's easy to see problems in things you know a lot about and also in things you know very little about.

- "The world divides into people who think there's two kinds of folk and those that don't." (a Custard song, title missing)

(I didn't finish writing this but the time it is taking me is actually becoming a problem. There's a few points in there and hopefully someone finds something worthwhile.)

Immature? No. Borderline Personality Disorder? Yes.

My suspicions are that well we sit at a computer a lot. That's not normal. Granted now smart phones have risen the tide of general intelligence one way to help the general populace. At least one would think - because I feel in general a lot of people have less patience than times before. Nowadays most arguments/disagreements where could be figured out by the sum of intelligence involved - since everyone is low on patience the immaturity of response/solutioning is poorer.

I have issues with mainstream dev/IT world. Too much fad and money.. makes them think too high of themselves often. I kinda miss the people working in simple manual jobs (a lot actually). They're not perfect but it's easier not to be annoyed with people who didn't have college education and have to produce "more" with less on a daily basis. Also the amount of people that have allergies toward anybody that is not ready to master the web or apps is staggering some times.

Is immaturity something entirely bad? Maturity aka the absence of play is a sign of a stagnant mind, designated to reproduce, cruise and die. Maybe we should stop decrying playfullness with immaturity aka unfinished humans as something bad.

Its also a sign of immaturity to have your value determined through eternal views and society, aka to be eternally stuck in high school, without experiencing the growth events that allow one to transcend that scenario via creativity.

Software engineering is a very new profession that is also evolving rapidly. Imagine how many centuries went by for the rules of English to get codified and accepted. And in some ways those rules are still constantly changing. These debates need to happen because through conflict and the sharing of stories the truth will emerge and determine the conventions for centuries to come.

I would say completely immature in what can achieve with the potential energy of million of brains around the world. I would say we are reinventing and complexing solutions all the time, we cannot even design a nice UX/UI just drawing it instead of talking about React, Vue, et al. Nothing against them, but it is time to cut the infinite growing software tree instead of cutting more leaves. UX/UI is just an example.

That's just how people are generally. Your bias might be to see it more in computing culture because that's where you attention is. Some communities have different rules for how they express gate-keeping or elitism, but they all have it. That's human nature. We are self-centered, greedy, and ignorant of our own ignorance. Deep down, we all know it, and that self-knowledge leads to want to hide our flaws.

You really shouldn't confuse programming culture and game subculture's since they are distinctly different.

Exactly. Go into the Minecraft subreddit, and you will see hilariously poor quality discussions on the Java programming language often. People who have read a few blog posts or youtube videos will feel obliged to present their expert opinions on anything.

Computers as an end in themselves attract neuro-atypical persons with poor social skills. That’s not necessarily a bad thing, but it needs to be accounted for.

Computing science is also quite immature, because of all the mathematical sciences it is by far the youngest. I don’t think that’s what you meant though.

I feel you. Not all the time, but def comes up more than it should.

It's the same feeling I used to get when playing MTG against Timmys/Spikes at local card shops. They're no fun to play with, have a good time, or to learn from. They're smug, douchey, and a turn off.

> it seems people cannot resist using obtuse language to virtue signal their intelligence relative to other people.

Its the same in every field, knowing the latest and greatest ten dollar words let's people know you are ingroup.

The most important aspect of this is this one: programmers can't form a guild, unionize or participate in any kind of collective action on their behalf when

* Some people think "Microsoft rules, and Linux sux" and other people think the opposite

* People talk about project management the way that they talk about agile (I'd say that agile proponents and detractors are equally bad... It's the style of the discourse that is the problem.)

* There is a general lack of respect for all of the skills that it takes to make software: for instance all of the trash frameworks (e.g. Microsoft's failed MVC for .NET) written by systems programmers who think they are better than applications programmers but have no idea of how to structure an application systematically.

I am not sure what do you mean by "failed MVC for .NET". I spend a few years writing web apps in MVC. It is basically a way to expose some code as HTTP endpoint. Nothing less and nothing more, there is auth stuff that mostly works out of the box, if you are doing integration with Active Directory it gets extra easy to setup the auth. The last time I had a chance to work with it they added async (although it was not foolproof, it mostly worked).

API layer is just a thin layer that either calls some other code (layered architecture) or is delegated to the "outskirts" of application (ports and adapters architecture). There should be no references to framework code in the application "domain" (DDD) code. By using alternative (beatter) IoC container you can get rid of any dependency on microsoft libraries.

Now I write in Java/Spring but the attitude that I use is the same. No framework code mixed with domain code. Sometimes it means I need to write stupid adapters that e.g. use spring @Scheduled but it allows me to switch to another framework without much work. For some people this will be over engineering, for others this would be good architecture.

I don’t think it is about leftist collectivist actions. What? Is that serious? Are medical doctors immature? Most engineers of any kind are not in unions, is electrical engineering immature? I don’t get this take.

Also, some might say the jab at ASP.NET MVC is an example of what OP is talking about.

If you were to replace programming/computing with any other field (professional or otherwise) would be any different? I doubt it.

All of human culture is immature. We still think bombing each other out of existence is a valid way to resolve our differences.

You went on reddit and read a post critical of the subreddit's topic, and expected some kind of nuanced discussion on it?

it's almost like programming culture is intentionally immature because it keeps people focusing on things like which programming language they should be using instead of asking whether or not they should be surveilling their users.

That is another case of dunning-kruger effect for sure. A Twitter clone can be written under an hour with cost of a meal and you can feel like you are above all. Lack of enough engineers might also be the actual reason but it seems like improving past 20 years.

it seems ppl become more ignorant and less into the craft … will render the field in ruin …

America, the plutocracy.

It's not just online, even in person, programmers display low maturity when it comes to arguments over tech. This used to be less of a thing many years ago, but is more common nowadays.

Some reasons:

- The field skews young. Like it or not, younger people are more obnoxious and doctrinaire than people with more experience.

- It used to be that the field attracted people who loved technology for its own sake and loved creating things (there was not much social cachet or recognition). But now it increasingly attracts people who are much more competitive and feel the need to project confidence to the point of being arrogant (any field that throws off large amounts of money eventually attracts these types). They are drawn to the money, recognition or a religious zeal to 'change the world'.

- Technical decisions such as libraries/languages/frameworks to pick are often the only avenues for self-expression and autonomy that are left in modern companies. Product Managers are often non-technical (still!) and tend to infantilize programmers. Programmers, despite making more money than other functions and providing obvious value and leverage, still have much lower standing in companies.

- Religion has disappeared from most people's lives, and for many, the religious fervor is replaced by fervor of a different kind. This is also why SJWs have proliferated everywhere. People need to believe and act on their beliefs.

Add to this if you do not use the Latest Language or framework de jour you are by default wrong.

Reply on news.ycombinator.com