Also, please don't fulminate in HN comments.
How can you expect people to follow these rules when you yourself don't? Looking at your history, you[0] leave[1] comments[2] like[3] this[4] (shallow dismissals at best, and snark at worse) pretty[5] consistently[6]. What gives?
[0] https://news.ycombinator.com/item?id=32808611
[1] https://news.ycombinator.com/item?id=32807734
[2] https://news.ycombinator.com/item?id=32803087
[3] https://news.ycombinator.com/item?id=32799206
[4] https://news.ycombinator.com/item?id=32798437
For example, in this comment here that I’m replying to, you caveat what you say, and yet you don’t caveat any of the comments I’ve cited as ”your opinion”, despite them being the same value judgements of someone else’s writing.
“Please stop <value judgement of comment>.” Is about as textbook of a “shallow dismissal” as one could get.
You don’t apply the same rules to yourself, so there’s zero reason or incentive to follow those rules for the rest of us.
Edit: Hey, within an hour of writing this comment, I'm now slowbanned (a thing you at one point claimed was removed from HN). So I guess you don't like dissent either, dang?
Edit2: Since I can't respond (you muted me), the community doesn't evaluate your activity objectively; you're worshipped, and aren't give feedback that represents a reflection of your actual behavior, so an appeal to the masses here isn't an effective argument. The community may disagree with you, but it's actively detrimental to say so, and will apparently create negative repercussions for the folks who do speak out, creating a "chilling effect", preventing you from getting the "bloodbath" you apparently think would be necessary for you to change your behavior.
Additionally, the fact that you've made it harder for me to interact on HN as a result of this conversation is an indication that everything I'm suggesting here is even more true than I initially thought.
Slowbanning and rate limiting are two different things. Your account is rate limited. That's standard practice in a number of cases, including (a) when an account is posting too many low-quality comments too quickly and/or getting involved in flamewars, and/or (b) there's reason to believe that an account is the latest incarnation of a user whom we've banned several times in the past. The bar for moderation penalties is a lot lower when we seem to be dealing with a serial abuser.
Edit: I deleted an earlier response to you because I didn't have time to finish it (I wanted to respond to the bit about 'slowbanning'). If I had seen that you'd already responded to it in your parent comment, I wouldn't have deleted it. The original text was:
We've already established that you interpret those comments very differently than I do. The question then would be: is there any way to
I post that sort of moderation comment all the time—tens of thousands of them by now. If the community agreed with you, we'd never hear the end of it; in fact, it would be a bloodbath. So I don't think the community agrees with you.
This is simply not true; you act like you're the only person who's been around here for 15 years. There is simply no mechanism to organize any kind of meaningful pushback. Additionally, by virtue of the fact that you already dismiss the people (like me, with your declarative statements about the nature of my comments) who give you this pushback, it's not clear you'd even notice. Just looking at your history I can see a number of folks who fundamentally disagree with how you give feedback, but I guess to you that's not "valid" pushback?
I only feel safe to give you this pushback in the first place because I know your moderation efforts are ineffective to how I prefer to use HN. Otherwise I'd be afraid of getting actioned against, as you aren't a rational actor when it comes to taking actions against users on HN.
Further, you have this habit of making declarative refutory statements such as these without justification or elaboration. That's pretty much the exact definition of "shallow dismissal".
For example, a "serial abuser" might actually just be someone you disagree with who you then take action against as part of that disagreement, but the way you operate is clearly without that possibility in mind.
Edit: What[0] would[1] you[2] call[3] these[4] comments[5], if[6] not[7] pushback[8][9]? Or do these not count because you dislike these users? I'm quite sure, in your mind, you've dismissed these complaints as invalid, and I think that's an error.
Also no, none of these are me. Also also not for nothing but 'tptacek seems to spend an inordinate amount of time defending your work in the form of replies to complaints, and I personally think that's a massive waste of his time, but c'est la vie...
[0] https://news.ycombinator.com/item?id=32857054
[1] https://news.ycombinator.com/item?id=32831746
[2] https://news.ycombinator.com/item?id=32801256
[3] https://news.ycombinator.com/item?id=32782368
[4] https://news.ycombinator.com/item?id=32777165
[5] https://news.ycombinator.com/item?id=32777628
[6] https://news.ycombinator.com/item?id=32780934
[7] https://news.ycombinator.com/item?id=32773572
I'm not talking about resentful responses from individual users—those are inevitable, if only because misunderstandings are inevitable on the internet, and they don't (necessarily) indicate community discontent. On the contrary, by and large the community downvotes and flags those comments. It's the admins who usually come along and unkill them later.
I'm sure it must be very annoying to be around here for 15 years only to see some random asshole get anointed the big boss of the place and start banning people left and right. But I'm a bit more interested in what people (including you) think I'm doing wrong than you seem to assume.
You’re hiding your behavior behind the mob mentality that punishes dissent, claiming that a shallow dismissal response is valid because the HN mob has attacked with downvotes, so violating your own policies is acceptable.
The fact that I was able to find so many examples in just the past week should concern you. It won’t, because it’s clear you don’t “count” those issues as legitimate, but it should and you should.
“I’m interested in what people think I’m doing wrong.” doesn’t mean you’re interested in improving, however. There are easy, concrete steps you could take; simple rewordings, a policy change or two, that would vastly improve how you interact with the “fringe” of HN.
The author did hit on the truth, no matter how he arrived there. Descriptive names are prone to collision, misdirection, and are much too long unless you use acronyms (in which case you may as well come up with a whimsical, pronounceable, unique name and just backronym it). This isn't a new idea. Lots of greybeards know this and name stuff accordingly.
But in OTHER contexts, your software components might be more like organs. If the heart has also become responsible for digestion, then it indicates your system design needs to be revisited. In lots of software projects, this is not an untenable proposition, such as it presumably is in a web service company.
As somebody who works in one of those other contexts, it's important to me that the web service monoculture be correctly contextualized. Otherwise you have people cargo culting it in situations where the wisdom no longer applies. That's probably why I'm being so bitter. :(
If a name is going to last a long time, and face a lot of different people, and have lots of relationships and sub-names of its own (e.g. "github"), then it's far better that it be short, unique, and memorable than that it be descriptive. There's nothing web-development-specific about that. Big projects get Name-names, like companies or people. Always have.
"Software component" has the connotation, to me at least, of being an inward-facing _piece_ of one of these products. It is but one component of a system, and thus it is to be understood by its function within that system.
I think in many domains, the best advice is to name those components helpfully, and to think about the component's role in the system. To start adding functionality to the component outside the scope of its name is to invalidate your design. There is no reason to bloat this component. You'd rather create a new component to handle the previously overlooked role in the system. This is made obvious when you take limiting cases, like designing a moon lander. Here, the software design must be purposeful and optimized, and it only needs to work once. In the opposite case, the component is a web microservice - a living thing managed by a 1-pizza team that always needs to be turned on. Uptime and speed of implementation are at a premium, and creative ways to add new functionality on existing systems are seen as a net good. Here, the article's advice might be good.
You've stumbled on yet another situation where you should give something a cute name instead of a descriptive name: If there will be many implementations of the same thing over time. Each generation of Intel processor, each sort algorithm (TimSort, thanks Tim), each rocket, each mid-sized sedan.
Now, do the individual software components within a moon lander get names? That depends! Are they re-used between landers? Are there many different implementations of the same component to choose from for each mission? The more affirmative the answers to these questions, the more likely it is the component will have/should have an actual name, instead of just being, say, "allocator.c".
There are just so many reasons you might want something to have an actual name. Competing implementations or historical implementations, userbase size, project longevity, researchability. And they're all subject to change in the future (and renaming sucks). I have a hard time faulting anybody for giving their little binary data format a name like "parquet", even if it's tiny and only used in one place by one other thing and might never have any users. Because it might end up used for a long time, or by many people, or in a period of competition with another implementation of the same thing. If any of those things comes true, you're going to be glad you didn't name it "Hierarchical Data Format".
And yeah, all of them start at zero lines of code and zero users. Naming things sucks, but renaming things sucks worse.
Often times when people get creative with names, the meaning dies with them. When they leave the company so too does the reasoning behind the name.
The author conflates service bloat with bad names. Fix the bloat and the name will make sense. If you have an app called “Authorizer” and it does email, you failed. If you have a service called “InfraValidator” all it should be doing is validation. If it’s not (such as tensor flow’s infra validator) then the service/app/codebase is misleading and needs to be renamed after what it does.
I also hate to see overly descriptive names. Package/crate/bundle/module should help classify the name of the class/object/func_collection.
Names like “EnvironmentPostProcessor” (Spring Boot) is succinct enough to know exactly what it does. It processes environment vars after a stage.
But many software projects are. not. that. That's really all I'm getting at. This web service developer bubble annoys me because they never feel any onus to introduce themselves in their blogposts and caveat their opinionated recommendations with the context they're coming from. In my world of robotics, just making a random family of services with non-descript names is a bad idea. The services in the system should have roles, and if the temptation arises to add functionality beyond that role, it probably means you need to step back and do some thinking about why that happened.
Also: I know you were just making a rhetorical point, but notice that your example is still clearly some web service that we're assumed to be running :)
I'm gonna close the Internet for today because you, sir, just won it
It’s up to principal/staff engineers to make sure that the components of the system stay lean to its purpose. They should be able to say “oh, we need to send an email when this happens? Here’s an email service we can use” that doesn’t introduce feature creep into AuthTokenValidator.
I get what you’re saying but these little shortcuts (adding email sending in AuthTokenValidator) cause enormous tech debt later on when you scale.
That's fine though. Anything you work on will inevitably develop a personality in your mind beyond what the name literally means, so what's the difference if the name is something like GAS (generic-acronym-service) or Fuel (GAS > gasoline > fuel).
A persuasive dev at my last job tried to insist on non-acronym names for every new service, and 5 years on, I can still remember every proper name, but none of the acronyms. That, to me, is sign of a good name.
I'd assume everyone here could at least agree that naming is hard. I don't think the article was attempting to explain how to name, but instead point out one potential pitfall when naming.
The author actually does discuss the nuance. They argue exactly your point saying that their “considered harmful” advice only applies in situations where the scope of the component is ambiguous/fluid/unknown/otherwise prone to change over time/etc. In cases where you have a mature fixed design, choose an appropriately descriptive name.
I’m glad you have only ever worked on projects that were perfectly designed up front. Sounds like the dream. For the rest of us, we engineer in reality. And I find the author’s point apropos.
Or, it could be that you're actually innovating and requirements are changing faster than you write code.
A late change in requirements is a competitive advantage.
There definitely are systems where BDUF is a valid approach. But at the same time there are systems where making mistakes is the best way to learn. Emergent design is a thing.
This strikes me as a false dichotomy. The choices aren't limited to "BDUF" OR "NDUF" (No Design Up Front). There's a continuum along which the amount of up-front design that is required can range. I prefer the term SDUF (Sufficient Design Up Front). And of course we all have to keep in mind that design and architecture aren't things that only happen "up front". Design and architecture work-streams should continue throughout the lifecycle of the project, IMO. The relative weighting of the different work-streams can vary, but the key is that it doesn't just end after the first (iteration|sprint|phase|whatever-you-call-it).
FWIW most of our deadlines are reasonable.
And if you just happen to change it eventually, it's best for everybody if you go and make it a different project with a different name. Descriptive or not.
Sure constantly changing in the complete opposite direction is probably a sign of something wrong, but changes are inevitable and we can’t expect to reinvent the wheel or start a new project as you say when you can potentially reuse what you already have.
So you keep the old product, and make a new one for solving the new problem. (You can even sell them on the same package.)
The alternative will have almost all of your customers badmouthing you because they brought your product, and you pulled the functionality out of their feet.
The one important thing is that if you decide you must solve some completely different problem, you should do it with a completely different product.
So the argument that a nondescriptive name allows you the freedom to change the product is bad. You never have the freedom to change the product.
Have you heard of brainstorming? The worst thing you could do is to ban mistakes.
Innovation is doing something that hasn't been done before. Inevitably that leads to mistakes.
Being sloppy also leads to mistakes.
Presence of mistakes doesn't tell you much. But lack of them tells a lot.
If all your experiments are successful, it doesn't mean you're a genius. It means you're experimenting too slow.
In spite of that, when did "making a database product" count as not "hard?" Building a database isn't "real software engineering™?" Since when was building "authorization microservices" easy? In the simplest case, sure. But authorization in general is a huge problem space and I don't understand calling that "bs." Active Directory would like a word...
A web service. Not a moon rocket, or an MRI machine, or high frequency trading software, or computation fluid dynamics simulations, or a compiler, or a video processing pipeline, or a word processor, or a 3D game engine.
So, just saying: When bloggers consider the headline "Software component names should be whimsical", I wish they'd spend a second to ask themselves whether their advice actually applies to any of the niche domains I mentioned, or if it's just a best practice for their fellow web service developers. Presently, there's a cultural trend that you don't have to bother with that step, and you can just write as if your audience is always the other web service people in the valley. To me, that gets very grating, and that's where the snark comes from.
However, consider whether your original post made that critique clear, or if it got lost amidst the other ... stuff. The first two lines, in particular, will immediately put some readers (myself included) on the defensive. Describing somebody's work as "some web service bs" is a bad start. And if your point had nothing to do with the "hardness" of the problems, only that those particular problems are most relevant to building web services, why not just say that? Instead of the "...somebody who works on some web service bs assumes that that's as hard as the world gets," bit.
So true. Web services are just a distraction from real software, which is writing compilers.
If all of your software components are constantly changing their scope, it indicates you are doing a bad job of producing an up-front system design. If your experience causes you to scoff at the concept of producing a design up-front, or drawing diagrams of how your system works, then this indicates one of two things about your background.
1. You're a relatively junior engineer who has gotten used to thinking about productivity as slamming code that tweaks existing systems into new incremental features
2. You work on some fucking web service.
Either way, your advice does not apply to the software engineering profession as a whole. Believe it or not, lots and lots of people write software, and not all of it is a web service or some tool / framework to help run your web service. There are many things out there are that can be envisioned, designed in detail, and implemented. And, crucially, in those cases, _it is wise to do so_.
I know I'm being overly dramatic, but it consistently enrages me reading blog posts that, through ignorance or deliberate omission, speak as if the world of software is just writing web services.