Tabs versus Spaces in Source Code

Discussion in 'Java' started by Xah Lee, May 15, 2006.

  1. Xah Lee

    Xah Lee Guest

    Tabs versus Spaces in Source Code

    Xah Lee, 2006-05-13

    In coding a computer program, there's often the choices of tabs or
    spaces for code indentation. There is a large amount of confusion about
    which is better. It has become what's known as “religious war†—
    a heated fight over trivia. In this essay, i like to explain what is
    the situation behind it, and which is proper.

    Simply put, tabs is proper, and spaces are improper. Why? This may seem
    ridiculously simple given the de facto ball of confusion: the semantics
    of tabs is what indenting is about, while, using spaces to align code
    is a hack.

    Now, tech geekers may object this simple conclusion because they itch
    to drivel about different editors and so on. The alleged problem
    created by tabs as seen by the industry coders are caused by two
    things: (1) tech geeker's sloppiness and lack of critical thinking
    which lead them to not understanding the semantic purposes of tab and
    space characters. (2) Due to the first reason, they have created and
    propagated a massive none-understanding and mis-use, to the degree that
    many tools (e.g. vi) does not deal with tabs well and using spaces to
    align code has become widely practiced, so that in the end spaces seem
    to be actually better by popularity and seeming simplicity.

    In short, this is a phenomenon of misunderstanding begetting a snowball
    of misunderstanding, such that it created a cultural milieu to embrace
    this malpractice and kick what is true or proper. Situations like this
    happens a lot in unix. For one non-unix example, is the file name's
    suffix known as “extensionâ€, where the code of file's type became
    part of the file name. (e.g. “.txtâ€, “.htmlâ€, “.jpgâ€).
    Another well-known example is HTML practices in the industry, where
    badly designed tags from corporation's competitive greed, and stupid
    coding and misunderstanding by coders and their tools are so
    wide-spread such that they force the correct way to the side by the
    eventual standardization caused by sheer quantity of inproper but set
    practice.

    Now, tech geekers may still object, that using tabs requires the
    editors to set their positions, and plain files don't carry that
    information. This is a good question, and the solution is to advance
    the sciences such that your source code in some way embed such
    information. This would be progress. However, this is never thought of
    because the “unix philosophies†already conditioned people to hack
    and be shallow. In this case, many will simply use the character
    intended to separate words for the purpose of indentation or alignment,
    and spread the practice with militant drivels.

    Now, given the already messed up situation of the tabs vs spaces by the
    unixers and unix brain-washing of the coders in the industry... Which
    should we use today? I do not have a good proposition, other than just
    use whichever that works for you but put more critical thinking into
    things to prevent mishaps like this.

    Tabs vs Spaces can be thought of as parameters vs hard-coded values, or
    HTML vs ascii format, or XML/CSS vs HTML 4, or structural vs visual, or
    semantic vs format. In these, it is always easy to convert from the
    former to the latter, but near impossible from the latter to the
    former. And, that is because the former encodes information that is
    lost in the latter. If we look at the issue of tabs vs spaces, indeed,
    it is easy to convert tabs to spaces in a source code, but more
    difficult to convert from spaces to tabs. Because, tabs as indentation
    actually contains the semantic information about indentation. With
    spaces, this critical information is lost in space.

    This issue is intimately related to another issue in source code:
    soft-wrapped lines versus physical, hard-wrapped lines by EOL (end of
    line character). This issue has far more consequences than tabs vs
    spaces, and the unixer's unthinking has made far-reaching damages in
    the computing industry. Due to unix's EOL ways of thinking, it has
    created languages based on EOL (just about ALL languages except the
    Lisp family and Mathematica) and tools based on EOL (cvs, diff, grep,
    and basically every tool in unix), thoughts based on EOL (software
    value estimation by counting EOL, hard-coded email quoting system by
    “>†prefix, and silent line-truncations in many unix tools), such
    that any progress or development towards a “algorithmic code unitâ€
    concept or language syntaxes are suppressed. I have not written a full
    account on this issue, but i've touched it in this essay: “The Harm
    of hard-wrapping Linesâ€, at
    http://xahlee.org/UnixResource_dir/writ/hard-wrap.html
    ----
    This post is archived at:
    http://xahlee.org/UnixResource_dir/writ/tabs_vs_spaces.html

    Xah

    ∑ http://xahlee.org/
     
    Xah Lee, May 15, 2006
    #1
    1. Advertising

  2. Xah Lee

    Eli Gottlieb Guest

    Actually, spaces are better for indenting code. The exact amount of
    space taken up by one space character will always (or at least tend to
    be) the same, while every combination of keyboard driver, operating
    system, text editor, content/file format, and character encoding all
    change precisely what the tab key does.

    There's no use in typing "tab" for indentation when my text editor will
    simply convert it to three spaces, or worse, autoindent and mix tabs
    with spaces so that I have no idea how many actual whitespace characters
    of what kinds are really taking up all that whitespace. I admit it
    doesn't usually matter, but then you go back to try and make your code
    prettier and find yourself asking "WTF?"

    Undoubtedly adding the second spark to the holy war,
    Eli

    --
    The science of economics is the cleverest proof of free will yet
    constructed.
     
    Eli Gottlieb, May 15, 2006
    #2
    1. Advertising

  3. Spaces work better. Hitting the TAB key in my Emacs will auto-indent
    the current line. Only spaces will be used for fill. The worst thing
    you can do is mix the two regardless of how you feel about tab vs
    space.

    The next step in evil is to give tab actual significance like in
    make.

    Xah Lee is getting better at trolling. He might fill up Google's
    storage.

    --
    http://www.david-steuber.com/
    1998 Subaru Impreza Outback Sport
    2006 Honda 599 Hornet (CB600F) x 2 Crash & Slider
    The lithobraker. Zero distance stops at any speed.
     
    David Steuber, May 15, 2006
    #3
  4. Xah Lee

    jmcgill Guest

    If I work on your project, I follow the coding and style standards you
    specify.

    Likewise if you work on my project you follow the established standards.

    Fortunately for you, I am fairly liberal on such matters.

    I like to see 4 spaces for indentation. If you use tabs, that's what I
    will see, and you're very likely to have your code reformatted by the
    automated build process, when the standard copyright header is pasted
    and missing javadoc tags are generated as warnings.

    I like the open brace to start on the line of the control keyword. I
    can deal with the open brace being on the next line, at the same level
    of indentation as the control keyword. I don't quite understand the
    motivation behind the GNU style, where the brace itself is treated as a
    half-indent, but I can live with it on *your* project.

    Any whitespace or other style that isn't happy to be reformatted
    automatically is an error anyway.

    I'd be very laissez-faire about it except for the fact that code
    repositories are much easier to manage if everything is formatted before
    it goes in, or as a compromise, as a step at release tags.
     
    jmcgill, May 15, 2006
    #4
  5. Xah Lee

    mystilleef Guest

    I agree, use tabs.
     
    mystilleef, May 15, 2006
    #5
  6. Xah Lee

    Mumia W. Guest

    Xah Lee wrote:
    > Tabs versus Spaces in Source Code
    >
    > Xah Lee, 2006-05-13
    >
    > In coding a computer program, there's often the choices of tabs or
    > spaces for code indentation. There is a large amount of confusion about
    > which is better. It has become what's known as “religious war†—
    > a heated fight over trivia. In this essay, i like to explain what is
    > the situation behind it, and which is proper.
    >


    Thanks Xah. I value your posts. Keep posting. And since your posts
    usually cover broad areas of CS, keep crossposting. Don't go anywhere
    Xah :)


    > Simply put, tabs is proper, and spaces are improper. Why? This may seem
    > ridiculously simple given the de facto ball of confusion: the semantics
    > of tabs is what indenting is about, while, using spaces to align code
    > is a hack.
    >


    I wouldn't say that spaces are a hack, but tabs are superior.

    > Now, tech geekers may object this simple conclusion because they itch
    > to drivel about different editors and so on. The alleged problem
    > created by tabs as seen by the industry coders are caused by two
    > things: (1) tech geeker's sloppiness and lack of critical thinking
    > which lead them to not understanding the semantic purposes of tab and
    > space characters. (2) Due to the first reason, they have created and
    > propagated a massive none-understanding and mis-use, to the degree that
    > many tools (e.g. vi) does not deal with tabs well and using spaces to
    > align code has become widely practiced, so that in the end spaces seem
    > to be actually better by popularity and seeming simplicity.
    >


    Don't forget the laziness of programmers like me who don't put the
    tabbing information in the source file. Vim deals with tabs well IMO,
    but I almost never used to put the right auto-commands in the file to
    get it set up right for other users.

    > In short, this is a phenomenon of misunderstanding begetting a snowball
    > of misunderstanding, such that it created a cultural milieu to embrace
    > this malpractice and kick what is true or proper. Situations like this
    > happens a lot in unix. For one non-unix example, is the file name's
    > suffix known as “extensionâ€, where the code of file's type became
    > part of the file name. (e.g. “.txtâ€, “.htmlâ€, “.jpgâ€).
    > Another well-known example is HTML practices in the industry, where
    > badly designed tags from corporation's competitive greed, and stupid
    > coding and misunderstanding by coders and their tools are so
    > wide-spread such that they force the correct way to the side by the
    > eventual standardization caused by sheer quantity of inproper but set
    > practice.
    >
    > Now, tech geekers may still object, that using tabs requires the
    > editors to set their positions, and plain files don't carry that
    > information. This is a good question, and the solution is to advance
    > the sciences such that your source code in some way embed such
    > information.


    Vim does this. We just have to use it.

    > This would be progress. However, this is never thought of
    > because the “unix philosophies†already conditioned people to hack
    > and be shallow. In this case, many will simply use the character
    > intended to separate words for the purpose of indentation or alignment,
    > and spread the practice with militant drivels.
    >
    > Now, given the already messed up situation of the tabs vs spaces by the
    > unixers and unix brain-washing of the coders in the industry... Which
    > should we use today? I do not have a good proposition, other than just
    > use whichever that works for you but put more critical thinking into
    > things to prevent mishaps like this.
    >
    > Tabs vs Spaces can be thought of as parameters vs hard-coded values, or
    > HTML vs ascii format, or XML/CSS vs HTML 4, or structural vs visual, or
    > semantic vs format. In these, it is always easy to convert from the
    > former to the latter, but near impossible from the latter to the
    > former. And, that is because the former encodes information that is
    > lost in the latter.


    Nope. Conversion is relatively easy. I've written programs to do this
    myself, and everyone and his brother has also done this. Virtually every
    programmer's editor that I've ever used can do this, and a great, great
    many independent programs convert tabs to spaces. It's like saying,
    "it's near impossible to write a calculator program." :)

    I bet that someone has a Perl one-liner to do it.

    On any Debian system, try a "man expand" and see what you find. Also,
    emacs and vim do it. Perl has a Text::Tabs module. TCL's
    ::textutil::(un)?tabify routines do it. The birds do it, and the bees do
    it. Oh wait, that's something else :)

    > If we look at the issue of tabs vs spaces, indeed,
    > it is easy to convert tabs to spaces in a source code, but more
    > difficult to convert from spaces to tabs.


    Nope again. It's easy, you just keep track of the virtual character
    position as you decide whether to write a space or a tab. Computers do
    the "counting" thing fairly well.

    > Because, tabs as indentation
    > actually contains the semantic information about indentation. With
    > spaces, this critical information is lost in space.
    >
    > This issue is intimately related to another issue in source code:
    > soft-wrapped lines versus physical, hard-wrapped lines by EOL (end of
    > line character). This issue has far more consequences than tabs vs
    > spaces, and the unixer's unthinking has made far-reaching damages in
    > the computing industry. Due to unix's EOL ways of thinking, it has
    > created languages based on EOL (just about ALL languages except the
    > Lisp family and Mathematica) and tools based on EOL (cvs, diff, grep,
    > and basically every tool in unix), thoughts based on EOL (software
    > value estimation by counting EOL, hard-coded email quoting system by
    > “>†prefix, and silent line-truncations in many unix tools), such
    > that any progress or development towards a “algorithmic code unitâ€
    > concept or language syntaxes are suppressed. I have not written a full
    > account on this issue, but i've touched it in this essay: “The Harm
    > of hard-wrapping Linesâ€, at
    > http://xahlee.org/UnixResource_dir/writ/hard-wrap.html
    > ----
    > This post is archived at:
    > http://xahlee.org/UnixResource_dir/writ/tabs_vs_spaces.html
    >
    > Xah
    >
    > ∑ http://xahlee.org/
    >


    I've never thought of tabs-vs-spaces as a religious war. Anyway, the
    authority of the programming environment will determine which one is
    used. Have a good week Xah.
     
    Mumia W., May 15, 2006
    #6
  7. Xah Lee

    Iain King Guest

    Oh God, I agree with Xah Lee. Someone take me out behind the chemical
    sheds...

    Iain


    Xah Lee wrote:
    > Tabs versus Spaces in Source Code
    >
    > Xah Lee, 2006-05-13
    >
    > In coding a computer program, there's often the choices of tabs or
    > spaces for code indentation. There is a large amount of confusion about
    > which is better. It has become what's known as “religious war†—
    > a heated fight over trivia. In this essay, i like to explain what is
    > the situation behind it, and which is proper.
    >
    > Simply put, tabs is proper, and spaces are improper. Why? This may seem
    > ridiculously simple given the de facto ball of confusion: the semantics
    > of tabs is what indenting is about, while, using spaces to align code
    > is a hack.
    >
    > Now, tech geekers may object this simple conclusion because they itch
    > to drivel about different editors and so on. The alleged problem
    > created by tabs as seen by the industry coders are caused by two
    > things: (1) tech geeker's sloppiness and lack of critical thinking
    > which lead them to not understanding the semantic purposes of tab and
    > space characters. (2) Due to the first reason, they have created and
    > propagated a massive none-understanding and mis-use, to the degree that
    > many tools (e.g. vi) does not deal with tabs well and using spaces to
    > align code has become widely practiced, so that in the end spaces seem
    > to be actually better by popularity and seeming simplicity.
    >
    > In short, this is a phenomenon of misunderstanding begetting a snowball
    > of misunderstanding, such that it created a cultural milieu to embrace
    > this malpractice and kick what is true or proper. Situations like this
    > happens a lot in unix. For one non-unix example, is the file name's
    > suffix known as “extensionâ€, where the code of file's type became
    > part of the file name. (e.g. “.txtâ€, “.htmlâ€, “.jpgâ€).
    > Another well-known example is HTML practices in the industry, where
    > badly designed tags from corporation's competitive greed, and stupid
    > coding and misunderstanding by coders and their tools are so
    > wide-spread such that they force the correct way to the side by the
    > eventual standardization caused by sheer quantity of inproper but set
    > practice.
    >
    > Now, tech geekers may still object, that using tabs requires the
    > editors to set their positions, and plain files don't carry that
    > information. This is a good question, and the solution is to advance
    > the sciences such that your source code in some way embed such
    > information. This would be progress. However, this is never thought of
    > because the “unix philosophies†already conditioned people to hack
    > and be shallow. In this case, many will simply use the character
    > intended to separate words for the purpose of indentation or alignment,
    > and spread the practice with militant drivels.
    >
    > Now, given the already messed up situation of the tabs vs spaces by the
    > unixers and unix brain-washing of the coders in the industry... Which
    > should we use today? I do not have a good proposition, other than just
    > use whichever that works for you but put more critical thinking into
    > things to prevent mishaps like this.
    >
    > Tabs vs Spaces can be thought of as parameters vs hard-coded values, or
    > HTML vs ascii format, or XML/CSS vs HTML 4, or structural vs visual, or
    > semantic vs format. In these, it is always easy to convert from the
    > former to the latter, but near impossible from the latter to the
    > former. And, that is because the former encodes information that is
    > lost in the latter. If we look at the issue of tabs vs spaces, indeed,
    > it is easy to convert tabs to spaces in a source code, but more
    > difficult to convert from spaces to tabs. Because, tabs as indentation
    > actually contains the semantic information about indentation. With
    > spaces, this critical information is lost in space.
    >
    > This issue is intimately related to another issue in source code:
    > soft-wrapped lines versus physical, hard-wrapped lines by EOL (end of
    > line character). This issue has far more consequences than tabs vs
    > spaces, and the unixer's unthinking has made far-reaching damages in
    > the computing industry. Due to unix's EOL ways of thinking, it has
    > created languages based on EOL (just about ALL languages except the
    > Lisp family and Mathematica) and tools based on EOL (cvs, diff, grep,
    > and basically every tool in unix), thoughts based on EOL (software
    > value estimation by counting EOL, hard-coded email quoting system by
    > “>†prefix, and silent line-truncations in many unix tools), such
    > that any progress or development towards a “algorithmic code unitâ€
    > concept or language syntaxes are suppressed. I have not written a full
    > account on this issue, but i've touched it in this essay: “The Harm
    > of hard-wrapping Linesâ€, at
    > http://xahlee.org/UnixResource_dir/writ/hard-wrap.html
    > ----
    > This post is archived at:
    > http://xahlee.org/UnixResource_dir/writ/tabs_vs_spaces.html
    >
    > Xah
    >
    > ∑ http://xahlee.org/
     
    Iain King, May 16, 2006
    #7
  8. In article <>,
    David Steuber <> wrote:
    >Spaces work better. Hitting the TAB key in my Emacs will auto-indent
    >the current line. Only spaces will be used for fill. The worst thing
    >you can do is mix the two regardless of how you feel about tab vs
    >space.


    This really hits at the crux of the matter if, as me, you largely code
    in Java. Sun uses a Java coding standard that includes tab-based full
    indents and space-based half indents. And, of course, their full
    indents are sometimes 8 spaces and sometimes 1 tab. This makes
    Sun-formatted code unreadable unless you have the exact same Tab-size
    as Sun does and, quite frankly, 8 spaces to the tab is just too much.

    Since I look at the Java API sources every now and then while
    programming, I therefore set my Tab to be 8 spaces to make it
    readable, and run with 3-space indents in my own source code.

    I wouldn't really mind much using Tab as indent instead, but that
    cannot coexist very happily with a Sun-mandated 8-space Tab setting.

    >The next step in evil is to give tab actual significance like in
    >make.


    Since I don't tend to use make a lot, I think of it as "quaint" rather
    than "evil" :)

    Cheers
    Bent D
    --
    Bent Dalager - - http://www.pvv.org/~bcd
    powered by emacs
     
    Bent C Dalager, May 16, 2006
    #8
  9. Xah Lee

    numeromancer Guest

    numeromancer, May 16, 2006
    #9
  10. Xah Lee wrote:
    > Tabs versus Spaces in Source Code
    >
    > Xah Lee, 2006-05-13
    >
    > In coding a computer program, there's often the choices of tabs or
    > spaces for code indentation. There is a large amount of confusion about
    > which is better. It has become what's known as “religious war†—
    > a heated fight over trivia. In this essay, i like to explain what is
    > the situation behind it, and which is proper.
    >
    > Simply put, tabs is proper, and spaces are improper.

    [...]

    I fullheartedly disagree :)

    So, no "essay" on this is necessary to read :->


    Ciao,
    Oliver
     
    Oliver Bandel, May 16, 2006
    #10
  11. > Simply put, tabs is proper, and spaces are improper.
    > Why? This may seem
    > ridiculously simple given the de facto ball of confusion: the semantics
    > of tabs is what indenting is about, while, using spaces to align code
    > is a hack.


    The reality of programming practice trumps original intent of tab
    characters. The tab character and space character are pliable in that
    if their use changes their semantics change.

    > ... and the solution is to advance
    > the sciences such that your source code in some way
    > embed such information.


    If/when time comes where such info is embeded perhaps then tabs will be
    OK.

    ---------------------------------------------------------------

    I use spaces because of the many sources I've opened I have many times
    sighed on opening tabed ones and never done so opening spaced ones.

    I don't get mad, but sighing is a clear indicator of negativity.
    Anyway, the more code I write and read the less indentation matters to
    me. My brain can now parse akward source correctly far bettter than it
    did a few years ago.


    All the best,
    Opalinski

    http://www.geocities.com/opalpaweb/
     
    opalinski from opalpaweb, May 16, 2006
    #11
  12. " opalinski from opalpaweb" <> writes:

    >> Simply put, tabs is proper, and spaces are improper.
    >> Why? This may seem
    >> ridiculously simple given the de facto ball of confusion: the semantics
    >> of tabs is what indenting is about, while, using spaces to align code
    >> is a hack.

    >
    > The reality of programming practice trumps original intent of tab
    > characters. The tab character and space character are pliable in that
    > if their use changes their semantics change.
    >
    >> ... and the solution is to advance
    >> the sciences such that your source code in some way
    >> embed such information.

    >
    > If/when time comes where such info is embeded perhaps then tabs will be
    > OK.
    >
    > ---------------------------------------------------------------
    >
    > I use spaces because of the many sources I've opened I have many times
    > sighed on opening tabed ones and never done so opening spaced ones.
    >
    > I don't get mad, but sighing is a clear indicator of negativity.
    > Anyway, the more code I write and read the less indentation matters to
    > me. My brain can now parse akward source correctly far bettter than it
    > did a few years ago.


    And anyways, C-x h C-M-\ comes automatically after C-x C-f source RET
    Just add this to your ~/.emacs :

    (add-hook 'find-file-hook
    (lambda () (indent-region (point-min) (point-max)) (pop-mark)))



    --
    __Pascal Bourguignon__ http://www.informatimago.com/

    IMPORTANT NOTICE TO PURCHASERS: The entire physical universe,
    including this product, may one day collapse back into an
    infinitesimally small space. Should another universe subsequently
    re-emerge, the existence of this product in that universe cannot be
    guaranteed.
     
    Pascal Bourguignon, May 16, 2006
    #12
  13. Xah Lee

    Dale King Guest

    Iain King wrote:
    > Oh God, I agree with Xah Lee. Someone take me out behind the chemical
    > sheds...
    >
    > Xah Lee wrote:

    <more worthless nonsense>

    Please don't feed the troll!

    And for the record, spaces are 100% portable, tabs are not. That ends
    the argument for me.

    Worse than either tabs or spaces however is Sun's mixture of the two.
    --
    Dale King
     
    Dale King, May 16, 2006
    #13
  14. opalinski from opalpaweb wrote:

    >>Simply put, tabs is proper, and spaces are improper.
    >>Why? This may seem
    >>ridiculously simple given the de facto ball of confusion: the semantics
    >>of tabs is what indenting is about, while, using spaces to align code
    >>is a hack.

    >
    >
    > The reality of programming practice trumps original intent of tab
    > characters. The tab character and space character are pliable in that
    > if their use changes their semantics change.

    [...]


    Yes, as I started programming I also preferred tabs.
    And with growing experience on how to handle this in true life
    (different editors/systems/languages...) I saw, that
    converting the "so fine tabs" was annoying.

    The only thing that always worked were spaces.
    Tab: nice idea but makes programming an annoyance.

    Ciao,
    Oliver
     
    Oliver Bandel, May 16, 2006
    #14
  15. In message <>, Iain
    King <> writes
    >Oh God, I agree with Xah Lee. Someone take me out behind the chemical
    >sheds...


    Jack Bauer is on his way...
    --
    Stephen Kellett
    Object Media Limited http://www.objmedia.demon.co.uk/software.html
    Computer Consultancy, Software Development
    Windows C++, Java, Assembler, Performance Analysis, Troubleshooting
     
    Stephen Kellett, May 16, 2006
    #15
  16. Xah Lee

    Kaz Kylheku Guest

    Xah Lee wrote:
    > Tabs vs Spaces can be thought of as parameters vs hard-coded values, or
    > HTML vs ascii format, or XML/CSS vs HTML 4, or structural vs visual, or
    > semantic vs format. In these, it is always easy to convert from the
    > former to the latter, but near impossible from the latter to the
    > former.


    Bahaha, looks like someone hasn't thought things through very well.

    Spaces, under a mono font, offer greater precision and expressivity in
    achieving specific alignment. That expressivity cannot be captured by
    tabs.

    The difficulty in converting spaces to tabs rests not in any bridgeable
    semantic gap, but in the lack of having any way whatsoever to express
    using tabs what the spaces are expressing.

    It's not /near/ impossible, it's /precisely/ impossible.

    For instance, tabs cannot express these alignments:

    /*
    * C block
    * comment
    * in a common style.
    */

    (lisp
    (nested list
    with symbols
    and things))

    (call to a function
    with many parameters)
    ;; how do you align "to" and "with" using tabs?
    ;; only if "to" lands on a tab stop; but dependence on specific tab
    stops
    ;; destroys the whole idea of tabs being parameters.

    To do these alignments structurally, you need something more expressive
    than spaces or tabs. But spaces do the job under a mono font, /and/
    they do it in a completely unobtrusive way.

    If you want to do nice typesetting of code, you have to add markup
    which has to be stripped away if you actually want to run the code.

    Spaces give you decent formatting without markup. Tabs do not. Tabs are
    only suitable for aligning the first non-whitespace character of a line
    to a stop. Only if that is the full extent of the formatting that you
    need to express in your code can you acheive the ideal of being able to
    change your tab parameter to change the indentation amount. If you need
    to align characters which aren't the first non-whitespace in a line,
    tabs are of no use whatsoever, and proportional fonts must be banished.
     
    Kaz Kylheku, May 16, 2006
    #16
  17. Xah Lee

    Kaz Kylheku Guest

    Bent C Dalager wrote:
    > In article <>,
    > David Steuber <> wrote:
    > >Spaces work better. Hitting the TAB key in my Emacs will auto-indent
    > >the current line. Only spaces will be used for fill. The worst thing
    > >you can do is mix the two regardless of how you feel about tab vs
    > >space.

    >
    > This really hits at the crux of the matter if, as me, you largely code
    > in Java. Sun uses a Java coding standard that includes tab-based full
    > indents and space-based half indents. And, of course, their full
    > indents are sometimes 8 spaces and sometimes 1 tab. This makes
    > Sun-formatted code unreadable unless you have the exact same Tab-size
    > as Sun does and, quite frankly, 8 spaces to the tab is just too much.


    The 8 space tab is industry standard. Anything else is an abomination.

    What Sun's source code is doing is the only acceptable use of tabs in
    source code whatsoever: groups of eight spaces are replaced by a tab in
    a maximally greedy way to save space.

    Many editors support this mode of indentation: use a greedy number of
    tabs instead of spaces, and then add a few spaces of padding to achieve
    the indentation.

    Vim, Emacs, even the editor in Microsoft's Visual Studio.

    > Since I look at the Java API sources every now and then while
    > programming, I therefore set my Tab to be 8 spaces to make it
    > readable, and run with 3-space indents in my own source code.


    If you have to set your tab to be 8 spaces, your editor is a
    braindamaged pile of crap.

    It should be the default setting, and ideally not even overrideable.

    And by golly, there is such a tool.

    Microsoft's NOTEPAD.EXE has an 8 space tab, which cannot be changed.

    So if your pointy-haired boss ever views a text file that you produced,
    and he uses Notepad on his Windows laptop, it behooves you to have
    assumed 8 space tabs.

    > I wouldn't really mind much using Tab as indent instead, but that
    > cannot coexist very happily with a Sun-mandated 8-space Tab setting.


    Or would that be Notepad-mandated? Hahahaha.
     
    Kaz Kylheku, May 16, 2006
    #17
  18. Xah Lee

    achates Guest

    Kaz Kylheku wrote:

    > If you want to do nice typesetting of code, you have to add markup
    > which has to be stripped away if you actually want to run the code.


    Typesetting code is not a helpful activity outside of the publishing
    industry. You might like the results of your typsetting; I happen not
    to. You probably wouldn't like mine. Does that mean we shouldn't work
    together? Only if you insist on forcing me to conform to your way of
    displaying code.

    You are correct in pointing out that tabs don't allow for 'alignment'
    of the sort you mention:
    (lisp
    (nested list
    with symbols
    and things))
    But then neither does Python. I happen to think that's a feature.

    (And of course you can do what you like inside a comment. That's
    because tabs are for indentation, and indentation is meanigless in that
    context. Spaces are exactly what you should use then. I may or may not
    like your layout, but it won't break anything when we merge our code.)
     
    achates, May 16, 2006
    #18
  19. Xah Lee

    achates Guest

    argh, sorry; missed the cross-post. Was replying from comp.lang.python..
     
    achates, May 16, 2006
    #19
  20. Xah Lee

    Kaz Kylheku Guest

    achates wrote:
    > Kaz Kylheku wrote:
    >
    > > If you want to do nice typesetting of code, you have to add markup
    > > which has to be stripped away if you actually want to run the code.

    >
    > Typesetting code is not a helpful activity outside of the publishing
    > industry.


    Be that as it may, code writing involves an element of typesetting. If
    you are aligning characters, you are typesetting, however crudely.

    > You might like the results of your typsetting; I happen not
    > to. You probably wouldn't like mine. Does that mean we shouldn't work
    > together? Only if you insist on forcing me to conform to your way of
    > displaying code.


    Someone who insists that everyone should separate line indentation into
    tabs which achieve the block level, and spaces that achieve additional
    alignment, so that code could be displayed in more than one way based
    on the tab size without loss of alignment, is probably a "space cadet",
    who has a bizarre agenda unrelated to developing the product.

    There is close to zero value in maintaining such a scheme, and
    consequently, it's hard to justify with a business case.

    Yes, in the real world, you have to conform to someone's way of
    formatting and displaying code. That's how it is.

    You have to learn to read, write and even like more than one style.

    > You are correct in pointing out that tabs don't allow for 'alignment'
    > of the sort you mention:


    That alignment has a name: hanging indentation.

    All forms of aligning the first character of a line to some requirement
    inherited from the previous line are called indentation.

    Granted, a portion of that indentation is derived from the nesting
    level of some logically enclosing programming language construct, and
    part of it may be derived from the position of a character of some
    parallel constituent within the construct.

    > (lisp
    > (nested list
    > with symbols
    > and things))
    > But then neither does Python. I happen to think that's a feature.


    Python has logical line continuation which gives rise to the need for
    hanging indents to line up with parallel constituents in a folded
    expression.

    Python also allows for the possibility of statements separated by
    semicolons on one line, which may need to be lined up in columns.

    var = 42; foo = 53
    x = 2; y = 10

    > (And of course you can do what you like inside a comment. That's
    > because tabs are for indentation, and indentation is meanigless in that
    > context.


    A comment can contain example code, which contains indentation.

    What, I can't change the tab size to display that how I want? Waaah!!!
    (;_;)
     
    Kaz Kylheku, May 16, 2006
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Xah Lee

    Tabs versus Spaces in Source Code

    Xah Lee, May 15, 2006, in forum: Python
    Replies:
    135
    Views:
    3,691
    Oliver Wong
    May 23, 2006
  2. Robert Hicks

    Re: Spaces and tabs messing up code

    Robert Hicks, Jan 9, 2008, in forum: Python
    Replies:
    1
    Views:
    340
    Ben Finney
    Jan 9, 2008
  3. rantingrick

    Tabs -vs- Spaces: Tabs should have won.

    rantingrick, Jul 16, 2011, in forum: Python
    Replies:
    95
    Views:
    1,859
    Roy Smith
    Jul 19, 2011
  4. Paul Butcher
    Replies:
    12
    Views:
    740
    Gary Wright
    Nov 28, 2007
  5. Xah Lee

    Tabs versus Spaces in Source Code

    Xah Lee, May 15, 2006, in forum: Perl Misc
    Replies:
    34
    Views:
    359
    Ben Rudiak-Gould
    May 23, 2006
Loading...

Share This Page