Табы или пробелы? Анализ 400 тысяч репозиториев GitHub, миллиарда файлов, 14 ТБ кода



    Для пытливых разработчиков до сих пор остается актуальным вопрос использования табуляции и пробелов для форматирования кода. Могут ли они быть взаимозаменяемы: например, 2 пробела на табуляцию или 4? Но единого стандарта нет, поэтому иногда между разработчиками возникает непонимание. Кроме того, различные IDE и их компиляторы обрабатывают табуляцию также по-своему.

    Решением вопроса обычно становится соглашение о правилах форматирования в рамках проекта или языка программирования в целом.

    Команда разработчиков из Google исследовала проекты в репозитории Github. Они проанализировали код, написанный на 14 языках программирования. Целью исследования было выявить соотношение табуляций и пробелов — то есть, наиболее популярный способ форматирования текста для каждого из языков.

    Реализация


    Для анализа использовалась уже существующая таблица [bigquery-public-data:github_repos.sample_files], в которую записаны наименования репозиториев Github.

    Напомним, что около двух месяцев назад весь открытый код Github стал доступен в форме таблиц BigQuery.

    Однако для анализа были выбраны не все репозитории, а только верхние 400 тысяч репозиториев с наибольшим числом звёзд, которые они получили за период с января по май 2016 года.



    Из этой таблицы были выделены файлы, содержащие код на 14 самых популярных языках программирования. Для этого в качестве параметров sql-запроса были указаны расширения соответствующих файлов – .java, .h, .js, .c, .php, .html, .cs, .json, .py, .cpp, .xml, .rb, .cc, .go.

    SELECT a.id id, size, content, binary, copies, sample_repo_name , sample_path
    FROM (
      SELECT id, FIRST(path) sample_path, FIRST(repo_name) sample_repo_name 
      FROM [bigquery-public-data:github_repos.sample_files] 
      WHERE REGEXP_EXTRACT(path, r'\.([^\.]*)$') IN ('java','h','js','c','php','html','cs','json','py','cpp','xml','rb','cc','go')
      GROUP BY id
    ) a
    JOIN [bigquery-public-data:github_repos.contents] b
    ON a.id = b.id

    864.6s elapsed, 1.60 TB processed

    Запрос выполнялся довольно долго. И это неудивительно, так как было необходимо выполнить операцию объединения (join) таблицы из 190 миллионов строк с таблицей в 70 миллионов строк. Всего было обработано 1,6 ТБ данных. Результаты запроса доступны по этому адресу.

    В таблице [contents] записаны файлы без своих дубликатов. Ниже указано общее количество уникальных файлов и их суммарный размер. Дубликаты файлов не учитывались в ходе анализа.



    После этого оставалось только сформировать и запустить на выполнение финальный запрос.

    SELECT ext, tabs, spaces, countext, LOG((spaces+1)/(tabs+1)) lratio
    FROM (
      SELECT REGEXP_EXTRACT(sample_path, r'\.([^\.]*)$') ext, 
             SUM(best='tab') tabs, SUM(best='space') spaces, 
             COUNT(*) countext
      FROM (
        SELECT sample_path, sample_repo_name, IF(SUM(line=' ')>SUM(line='\t'), 'space', 'tab') WITHIN RECORD best,
               COUNT(line) WITHIN RECORD c
        FROM (
          SELECT LEFT(SPLIT(content, '\n'), 1) line, sample_path, sample_repo_name 
          FROM [fh-bigquery:github_extracts.contents_top_repos_top_langs]
          HAVING REGEXP_MATCH(line, r'[ \t]')
        )
        HAVING c>10 # at least 10 lines that start with space or tab
      )
      GROUP BY ext
    )
    ORDER BY countext DESC
    LIMIT 100

    16.0s elapsed, 133 GB processed

    Анализ каждой из строк 133 Гб кода занял 16 секунд. Добиться такой скорости помог все тот же BigQuery.


    Чаще всего табуляция встречается в языке С, а пробелы — в Java.

    Хотя для кого-то соотношение тех или иных управляющих символов не имеет значения, а споры на эту тему кажутся надуманными. Это не имеет значения и для некоторых IDE, которые сохраняют табуляцию как некоторое количество пробелов. Также существуют IDE, в которых это количество можно настраивать вручную.

    Некоторое время назад эта проблема была обыграна в сериале «Кремниевая долина». Парень и девушка не сошлись в вопросе форматирования. В результате старый холивар не только привел к недопониманию в профессиональном плане, но и создал проблемы в их личных отношениях.

    Только зарегистрированные пользователи могут участвовать в опросе. Войдите, пожалуйста.

    Табы или пробелы?

    Поделиться публикацией

    Комментарии 242

      +46
      Я всегда делаю отступы табами, но перед этим включаю в IDE опцию «заменять табы на пробелы».
        +63

        Нескромный вопрос: вы думали, что остальные нажимают пробел 2 или 4 раза?

          +61
          Более того, я не раз видел ЭТО.
            –7
            Я один из тех, кто иногда клацает несколько раз пробел. Иногда мне это кажется проще, чем выровнять табом.
              0
              Вас не смущает что все нажимают один раз таб, и вместо таба подставляется 2/4 пробела? А вы клацаете 2/4 раза пробел.
                0
                Абсолютно не смущает. Я написал — иногда клацаю пробелы. И это иногда не такая уж редкая ситуация, как может показаться.
                Использую почти всегда IDE. тектовые файлы только для скриптов.
                В проектах стараюсь использовать только пробелы. Отбивку делаю естественно клавишей TAB. Разные языки, проекты и редакторы имеют разное количество пробелов в оступе между блоками и я не собираюсь следить за этим. ТАБ делает за меня эту работу.
                Тем не менее в большинстве редакторов попробуйте кодить с копипастой. Если вы всегда попадаете в нужную разметку — вы бог. Если у вас IDE сама выравнивает — божественная IDE. У меня же всё низменно и просто. Либо я не попадаю в разметку и мой текст куда-то убежал, либо IDE косячит разметку, которую я хочу видеть. Речь идёт в частности о вторых, третьих параметрах, когда идет вызов одинаковой/ых функций, заполнении текстур и т.д.
                И вот тогда я использую божественный пробел, который приводит мою разметку к удобному, читаемому виду, а не пытаюсь угадать где же мне поставить пару табов и потом еще пару backspace-ов.

                А с точки зрения структурирования вообще — я сторонних пробелов. Именно из-за ужасно неопределённого поведения ТАБов. Бывало что текст начинался с половины страницы.
                Хорошие IDE сами конвертнут тебе табы в пробелы, переформатируют перед открытием и сохранением и т.д.
                И тем не менее пробелами можно добить 3 нужных раза, можно добить на глазок, когда не сразу видно сколько там табов и т.п.
            –26
            Нажимаю пробел два раза и не вижу проблемы.
            Пробел — под большим пальцем, кликнуть два раза — не проблема.
            Таб — не интуитивен и не глядя сложно попасть, особенно без привычки.
              0
              Взяли и заминусовали, но никто так и не пояснил, как это редкоиспользуемая клавиша может быть удобнее частоиспользуемой.

              Я же не пишу, что НАДО использовать пробелы или что НЕЛЬЗЯ использовать таб. Я просто не понимаю, зачем использовать таб, когда быстрее отбить пару пробелов.
                +7
                Проблема в том, что из-за некоторых личностей пробелы отбивать приходится чаще раза 4, поэтому табы куда удобнее. Пару тройку вложенностей пробелами отбивать по 4 раза — увольте. А еще удобнее использовать нормальный редактор.
                  +1
                  Как раз таки не люблю подгонять привычки под редактор.
                  Это примерно так же вредно, как пытаться кнопкой «Break» поменять раскладку введенного текста, привыкнув к пунто-свитчеру. (Мне так комп вырубают, попадая на power, отличная работа.)

                  Лучше я буду руками вбивать текст одинаково, чтобы работала мышечная память, а не пытаться каждый раз сообразить, а в том ли я редакторе, где таб развернётся в пробелы.

                  ПС: не всегда же приходится писать в IDE, а ещё — не всегда в своей IDE, где всё настроено под вас.
                    +3

                    А востребована ли у вас кнопка power? Может её того? В студенческие годы я умудрялся несколько раз подряд перегружать университетский ПК, нажимая её вместо PrintScreen. Несколько досаждало.

                      –1
                      Сам не промахиваюсь, так что кнопку «чинить» так или иначе — лень.
                        +1
                        У не помню была ли у меня кнопка power, но помню что вырывал с клавиатур кнопку sleep.
                          +2
                          У меня для вас плохие новости:
                          http://image.prntscr.com/image/2dbfeba36ee94d89a31d556e39140fa8.png
                            0
                            Видимо я был слишком ленив, чтобы разобраться в настройках)))
                        +5
                        А что это за кейс, когда приходится регулярно работать в разных чужих IDE? У нас вот по опыту наоборот разработчики годами работают в любимой IDE и синхронизируют конфиг с домашней версией. Это повышает производительность, для того оно и придумано.
                          0
                          Парное программирование, подойти помочь новичку, найти на машине другого разработчика кусок кода и поправить багу.
                          Кейсов хватает. Я не ношу с собой нетбук, чтобы править как мне удобно, я просто привык к тем форматам, которые работают не зависимо от того, кто за ПК.
                            0
                            Думаю, это обусловлено спецификой именно вашей позиции. В общем случае регулярное написание кода за кого-то означает отсутствие желания делегировать ответственность со стороны лида и/или неспособность работать самостоятельно со стороны разработчика. В профессиональной команде оба случая по идее должны плавно сойти на нет. Отдельный случай — парное программирование, но в рамках проекта (а лучше всего пула проектов, использующих одни и те же ресурсы) все равно должны быть единые требования к написанию и оформлению кода, к которым участник команды рано или поздно привыкнет.
                          0
                          Это как хоткей ctrl+alt+L в IDEA, который на убунте блокирует комп.
                        +3

                        Tab отлично лежит под мизинцем левой руки. К тому же те самые пробелы, которые вы отбиваете space-ом, большинство отбивает всё тем же Tab-ом. Хотя по правде говоря для меня и Ё отбивать не составляет труда. Мизинец не так уж и короток.

                          0
                          Солидарен. Для меня удобнее использовать Tab, а нажимаю его безымянным пальцем.

                          Пользоваться Tab'ом или отбивать все пробелами, дело привычки каждого, но порой (опять же лично мне) не совсем удобно работать с кодом отбитым пробелами.
                            0

                            Владимир Шахиджанян („Соло на клавиатуре“) сейчас негодует. Мизинцем же надо!

                              0
                              а за то, что я контрол нажимаю ладонью, а не пальцем вообще?)
                                +2

                                Вы очень опасный человек.

                          +6
                          Да не быстрее. Один отступ — ладно, а лесенку на 4-5 отступов тоже дятлом стучать? Табуляция применяется нередко, например при переключении приложений, при переходе по вкладкам IDE и в браузере, при сдвиге влево/вправо блока кода, а не строки.
                            0
                            А такие лесенки я никогда не был вынужден писать, вот уж извините. Не знаю, зачем это может потребоваться.
                              0
                              Тело метода — раз, два вложенных цила и 1 if — еще 3. Это примитивная маленькая функция.
                                0
                                Вот здесь, например, в первом же пункте объясняется «малоотступовый» подход: https://habrahabr.ru/post/206802/

                                Впрочем, с Java я дел особо не имею, может там так и правильней. А вот в C и Perl 4 уровня — обычное дело. Впрочем, сам я расстановкий их и не занимаюсь, ибо есть 1) при нажатии на Enter в 90% случаев IDE сама проставит нужный уровень и 2) после написания блока кода автопилотом жмётся кнопка, на которой висят «perltidy -pbp» и один раз настроенный astyle для C/C++/Java :)
                          +5
                          Если вы только кодите, то беспорно для вас Таб очень непопулярная клавиша. Я, же, «тракторист» старой закалки и еще в 90-х получил привычку безошибочно бить мизинцем в таб, при смене панелей в разных нортон/волков- командерах, а позже, с появлением табкомплитишина в линуксе я постоянно добиваю пути и команды именно табом.
                          Имхо, влияет на использование таба или пробела разница поколений и точка в хода в индустрию.
                            0
                            В командерах \ фаре табом пользуюсь. в IDE — как то не надо. Возможно и удобный вариант, надо проверять. Или не проверять, чтобы не ломать привычки.
                          +2
                          Эти люди не хотят по-другому, они не используют все преимущества, которые им предоставляют всевозможные тулы. Есть исключения (нету редактора), но это редкость.

                          зы: я уже и забыл, когда сам делал отступы в коде.
                            0
                            Я так делаю, 2 пробела =)
                            Меня оправдывает то, что я не кодер, а админ, кода мало и пишу я его в основном через ssh в vim или mcedit.
                              +4
                              Скромный вопрос: а в современных IDE всё ещё приходится выравнивать код вручную?
                              Что-то я привык к автоматическому выравниваю…
                                +1
                                Выравнивать умеют и блокноты, и даже редакторы в браузерах.
                              +1
                              Интересно, почему *.c и *.h считали отдельно.
                                0
                                *.h не только в C, но и в C++ используется.
                                  0
                                  *.h не известно куда добавить — к *.c или *.cpp
                                    0
                                    Если анализировались проекты целиком, то можно, в принципе, отследить. Просто получаются в некотором роде взаимоисключающие параграфы — в *.c лидируют с хорошим отрывом табы, а в *.h пробелы.
                                      0
                                      Есть много проектов, где выйдет мешанина. Например сам проект на С++, но использует legasy «С» библиотеки, ну например OpenSSL и аналоги.
                                        0
                                        Статистика С «испачкана» ядром линукса, где используются табы.
                                          +1
                                          Я бы сказал, напротив — ядро линукса один из важнейших проектов на С, который помимо прочего показывает, что табы ещё живы.
                                            0
                                            Но это один проект. А статистика велась по фийлам. Ну и конечно-же — табы живы!

                                            Самое страшное это проекты где есть и табы, и пробелы!
                                    +2
                                    ИМХО в современных IDE делать отступы вручную — надо КРАЙНЕ редко. Code Format делает все сам прелестно.
                                    +1
                                    Я из «пробельщиков», но задумался вот над чем: так весь вопрос только в том, что табы в разных IDE занимают разное пространство?
                                    И из-за этого были написаны десятки статей на хабре?
                                      +7
                                      начнем с того что код еще и в блокноте смотрят, и в браузере и даже печатают! В итоге хочется таки иметь что-то одинаковое.
                                        0
                                        Одинаковое для кого? Для вас? А если я люблю отступ в 8 пробелов, зачем меня ограничивать потому что вам нравится 4? Все табы настраиваются везде, каждый кто будет смотреть увидит код так как он любит, а не так как любит автор кода. Пробелы — эгоизм.
                                      +18
                                      Я думал что холиво давно закрыт и все используют пробелы.
                                        +47

                                        А я думал, что похоливарили и перешли на табы. ;)

                                          +3
                                          Я думал что холиво давно закрыт и все используют табы.
                                            +2
                                            Большинство не может ошибаться, я тоже за пробелы, ставьте везде пробелы, больше пробелов!
                                            Хотя сам конечно же использую табы, и шрифт не моноширинный ещё, ну чтобы работу себе усложнить, не делайте так никогда.
                                              +1
                                              Как было верно замечено в статье, для разных языков и проектов удобнее либо то, либо другое.

                                              Например, если брать bash, который с некоторым натягом таки можно считать языком программирования, то для него наиболее естественно использовать табы, ибо только ими можно делать отступы для here-docs.
                                              В питоне отступы в виде четырёх пробелов прописаны в PEP, поэтому табовые бунтари в меньшинстве.
                                              У go, похоже, самое сплочённое сообщество в смысле статьи.
                                              +11
                                              Интересный пример того, как набор сомнительных доводов и агрессивная автозамена табов на пробелы привела к победе одной из сторон. То есть это такой вообще не научный способ решения проблемы методом «ой всё» от разработчиков основных инструментов. А теперь вместо одного символа на очередной уровень отступа там этих символов несколько.

                                              Похожая беда с автозаменой переводов строк. И с финальным переводом строки. Просто диктатура людей на местах, чем управляем, тем и давим несогласных — борьба мемов влияет на реальность, чисто по Докинзу.
                                                +12
                                                Надо дальше развивать эту мысль, лишние символы требуют больше места на дисках, т.е. требуется больше дисков, а значит, и больше электроэнергии. Плюс, производство дисков, плюс их утилизация, плюс добыча и сжигание углеводородов. Сделать расчёт, обоснование, отправить это в Гринпис, и начать всемирную войну с пробелами.
                                                  0
                                                  Можно развивать ещё дальше. Требуется больше дисков, больше электроэнергии, утилизация, добыча и сжигание углеводородов. Да это же всемирный заговор корпораций!
                                                  +1
                                                  А теперь вместо одного символа на очередной уровень отступа там этих символов несколько.

                                                  Я понимаю, когда при диске в 5 мегабайт писали архиваторы, чтобы сжимать пустое место и ключевые слова в исходниках. Но сегодня считать доводом «тут 2-4-8 символов, а не 1»?
                                                    –1
                                                    Это один из многих аспектов осмысленности действий погромиста. Отступ ставится кнопкой Tab, превращается в пробелы, которые приходится удалять по одному, ходить по ним курсором, а если копипастишь и зацепил выделением лишний пробел, сразу всё ломается. Куча лишних действий. Для чего? Для кого?
                                                      +3
                                                      которые приходится удалять по одному, ходить по ним курсором, а если копипастишь и зацепил выделением лишний пробел

                                                      Да нет, все от IDE зависит. У меня клавиши «влево»-«вправо» по отступам переходят, при том, что они — пробелы. Удаляется все опять же комбинацией клавиш «убрать отступ», встроенной в IDE. При копировании, выделении, сразу целиком отступ копируется.
                                                    +5
                                                    Очень субъективное наблюдение об обоих сторонах конфликта.
                                                    1. Если человеку удобно нажимать на Таб, но гайдлайны проекта не позволяют табы-символы, человек ставит настройку «заменить таб на пробелы» — все счастливы и довольны. «Человек-таб» понимает ситуацию и принимает ее с компромиссом в виде настройки.
                                                    2. Если человек принципиально пользуется пробелом, но гайдлайны требуют табы (да, такое бывает) — человек будет брюзжать, дуться и топать, требуя смены гайдлайнов, ни о каком компромиссе или настройках речь даже не идет (повторюсь, все очень субъективно, может мне просто не повезло, и понимающие ситуацию «люди-пробелы» мне просто не попадались). Косвенно это глобальное явление подтверждается тем, что чаще всего опции в IDE «превращать пробелы в табы» просто не бывает — «люди-пробелы» в принципе не рассматривают возможность инакомыслия.
                                                      0
                                                      заменить таб на пробелы» — все счастливы и довольны

                                                      Не совсем, проблема в том что "человек-таб" хочет отступы в 2 пробела, но по гайдлайам должень использовать 4.

                                                        0
                                                        Очень напомнило вот этот лонгрид https://ru.insider.pro/opinion/2016-08-16/kak-rabotaet-diktatura-menshinstva/
                                                        +5
                                                        набор сомнительных доводов и агрессивная автозамена табов на пробелы привела к победе одной из сторон.


                                                        Ага. А еще такие ложные статьи с ошибочной статистикой, как эта.

                                                        Никакой победы нету. Статья имеет ошибку в алгоритме и отсюда ложные выводы.
                                                        «at least 10 lines, that start with space» — нельзя считать по одному пробелу. В пример Гибернейт из Джавы.

                                                        https://github.com/hibernate/hibernate-orm/blob/master/hibernate-core/src/main/java/org/hibernate/Filter.java
                                                        /*
                                                         * Hibernate, Relational Persistence for Idiomatic Java
                                                         *
                                                         * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
                                                         * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
                                                         */
                                                        package org.hibernate;
                                                        import java.util.Collection;
                                                        
                                                        import org.hibernate.engine.spi.FilterDefinition;
                                                        
                                                        /**
                                                         * Type definition of Filter.  Filter defines the user's view into enabled dynamic filters,
                                                         * allowing them to set filter parameter values.
                                                         *
                                                         * @author Steve Ebersole
                                                         */
                                                        public interface Filter {
                                                        
                                                        	/**
                                                        	 * Get the name of this filter.
                                                        	 *
                                                        	 * @return This filter's name.
                                                        	 */
                                                        	public String getName();
                                                        
                                                        


                                                        А ведь вся джава начинается с таких заголовков. И они ложно засчитывают пункт в сторону пробела, хотя реально в файле используется табуляция.
                                                        +7
                                                        Я думал что холиво давно закрыт и все используют табы.
                                                          +2
                                                          А я думал, что это тема обсуждения интересна только в Python.
                                                          +17
                                                          Адепты языка GO явно что-то знают!
                                                            +3
                                                            Не хочу выступать К.О., но это потому что у них с этим строго.
                                                              0

                                                              это гугл знает за них


                                                              зы: не успел :(

                                                                0
                                                                У них в синтаксисе короткие слова, которые с табами в 4 символа хорошо сочетаются (ну и форматер стандартный, но как видно по гитхабу, не все его используют).

                                                                func f() {
                                                                    var a = 5,
                                                                        b = 5;
                                                                }
                                                                
                                                                  0
                                                                  По-хорошему, в документации к gofmt табы по 8 символов, но не всем и не всегда бывает так удобно.
                                                                  0
                                                                  Теперь и я знаю зачем мне нужен GO
                                                                  +4

                                                                  Из-за этого и появляются проекты вроде EditorConfig. Кстати, не могу понять, почему он не упомянут в статье, как возможное, и, наверное, наилучшее на данный момент средство удаления разногласий в этом вопросе.

                                                                    +12
                                                                    Нужно было еще посчитать количество файлов, где используются и табы, и пробелы вместе.
                                                                      +6
                                                                      А заодно вычислить авторов такого кода и принудительно переселить куда-нибудь на марс.
                                                                        0
                                                                        Обычно решаемо прикруткой конвертера отступов к системе контроля версий. Заодно дисциплинирует не приносить код откуда попало.
                                                                        +3

                                                                        Отступы табами, всё, кроме отступов пробелами.

                                                                          0

                                                                          И не забыть вычесть из этого числа smart-tabs

                                                                            +2
                                                                            Вообще-то с табами обязательно нужно использовать пробелы. Например в некоторых конструкциях люди, использующие табы часто делают так:
                                                                            [tb]var a=1,
                                                                            [tb][tb]b=2;


                                                                            При настроенном табе в 2 или 8 символов (а это ведь один из основных доводов) получается такая каша:
                                                                            ..var a=1,
                                                                            ....b=2;

                                                                            или
                                                                            ........var a=1,
                                                                            ................b=2;
                                                                            .

                                                                            Поэтому нужно использовать пробелы с табами:
                                                                            [tb]var a=1,
                                                                            [tb]....b=2;


                                                                            Если использовать только пробелы, то проблем тоже не будет
                                                                              0
                                                                              Посимвольное выравнивание с табами плохо совместимо.
                                                                                0
                                                                                > При настроенном табе в 2 или 8 символов (а это ведь один из основных доводов) получается такая каша

                                                                                Смотря какой тул использовать. Если использовать качественный — то все будет нормально выравниваться, если в простом блокноте работать — да, будет не удобно.
                                                                                  0

                                                                                  Вне зависимости от редактора так делать не стоит. Вот вам пример.


                                                                                    0
                                                                                    Возможно мы друг друга не поняли. Я подразумевал настройку замены пробелами при нажатии на клавишу табуляции. При нажатии на клавишу вставляется на 1 символ табуляции, а 2-4-8 пробелов, в зависимости от того, где сейчас стоит каретка (Таб по своей семантике может занимать место в N знаков).

                                                                                    Но в указанном примере есть проблема: в настройках стоит 8 знаков на 1 таб, если было бы 4 — было бы красивее.
                                                                                    Обычно табы в 4 символа хорошо сочетаются с языками в которых короткие ключевые слова: def, var, let, val; потому их там и любят применять.

                                                                                    зы: я предпочитаю пробелы.
                                                                                  +2

                                                                                  Насколько я понимаю, это как раз и есть smartTabs. Табы для indent-а, а пробелы для aligment-а. Наверное, это единственная заморочка с табами, что мне попадалась (в сравнении с пробелами). Использование tab-ов для выравнивания гарантировано превращает код в кашу за пределами вашего редактора.

                                                                                    0
                                                                                    Единственная проблема Smart Tabs в том, что поперву к этому надо привыкать. Я на период привыкания выставлял размер таба в 3 или в 5 пробелов, чтобы не было соблазна форматировать текст табами.

                                                                                    В остальном же Smart Tabs — отличный способ позволить людям использовать свой любимый indent, просто выставив ширину таба в настройках редактора.
                                                                                    0
                                                                                    При настроенном табе в 2 или 8 символов (а это ведь один из основных доводов)

                                                                                    Вообще-то, табуляция изначально не в символах, а в частях листа, грубо говоря, это условные колонки, на которые он поделен, так что в электронном виде у него вообще должна быть переменная длинна, особенно не в моноширинных шрифтах.
                                                                                    Какой вообще смысл приравнивать таб к пробелам — или вы привязываетесь к началу какой-то колонки (типа красной строки) или — нет. Если — нет, то что, большое значение имеют с какой кнопки запускать скрипт, который проставит удобное количество пробелов?
                                                                                • НЛО прилетело и опубликовало эту надпись здесь
                                                                                    0

                                                                                    Кстати, вот интересно, а в каком-таком рейтинге C# не входит в список 14 самых популярных языков программирования?

                                                                                      +2

                                                                                      Так cs же есть, там не языки а расширения файлов

                                                                                        +2

                                                                                        Виноват. Точно! Спасибо огромное за подсказку!

                                                                                        0
                                                                                        В C# расширение файлов cs и оно присутствует в рейтинге.
                                                                                          –2
                                                                                          Тот же вопрос по swift-у. :(
                                                                                          +1
                                                                                          использую то что, иде предлагает.
                                                                                          А с GoLang ситуация ясна, в го заставляют юзать gofmt.
                                                                                            +1
                                                                                            Не знаком с языком, но почему в Go практически только табы, синтаксис?
                                                                                              +9
                                                                                              Встроенная утилита gofmt является одним и единственным на всех форматированием кода. Программы просто не компилируются, если не соблюдать ее правила. Для указания отступов там используются только табы. Для выравнивания используют только пробелы. Т.е., по сути, то, как это должно было быть с самого начала у всех и с чем никаких проблем никогда не будет при отображении. А все проблемы пошли от того, что кому-то вздумалось выравнивание делать табами, от чего и съезжает в разных просмотрщиках все.
                                                                                                +2
                                                                                                Программы просто не компилируются, если не соблюдать ее правила.

                                                                                                Вообще конечно компилируются, просто подавляющее большинство разработчиков запускает gofmt после сохранения/перед коммитом.

                                                                                                  +1
                                                                                                  На табы и пробелы он конечно не ругается, а вот неправильно расположенные { } вываливаются в ошибку компиляции. Если честно, не пойму, почему не сделали еще более жесткую проверку тех же отступов.
                                                                                                    +1
                                                                                                    неправильно расположенные { } вываливаются в ошибку компиляции

                                                                                                    Это не из-за того что это стилевая ошибка, просто лексер языка устроен так чтобы автоматически "вставлять" точки с запятой в нужных местах. Механизм этой автоматической расстановки точек с запятой описан в спецификации, и из него следует, что ifы и прочие стейтменты должны содержать открывающую скобку на той же строке, иначе точка с запятой вставится не туда, куда нужно. То, что это принуждает использовать конкретный стиль, является следствием, а не причиной и не основной мотивацией.

                                                                                                      0
                                                                                                      Про это я забыл, но тут не совсем очевидная последовательность событий. Изначально этого правила вставки не было, но gofmt был с самого начала — единый стиль для всех был одной из самых первых фич языка. Было ли с самого начала желание показывать ошибку при неправильном форматировании кода или же это пришло с этим правилом уже вопрос. Эта вставка точек с запятой пришла, судя по по посту Роба Пайка, когда они решили сделать их необязательными, но наткнулись на некоторые проблемы с реализацией этого.
                                                                                                  0
                                                                                                  Программы просто не компилируются, если не соблюдать ее правила.


                                                                                                  Большинство правил форматирования можно спокойно нарушать и программа при этом нормально компилируется.
                                                                                                  Но в больших проектах часто делаются автопроверки на соответствие кода стилю и туда не пропускаются коммиты, не соответствющие правилам gofmt — чтобы код выглядел одинакого.

                                                                                                  В личных проектах тоже запускаю gofmt, просто потому что это удобно.
                                                                                                    0
                                                                                                    На самом деле там два парсера — один в gofmt, другой непосредственно в компиляторе. Компилятору пофиг на табы и пробелы. А gofmt создает синтаксическое дерево и по нему заново строит код по сути.
                                                                                                    –1
                                                                                                    Скорее хипстерские редакторы ;)
                                                                                                    0
                                                                                                    Если я не ошибаюсь для java и в eclipse, и в intellij пробелы по умолчанию используются для отступов. Причем разницу заметить сложно, так что если принципиальной разницы нет, то они так и останутся. Думаю это вполне может потянуть на один из факторов
                                                                                                      0

                                                                                                      Для ruby, python, php, js продукты от intelliJ также являются очень популярными и настройки по умолчанию там так же с пробелами.

                                                                                                        +2
                                                                                                        В python есть PEP-8
                                                                                                      –3
                                                                                                      Вместо того, чтобы думать про чистоту кода на уровне дизайна, люди заморачиваются с какого конца разбивать яйцо… Гламурненько!
                                                                                                        +5
                                                                                                        Чистота кода начинается как раз с его оформления, дизайн — это уже следующий этап.
                                                                                                          –1
                                                                                                          Оформление должно преследовать только одну цель — улучшение читаемости кода. Если ты видишь отступ, то очень странно задумываться что там «внутри»: пробелы или табуляция.
                                                                                                            +6
                                                                                                            > Если ты видишь отступ, то очень странно задумываться что там «внутри»: пробелы или табуляция.
                                                                                                            А если ты видишь отступ на 8 символов, и у тебя часть кода оказывается за пределами экрана? Потому что там табуляция, а в твоем редакторе её размер 8 колонок?
                                                                                                            А если того хуже, ты видишь часть кода смещённой влево, часть вправо, и это потому, что его писали в разное время разные разработчики, один ставил два пробела, а другой делал отступы табом. И в итоге код первого отображается «как есть», а код второго едет по настройкам табуляции текущего редактора.
                                                                                                            Поэтому задумываться над этим как раз приходится. А читаемость кода, она как раз первичнее любого дизайна. Потому что нечитаемый код не может априори иметь хороший дизайн и подлежать нормальному сопровождению.
                                                                                                              –2
                                                                                                              А если ты видишь отступ на 8 символов, и у тебя часть кода оказывается за пределами экрана? Потому что там табуляция, а в твоем редакторе её размер 8 колонок?

                                                                                                              Любой редактор способен установить табуляцию на конкретное число символов.

                                                                                                              один ставил два пробела, а другой делал отступы табом.

                                                                                                              Если отступы во всем коде имеют одинаковое число пробелов, то см. пункт выше. Если нет (один разработчик ставит 2 пробела, второй 4 а третий 8) то это совершенно другая проблема.

                                                                                                              Потому что нечитаемый код не может априори иметь хороший дизайн

                                                                                                              В качестве опровержения: Берем отлично форматированный код с прекрасным дизайном, пропускаем через обфускатор. Получаем полностью нечитаемый код. Что, дизайн тоже «испортился»?
                                                                                                                +4
                                                                                                                > Любой редактор способен установить табуляцию на конкретное число символов.
                                                                                                                > Если отступы во всем коде имеют одинаковое число пробелов,
                                                                                                                Вы готовы менять настройки редактора под капризы каждого исходника? Мне кажется, это за гранью продуктивной работы.

                                                                                                                > Берем отлично форматированный код с прекрасным дизайном, пропускаем через обфускатор.
                                                                                                                > Получаем полностью нечитаемый код. Что, дизайн тоже «испортился»?
                                                                                                                Нет, но код на выходе обфускатора уже не имеет отношения к предмету спора. Он не предназначен для разработчиков, и это просто заготовка для дальнейшей машинной обработки. С тем же успехом вы можете в качестве «опровержения» привести обычную компиляцию в бинарник. При этом тоже дизайн не меняется, а всего лишь преобразуются человекочитаемые конструкции в машинные коды.
                                                                                                                0
                                                                                                                Потому что там табуляция, а в твоем редакторе её размер 8 колонок?

                                                                                                                Поставить в редакторе длину табуляции в 2 или 4 колонки, не? Я выиграл миллион?

                                                                                                                А если автор кода использовал 8 пробелов для отступа, что мне делать в редакторе чтоб оно не уезжало?
                                                                                                                  0
                                                                                                                  Поставить в редакторе длину табуляции в 2 или 4 колонки, не? Я выиграл миллион?
                                                                                                                  ответ
                                                                                                                  Вы готовы менять настройки редактора под капризы каждого исходника? Мне кажется, это за гранью продуктивной работы.
                                                                                                                –1
                                                                                                                А если не видишь отступ, потому, что автор намудрил с табами или пробелами? Тут-то после 20-го кодревью ТимЛид с окровавленными глазами и хлопает кулаком постолу со словами «хватит это терперть, слушать всем сюда! С этого дня переходим все на форматирование пробелами/табами (нужное подчеркнуть) „
                                                                                                                  +1
                                                                                                                  Достаточно один раз спокойно сказать: «у нас отступы N символов». Если форматирование поехало — заворачивать сразу на ревью. И не надо делать окрававленные глаза и стукать кулачками по столу — это как минимум смешно.
                                                                                                            +1
                                                                                                            В IDE использую то, что предлагает IDE (так понимаю, чаще всего это 2 или 4 пробела — разные установки по умолчанию)
                                                                                                            В текстовых редакторах использую исключительно табы, если это не правки в чужой проект.
                                                                                                              0
                                                                                                              В IDE тоже желательно использовать настройки проекта или хотя бы придерживаться тех отступов, которые у тебя в текущем файле, я бы даже сказал, в текущей функции / методе. Не редко бывают проекты, где часть кода с пробелами, а часть с табами. Более того, иногда в одной строке могут быть как пробелы, так и табы :(
                                                                                                              –2
                                                                                                              Space, only space!
                                                                                                              «Нам нужно больше пробелов, больше!»
                                                                                                                0
                                                                                                                Чаще всё-таки в go (там настолько часто, что почти одни только табы), а вот больше — в C (но частота так себе, почти пополам). Если под чаще понимать вероятность попасть в цель, ткнув наугад.
                                                                                                                  +2
                                                                                                                  Ну а где проверка насколько уменьшится объем кода при замене пробелов на табы?
                                                                                                                    0
                                                                                                                    Привык к пробелам хотя могу и табы, в IDE использую таб переводимый в пробелы. А холивара по поводу символов конца и такой же статистики строки случаем нету?))
                                                                                                                      0
                                                                                                                      В том же Саблиме — табы легко на пробелы заменяются, а наоборот часто не очень. Потому предпочитаю табы.
                                                                                                                        +11
                                                                                                                        Я давно не могу понять, почему пробелы популярнее табов, и почему они вообще используются для отступов. Это для меня величайшая загадка. Табы — специальные символы для отступов от края, они для этого и придуманы еще со времен печатных машинок. В редакторах их визуальную длину можно регулировать. Когда нажимаешь backspace, удаляется весь таб целиком; если использовать пробелы, то в этой ситуации тебе надо жать два или четыре раза. Короче, я не понимаю людей.
                                                                                                                          0
                                                                                                                          А что за кейс с удалением одного таба? Я обычно строчку целиком удаляю, т.е. ctrl+backspace.
                                                                                                                            0
                                                                                                                            В Python часто при рефакторинге натыкаюсь на лишние отступы. Конечно, можно и Ctrl+[ нажать, многие редакторы эту комбинацию поддерживают, но если уже курсор упал на начало кода в этой строке, то можна и backspace ткнуть. Это мелочь, просто табы ведут себя логично, а пробелы мне кажутся какими-то костылями.
                                                                                                                            +2
                                                                                                                            Выше же писали уже — с пробелами код всегда и сразу железобетонно одинаково выглядит в любом редакторе. Даже если на чужом компе открываешь файл каким-н блокнотом посмотреть, а там у человека таб шириной 8 пробелов и все размажется по экрану, что тоже лезть в настройки менять, а потом обратно?
                                                                                                                              +1
                                                                                                                              Так это же как раз недостаток. Если в проекте используются табы, любой участник может открыть файл и настроить визуальные отступы так, как ему нравится — хоть в два символа, хоть в десять. И это никак не затронет сам код. Если же используются пробелы, программист, нравится ему это или нет, вынужден подстраиваться под принятые гайдлайны, и ничего он с этим не поделает.
                                                                                                                              Пример с блокнотом, откровенно говоря, является редким случаем и мало относится к разработке как таковой. Это, скорее, из будней админа, который скрипт на сервере поправляет.
                                                                                                                                +1
                                                                                                                                программист, нравится ему это или нет, вынужден подстраиваться под принятые гайдлайны, и ничего он с этим не поделает.

                                                                                                                                Естественно. Программист должен, нет, обязан даже подстраиваться под проект. Не нравится — пусть идет в другой проект или делает свой. А если кому то из програмистов скобочки приспичит так писать
                                                                                                                                if (a) {
                                                                                                                                }
                                                                                                                                

                                                                                                                                вместо расово-верных используемых в проекте
                                                                                                                                if(a)
                                                                                                                                {
                                                                                                                                }
                                                                                                                                

                                                                                                                                то что тогда?
                                                                                                                                  +2
                                                                                                                                  Табы позволяют программисту работать в привычном стиле, не нарушая гайдлайнов. Вместо того чтобы проклинать своих коллег, которые придумали отступы в 8 пробелов, он может спокойно поменять длину таба у себя в редакторе и не париться.
                                                                                                                                    –4
                                                                                                                                    Вот вам форматирование табами. Не совсем отступы от края, но привычка используется для этого та же. В IDE это выглядит ровно. Или такое как раз пробелами набивать бешено давя на клавишу?
                                                                                                                                    #define AAAAAAA		1
                                                                                                                                    #define B			2
                                                                                                                                    


                                                                                                                                      +4
                                                                                                                                      Как раз такие отступы я, во-первых, не поощряю, а во-вторых, если уж они вам сильно нужны, то естественно их следует выполнять в виде пробелов. Таб — отступ от края. Пробел — отступ между символами.
                                                                                                                                        0
                                                                                                                                        Так большинство этого не понимает. + такая ситуация: https://habrahabr.ru/post/308974/#comment_9783072, тут не между символами
                                                                                                                                    0
                                                                                                                                    Программист должен, нет, обязан даже подстраиваться под проект

                                                                                                                                    Ужас какой, про инструменты автоматического форматирования кода при коммите вы наверно не слышали? Скажите пожалуйста, в какой фирме вы работаете, я ее в черный список сразу закину.
                                                                                                                                      +2
                                                                                                                                      Вы тут нам холивары не путайте! Расстановка скобок — совсем другой холивар, ещё, пожалуй, холиваристей этого.
                                                                                                                                      –1
                                                                                                                                      А потом, я такой с настройкой конвертирования табов в пробелы кликаю «переформатировать» и что происходит? Табов в коде больше нет и вернуть их нельзя фактически.

                                                                                                                                      Всем спасибо, табы на выход.
                                                                                                                                        0
                                                                                                                                        Не понял, зачем вам это делать и как в этом виноваты табы? Зачем вообще что-то переформатировать, если вам специально придумали символ для отступов?
                                                                                                                                          0
                                                                                                                                          VS как минимум дает хоткей ctrl+K + ctrl+D, который всю страницу форматирует согласно моим настройкам. И если у меня стоит автозамена табов на пробелы — это он тоже сделает. В итоге, если я хотел выровнять всего лишь одну добавленную мной строчку, то и табы я чьи то случайно удалил.
                                                                                                                                            0
                                                                                                                                            то и табы я чьи то случайно удалил

                                                                                                                                            И правильно сделали. Это ваша локальная копия, делайте с ней что хотите.
                                                                                                                                              0
                                                                                                                                              Эм, так я потом это же и зачекиню. Особенно если студия же игнорит пробелы при чекине.
                                                                                                                                                0
                                                                                                                                                Так настройте автоформатирование при коммите и будет вам счастье.
                                                                                                                                                  0
                                                                                                                                                  Существует способ вернуть табы из пробелов?
                                                                                                                                                  Я не понимаю, как вернуть теперь файл, кроме полной отмены и внесения исключительно моих изменений.
                                                                                                                                                    0
                                                                                                                                                    Существует способ вернуть табы из пробелов?

                                                                                                                                                    Так я же говорю, есть инструменты автоматического форматирования, они выполнены в виде настраиваемых консольных утилит. Вешаете их на хук git при коммите и они вам из ваших пробелов сделают табы и наоборот (смотря как настроите). И не мучайте больше себя и коллег.
                                                                                                                                              +2
                                                                                                                                              Вот поэтому я и ратую за табы. Если принять их за единый стандарт, то все эти инструменты для форматирования утратят свою актуальность. Не нужно прописывать в гайдлайнах длину отступа, не нужно париться о том, что у тебя редактор что-то конвертировал не так. Ставишь таб — и все у тебя хорошо. И этот таб — он и в Африке будет табом. А как ты его у себя в редакторе отобразишь — это твое дело.
                                                                                                                                                0
                                                                                                                                                Такое ощущение, что мы пишем разный код. В разных IDE, с разными сниппетами и разными гайдлайнами. Потому что когда я делаю новую строку при незакрытой кавычке, VS спокойно может не тот отступ проставить. Потом я исправлю кавычку, а чтобы руками не пробивать правильный отступ — использую хоткей на переформатирование. Таб не таб — никакой разницы.
                                                                                                                                        0
                                                                                                                                        Почему у человека там шириной 8 пробелов???
                                                                                                                                          0
                                                                                                                                          Ну так когда нет аргументов всегда в ход идут «преувеличения».
                                                                                                                                            +1
                                                                                                                                            Например кроме виндового блокнота нет ничего. Там даже поменять нельзя. Xml-файл имеющий в ide ширину таба в 2 некисло разъезжается.
                                                                                                                                            0
                                                                                                                                            тоже лезть в настройки менять, а потом обратно?

                                                                                                                                            А зачем обратно? Нормально настроить ширину табов и забыть о них не? А если вы используете 8 пробелов для отбивки, как мне посмотреть ваш код? Что в редакторе надо для этого настроить?
                                                                                                                                            0
                                                                                                                                            +1

                                                                                                                                            Лучший комментарий касаемо всего этого безумия «tabs vs. spaces», что я видел до сих пор.

                                                                                                                                            Спасибо!
                                                                                                                                              0
                                                                                                                                              Я давно не могу понять, почему пробелы популярнее табов

                                                                                                                                              Этого никто не знает, поверьте. Просто люд привык. Я сам когда то использовал пробелы для отступа, а потом спросил себя — а нах*ра? — после начал использовать табы.
                                                                                                                                              +2
                                                                                                                                              Уже и не сосчитать, сколько раз я видел этот холивар. Разницы что именно использовать нет вообще никакой, главное чтобы все в команде использовали один способ.
                                                                                                                                                –22
                                                                                                                                                Дошик или нормальная еда?
                                                                                                                                                (дошик — пробелы )
                                                                                                                                                image
                                                                                                                                                  +4

                                                                                                                                                  Вебгуй гитхаба давольно паршиво отображает код на табах — эквивалетно 8 пробелам.

                                                                                                                                                    0
                                                                                                                                                    Оно же настраивается, нет?
                                                                                                                                                      0
                                                                                                                                                      Это все браузеры вроде так (на всех сайтах) :(
                                                                                                                                                        0
                                                                                                                                                        Добавляете файл .editorconfig и применяете свои настройки indent_style и indent_size
                                                                                                                                                        Спецификация — EditorConfig.org
                                                                                                                                                        github поддерживает это нативно
                                                                                                                                                        0
                                                                                                                                                        Не понимаю холивар между церквями табуиров и спайсериан. По-моему это такой же бред как опускание крышки унитаза.

                                                                                                                                                        Может не так удобно переключаться между проектами, но в рамках одного проекта можно выбирать любой метод и просто не смешивать подходы.
                                                                                                                                                          +6

                                                                                                                                                          Ну а самое важное не написали. Крышку-то опускаете?

                                                                                                                                                            0

                                                                                                                                                            И есть ли корреляция между крышкой и табами? 27 лет, табы, крышку не опускаю.

                                                                                                                                                          0
                                                                                                                                                          Эта статистика показывает только одно — абсолютно всё равно, пробелы или табы. Можно юзать и то, и то, и никто от этого не умрёт. Кодстайлы в первую очередь должны быть одинаковыми у всех в проекте и лишь во вторую очередь учитывать мелкие плюсы и минусы пробелов/табов, переноса открывающей фигурной скобки, ширины отступа и тд.
                                                                                                                                                            0
                                                                                                                                                            А в какую категорию попал код где используется смешанный отступ? Я видел (и работал с) кодом где 1 отступ — 4 пробела, все группы из 8 пробелов заменяются на таб. Таким образом 3 уровня отступа — 1 таб и 4 пробела.
                                                                                                                                                              +9
                                                                                                                                                              Так, наверное, выглядит ад.
                                                                                                                                                                0
                                                                                                                                                                Похоже, этот код набирали в Midnight Commander'е.
                                                                                                                                                                0
                                                                                                                                                                В Delphi/Lazarus/Pascal два пробела, в C/C++ — таб.
                                                                                                                                                                  +4
                                                                                                                                                                  Проблема «табы vs пробелы» это локальная проблема общих настроек IDE у команды, а не глобальная. Связанная она с репозиторием кода, очень сложно мержить и ревьювить код когда там весь диф «красный» из-за разных настроек отступов у колег по цеху. Поэтому холивар, считаю, бестолковый на уровне религии и астрологии.
                                                                                                                                                                    0

                                                                                                                                                                    Клянусь, на данный момент я не знаю ни одной системы контроля версий, которая не умеет в диффах игнорировать различия в пустых символах.


                                                                                                                                                                    Это, конечно, не оправдание для смешения разных стилей стилей в одном проекте или (того хуже) файле. Если такая ситуация при слияниях встречается у коллег по одному цеху — в цехе явно проблемы.

                                                                                                                                                                      0
                                                                                                                                                                      Я просто оставлю это здесь…
                                                                                                                                                                      image
                                                                                                                                                                        +1

                                                                                                                                                                        Я не написал, что обязательно игнорируют разницу в белых символах, я написал, что умеют игнорировать.

                                                                                                                                                                    0
                                                                                                                                                                    различные IDE и их компиляторы обрабатывают табуляцию также по-своему


                                                                                                                                                                    Можете пояснить? Какие IDE и какие компиляторы как по-своему обрабатывают табуляцию?
                                                                                                                                                                    Табуляция – это просто 1 символ. По-моему, любой современный текстовый редактор сейчас позволяет настроить как его показывать (какой длины он должен быть).
                                                                                                                                                                    Что вы имеете в виду?
                                                                                                                                                                      0
                                                                                                                                                                      Это конечно не IDE, но в Makefile оно так и есть
                                                                                                                                                                        0
                                                                                                                                                                        Так и есть – в смысле, там есть разница пробел используется или tab?
                                                                                                                                                                          0
                                                                                                                                                                          Да.
                                                                                                                                                                            0
                                                                                                                                                                            Ну, окей, но это все равно пример натянутый несколько. Речь шла о языках программирования и IDE, и, я так понимаю, наиболее популярных. Java, C++, Ruby, etc., IDEA, NetBeans, Visual Studio, Vim, etc. – для них нет разницы, пробелы используются или tab. Как и для компиляторов/интерпретаторов тех языков. Просто фраза в статье довольно некорректно звучит, по-моему.
                                                                                                                                                                      +1
                                                                                                                                                                      «Людям не нужны лучшие стандарты, людям нужны стандартные стандарты»
                                                                                                                                                                        +2
                                                                                                                                                                        «Табы занимают меньше места» — это какое-то типичное мнение любителей пробелов о тех, кто предпочитает табы.
                                                                                                                                                                        Я предпочитаю табы, но размер — это простите последнее о чем я вообще могу подумать в качестве аргумента «за». Более того — я предпочту не использовать этот аргумент, т.к. он — глупый.
                                                                                                                                                                          +1
                                                                                                                                                                          Табы и шрифты с лигатурами.
                                                                                                                                                                            +1
                                                                                                                                                                            Я за табы, но использую пробелы, потому что стандарты кодирования.
                                                                                                                                                                              +1
                                                                                                                                                                              Когда то давно активно использовал пробелы для всех целей форматирования, но затем задумался — а почему? — в результате получил вот такой ответ:

                                                                                                                                                                              Пробелы для всех целей форматирования (отступ и выравнивание) используется только теми людьми, которые считают свою стиль форматирования наиболее кошерным и совершенно не приемлют других форматов. Даже нет, не форматов, а других мнений и предпочтений! Подумайте сами, мне нравится использовать для отступов в исходном коде 2 столбца, а для отступов в «стене» XML 4, а то и 6 столбцов (в зависимости от «заполненности стены» символами), но мне присылают файлик, в котором 2 пробела под XML и 4 под исходные коды. Мне это не привычно, не удобно, но моему коллеге на меня плевать, он считает свой формат самым правильным и ему совершенно не важно, что существуют инструменты, позволяющие хранить тексты в репозитории в неком стандартном виде (автоматическое форматирование при коммите), а писать и просматривать локально в том виде, в котором вы привыкли.

                                                                                                                                                                              Вот такие выводы были мной сделаны. Подрезюмирую: используйте то что вам нравится (в том числе и стиль скобок, переносов и т.д.). Это позволит вам с помощью соответствующих инструментов хранить тексты в стандартном виде, а получать в удобном для вас формате. Никогда не требуйте от ваших коллег придерживаться на письме определенного стиля. Стиль, это их дело и вы не в праве его оспаривать.

                                                                                                                                                                              P.S. Сам использую табуляцию для отбивки и пробелы для выравнивания.
                                                                                                                                                                              P.P.S. Терпеть не могу, когда требуют соблюдения PSR-1 и PSR-2 на письме. Эти стандарты разработаны для корректной настройки инструментов автоматического форматирования (если кто не в курсе).
                                                                                                                                                                                +2
                                                                                                                                                                                «Чаще всего табуляция встречается в языке С, а пробелы — в Java. „

                                                                                                                                                                                Откуда такой вывод? Я в таблице явно вижу, что чаще всего табуляция встречается в Go, практически 99%.
                                                                                                                                                                                Просто самих проектов на Си пока что в выборке больше, чем на Go.
                                                                                                                                                                                  0
                                                                                                                                                                                  Форматирую в студии по Ctrl+K+D и даже не знаю что там получается в итоге — табы или пробелы. До лампочки вообще.
                                                                                                                                                                                    +25

                                                                                                                                                                                    Закрыл для себя этот вопрос давным-давно.


                                                                                                                                                                                    Спор „пробелы против табов“ имел под собой хоть какие-то логические основания, когда IDE не умели с ними работать: надо было нажимать много раз пробел или бекспейс (при использовании пробелов), выравнивание ломалось при смене размера таба (при использовании табов).
                                                                                                                                                                                    Сейчас IDE умеют работать с табами, а люди до сих пор не научились.


                                                                                                                                                                                    Главный плюс табуляции — семантичность. Это символ, специально созданный для отступов.
                                                                                                                                                                                    Когда вам нужно поставить ссылку, вы же пишете <a href="…">, а не <span onclick="…"?
                                                                                                                                                                                    Наверняка, каждого более-менее технически подкованного человека бесит, когда в ворде отступ параграфа сделан не отступом параграфа, а пробелами (скачайте пару первых попавшихся рефератов). Но при этом такая же ситуация у себя в коде людей не бесит :-)
                                                                                                                                                                                    Разный стиль параграфов


                                                                                                                                                                                    Все остальные аргументы теряют свою важность перед смыслом: размер файла, можно конфигурировать ширину, выглядит одинаково — вы серьёзно?


                                                                                                                                                                                    Самый разумный и естественный метод отступов — это смарт-табуляция: табы для отступов, пробелы для выравнивания:
                                                                                                                                                                                    Иллюстрация смарт-табуляции


                                                                                                                                                                                    Если среда разработки не понимает смарт-табуляцию и не может автоматически понять, где вставить табуляцию, а где пробел, то грош ей цена, такой среде.
                                                                                                                                                                                    Вот скриншот из настроек джетбрейновской Идеи:
                                                                                                                                                                                    Настройка табуляции в стилях кодирования


                                                                                                                                                                                    https://github.com/maximal/tab
                                                                                                                                                                                    https://www.emacswiki.org/emacs/SmartTabs

                                                                                                                                                                                      +4
                                                                                                                                                                                      Самый мощный комментарий, хоть и плюсов маловато. Реквестирую запостить в виде отдельной статьи, чтобы /раз-и-навсегда/ закрыть этот холивар!
                                                                                                                                                                                        +1

                                                                                                                                                                                        Спасибо на добром слове. „Раз и навсегда“ не получится, думаю :-)
                                                                                                                                                                                        По поводу статьи чёрт его знает, репозиторием в Гитхабе, думаю, лучше.

                                                                                                                                                                                          +1
                                                                                                                                                                                          Ваш пост уже собрал +22, статейку небольшую всё-же надо. Очень коротко и по теме, хабр это любит.
                                                                                                                                                                                          +2
                                                                                                                                                                                          Реквестирую запостить в виде отдельной статьи

                                                                                                                                                                                          https://habrahabr.ru/post/118208/ 2011 год)
                                                                                                                                                                                          +3
                                                                                                                                                                                          После этого комментария топик можно закрывать. А содержимое комментария — в пост.
                                                                                                                                                                                            0
                                                                                                                                                                                            Но при этом такая же ситуация у себя в коде людей не бесит :-)

                                                                                                                                                                                            Это некорректный аргумент: код моноширинный и форматирование пробелами не едет при добавлении/удалении отступа.

                                                                                                                                                                                            Если среда разработки не понимает смарт-табуляцию и не может автоматически понять, где вставить табуляцию, а где пробел, то грош ей цена, такой среде.

                                                                                                                                                                                            Смысл, если можно везде использовать пробел, без переключений? И для отступа, и для выравнивания? Вы предлагаете более сложную систему, которая функционально полностью эквивалентна «пробельной» — зачем?
                                                                                                                                                                                            «тут внутри строки я нажимал Tab среда сама поставила пробелы — в чем разница с ситуацией, когда пробелы будут везде?

                                                                                                                                                                                            Все остальные аргументы теряют свою важность перед смыслом

                                                                                                                                                                                            Исходный смысл табуляции — разметка таблиц при печати, он утерян уже очень давно.
                                                                                                                                                                                              –2
                                                                                                                                                                                              Полностью согласен, удивлён количеству плюсов у MaximAL. Дополню парой мыслей.

                                                                                                                                                                                              * Про «смысл» полная чушь, многие вещи используют по назначению изначально не рассчитанному.
                                                                                                                                                                                              * Про «смарт-табуляцию». Сначала издалека. Два единственных плюса табов это размер исходного текста и изменение ширины в зависимости от настроек у конечного пользователя.
                                                                                                                                                                                              Первый плюс ничтожен, так как занимает место только у разработчиков, на конечных пользователей это не влияет. По сравнению с несжатым видео, которое приходиться хранить — капля в море и смех под бородой.
                                                                                                                                                                                              Второй плюс сходит на нет при использовании смарт-табуляции, потому что если будут заменены табы другими размерами, допустим с 4 до 2, то пробелы для выравнивания всё испортят. Этот плюс не важен, если у вас «среда, которой не грош цена», заменяющая серию пробелов на табуляцию с последующим изменением размера отступов.
                                                                                                                                                                                                +3
                                                                                                                                                                                                Ничего пробелы не испортят. Все выравнивание пробелами останется ровно таким же, каким и было. В этом весь смысл, и в этом и есть решение всех проблем, но почему-то кому-то вздумалось ставить везде пробелы и пошло поехало.

                                                                                                                                                                                                Пробелы не решают проблемы их различного количества у проектов. У кого-то два, у кого-то четыре. Вместо того, чтобы использовать правильное решение вообще всех проблем, мы получаем ситуацию, где надо постоянно менять настройки IDE, либо пытаться сделали уникальные для проектов настройки, чтобы можно было и 4, и 2 пробела использовать. Почему-то считается, что это объективно менее функциональное и более проблемное решение является более правильным.
                                                                                                                                                                                                  0
                                                                                                                                                                                                  Первый плюс ничтожен

                                                                                                                                                                                                  Вы, наверное, не поняли исходный посыл текста. Там так и написано, что эти плюсы — ничто по сравнению с семантичностью (смыслом).


                                                                                                                                                                                                  Второй плюс сходит на нет при использовании смарт-табуляции, потому что если будут заменены табы другими размерами, допустим с 4 до 2, то пробелы для выравнивания всё испортят

                                                                                                                                                                                                  Смысл смарт-табуляции, как раз в том, что при изменении ширины таба выравнивание не портится.

                                                                                                                                                                                                  +1
                                                                                                                                                                                                  Вы предлагаете более сложную систему, которая функционально полностью эквивалентна «пробельной» — зачем?

                                                                                                                                                                                                  Ну разумеется, что она функционально не эквивалентна, а лучше: каждый разработчик может подстроить себе удобный вид для кода используя конфигурируемую ширину. У меня много коллег, например, сначала любили 4, а потом полюбили 2.

                                                                                                                                                                                                    0
                                                                                                                                                                                                    Почему обязательно моноширинный? У меня не моноширинный, например, никакая IDE не принуждает.
                                                                                                                                                                                                    Меня каждый раз минусуют, потому сошлюсь на то, что вроде у Страуструпа тоже :)
                                                                                                                                                                                                      0
                                                                                                                                                                                                      In code examples, a proportional-width font is used for identifiers. For example:…
                                                                                                                                                                                                      At first glance, this presentation style will seem ‘‘unnatural’’ to programmers accustomed to seeing code in constant-width fonts. However, proportional-width fonts are generally regarded as better than constant-width fonts for presentation of text. Using a proportional-width font also allows me to present code with fewer illogical line breaks. Furthermore, my experiments show that most people find the new style more readable after a short while.

                                                                                                                                                                                                      http://www.stroustrup.com/3rd_notes.pdf
                                                                                                                                                                                                    0
                                                                                                                                                                                                    Нагуглил ещё elastic tabstops, но это концепт, как я понял.
                                                                                                                                                                                                      0

                                                                                                                                                                                                      Ну, по сути, это идеальное решение, так, как оно должно работать.
                                                                                                                                                                                                      Пока что имеем то, что имеем.

                                                                                                                                                                                                    –4
                                                                                                                                                                                                    Пользуюсь тем способом, который описан в code style.
                                                                                                                                                                                                    Например, если язык PHP, то однозначно пробелы (по общепринятому стандарту).

                                                                                                                                                                                                    Если был бы другой стандарт, который заставлял использовать табы, то использовал бы табы, хоть и считаю их пережитком прошлого.
                                                                                                                                                                                                      +3
                                                                                                                                                                                                      Холиварить не буду, но лично у меня логика такая: форматирование строк — табы, форматирование внутри строк — пробелы. Имхо довольно логично, но как говориться на вкус и цвет… еще люблю большие отступы и не готов клацать 4 раза на пробел.
                                                                                                                                                                                                        0

                                                                                                                                                                                                        4 раза на пробел (или на бекспейс при удалении отступов) в средах разработки клацать уже давно не нужно, редакторы разворачивают нажатие на клавишу табуляции в нужное количество пробелов сами (если вы выбрали стиль кодирования с пробелами, конечно).
                                                                                                                                                                                                        То, что вы описали вначале, называется смарт-табуляцией, да.

                                                                                                                                                                                                          0
                                                                                                                                                                                                          4 раза на пробел (или на бекспейс при удалении отступов) в средах разработки клацать уже давно не нужно


                                                                                                                                                                                                          Спасибо Кэп))) Не смотря на это, многие их моих коллег именно так и делают, потому что считают что такое поведение неочевидно и лучше явно использовать клавишу пробела. Я тоже считаю, что поведение должно быть максимально явным, поэтому использую табы для выравнивания строк и пробелы внутри них.
                                                                                                                                                                                                        +2
                                                                                                                                                                                                        Как получить «отличную статью»:
                                                                                                                                                                                                        1. По ссылке с зарубежных ИТ-сайтов найти ссылку на интересную запись в блоге
                                                                                                                                                                                                        2. Перевести ее по возможности легким слогом
                                                                                                                                                                                                        3. Добавить пару картинок, можно ролик с youtube
                                                                                                                                                                                                        — профит!

                                                                                                                                                                                                        P.S. Тег «перевод» ставить не нужно, к чему оно? ))
                                                                                                                                                                                                          +4
                                                                                                                                                                                                          Внезапно:
                                                                                                                                                                                                            +2
                                                                                                                                                                                                            Я ненавижу пробелы по одной простой причине — их неудобно удалять.

                                                                                                                                                                                                            Большинство современных IDE вставляют N пробелов когда нажимаешь клаыишу tab (если в настройках выбраны пробелы).
                                                                                                                                                                                                            То есть в сторону добавления индентации проблема решена.
                                                                                                                                                                                                            Но когда нужно уменьшить индентацию приходится удалять N пробелов — это идиотизм.

                                                                                                                                                                                                            P.S. Людей которые индентируют код нажимая клавишу пробел я вообще не понимаю.
                                                                                                                                                                                                              +2
                                                                                                                                                                                                              Во многих IDE уменьшение отступа делается горячей клавишей, в частности, через Shift+Tab, ничего руками удалять не надо.
                                                                                                                                                                                                                +1

                                                                                                                                                                                                                В Идее (если для отступов выбраны стрёмные пробелы, конечно) при одиночном нажатии бекспейса попадаешь на уровень ниже.


                                                                                                                                                                                                                В общем, я считаю, что проблема „нажимать много раз пробел или бекспейс“ вообще не стоит. Это всё должно решаться средой, если не решается — среда отстой.

                                                                                                                                                                                                                  0

                                                                                                                                                                                                                  Более того, в новых версиях идеи (c 14-й, если не ошибаюсь) бэкспейс в начале строки, когда ничего кроме отступов нет, не только удалит все отступы, но и вернёт курсор на предыдущую строку, что весьма удобно.

                                                                                                                                                                                                                    0

                                                                                                                                                                                                                    Ну это, вроде как, настраивается. Проверить поведение бекспейса можно добавив „лишних“ отступов. В конец предыдущей строки курсор попадает, только если он находится на текущем или меньшем уровне вложенности. Если на большем, то редактор просто убирает один уровень вложенности.


                                                                                                                                                                                                                    Короче, аргумент про „много раз бекспейс“ — не аргумент.

                                                                                                                                                                                                                      0
                                                                                                                                                                                                                      В конец предыдущей строки курсор попадает, только если он находится на текущем или меньшем уровне вложенности. Если на большем, то редактор просто убирает один уровень вложенности.

                                                                                                                                                                                                                      Только что проверил — да, правда, так и есть. Удаляет до того уровня вложенности, который положен на этом месте согласно форматированию. К таким вещам привыкаешь и перестаёшь в итоге их замечать)


                                                                                                                                                                                                                      аргумент про „много раз бекспейс“ — не аргумент

                                                                                                                                                                                                                      Да, здесь я полностью согласен)

                                                                                                                                                                                                                        0

                                                                                                                                                                                                                        В этом и смысл великолепного продукта, коим несомненно является джетбрейновская Идея.
                                                                                                                                                                                                                        Сделать логичное поведение полностью прозрачным, чтобы пользователь даже не задумывался о нём.
                                                                                                                                                                                                                        И таких мелочей в нормальных IDE тысячи.

                                                                                                                                                                                                                  0
                                                                                                                                                                                                                  Когда надо уменьшить идентацию, можно юзать комбинацию shift + tab, или вообще отформатировать весь код сразу через ctrl + shift + f
                                                                                                                                                                                                                  0
                                                                                                                                                                                                                  Рискну предположить, что большая популярность табов в Java в определенной степени связана с документом «Java Code Conventions» от Oracle. Там сказано следующее: «Four spaces should be used as the unit of indentation. The exact construction of the indentation (spaces vs. tabs) is unspecified. Tabs must be set exactly every 8 spaces (not 4).»

                                                                                                                                                                                                                  Думаю, этому соглашению стараются следовать отдельные компании и разработчики. Мне же оно кажется крайне странным.
                                                                                                                                                                                                                    0
                                                                                                                                                                                                                    > Чаще всего табуляция встречается в языке С, а пробелы — в Java.
                                                                                                                                                                                                                    > Рискну предположить, что большая популярность табов в Java

                                                                                                                                                                                                                    Совсем запутали))))
                                                                                                                                                                                                                      0
                                                                                                                                                                                                                      Я опечатался. Конечно же, Java Code Conventions популяризирует именно пробелы, а не табы.