Contempt Culture (2015)
blog.aurynn.com
blog.aurynn.com
There is a lot of bad technology being pushed via social hacks - examples include PHP, MongoDB, NodeJS and Go. Typically the social hacks are low learning curve + easy tutorials that gloss over important details [1] + rapid setup + culture of piling on tech debt (e.g. rails ignoring how relational DBs work).
Technical superiority, particularly if that superiority requires people to learn new things, has demonstrated an inability to gain traction.
So if we want superior technologies to win, we'll need to engage in some social hacks of our own. Vocal and demonstrable elitism is a valid social hack - if the people who are demonstrably great coders are proponents of Haskell and sneering at PHP, while the code monkeys are all using PHP, that's a pretty clear social signal. Who wants to be part of the code monkey crowd?
When I was younger, and nothing but a BasicA/Visual Basic coder, these attitudes pushed me towards learning C and Perl (yes I'm showing my age). I saw all the better coders using these superior technologies with a higher learning curve. I realized that I had a lot to learn, I put in the effort and I learned it. With the decline of hacker culture, I don't see that happening anywhere near as much these days.
[1] E.g. a while back there were RoR tutorials that used update_attributes (skipping input validation) to show how easy RoR is. Net result was various hacks, I think including Homakov's hack of github.
People publish blog posts about how they aren't using MongoDB or aren't using PHP anymore because X and Y and do you know who cares? Pretty much no one aside from the pro PHP people who get mad or the anti-mongo people who point to it as justification for their part in a completely pointless argument.
Yes, low skill and approachable languages attract amateur coders because that's what they're supposed to do. PHP was designed from the get go to be an accessible web server language that anybody could use, that was the POINT so naturally anybody who can will use it.
I've seen brilliant PHP websites and I've seen utterly garbage C code, and both of those reversed too. There is a correlation between use of high level languages and skill but it is far from a fixed relationship, so to parade about someone's use of those to justify their arrogance as a programmer relative to people who are WELL AWARE that they are better than them just makes that person look like a windbag.
/rant
They care about bugs, vulnerabilities, and third-party quality issues - all of which a bad language/framework will help you to have.
Human beings are the original proof engines, so I'm sure that a great programmer could perform amazing type checking in any language. I'm sure they could also architect their way around Java's weak points with Abstract Factory Patterns, xor hand-tune their code for the JVM JIT to be only 1.9x slower than a naive C implementation (See: what they had to do for Minecraft).
But, why?
It's easier to learn the syntax for a good compiler than it is to implement one in your head...
I don't see the raspberry pi people being derided and mocked by Intel's engineers because they use such lowly plebian tools.
Its interesting that this point comes up in a world containing useful google results for "try ruby" "try clojure" "try haskell" "try-python" "try scheme" but there are no useful google results for "try cobol" "try java" "try php" or "try visual basic".
We can play a similar game with Koan style learning with very similar results.
I agree that PHP was designed to be a bad language but easy for noobs. That's the point. By having a low learning curve it has displaced vastly better choices. And that's why I'm suggesting we need to fight social hacks with other social hacks.
I think we see this narrative a lot with Haskell. Although the Haskell community is reportedly very friendly once you actually try to work with Haskell, I've seen a lot of comments by its enthusiasts denigrating "lesser" languages.
So I agree with the OP. There's not a lot to be gained by telling people they're stupid. By and large this just causes them to entrench their positions. (See also: electoral politics.) I think there's much more ground to be gained by deliberately blurring the lines (a different social hack.) Examples of this include Cygwin and optional type systems for dynamic languages.
As an example within tech, sneering and contempt have enabled social justice to spread wildly. Look at how many projects/conferences have codes of conduct now, compared to a few years ago, and at how many technology companies are throwing money at diversity efforts.
I don't know if it's the right strategy, but it's definitively not a strategy I can immediately dismiss.
The problem is that this doesn't mean every option is equally good for the end user. A lot of software that gets belittled is criticized for being a good way to provide a bad product. These are tools that are great for getting things done quickly and smoothly, in return for kicking the can down the road on reliability, security, or modifiability.
Think of the small insurance companies which offer easy signup at low rates - and then don't come through when you file a claim. When people go out and produce lengthy essays on why Mongo is dangerous, it's often a response to seeing systems that work for now, but are likely to fall over completely sometime after the contract is done. When your database offers high throughput by not actually checking for successful writes, it's easy to hand over a performant system that's going to lose a bunch of medical records the first time a server fails.
So no, the client doesn't know or care, but all too often that's because they're getting immediate benefit in return for delayed, probabilistic risk, and no one is telling them about the tradeoff.
None of that is justification for being a jerk, or mocking actual people (obviously!) Nor is it a reason to pretend that Mongo is never a good database choice, or that PHP is never a good language choice. And you're right about the grossness of mocking beginning programmers for starting with approachable tools.
But I object to the idea that the value of debates should be measured by whether users care about them. I'm not much interested in what my bridges are made of, but that's because I have faith that someone behind the scenes built them reliably. All too often, that's not the case in software.
Could a language be "better" simply by being harder to learn?
<? print("hello world")
main = print "hello world"
With apache configured to run the program as a CGI script? Still the same thing.
That's not a great way to run Haskell on the web, but it's not too far from what's going on with historically common out-of-the-box PHP setups (and I understand that modern PHP setups take a little more code).
But, no matter how complex the language is, it doesn't, unless "hello world" becomes incredibly platform, context, and (e.g.) day-of-the-motnh-on-which-it-is-compiled sensitive.
Because, otherwise, it may take the first person some competence to "hello world", but everyone else can get by with copypasta and memorization.
https://www.rosettacode.org/wiki/FizzBuzz/Java
vs fizzbuzz Enterprise java
https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpris...
Enterprise style java is not inherently bad, anyway. Its ideal for padding hours of government cost plus contracts, or megacorporation initiatives that'll be scrapped before deployment anyway.
There is a competing force though: if a language is flat out difficult to use, then much of the programmer's ability will be spent getting the damned thing to work.
Passing the ACID3 test suite with a browser written by hand entirely in Brainfuck is a clear indication of a highly skilled programmer. That doesn't mean you should build a business on Brainfuck though :)
I've mostly heard good things about Go, except for lack of generics and the use of github repos in "import" statements.
Are those the reasons you think it's bad, are there more serious ones? Is Go actually "bad", or does it just bring little to the table? I understand Go's meant to be a middle-ground between Python (dynamic, memory-safe, slow) and C (static, unsafe, fast); do you consider it a step forward in that regard? If a bug-free, non-obfuscating source-to-source translator between two languages appeared overnight, would you prefer those languages to be Python -> Go, Go -> Python, C -> Go or Go -> C?
If you want a middle ground between Python, there are already great options that provide everything Go does and more, for example Java, Scala, Common Lisp, Haskell and Rust. Lisp is a bit closer to the dynamic/slow side, Haskell/Java/Scala are more or less Pareto superior to Go, and Rust is a little closer to the static/fast/unsafe side.
But unlike Go, Haskell/Scala/Java expect you to learn a few things before you can be really productive in them.
(I completely agree with your original point. "Worse is better" is not meant to be an equivalence)
This is a nitpick for sure, but Lisp via SBCL is hardly on the "slow side." This isn't 1970 anymore. Perhaps this is evident of "contempt culture" and how we propagate memes of fast vs. slow, types are good vs. types are restricting, and other non-specific comparisons.
The justification for Go is basically "developers are stupid and don't know what they are doing,so we're going to tell them what to do, how to do it and not trust them in any ways". Which is bullshit of course, it's just that Go compiler is bare-bone and so is its type system.
Go is bait+switch . It has just enough features to make it easy to learn/deploy, its standard library has just enough things to get one started quickly when it comes to writing servers.
But as soon as one tries to write something a bit complicated its short comings become obvious and tedious. Some see it as a blessing, some see it as an insult to software development. There is a bit of bad faith in both camps but Go authors have masterfully been able to escape any criticism with dubious arguments.
Imagine Java maintainers refusing to add closures to the language and the Java community would be justifying it by saying "closures are too complicated, slow and a bad practice".
Does it make Go a bad tech ? no, but it sure has a weird community. But Go has great ideas, it's just has horrible ones too. Fortunately, as the language becomes more popular, it will be more exposed to criticism. Which hopefully will lead to a better Go in the future, whether it comes from Google or not.
It's one of the few languages I've seen where a programmer can progress from novice to master in a couple of months because its features are few and its opinions strong. It's easy and fun to learn (it might make an excellent CS 101 language, actually), but spend enough time with it and you will grow to dislike it.
That said, I do occasionally use it when I need to whip up a quick command line utility to do something simple :)
'Superior technology', when talking about a language, is entirely subjective and based on your opinion of why it is superior.
I've seen some amazingly elegant code in all of those things you've dismissed. Facebook is written in PHP, and I'm willing to bet you use an application or two that runs nicely on Node or Go. so what social signals are you talking about?
No it's not.
That said, I do not see how anyone could not consider Python superior technology to PHP, C superior technology to BCPL and Pascal superior technology to punch cards.
I do agree with that. I can think of various languages over ColdFusion as an example. Python versus PHP is not so clear cut if you look at the modern versions.
Anyway, I do think we should be more welcoming to those that use other languages though as the article recommends. It's possible to make a LOT of money these days doing simple CRUD apps. It's a great time to be a developer. We're all very blessed. So shouting about how one language is superior to another is meaningless to a lot of people. Even if you're right, people will feel like you're telling them they wasted their time with the others language(s). And that approach won't convert them if that's your goal.
Many of us also partake in business decisions so even if you think Python is technologically superior to PHP as an example, it won't make sense for many projects. Depending on your client base and/or your in-house skill-set - it may rarely make sense.
After you factor in things like total cost of ownership, what a client's current tech team is capable in, hosting costs, etc, technologically superior can be meaningless in many situations.
Enterprise systems are usually technologically superior and clients often only need or use 25% or less of the capabilities. Most of us could care less about enterprise systems.
For social reasons, not technical ones. PHP is the language of cheap labour. To address the technical issues, Facebook's PHP code gets thoroughly translated in their backend.
Nice straw man argument. Pointing out that PHP is used for social/economic reasons is exactly saying that there are considerations outside technical merit.
At the same time, Facebook is a big Haskell user, but that is because of its technical merits. (Simon Marlow works for Facebook) On a back-end technology such as a compiler, the technical merits of the language are much more important than the social merits of finding enough low-skilled/low-paid developers.
Or so I've heard
Sure, but the sneering is totally unnecessary. Being great, and being vocal, and being critical – those are the things that get the job done in a constructive way. Why do we also need to cop an attitude that is unpleasant, socially undesirable more broadly, and aggressive towards people who could end up being valuable members of our preferred tribe?
Explaining the advantages and disadvantages of different approaches without falling back on derision takes a lot of effort -especially given that there will never be an end to newbies who haven't heard a good explanation. But, it's necessary to avoid teaching that tech should be evaluated by comparing the insults of the competing communities.
A more experienced developer knows that there are only superior decisions; choosing the appropriate technology for the time and circumstances.
But not one that gets you where you're trying to go. It makes people regard you as an arrogant jerk, and therefore not listen to you. For your claimed purpose, that's counterproductive.
I suppose one way to jump start things would be for some forward thinking company that wants to have a solid tech culture should proactively hire elitists.
Second: If you're the first individual to follow this practice, it's not harmful to you (other than turning you into a snob who acts like a jerk). It's harmful to what you're trying to achieve. It makes it take longer to get to the point where you have people using languages you regard as superior, because they avoid talking to you. "Pompous jerk alert; run away! Don't get any of that on you!" That doesn't make it easier to persuade people that the languages you advocate are good on their merits.
Instead, show people why the languages you like are better. Actually listen when they disagree; they may have more of a point than you know.
I think we may disagree on this, but my position is that such bugs are an unavoidable consequence of too many friendly abstraction layers.
If you really want to influence someone's behavior, engage them, ask them honest questions, accept them. If you do not want to influence their behavior, leave them alone. Do not drag your own heart through mockery and judgment and scorn because it was done to you, or because others will find it funny. Those marks on your heart will be visible to all, and truly, you will feel them in your dark hours.
"When you realize where you come from,
you naturally become tolerant,
disinterested, amused,
kindhearted as a grandmother,
dignified as a king.
Immersed in the wonder of the Tao,
you can deal with whatever life brings you,
and when death comes, you are ready."
The supreme good is like water,
which nourishes all things without trying to.
It is content with the low places that people disdain.
Thus it is like the Tao.I have INFINITE contempt for professional programmers who (1) use PHP (2) have never used anything else and (3) vociferously defend PHP because it "gets things done" but then (4) leak MD5 hashes of credit card info in an error page.
Why wouldn't I be contemptuous of fraudsters?
I have no interest going around belittling people for choices that work for them, but this implicit idea that technological decisions are all a matter of taste and nobody can criticize them is dumb to me.
On the other hand, the people wielding those languages do not deserve any hate, shame, nor prejudice. Attacking people for using a language is like attacking people for any other opinion that they might harbor; it is bigotry. There is no reason to be a bigot when it comes to languages; it should suffice merely to hold the opinion, to have the opinion be well-reasoned, and to always be conscientious of how we treat the people around us.
(I cannot believe that I had to write the previous paragraph, but HN's inability to hold this discussion in a calm and rational way in the past has made it clear that I must directly tell you all to not be bigots. Disappointing.)
It is a recurring pattern that discussions about these low-quality languages turn into us-vs.-them discussions, where one side harbors people who espouse the opinion that the language in question is low-quality, and the other side consists of people who use the language in question on a daily basis. The first side needs to avoid attacking and hurting people on the other side. It is unhelpful and derails the conversation. In particular, trying to communicate an idea of the form, "You need to be aware of the language's failings and flaws, and understand that not all other languages have these problems," is subtle and cannot be done while simultaneously flinging insults.
On the other side, we all must realize that our favorite languages are terrible. Our languages, like almost all facets of computing in this era, are primitive. We have only a few fundamental rules which guide our knowledge of computing, but otherwise we are usually walking blind, exploring and feeling our way through a field which is still largely unlit. When we discuss the failings of a particular language, we are trying to build up our understanding of which linguistic features do not work, and which features should be avoided.
In summary, we should kill PHP and JS, but we should have empathy for those who use these languages, and we should make sure that we learn from the mistakes which these languages embody as we step forward.
You said it yourself, sometimes you need things to be done faster, but most of the time systems should be robust. Python is an excellent companion to Java. Python is one of the most versatile language out there while Java is one of the most robust.
If we take a criticism of a technology we use as criticism of us, it's a rather unhealthy state to be in. Technologies come and go. They aren't something we should immerse our identity in.
Not being able to switch tools for different tasks is a source of frustration, and this frustration WILL find a vent :-)