Pedantry – how much is too much?

I’m a pedant, there’s no doubt about it. I’m particularly pedantic when it comes to terminology in computing discussions – at least where I see value in being precise about what is meant. So, when discussing static constructors in a mailing list thread recently, I’ve been very carefully distinguishing between a static constructor (which is a C# term) and a type initializer (which is a CLI term). This hasn’t been met terribly favourably by those who wish to use the term “static constructor” to mean both the .cctor member in a (compiled) type and the C# static constructor, despite them being slightly different in semantics and belonging to different domains. Now, I don’t wish to spill that discussion over onto my blog, but it has made me think about the general issue of pedantry when it comes to terminology.

Pedantry is rarely popular, but I believe it does bring value to a discussion, especially when some subtleties are involved. I generally assume a specification to be the authoritative source of information on terms related to the topic covered by the specification, as it’s a piece of common ground on which to base discussions. (The exception to this is if the spec is generally agreed to be incorrect in a particular regard.) If I talk about something being a variable and you understand “variable” in a completely different way to me, it’s a potential source of great confusion. I’m not pedantic to gain a feeling of superiority – I’m pedantic to try to make sure everyone’s effectively speaking the same language.

Of course, you don’t need to be absolutely precise all the time. If I were discussing an ASP.NET problem, for instance, I probably wouldn’t feel too bad about a sentence such as “x is now a string of length 5”. However, if I were discussing variables, reference types etc, I’d probably try to be more precise: “The value of x is now a reference to a string of length 5.” Writing (or reading) the second style for prolonged periods gets quite tedious, but I believe it’s important to be able to move into that mode when the need arises.

So, the question is: am I the only one who feels this way? I would expect most of the readers of this blog to be people who’ve read either my newsgroup posts, mailing list posts, or C# articles, so you probably have a fair idea of what I’m like. Do I go over the top, or do you find it useful? Is there a way of bringing precision to a discussion without irritating people (as I tend to, unfortunately)? Just to possibly remind you of things I’m often pedantic about, here’s a brief list of “pet peeves” which tend to involve people cutting fast and loose with terminology:

  • Value types “always being on the stack”
  • “Objects are passed by reference by default”
  • “C# supports two floating-point types: float and double.” (That one’s in the C# spec, unfortunately – decimal is also a floating point type.)
  • “I’m having trouble with ASCII characters above 127…” (along with its side-kick “I’m using extended ASCII”)
  • Volatility and atomicity being mixed up

15 thoughts on “Pedantry – how much is too much?”

  1. I agree that being precise is better, even if it hurts someone’s feelings. The root cause for frustration and anger during discussions is almost always misunderstandings, mainly caused by different definitions of terms used by the discussion participants.

    To nittpick ;) ->
    “C# supports two floating-point types: float and double.” (That one’s in the C# spec, unfortunately – decimal is also a floating point type.)”
    That’s not true. It should be: C# supports 2 types of fractional types: IEEE standard based (float/double) and BCD based (decimal). At least, it’s my understanding dat decimal in .NET isn’t IEEE formatted internally but is stored as a BCD-style number with a position marker for the ‘dot’.

    This difference is important: with IEEE standard based floating point variables, you can get fractional differences even though you execute a precise operation. The common example for that is that after an operation you test for 0.0f and it not always hits when you expect it to hit. A decimal doesn’t suffer from that.


  2. (Continuing the floating point discussion, because it’s interesting. I did note the first paragraph – thanks :)

    I didn’t say it was an IEEE standard based floating point type, but it certainly is a floating point type according to reasonable definitions I’ve seen, eg:

    Heck, even MSDN *now* calls it a floating point type :) (They called it a fixed point type before).

    The Decimal structure consists of a mantissa and an exponent, and the value represents mantissa*(10^exponent). Isn’t that the whole basis of floating point arithmetic (where the base itself happens to be 10 in this case)? Would you accept that “floating point” doesn’t in itself imply that the point is a binary point? If so, what would need to be different about the decimal type in order for you to count it as a floating point type?

    Whether it’s a “BCD style” number depends on exactly what you mean by that. I’d understood BCD to be a form where each byte represented two digits, one per nybble. However, I suspect it means different things to different people.

    Not sure what you mean by the “fractional differences” part though. Could you give an example? Decimal can certainly give unexpected results if you expect it to be absolutely accurate too – it’s got a limited range and precision just as float/double have.


  3. Jon,
    Pedantry, insofar as it furthers the potential for clarity in a technical discussion, is 100%without reproach. So is good grammar, which unfortunately most of us over here on the other side of the Pond have issues with.. Our own “Dr. Dotnetsky” at the link I post provided his “all time pet peeves” on that one.



  4. I hear you!
    it’s dissapointing to find so many programmers that just don’t care, and not only about correct terminology which I consider a good practice, but they don’t care about so many other good practices that cost little and give you great benefits, simple things like backups (of everything you touch), comments (in every code, SQL procedures don’t have to be the exception!), etc
    it bothers me that programmers are lazy that way


  5. If you feel like being pedantic, be pedantic, Jon. Don’t let anyone sway you.

    I for one have learnt a lot from reading over pedanticity (?) of yours in the past in the C#/.NET newsgroups.

    And, anyway, it’s a sign that the person knows what they’re talking about, and thus something to home in on when asking for help.


  6. I agree – pedantry is almost always useful in technical discussions. For example, there’s no way I would have understood parameter passing in C# properly without your pedantry :p


  7. Short answer: Pedantics can certainly be used to annoy, but I don’t think I’ve ever seen YOU do it, Jon and in general we need to be more pedantic.

    Having said that; people just want to be understood and pedantics has a way of backing someone into a corner that makes them want to defend their position. If I say “I change the value of the string to ‘x'” and you correct me with a more accurate description of what my code is actually doing, it could be interpreted badly because it may not be relevant to the problem I’m having. Which makes it less likely for me to accept the solution you offer to my real problem. Not saying *you* do that, Jon, just that communication is not without context and emotion, even in matters technical.

    Political Correctness was *supposed* to be about accuracy (African Americans are not technically ‘black’) but it turned into the opposite in some cases. Pedantry has the same power, if misused. Personally, I don’t feel you will ever do that and I would like you to keep on raising the standards of technical discussion wherever you post!!


  8. Jon,

    I read your blog (I like it) I also read your posts in the newsgroups, especially when they are for problems that I also try to help with. I value everything you write, but I feel like you go over the board very often.

    People that ask questions on the newsgroups and forums are very often newbies that has limited vocabulary in the problem domain. They use the words they know. It is easier for you (us) to change our terminology for the sake of helping them than for them to understand that there is some difference between type initializer and static constructor.

    I couldn’t help to notice that usually pedantry creates endless threads where people argue about the correctness of some word moving the focus away of the problem that the original poster has.

    I believe there are places where one can be a pedant and places where the pedantry is not appropriate.

    Don’t get me wrong, everyone can agree that what you do for the community is priceless and no one can possibly count the number of people you have helped, but a little more balance wouldn’t be a bad idea.

    I hope I didn’t offend you in any way. You asked, I answered.

    Stoitcho Goutsev


  9. No offence taken, certainly – as you say, I asked the question :)

    I agree I sometimes go overboard, but I disagree that the right answer is to use the incorrect terms. I believe education is preferable to continuing a misunderstanding.

    Having said that, the *way* I correct people (and occasionally bothering to do it at all if it’s not absolutely essential to the question) is certainly something I’d like to improve on.

    (In the case of the CLR mailing list thread, I’m having a great time watching the bifurcation. It’s a fascinating thread, even if it’s now mostly miles off the original topic. It helps that many of the participants are very experienced indeed. It’s somewhat scary at the same time, admittedly…)



  10. I once had a drafting teacher that taught me the value of being “meticulous”. In communication and practice, I believe that being precise is necessary in our profession. As you may know, I don’t always practice what I preach because the endeavor of writing tempts me to find creative new ways to say things (i.e. art and science don’t always mix). However, when teaching a class, I’m just like you in that I am persistent with making sure that students are communicating with precise terms. Whatever people do in life, effective communication is an essential element of success. I think you are right-on in educating others about proper terminology.


  11. The value of pedantry was recently reinforced for me thanks to enduring an extreme case from the other end of the spectrum.

    I had to do some work with someone who sometimes appeared to be using terms almost at random. I got the impression that he would use the first word the popped into his head that was remotely related with the topic at hand.

    For example, there was a discussion about a piece of diagnostic instrumentation code which could write diagnostic text messages to various places, including the Windows Event Log, a file, and the debug output target. (I.e. what DbgView shows you. Ironically I can never remember the proper name for it.) The context in which we were discussing this code was one in which we were encountering problems adding rows to a table in a SQL server database.

    In this context, the phrase “They’ve probably logged that to the database” was used, or something very like that. It took a couple of confused minutes to establish that what he meant by this was that Microsoft (‘they’) have probably added an entry concerning the issue we had run into (‘logged that’) to some Microsoft-internal issue tracking database he presumes exists (‘the database’) used by product support services.

    And that’s a fairly mild example, in that once you understand what he had in mind, there’s a fairly direct correspondence between the words he said and the concept. It was a wildly bad choice of words, but only because the context meant that most of the terms would be most likely to be interpreted as meaning something different.

    He often used entirely inappropriate words that didn’t make sense even after you’d decoded the sentence.

    This made technical discussions with him exceptionally hard work. You could never really know what he actually meant by anything he said – you had to decode everything first.

    When the volume’s turned all the way up, it’s very clear how approximate use of terminology has a detrimental effect on communication.

    I think it’s the same basic problem even when it’s just an isolated piece of vagueness. And if the vagueness is acting as a barrier to communicating the concepts you need to communicate it, it’s not only appropriate to get pedantic, it’s *necessary* if either side is going to get anything out of the exchange.

    (Anyone who has answered many questions on mailing lists is extremely familiar with the “Decode the question before attempting to answer it” phase…)

    A good rule of thumb is to be as precise as necessary, and no more so. Or if you prefer, be as vague as it’s possible to be without impeding the communication.

    I happen to think that a lot of people underestimate how precise is ‘necessary’ for a lot of technical discussions. (And if you’re new to a topic, it’s a particularly easy mistake to make. Then again, it’s also a particularly easy mistake to make if you’re lazy and would rather somebody told you what to do instead of you having to put the effort into constructing a meaningful question.)

    Going the other way – being more precise than necessary – is less common, although I know I often do it for pet topics… I’ve sometimes been guilty of opportunistic pedantry: pedantry in the name of an ongoing crusade to correct a popular fallacy. This can result in my correcting someone even though it makes no difference to the discussion at hand.

    There’s another angle on this. In my experience, there is a correlation between imprecise use of terminology, and imprecise application of technology. It’s not a hard and fast thing, but I’ve found it common for people who cannot accurately describe a technology to make mistakes symptomatic of not understanding that technology. Conversely, I’ve found it extremely rare for people who can describe technology precisely not to understand that technology.

    They still make mistakes of course, but will usually understand their mistakes instantly once pointed out. Whereas people whose understanding of a technology is vague tend to have trouble grasping why something isn’t working even when it has been pointed out to them.


  12. If you know what the person means – and I know you do – then yes by all means correct them – but at least answer their question too.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s