6

Looking at GenericWhitespaceCheck in Checkstyle docs,

Left angle bracket (<):

  • should be preceded with whitespace only in generic methods definitions.
  • should not be preceded with whitespace when it is precede method name or following type name.
  • should not be followed with whitespace in all cases.

Right angle bracket (>):

  • should not be preceded with whitespace in all cases.
  • should be followed with whitespace in almost all cases, except diamond operators and when preceding method name.

I am not sure I fully understand the reasoning behind why < should not be followed by a space and why > should not be preceded by one.

In other words, why is Map<String> the convention over Map < String > ?

Is this only because as the number of parameters and depth increases it, the without spaces version is more readable.

Like, Map<String, List<String>> is more readable than, Map < String, List < String > > ?

Also as a general question is there some repository/guides which explains reasons behind Checkstyle conventions ?

Linus Fernandes
  • 498
  • 5
  • 30
Adwait Kumar
  • 1,552
  • 10
  • 25
  • 4
    It's the same as parenthesis. `(a, b, c(d))`, `>`. And you don't just squish everything together. You can put spaces after your commas, instead of `>`. – Brandon Dyer Dec 27 '19 at 17:24
  • 2
    The reasoning is basically, "because that's how it is". This is what the greater community accepted as a convention; it's a balance between zero whitespace and excessive whitespace. Also, it should be `Map>` (notice the space after the comma). – Slaw Dec 27 '19 at 17:29
  • 1
    It's also similar to writing plain old English: space after punctuation like comma, period, question mark, and exclamation mark. Space before opening braces and after closing ones. People are used to this style, and it makes it easier to read as when everything is squeezed together. – Robert Dec 27 '19 at 17:31
  • @Slaw, corrected it. – Adwait Kumar Dec 27 '19 at 17:32
  • `Checkstyle` is a development tool to help programmers write Java code that adheres to a coding standard. This is the standard that was assumed and accepted by people. If you wish to, you can disable the feature and add spaces. no one is stopping you and it wouldn't break any functionality. But your peers may not like it :) – Sunil Dabburi Dec 27 '19 at 17:34
  • @SunilDabburi I understand, my question was to understand if there is some reason behind this standard. Like for e.g in `C` its is a standard to do `if(null == x)` instead of `if(x == null)` to avoid mistaken assignment by doing, `if(x = null)`. Wanted to know if something similar exists here too. – Adwait Kumar Dec 27 '19 at 17:38
  • I don't think so. I think it's merely cosmetic that's comfortable for most of the people. It is a style. – Sunil Dabburi Dec 27 '19 at 17:41
  • 2
    Java does not care about whitespace _most of the time_. You could put a 10,000+ line class all on one line, and remove all spaces not strictly needed to delineate, for instance, variable types from variable names, and it would still compile. The reason we add whitespace (including new-line characters) is to make the code readable. Readability is paramount. – Slaw Dec 27 '19 at 17:41
  • @Slaw, the `C` reference was an example that sometimes there is a reasoning behind conventions that get lost with time. I agree there might be nothing here, which is what the question was about, to know if there is one. – Adwait Kumar Dec 27 '19 at 17:43
  • 1
    My comment was meant to imply there's no behavior-based reason like with the C example you gave. In this case, whether there's whitespace or not does not change how the code compiles or behaves. – Slaw Dec 27 '19 at 17:48

3 Answers3

5

The introduction to an early tutorial on generics (from 2004) says (emphasis mine):

This tutorial is aimed at introducing you to generics. You may be familiar with similar constructs from other languages, most notably C++ templates. If so, you’ll soon see that there are both similarities and important differences. If you are not familiar with look-a-alike constructs from elsewhere, all the better; you can start afresh, without unlearning any misconceptions.

This is acknowledging that Java generics look like C++ templates. C++ templates also conventionally omit the space after the opening <, and before the closing >.

The conventions around Java generics will follow from the ways they were written in early tutorials.

Andy Turner
  • 137,514
  • 11
  • 162
  • 243
4

Although I have no evidence or research to base my theory on, I'd reason as follows:

Cohesion

A (kind of language-philosophical) rationale could be:

The parameterization of types (generic's major role) such as in Map<String, Object> belongs to the type-name the same like parentheses and parameters belong to the method-name. So adding parameter to a signature should follow a consistent spacing-rule: no space around parametrizing brackets (neither in generic-type's parameter definition, nor in method's parameter definition).

Thus the angel-brackets are coherently defining the "type signature" and should stay as close to the type as possible (semantical and spatial), which means no space should untie this relation.

Readability

From the (Clean Code) perspective there is a clear benefit for avoiding spaces:

Spaces around angel-brackets rather make them mis-read or mis-interpreted as logical comparison operators.

hc_dev
  • 8,389
  • 1
  • 26
  • 38
0

Most coding styles have a limit of characters per line or column length. Reducing whitespace make shorter lines that are easier to read.

For example, the google code style for java has a column limit of 100 characters.

Coding styles depend on the community behind the language, so I would recommend checking their standards.

Jocorta
  • 9
  • 2
  • This isn't the reason. If it were, whitespace would be omitted in other places, such as after a comma, or after the semicolon in a for loop declaration. – Andy Turner Dec 27 '19 at 18:55