Результаты опроса Stack Overflow 2017: разработчики, которые используют пробелы, зарабатывают больше

https://stackoverflow.blog/2017/06/15/developers-use-spaces-make-money-use-tabs/
  • Перевод
Это с определенной точки зрения «священная война» среди разработчиков программного обеспечения, эта тема стала предметом множества дебатов и шуток. Я использую пробелы и никогда не задумывался о важности этого момента. Но сегодня мы публикуем исходные данные опроса разработчиков Stack Overflow 2017 и некоторые аналитики считают, что этот выбор имеет большее значение, чем я ожидал.

Пробелы приносят больше денег чем табы


Было опрошено 28 657 респондентов, которые выразили свое предпочтение табам или пробелам и считали себя профессиональным разработчиками (ученики и бывшие программисты не учитывались). В этой группе 40,7% используют табы и 41,8% пробелы (17,5% используют оба метода). Из них 12 426 оставили информацию о своей зарплате.

Анализ данных приводит нас к интересному выводу. Разработчики которые используют пробелы для отступов, зарабатывают больше денег, чем те, кто используют табы, даже если они имеют такой же объем опыта:



Среднестатистический разработчик, который использует пробелы, имеет зарплату в 59 140 долларов, в то время как разработчик использующий табы имеет зарплату в 43 750 долларов. (Обратите внимание, что все результаты были конвертированы в доллары США из валюты респондента). Результаты разработчиков, которые выбрали вариант «Оба», как правило, неотличимы от тех, кто выбрал «Табы».

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

Мы решили узнать, имеет ли место данный эффект в каждой из стран по отдельности. Выбраны страны с наибольшим количеством респондентов участвующих в опросе:



Данный эффект наблюдался в наименьшей степени в Европе, а наибольший разрыв был зафиксирован в Индии, но, тем не менее, он проявляется в каждой стране.

В качестве другой гипотезы мы знаем, что разработчики из разных сфер часто используют разные пробелы (например, разработчики DevOps с большей вероятностью используют пробелы, а мобильные разработчики более вероятно используют табы), часто потому что они используют разные редакторы и языки. Участвующие в опросе, также оставили информацию о том, какие языки программирования они используют (Python, Javascript и т. Д.) и в какой сфере работают (web developer, embedded developer и т. д.).



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

Я сделал ряд других осмотров возможных причин (таких как уровень образования или размер компании) и увидел те же результаты: пробелы били табы в каждой группе. Теперь, когда исходные данные доступны, я призываю вас проверить возможные факторы самостоятельно.

Если мы проверили все факторы, которые, как мы подозреваем, могли бы повлиять на зарплату, какой эффект в реальности будет иметь выбор табов/пробелов?

Чтобы ответить на этот вопрос, я подхожу к линейной регрессии, прогнозируя зарплату на основе следующих факторов:

  • Табы/пробелы
  • Страна
  • Годы опыта
  • Тип разработчика и язык программирования
  • Уровень образования (бакалавриат, магистр, докторантура)
  • Вносят ли они вклад в открытый исходный код
  • Будут ли они программировать в качестве хобби
  • Размер компании

Использование пробелов вместо табов приводит к увеличению зарплаты на 8,6% (доверительный интервал (6%, 10,4%), P-значение <10 ^ -10). Иными словами, использование пробелов вместо табов приравнивается дополнительным 2.4 годам опыта.

Заключение


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

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

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

Метки:
Поделиться публикацией
Комментарии 152
  • +49
    Надо будет написать в резюме: «Использую пробелы для отступов». Пусть сразу знают, что я не абы какой разработчик, а высокооплачиваемый.
    • +1
      Интересно, что автор статьи не использовал в тексте ни одного таба, а ведь, наверное, мог бы, хотя бы в качестве красной строки )
    • +20
      Все верно, и даже больше. Раньше я использовал 2 пробела, когда перешел на 4 — мою зарплату повысили на 3%

      • +14
        Может, вам платят за количество символов?
        • +7
          возможно, как раз этот фильм показывает причину — tab-разработчики чаще зацикливаются на мелочах, в то время как пробельщики тупо ищут решения

          интересно было бы еще как-то оценить собственно степень говно-кода у тех и у других
          • +1
            Я тоже ставлю пробелы вместо табов. Более того, я еще и использую 5 пробелов для отступа. И да) Я тоже извращенец и люблю Vim больше Emacs)
            • 0
              Я использую табы для равномерных отступов (C#, C), пробелы для неравномерных (Common Lisp, Haskell), и пишу иногда в vim, но чаще в emacs с evil-mode. Я больший извращенец, чем вы.
              • 0
                лень было заходить на машину с VM, кодил в nano, без подсветки синтаксиса ^^
              • +2
                А мы всё ещё используем обычный порошок.
                • +1
                  Я не понимаю конфликт. Я всегда жму на таб, но у меня стоит настройка «менять табы на пробелы», т.е. технически, я использую пробелы, но просто экономлю нажатия. Из-за чего вообще весь сыр-бор?
                  • 0
                    В сериале конфликт показан шутливо. Вопрос именно в том, что должно отправляться в репозиторий. Вы отправляете пробелы, я отправляю табы.
                • +4

                  Мне интересно почему для Go эта зависимость тоже работает: там же строго табы согласно официальному гайду и найти проекты где забивают на gofmt и используют пробелы не так просто.

                  • +5
                    F# — тоже самое, но наоборот — только пробелы. Разгадка кроется в фразе «Обратите внимание, что респонденты могут выбирать несколько языков».
                  • +3

                    а где те анализ тех, которые используют Smart Tab?

                    • 0
                      Я думаю их слишком мало для того, чтобы сделать какие-либо выводы.
                      • 0

                        либо в опросниках даже опции такой не было

                    • +1

                      Кстати, на ту же тему: http://tylervigen.com/spurious-correlations

                      • +14
                        Корреляции, которые мы заслужили.
                        • +40

                          Вспоминается эта история:


                          Читать

                          В отделение Pontiac корпорации General Motors пришло письмо. "Я понимаю, — писал автор, — что могу показаться идиотом, но все, что я хочу рассказать, — святая правда.
                          В нашей семье все очень любят мороженое. Каждый вечер после ужина мы решаем, какой сорт будем есть на десерт, и я еду за ним в магазин. Проблемы начались после того, как я приобрел новый Pontiac. Каждый раз, когда я покупаю ванильное мороженое и собираюсь вернуться с ним домой, машина напрочь отказывается заводиться! Если мороженое клубничное, шоколадное или любого другого сорта — никаких проблем с пуском. Звучит глупо, но, может быть, в Pontiac есть нечто, что реагирует на ванильное мороженое?".
                          Президент отделения, понятное дело, отнесся к письму скептически, но все-таки послал инженера на проверку. Владелец автомобиля производил приятное впечатление — вежливый, образованный и явно не псих… Встретились после ужина, поехали в магазин, купили ванильное мороженое.
                          Все точно — машина не заводится! Так продолжалось несколько дней подряд. Шоколадное — заводится. Клубничное — заводится. Ванильное — не заводится! Инженер был человеком здравомыслящим и отказался верить тому, что у автомобиля может быть аллергия на ваниль. Он продолжал ездить с хозяином в магазин, но теперь отмечал все детали — время поездки, каким бензином и на какой колонке заправляли машину, даже температуру и облачность…
                          Довольно быстро выяснилось, что дело не в ванили, а в расположении товаров в торговом зале магазина. Ванильное мороженое — как самое ходовое — размещалось в холодильнике самообслуживания у самого входа, а все остальные сорта — в глубине зала, и продавались через кассира. Купить ванильное можно было намного быстрее, чем любое другое…
                          Задача перешла в разряд технических — почему машина не заводится, если хозяин возвращается к ней быстро? И ответ был найден сразу же — двигатель не успевал остыть, и в карбюраторе оставались пробки, вызванные интенсивным испарением бензина!

                          • +1
                            В общем, те, кто используют пробелы, более активно стучат по клавиатуре и поэтому создают немного более занятый, деловой и рабочий вид в глазах начальства и получают чуть более жирные офферы.
                            • +20
                              Так TAB ведь просто ставит пробелы )
                              • 0
                                Зависит от настроек редактора, в котором текст набираете. Редактор может как заменять tab пробелами, так может и не заменять. (более того, разные редакторы могут по разному интерпретировать tab'овые отступы)
                                • +2
                                  Вот мне всегда было интересно, КАК можно по-разному интерпретировать TAB кроме как размером отступа? А если весь или только в табах или только в пробелах то проблем не будет. (У всех же IDE/текстовый редактор умеет заменять X на Y? Еще немного не хватает этой замены при открытии.)
                                  • 0
                                    О, тут стоит вспомнить, что такое Tab исторически. И вспомнить про пишущие машинки, на которых была такая клавиша. На машинках устанавливались специальные таб-стопы для вертикального выравнивания текстов.И клавиша таб смещала курсор направо до ближайшего стопа. Количество и расстояние этих стопов не всегда фиксировано от машинки к машинке, но всё же удобно при набирании, например, таблиц. Далее печатные машинки были адаптированы до телетайпов и этот замечательный рудимент пришёл в терминалы. Так что таб исторически — инструмент для вертикального выравнивания текста и это не обязательно отступы слева. Это могут быть и отступы посередине строки. На практике же в настройках редакторов можно встретить 2,3,4 и 8 символов для табстопов. И переменный размер табов может очень сильно попортить читаемость кода. Я вообще не вижу смысла использовать табы в коде. Хотя для представления табличных текстовых данных они часто неплохо подходят.

                                    PS Я использую пробелы в коде и табы в табличных данных
                                    • +1
                                      Увы плохо подходят. Если у вас таб например 8 символов, а в какой-то строчке столбец с текстом в 11 символов — то тут-то все форматирование и поедет. :(

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

                                        А таблицы — всем хороши, ктоме того, что не поддерживаются теминалами и текстовыми редакторами, языками программирования и многими другими вещами. Там где они есть — да, лучше использовать их…
                                        • +1
                                          Если размер таба заранее известен, то он не лучше пробела для моноширного шрифта.

                                          А если буковки в шрифте разного размера, то либо это не терминал, либо это редактор который умеет таблицы, либо это редактор который и табы-то адекватно не умеет, либо да — счастливый случай.

                                          Я не против табов. Особенно они хороши когда надо сделать printf
                                          • –1
                                            Если размер таба заранее известен, то он не лучше пробела для моноширного шрифта.
                                            Он лучше, так как при добавлении данных в таблицу позволяет нажимать меньше клавиш. Для чего и был, в общем-то, придуман.
                                            • 0
                                              В какую таблицу? В такую?

                                              1 2 3
                                              a b c
                                              d e f
                                              • 0
                                                Вообще-то наиболее ярко видно в случаях хвостовых пробелов колонки, а не отступов

                                                123456          123             12345678        1234
                                                123             123456          1234            12345678
                                                1234567890      12345678901     1234567890123   123
                                                


                                                изменение длины контента в любой из колонок в рамках своего таба не будет менять форматирование

                                                А для отступа пробелы естественно без вариантов особенно в современных IDE
                                                • +2

                                                  Для выравнивания без вариантов. Для отступов табы идеальны.

                                                  • 0
                                                    Вообще-то наиболее ярко видно в случаях хвостовых пробелов колонки, а не отступов

                                                    123456 123 12345678 1234

                                                    Знаете, что интересно? Вы использовали пробелы вместо табов, чтобы отобразить таблицу как пример использования табов для отображения таблицы
                                                    • +1
                                                      Это не мои проблемы.
                                                      Это проблемы парсера и трансляции в html

                                                      В исходном файле это именно табы.
                                                      • 0
                                                        Какого парсера, какой трасляции? Я не совсем понимаю о чем вы, позвольте проверить:

                                                        function foo () {
                                                        	alert(123);
                                                        }
                                                        


                                                        UPD: Смотрите, у меня просто вставилась табуляция. О каких проблемах парсера и трансляции в html вы говорите? Это исключительно ваша проблема. Скорее всего у вас и в исходном файле пробелы, просто вы не задумывались или не очень в этом разбираетесь.
                                                        • 0
                                                          О каких проблемах парсера и трансляции в html вы говорите?
                                                          Попробуйте просто в текст сообщения на Хабре вставить табуляцию — и вы увидите, что она будет замена на пробелы. Внутри <source> или <pre> — да, табуляция сохраняется. Просто внутри текста заменяется на 1 (один) пробел, что, разумеется, для выравнивания таблиц использовать непросто.

                                                          Это исключительно ваша проблема.
                                                          Нет, это проблема любого, кто пытается писать на Хабре. Его «интеллект» достоин отдельного рассказа. Но да, с <pre> всё работает:

                                                          123456		123		12345678	1234
                                                          123		123456		1234		12345678
                                                          1234567890	12345678901	1234567890123	123
                                                          

                                                          Скорее всего у вас и в исходном файле пробелы, просто вы не задумывались или не очень в этом разбираетесь.
                                                          Я думаю он неплохо разбирается в текстовых файлах, но плохо — в Хабраредакторе. Вряд ли его можно в этом винить…
                                                          • 0
                                                            Попробуйте просто в текст сообщения на Хабре вставить табуляцию — и вы увидите, что она будет замена на пробелы

                                                            Не на «пробелы», а на один пробел, как вы правильно уточнили далее. Точно так же как несколько пробелов, которые я вставил между этими словами. Это сделано, для того, чтобы удобное программисту форматирование html-файла не влияло на результат.

                                                            Его изначальная таблица была обернута именно в pre и там прекрасно поддерживается как табуляция, так и множественные пробелы:


                                                            Но да, с pre всё работает

                                                            Да, я это прекрасно знаю.

                                                            Я думаю он неплохо разбирается в текстовых файлах, но плохо — в Хабраредакторе. Вряд ли его можно в этом винить…

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

                                                            Из двух разных случаев одинаковой ошибки я допускаю, что у Fortop редактор автоматически заменяет табуляцию на пробелы, но он об этом раньше не знал и искренне считал, что это проблемы отображения табуляции в браузере.

                                                            Как я уже выше показал (а так же вы в своем сообщении) — табы прекрасно живут что на Хабре в теге pre, что в веб-интерфейсе Гитхаба и не заменяются на пробелы.
                                                          • –3
                                                            Мне не нужно задумываться о том, что я набрал руками и воспроизвел лично.

                                                            То что при копировании в сообщение и обработке парсером заменились табы на пробелы уж точно не моя проблема и отлавливать это я не собираюсь.
                                                            image

                                                            Более того, внимательно читая написанное и включив мозг вы бы заметили, что использование пробелов не дает никакого автоматического выравнивания контента по позициям табуляции, если удалить любую цифру в любом столбце. О чем я собственно и писал.
                                                            А табы дают.

                                                            Скорее всего вы просто не читаете что пишут. Но с определенной долей вероятностью просто не привыкли включать мозг в принципе.
                                                            • +1
                                                              Но с определенной долей вероятностью просто не привыкли включать мозг в принципе.

                                                              Ну ты и хамло.

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

                                                              Да, я заметил.

                                                              табы на пробелы уж точно не моя проблема

                                                              Эффект Даннинга — Крюгера

                                                              А табы дают.

                                                              Не совсем так. Правильно будет «а табы — то дают, то не дают».

                                                              Что у меня, что у khim парсер прекрасно работает с табами. Возможно, это недостатки вашего редактора, что вместо табов он копирует пробелы. Пробовали перейти на что-то получше? С другой стороны, вам и правда не стоит разбираться, в чем ваша ошибка и вы просто можете и дальше обвинять всех окружающих в собственном невежестве
                                                              • –2
                                                                Не совсем так. Правильно будет «а табы — то дают, то не дают».


                                                                Процитирую тот текст, который вы не осилили с первого раза

                                                                изменение длины контента в любой из колонок в рамках своего таба не будет менять форматирование

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

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

                                                    А вы таки ставите пробелы клавишей пробела?
                                      • 0
                                        > Так TAB ведь просто ставит пробелы )

                                        У меня Enter ставит пробелы (и Таб тоже, но до него дело, обычно, не доходит).
                                  • +19

                                    По моему всё просто. Компании, готовые платить больше, требуют тоже больше. И, в частности, они требуют соблюдение стайлгайда. Большинство стайлгайдов основаны на пробелах.

                                    • +26
                                      А я хитрый, я нажимаю TAB а IDE мне рисует четыре пробела :-)
                                      • НЛО прилетело и опубликовало эту надпись здесь
                                        • +13
                                          Мой мир никогда не станет прежним…
                                          • 0
                                            Ну надо же им как то прибавку к зарплате отрабатывать :-D
                                            • –2
                                              я так делаю. Каюссь
                                              • 0
                                                В сериале «кремниевая долина» (см видео в комменте выше) даже 8 раз жмякали, и один из «веских аргументов в пользу табов» был, что, мол, меньше клавиш нажимать.
                                              • +1
                                                Как бы еще сделать чтобы стрелки влево-вправо переходили сразу бы по 4 пробелам, но по одному символу.
                                                • НЛО прилетело и опубликовало эту надпись здесь
                                                  • 0
                                                    Ну сидишь, думаешь, смотришь на эти вложенные циклы/условия. При поиске ошибок методом пристального взгляда или рефакторинге, или просто запутался. Для навигации по уровням, отмечать где ты сейчас.
                                                    • +2

                                                      в нормальных IDE для этого существует "фоновая" вертикальная линейка для каждого уровня


                                                      скрин
                                                      • 0
                                                        Текст разбивают на абзацы для более удобной навигации, но некоторые все равно при чтении выделяют его пальцем, линейкой или курсором. Так и линейка эта, и сворачивание кода и навигация курсором — все об одном, но это не взаимозаменяемые вещи.
                                                      • 0
                                                        Если по нему много надо туда-сюда ходить по уровням, значит пора рефакторить.
                                                    • –1
                                                      Перейти в лагерь TAB?
                                                      • 0
                                                        Если бы я писал пробелами то возможно и не было бы такой проблемы, т.к. я бы не знал что так можно. Но в чужой монастырь со своим уставом не ходят. И иногда приходится работать с чужим исходником с пробелами.
                                                      • 0
                                                        В IDE от Jetbrains использую 'Ctrl' вместе со стрелками, ну а для Vim/Emacs, полагаю, вопрос не актуален. Вообще, сравнительно редко использую навигацию влево-вправо по тексту без 'Ctrl', т.к. в большинстве случаев требуется перемещение на n слов, а не букв.
                                                        • 0
                                                          В CoolEdit'е (редакторе Midnight Commander'а) при всей его убогости такой режим есть и используется по умолчанию.

                                                          А ещё там TAB ставит 4 пробела, но второй — удаляет 4 пробела и ставит один TAB на их место.
                                                          • 0
                                                            а ctrl + → для таких случаев не подходит?
                                                        • +5
                                                          Пробелы с табами это всё ерунда, IDE всё должно ставить, я даже не помню, что у меня там настроено (на самом деле табы, конечно же), просто нажимаю Enter или автоформат и всё выравнивается.
                                                          Было бы интересно сравнить зарплаты тех, кто использует моноширинные или пропорциональные шрифты в IDE (хотя подозреваю что я такой один в мире, не моноширинный, и сравнивать не получится).
                                                          • +7
                                                            Как бы мне на пробелы то теперь перейти?

                                                            image
                                                            • 0
                                                              Обычно в редакторе есть галочка. Использовать пробелы вместо tab. Возможно это решение.
                                                            • +3
                                                              Статья смешная, а перевод ужасный — явно автоматический и плохо отредактированный, в куче мест присутствуют «вкладки» вместо «табов».
                                                              • +2
                                                                Google в StyleGuide тоже рекомендует 2 пробела вместа табов
                                                                • –2
                                                                  Анализ данных приводит нас к интересному выводу. Разработчики которые используют пробелы для отступов, зарабатывают больше денег, чем те, кто используют табы, даже если они имеют такой же объем опыта

                                                                  А можно еще прийти к такому выводу, что те кто используют пробелы более склонны врать про свою зарплату. Идиотское Странное исследование, скорее причина в стайлгайдах на пробелах и крупных корпорациях, как уже сказали выше.
                                                                  • +1
                                                                    Сейчас все резко перейдут на пробелы
                                                                    • 0
                                                                      Наоборот. Все компании резко начнут в гайдлайнах требовать табы.
                                                                    • +7
                                                                      > Среднестатистический разработчик, который использует пробелы, имеет зарплату в 59 140 долларов, в то время как разработчик использующий табы имеет зарплату в 43 750 долларов. (Обратите внимание, что все результаты были конвертированы в доллары США из валюты респондента)

                                                                      При такой зарплате я могу использовать хоть символы нижнего подчёркивания!
                                                                      • +1

                                                                        Да что уж темнить. Можно вообще без отступов обходиться )

                                                                        • +12
                                                                          Даже в питоне!
                                                                          • 0
                                                                            А как?
                                                                            «Можно вообще без отступов обходиться»
                                                                            • 0

                                                                              Использовать точку с запятой. Только придется писать все в одну строчку.

                                                                              • 0
                                                                                Спасибо! И вправду работает))
                                                                                name = 'Дуня'; print ('Привет, %s!' % name);
                                                                                

                                                                                Привет, Дуня!
                                                                                [Finished in 0.1s]
                                                                        • 0
                                                                          Особенно, есль жить при этом где-нибудь в Воронеже, а не в Сан-Франциско большой семьёй (страшно даже подумать про возможный состав семьи в С.-Ф.).
                                                                          • 0

                                                                            А символы верхнего подчеркивания сможете?

                                                                          • +2
                                                                            Я очень люблю табы, т.к. они значительно упрощают навигацию по коду «стрелочками». Но — современная мода требует использования пробелов, во всех гайдах пишут про пробелы, git diff рисует табы ярким красным цветом, многие редакторы работают в пробельном режиме…

                                                                            Так что мне пришлось перейти на пробелы, чтобы не отстать от жизни. С понижением зарплаты.
                                                                            • +1
                                                                              Я очень люблю табы, т.к. они значительно упрощают навигацию по коду «стрелочками».

                                                                              Как насчет Ctrl + «стрелочки»?
                                                                              • +3
                                                                                git diff рисует табы ярким красным цветом

                                                                                Только в коммите, в котором табы заменили на пробелы ведь.
                                                                              • –5
                                                                                Пока стучишь пробелы — успеваешь подумать. С табами — тупо кодишь.
                                                                                • 0
                                                                                  Я не понимаю, Вы правда думаете всё это о том кто какие кнопки нажимает? Или просто «шутка»?
                                                                                  • +1
                                                                                    Разумеется, шутка. Помните Рабле? С какой стороны яйцо чистить — с острой или тупой? Или как правильно креститься — двумя пальцами или тремя?
                                                                                    Помню, раньше за это глотки резали. Сейчас, по-моему, стало лучше — можно пошутить. Хотя на Хабре шутки не любят, здесь народ серьезный.
                                                                                    • 0
                                                                                      Это был Свифт.
                                                                                • +1
                                                                                  set sw=2
                                                                                  set ts=2

                                                                                  И никаких проблем. Даже не знаю, табы там или пробелы используются.
                                                                                  • +2
                                                                                    Годный, юморной вброс в holy war.

                                                                                    На премию ингобеля — «заставляет сначала смеяться, потом задуматься».
                                                                                    • +4
                                                                                      Альтернативный вывод: «Разработчики, которые используют пробелы, врут больше, чем те, которые используют табы» :)
                                                                                      • 0
                                                                                        Не обязательно. Если и у тех и у тех оплата почасовая, то настучать 4 пробела займет больше времени, чем 1 таб.
                                                                                      • 0
                                                                                        Я так понимаю, одинэсники в опросе не участвовали???
                                                                                        • +10
                                                                                          В вопросе участвовали только разработчики
                                                                                        • +2
                                                                                          Пробелы приносят больше денег чем табы

                                                                                          А не кажется ли вам, что авторы статьи путают причину и следствие? Не думаю, что они идиоты, но прикидываются ими ради громкой статьи.

                                                                                          • 0
                                                                                            Вот тут недавно статья была про когнитивные искажения. И мне хочется спросить, а не соответствует ли исследование?
                                                                                            Ошибочность в духе меткого стрелка из Техаса — выбор или подстройка гипотезы после того, как данные собраны, что делает невозможным проверить гипотезу честно.
                                                                                            Т.е. сначала сформулировали гипотезу, а потом опросили программистов или взяли bigdata понаходили корреляций, а теперь выдают гипотезы. (А по закону bigdata там будут любые, даже самые абсурдные корреляции.)
                                                                                            • 0

                                                                                              Наверное настоящая зависимость между языками программирования, в каких-то принято пользоваться табами, в других — пробелами, это и влияет на зарплату.

                                                                                              • +1

                                                                                                Вы правы по поводу того что прикидываются).
                                                                                                Данный эффект как минимум есть в разрезе размера компании, пруф:



                                                                                                А размер компании корелирует с зарплатой, пруф:



                                                                                                Из этого можно сделать вывод, что:
                                                                                                Размер компании влияет на использование пробелов.
                                                                                                И так же размер компании влияет на среднюю зарплату.

                                                                                              • +3

                                                                                                Наличие корреляции на ограниченной выборке еще не говорит о наличие какой-либо причинно-следственной связи.
                                                                                                Вот отличный набор примеров странных корреляций

                                                                                                • +1
                                                                                                  Я не силён в статистике, но помню, как раньше нам преподаватель демонстрировал зависимости между курсом рубля и фазой луны или убедительно доказывал, что у монетки только одна сторона, так что думаю поговорка про малую, большую ложь и статистику это как раз тот случай, но шутка хорошая =)
                                                                                                  • 0
                                                                                                    Не зависимость, а корреляция.
                                                                                                  • +2
                                                                                                    Почему не исследовался метод CTRL-ALT-L?
                                                                                                    Я уже двести лет никакие отступы руками не ставлю, их вставляет IDE согласно командным правилам форматирования кода.
                                                                                                    В правилах же как правило используются пробелы, потому что дифы проще читать.
                                                                                                    • 0

                                                                                                      в некоторых IDE diff-сравнение убирает различия на тему пробелов и табов и акцентируешься только на коде

                                                                                                      • 0
                                                                                                        Если читаешь диф в виде вывода команды diff в консоли, ну или в веб интерфейсе каком-нибудь, то да, табы съезжают все нафиг.
                                                                                                          • +1
                                                                                                            Вы не поняли — дело не в игнорировании разницы в вайтспейсах, а в том, что съезжает разметка, потому что diff вставляет в начале каждой строчки один символ (пробел, + или -). С пробелами всё просто сдвигается вправо на одну колонку, с табами что-то перескакивает на следующую позицию табуляции, всё разъезжается.
                                                                                                            • 0

                                                                                                              видимо я давно так много за пределами IDE не сравнивал код, чтобы обратить внимание на такое смещение

                                                                                                              • 0
                                                                                                                Какие-то ужасы непонятные рассказываете. Явно не про табы:



                                                                                                                Да и в чистом гите можно настроить.
                                                                                                                • 0
                                                                                                                  А шо? У вас таки в html там табы?
                                                                                                                  image

                                                                                                                  Я вас разочарую. 3-я строка на скриншота после минуса. Изучайте
                                                                                                                  • 0
                                                                                                                    Я вас разочарую. Да, именно табы. Выделил (это 28-ая строка на первом скриншоте). Изучайте



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

                                                                                                                    Пробелы в качестве отступов:


                                                                                                                    Табы в качестве отступов:


                                                                                                                    Эта быстрая проверка однозначно и правильно показывает, какой символ реально используется, но вы всегда можете дополнительно проверить в хекс-редакторе.
                                                                                                      • 0
                                                                                                        Может быть есть какая-то корреляция между количеством изученных\используемых языков программирования и ростом зарплаты? И соответственно — человек имеет больший\разносторонний опыт и потому и получает больше, а этот самый разносторонний опыт подталкивает везде и всюду использовать пробелы?
                                                                                                        Лично я начал использовать только пробелы и следить за этим только после того, как узнал Python + натыкался на косяки с отступами в конфигурациях некоторых программ, до этого я об этом даже и не задумывался…
                                                                                                        • 0
                                                                                                          Или же наоборот, в легаси больше пробелов, никто не хочет пилить легаси, приходится заманивать калачом :)
                                                                                                        • –3
                                                                                                          До кого-то не дошло, что это — сарказм.
                                                                                                          • –4
                                                                                                            Пробелы — старые, древние проекты в большой корпорации, использование какого-нибудь emacs или vi в качестве основного редактора. Большой документ по кодинг-стайлу, под грифом «почти секретно», где написано, что "никада-никада-никада низя использовать табуляции, потому, что у нашего супергуру, на емаксе съезжает индент, который был равен 5 по религиозным соображениям, а ещё каретка суперпринтера на 128 этаже небоскрёба пробивает капитальную стену, ибо там размер табуляции -1".
                                                                                                            Табуляции — новые мелкие проекты в мелких современных транснациональных корпорациях. Хипстеры, вейперы, вот-это-вот-всё. Массовое использование IDE. Дыроколы в аренду.
                                                                                                            • 0
                                                                                                              Прочитав статью, задумался что использую я… А использую я в основном Visual Studio и настройка по умолчанию в ней для большинства языков — при нажатии на Tab вставлять пробелы (обычно 4). Т.е. выходит что я как бы использую побелы, но вставляю их кнопкой Tab. Если представить что у меня не было бы такой умной IDE, то конечно я бы не стал каждый раз 4 раза барабанить по пробелу (как в видеоролике выше) и использовал бы Табы.

                                                                                                              На мой взгляд в студии довольно удачное решение этой пролемы, оно похоже на настройку:

                                                                                                              git config --global core.autocrlf true

                                                                                                              — позволяет разработчикам на разных системах писать код и при этом в репозитории будет порядок. Так же и с отступами — кто использует побеллы, кто-то табы, но в результате у всех пробелы и все счастливы. Единственное замечание — для стирания отступа бэкспейсом приходится уже нажимать 4 раза (но ведь есть Shift+Tab!)

                                                                                                              PS: в компании есть один человек, который эту настройку у себя поменял и каждый раз плачет и кололется мучается с мержами, но продолжает грызть кактус использовать табы =)
                                                                                                              • +3

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

                                                                                                              • +3
                                                                                                                Т.е. верный способ для IT компании сократить издержки — перевести весь софт на табы.
                                                                                                                • 0
                                                                                                                  В HR на собеседовании спрашивать: «вы, таки, используете табы или пробелы?» и понижать зарплату табуляторщикам.
                                                                                                                  Хотя (это «бигдата») использование табуляций сокращает время компиляции и размер исходника. В мировых масштабах это позволит сэкономить природный газ на тысячу зажигалок, которые можно раздать африканским детям, научив их курить.
                                                                                                                  • 0
                                                                                                                    > В HR на собеседовании спрашивать: «вы, таки, используете табы или пробелы?» и понижать зарплату
                                                                                                                    > табуляторщикам.

                                                                                                                    А для уже нанятых делать так. Вице-президент собирает всех для супер презентации и мотивируя зажигалками для африканских детей обязывает всех использовать табы. А потом все просто получают пониженную зарплату.

                                                                                                                    > В мировых масштабах это позволит сэкономить природный газ на тысячу зажигалок, которые можно раздать
                                                                                                                    > африканским детям, научив их курить.

                                                                                                                    Вы совершенно правы. Тут эффект бабочки. Они будут курить — быстрее умрут, оставят меньше потомства (а то, что оставят умрет от рака легких); а значит это, наверняка, скорее всего, возможно, позволит снизить выбросы CO2 и избежать глобального потепления арктических льдов.
                                                                                                                    • 0
                                                                                                                      Видно глобальное мышление! Какие Гарварды заканчивали?
                                                                                                                • 0

                                                                                                                  Все используют пробелы, но ставят их все равно другой клавишей.

                                                                                                                  • 0
                                                                                                                    Кто «все»?
                                                                                                                    • –1
                                                                                                                      95%
                                                                                                                      • 0

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

                                                                                                                        • 0
                                                                                                                          Tab «выплевывает» фиксированное количество пробелов. Фишка же в том, чтобы добить отдельные при необходимости, при этом сохранив консистентность отступов (одинаковые символы). Иначе не было бы споров и все использовали табы.
                                                                                                                    • 0
                                                                                                                      Это легко объясняется. Во многих IDE настройка по умолчанию TAB'ы вместо пробелов. Новички обычно не заморачиваются по поводу стиля кодирования и фигачат табами. В большинстве серьезных проектов с кодинг стандартами все же предпочитают пробелы вместо табов, ну и соответственно на таких проектах уровень дохода выше и квалификация чаще всего выше, поэтому те кто ставят пробелы зарабатывают в среднем больше. Сам раньше ставил табы, отучили как-раз на проекте с кодинг стандартом.
                                                                                                                      • 0
                                                                                                                        Во многих IDE настройка по умолчанию TAB'ы вместо пробелов

                                                                                                                        В VS и WebStorm по-умолчанию именно пробелы.
                                                                                                                        А ещё ваше предположение не объясняет почему с ростом опытности зависимость не пропадает
                                                                                                                      • –3

                                                                                                                        А почему нет варианта ответа "а хрен его знает"?
                                                                                                                        Потому что за меня отступы делает IDE.

                                                                                                                        • 0
                                                                                                                          Интересно было бы провести ещё исследование, больше ли зарплата у тех, кто переносит открывающую фигурную скобку на новую строку, или у тех, кто оставляет её в конце строки.
                                                                                                                          • 0
                                                                                                                            И тех, кто пишет одинарные кавычки и двойные.
                                                                                                                            • 0

                                                                                                                              И тех, кто ставит пробелы внутри скобок и снаружи.

                                                                                                                              • 0
                                                                                                                                И у тех, кто не ставит пробелы везде, где позволяет компилятор: между операторами, после запятых в однострочных списках и перед открытием фигурных скобок в объявлениях, циклах и т.д.
                                                                                                                                • 0
                                                                                                                                  А также тех, кто ставит табы везде, где позволяет компилятор: между операторами, после запятых в однострочных списках и перед открытием фигурных скобок в объявлениях, циклах, между двумя другими табами и т.д
                                                                                                                            • +1
                                                                                                                              Кстати да. Скобки в конце строки выглядят хорошо только в очень коротких условиях/циклах. Когда появляется больше кода, часто это сливается в сплошной текст, и приходится все равно пустые строки добавлять.

                                                                                                                              Скрытый текст
                                                                                                                              if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue) {
                                                                                                                                  if ($someObject->attributeLongName !== $someValue) {
                                                                                                                                      foreach ($someObject->attributeLongName as $item) {
                                                                                                                                          doSomethingWithItem($item);
                                                                                                                                      }
                                                                                                                                      someCommonAction();
                                                                                                                                  } elseif ($someObject->anotherAttributeLongName !== $someValue) {
                                                                                                                                      foreach ($someObject->anotherAttributeLongName as $item) {
                                                                                                                                          doSomethingWithItem($item);
                                                                                                                                      }
                                                                                                                                      someCommonAction();
                                                                                                                                  }
                                                                                                                              }
                                                                                                                              
                                                                                                                              
                                                                                                                              if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue) {
                                                                                                                              
                                                                                                                                  if ($someObject->attributeLongName !== $someValue) {
                                                                                                                                  
                                                                                                                                      foreach ($someObject->attributeLongName as $item) {
                                                                                                                                          doSomethingWithItem($item);
                                                                                                                                      }
                                                                                                                                      someCommonAction();
                                                                                                                                      
                                                                                                                                  } elseif ($someObject->anotherAttributeLongName !== $someValue) {
                                                                                                                                  
                                                                                                                                      foreach ($someObject->anotherAttributeLongName as $item) {
                                                                                                                                          doSomethingWithItem($item);
                                                                                                                                      }
                                                                                                                                      someCommonAction();
                                                                                                                                  }
                                                                                                                              }
                                                                                                                              

                                                                                                                              • +2
                                                                                                                                Лично мне субъективно удобнее читать первый вариант, без дополнительных пустых строк. Пустыми строками выделяю логически однородные фрагменты кода типа инициализации переменных, вычислений в том или ином контексте. Кроме того, строки, содержащие ключевые слова «if», «else if», «else», «for», «while» и т.д., чаще всего уже отделены от окружающего кода отступом.
                                                                                                                                • 0
                                                                                                                                  Из того, что нашлось в vendor:

                                                                                                                                  jQuery, Doctrine, HTMLPurifier, Guzzle

                                                                                                                                  Чаще всего встречается, если дальше идет комментарий.

                                                                                                                                  уже отделены от окружающего кода отступом.
                                                                                                                                  А если окружающий код это тоже «if», «else if»...? В простом коде с одним оператором это выглядит неплохо, а в коде посложнее иногда приходится отделять. Значит читабельность у такого варианта меньше.

                                                                                                                                  Ну и со отдельными скобками как-то посимметричнее выглядит. Особенно с elseif, который с третьего символа начинается.
                                                                                                                                  • 0

                                                                                                                                    Ну или когда условие в if занимает несколько строк, как тут, например:


                                                                                                                                    if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
                                                                                                                                        ( copyIsArray = Array.isArray( copy ) ) ) ) {

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


                                                                                                                                    Ну и ещё одна мелочь, правда, относящаяся к coding convention: если правила написания кода требуют указания скобок всегда, даже когда в ветке if один return, то такой стиль расстановки скобок приемлем. Если же допустимо опускать скобки для однострочников, чтобы не перегружать код скобками, то нужно видеть каждую скобку, поэтому они и ставятся в начале строки.

                                                                                                                                    • 0
                                                                                                                                      Если же допустимо опускать скобки для однострочников, чтобы не перегружать код скобками, то нужно видеть каждую скобку, поэтому они и ставятся в начале строки.
                                                                                                                                      А нет ли тут шизофрении? Вы разрешаете «опускать скобки, чтобы не перегружать ими код» и тут же посещаете их в такое место, чтобы они сразу бросались в глаза!
                                                                                                                                      • 0
                                                                                                                                        А нет ли тут шизофрении?

                                                                                                                                        Нет. Либо обе скобки видны, либо их просто нет.


                                                                                                                                        Вы разрешаете «опускать скобки, чтобы не перегружать ими код» и тут же посещаете их в такое место, чтобы они сразу бросались в глаза!

                                                                                                                                        Именно так. Если скобки есть, то они обе — и открывающая, и закрывающая — должны быть видны. Преимущество такого подхода: если хотя бы одна из скобок не видна, значит, с балансом скобок что-то не так.


                                                                                                                                        А уж если у вас выработалась привычка вставлять пустую строку в начало блока, то перенос скобки туда выглядит абсолютно логичным.

                                                                                                                                        • 0
                                                                                                                                          Преимущество такого подхода: если хотя бы одна из скобок не видна, значит, с балансом скобок что-то не так.
                                                                                                                                          Если «с балансом скобок что-то не так», то что этот код вообще делает в репозитории? Я уж не говорю о том, что «одна из скобок не видна» может быть просто потому что у вас часть конструкции за край экрана ушла.

                                                                                                                                          А уж если у вас выработалась привычка вставлять пустую строку в начало блока, то перенос скобки туда выглядит абсолютно логичным.
                                                                                                                                          Возможно. Но у меня такой привычки нет — именно потому что «обе скобки должны быть видны». Чем больше вы вставляете всяких «пустых» конструкций (пустые строки, отдельно стоящие складочки), тем меньше остаётся места на экране…
                                                                                                                                          • +1
                                                                                                                                            Если «с балансом скобок что-то не так», то что этот код вообще делает в репозитории?

                                                                                                                                            Такое тоже бывает. См. посты от PVS Studio.


                                                                                                                                            Я уж не говорю о том, что «одна из скобок не видна» может быть просто потому что у вас часть конструкции за край экрана ушла.

                                                                                                                                            А если скобки ставить с новой строки, то они видны всегда.


                                                                                                                                            Чем больше вы вставляете всяких «пустых» конструкций (пустые строки, отдельно стоящие складочки), тем меньше остаётся места на экране…

                                                                                                                                            Когда я начинал программировать, тоже экономил место. Потом со временем пришёл к тому, что читаемость кода важнее его компактности, поэтому даже в пределах одного блока вставляю пустые строки, чтобы разделить логику в коде, например, отделить объявление переменных от остального кода.


                                                                                                                                            А если вам недостаточно места, то используйте для разработки соответствующее аппаратное обеспечение. Забудьте про ноутбуки с маленькими экранами, используйте нормальный экран с минимум 1200 логических пикселей по вертикали.

                                                                                                                                    • 0
                                                                                                                                      Из того, что нашлось в vendor: ...

                                                                                                                                      Что доказывают эти примеры? Вот совершенно легко, не перебирая, нашёл примеры противоположного стиля:


                                                                                                                                      Symfony
                                                                                                                                      Laravel
                                                                                                                                      AngularJS
                                                                                                                                      VueJS


                                                                                                                                      А если окружающий код это тоже «if», «else if»...?

                                                                                                                                      Прошу прощения, не вполне точно выразился. Лучше было сказать, что код внутри блоков «if», «else if», «else», «for», «while» и т.д. отделён отступом от строк, инициализирующих блоки, соответственно, «if», «else if», «else», «for», «while» и т.д. Например, бессмысленный кусок кода для иллюстрации:


                                                                                                                                      #!/usr/bin/perl
                                                                                                                                      my @arr = (3, 2, 1);
                                                                                                                                      my %hash = (k1 => 'v1', k2 => 'v2');
                                                                                                                                      if (@arr) {
                                                                                                                                          if (%hash) {
                                                                                                                                              for my $el (@arr) {
                                                                                                                                                  keys %hash;
                                                                                                                                                  for (my ($key, $val) = each %hash) {
                                                                                                                                                      print "$el$key$val\n";
                                                                                                                                                  }
                                                                                                                                              }
                                                                                                                                          } else {
                                                                                                                                              print "$_\n" for @arr;
                                                                                                                                          }
                                                                                                                                      } elsif (%hash) {
                                                                                                                                          print "%hash\n";
                                                                                                                                      } else {
                                                                                                                                          print "No luck, screw it!\n";
                                                                                                                                      }

                                                                                                                                      На мой взгляд, отступы достаточно ясно показывают, где ветвления и циклы, а где предложения (или как лучше на русском сказать "statement"?).


                                                                                                                                      В простом коде с одним оператором это выглядит неплохо, а в коде посложнее иногда приходится отделять. Значит читабельность у такого варианта меньше.

                                                                                                                                      Без конкретного примера мне не вполне ясно, о чём тут речь. И кому конкретно приходится отделять. Но если речь о сложных условиях в операторах ветвления — настолько сложных, что за несколько секунд не разобраться, то я вполне согласен с мнением Роберта Мартина в его "Чистом коде", что такое условие следует выносить в функцию, по названию которой будет понятно, о какой проверке речь. Часто бывает нужно не досконально понять условие, а (в терминах Р. Мартина) "прочитать осмысленную историю" на пути к предмету, по-настоящему требующему внимания.


                                                                                                                                      И опять же, лично мне дополнительные пустые строки сами по себе не помогают понять логику того или иного кода. Отступы необходимы, чтобы видеть (а не вычислять) иерархию вложенности блоков. Пустые строки, объединяющие отдельные совокупности предложений по некоторому общему логическому признаку (группы инициализаций, последовательности какого-то вычисления) — бывают полезны для быстрого просмотра кода, хотя ещё полезней часто бывает разбивать длинные простыни на вызовы функций с лаконичными названиями, после чего код читать куда удобнее. И в любом случае, при столкновении со сложным условием лично мне пустые строки не помогут понять его быстрее. Да, есть случаи с многострочными условиями, когда код внутри блока имеет тот же отступ, что и строки условия. Мне это как-то не мешает, б.м., потому, что сталкиваясь с инициализацией блока, сразу ищу открывающую его фигурную скобку (или двоеточие в случае с Python).


                                                                                                                                      Ну и со отдельными скобками как-то посимметричнее выглядит. Особенно с elseif, который с третьего символа начинается.

                                                                                                                                      Что значит "с отдельными скобками"? Когда фигурная скобка открывается на новой строке? Вообще говоря, для разных языков (по крайней мере, для некоторых) существуют в той или иной мере стандартизированные рекомендации по стилю. Например, для PHP есть PSR-1 и PSR-2. Во многих командах также практикуется следовать какому-то общему стилю. Т.е., мы должны понимать, что абсолютно идеального подходящего всем решения попросту нет — Вам удобнее с дополнительными к отступам пустыми строками, а меня это будет отвлекать и раздражать при чтении кода, кому-то хочется видеть открывающие фигурные скобки на отдельной строке, а кому-то отрадно их видеть на последней строке инициализации блока. Такова жизнь.

                                                                                                                                      • 0
                                                                                                                                        Что доказывают эти примеры?
                                                                                                                                        Без конкретного примера мне не вполне ясно, о чём тут речь. И кому конкретно приходится отделять.

                                                                                                                                        Хм. Приведенные ссылки и были конкретные примеры. Отделяют авторы кода, разработчики известных проектов. Наверно у них есть причины.


                                                                                                                                        И опять же, лично мне дополнительные пустые строки сами по себе не помогают понять логику того или иного кода.

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


                                                                                                                                                }
                                                                                                                                                someCommonAction();
                                                                                                                                            } elseif ($someObject->anotherAttributeLongName !== $someValue) {
                                                                                                                                                foreach ($someObject->anotherAttributeLongName as $item) {
                                                                                                                                                    doSomethingWithItem($item);
                                                                                                                                                }

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

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


                                                                                                                                        Например, для PHP есть PSR-1 и PSR-2. Т.е., мы должны понимать, что абсолютно идеального подходящего всем решения попросту нет

                                                                                                                                        Я про них и говорю. Требования в них основаны на каких-то причинах. Обсудить эти причины ничего не мешает. Идеальное решение я не предлагаю.
                                                                                                                                        К тому же, для классов и функций скобка должна быть на отдельной строке. И на это тоже есть какие-то причины.

                                                                                                                                  • 0

                                                                                                                                    Я, конечно, не программист на PHP, но что мешает вместо добавления строк просто переносить саму скобку, как в C#?


                                                                                                                                    Скрытый текст
                                                                                                                                    if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue)
                                                                                                                                    {
                                                                                                                                        if ($someObject->attributeLongName !== $someValue)
                                                                                                                                        {    
                                                                                                                                            foreach ($someObject->attributeLongName as $item)
                                                                                                                                            {
                                                                                                                                                doSomethingWithItem($item);
                                                                                                                                            }
                                                                                                                                            someCommonAction();        
                                                                                                                                        }
                                                                                                                                        elseif ($someObject->anotherAttributeLongName !== $someValue)
                                                                                                                                        {    
                                                                                                                                            foreach ($someObject->anotherAttributeLongName as $item)
                                                                                                                                            {
                                                                                                                                                doSomethingWithItem($item);
                                                                                                                                            }
                                                                                                                                            someCommonAction();
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                    • 0
                                                                                                                                      Так я про это и говорю) Чем писать скобку в конце и добавлять пустую строку для читаемости, проще скобку переносить.
                                                                                                                                      • 0
                                                                                                                                        Ещё сделать скобки с отступом в 2 символа (а вложенный туда код — сдвигать на 2 отступа, то есть на 4 пробела) и вы придёте к GNU style, про которые Линус говорит First off, I'd suggest printing out a copy of the GNU coding standards, and NOT read it. Burn them, it's a great symbolic gesture.
                                                                                                                                        • 0

                                                                                                                                          Некоторые люди не находят преимуществ ни в добавлении пустых строк, ни в переносе открывающей скобки на отдельную строку. Кстати, рекомендации PHP-FIG (PSR-1, PSR-2) применительно к ветвлениям и циклам тоже. Хотя, имхо, если уж тратить место на отдельную строку, то хотя бы открывающую скобку туда вставить… :)

                                                                                                                                          • 0
                                                                                                                                            Ничего не мешает переносить скобку, но при этом не обязательно добавлять строку (я так пишу):
                                                                                                                                            Впечатлительным и беременным не открывать.
                                                                                                                                            if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue)
                                                                                                                                                {   if ($someObject->attributeLongName !== $someValue)
                                                                                                                                                      {   foreach ($someObject->attributeLongName as $item)
                                                                                                                                                                {   doSomethingWithItem($item);
                                                                                                                                                                }
                                                                                                                                                            someCommonAction();        
                                                                                                                                                        }
                                                                                                                                                    elseif ($someObject->anotherAttributeLongName !== $someValue)
                                                                                                                                                        {   foreach ($someObject->anotherAttributeLongName as $item)
                                                                                                                                                                {   doSomethingWithItem($item);
                                                                                                                                                                }
                                                                                                                                                            someCommonAction();
                                                                                                                                                        }
                                                                                                                                                }
                                                                                                                                            Первую строчку с открывающей строчкой чуть сложнее редактировать, но не так чтобы уж сильно. За то компактно и наглядно. А из любителей не переносить скобку встречал такое:
                                                                                                                                            Впечатлительным и беременным не открывать.
                                                                                                                                            if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue) {
                                                                                                                                                    if ($someObject->attributeLongName !== $someValue) {
                                                                                                                                                            foreach ($someObject->attributeLongName as $item) {
                                                                                                                                                                    doSomethingWithItem($item); }
                                                                                                                                                            someCommonAction(); }
                                                                                                                                                    elseif ($someObject->anotherAttributeLongName !== $someValue) {
                                                                                                                                                            foreach ($someObject->anotherAttributeLongName as $item) {
                                                                                                                                                                    doSomethingWithItem($item); }
                                                                                                                                                            someCommonAction(); } }
                                                                                                                                            • 0
                                                                                                                                              Какой-то в вашем первом примере бардак. Каждая строчка и скобка стоит не пойми где
                                                                                                                                              • 0
                                                                                                                                                Как выше упомянули он похож на GNU формат, но только блок начинается с той же строчки что и открывающаяся скобка.
                                                                                                                                                Сверху-вниз мой стиль, GNU, K&R
                                                                                                                                                Для удобства свой еще раз скопировал и у всех стилей поставил одинаковые отступы.
                                                                                                                                                if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue)
                                                                                                                                                  { if ($someObject->attributeLongName !== $someValue)
                                                                                                                                                      { foreach ($someObject->attributeLongName as $item)
                                                                                                                                                          { doSomethingWithItem($item);
                                                                                                                                                          }
                                                                                                                                                        someCommonAction();        
                                                                                                                                                      }
                                                                                                                                                    elseif ($someObject->anotherAttributeLongName !== $someValue)
                                                                                                                                                      { foreach ($someObject->anotherAttributeLongName as $item)
                                                                                                                                                          { doSomethingWithItem($item);
                                                                                                                                                          }
                                                                                                                                                        someCommonAction();
                                                                                                                                                      }
                                                                                                                                                  }
                                                                                                                                                if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue)
                                                                                                                                                  {
                                                                                                                                                    if ($someObject->attributeLongName !== $someValue)
                                                                                                                                                      {
                                                                                                                                                        foreach ($someObject->attributeLongName as $item)
                                                                                                                                                          {   
                                                                                                                                                            doSomethingWithItem($item);
                                                                                                                                                          }
                                                                                                                                                        someCommonAction();        
                                                                                                                                                      }
                                                                                                                                                    elseif ($someObject->anotherAttributeLongName !== $someValue)
                                                                                                                                                      { foreach ($someObject->anotherAttributeLongName as $item)
                                                                                                                                                          {
                                                                                                                                                            doSomethingWithItem($item);
                                                                                                                                                          }
                                                                                                                                                        someCommonAction();
                                                                                                                                                      }
                                                                                                                                                  }
                                                                                                                                                if (someLongFunction() === $someLongValue && anotherLongFunction() === $anotherLongValue) {
                                                                                                                                                    if ($someObject->attributeLongName !== $someValue) {
                                                                                                                                                        foreach ($someObject->attributeLongName as $item) {
                                                                                                                                                            doSomethingWithItem($item);
                                                                                                                                                        }
                                                                                                                                                        someCommonAction();
                                                                                                                                                    } elseif ($someObject->anotherAttributeLongName !== $someValue) {
                                                                                                                                                        foreach ($someObject->anotherAttributeLongName as $item) {
                                                                                                                                                            doSomethingWithItem($item);
                                                                                                                                                        }
                                                                                                                                                        someCommonAction();
                                                                                                                                                    }
                                                                                                                                                }
                                                                                                                                                Каждому конечно свое, но мне хуже всего K&R. В моем скобки на против друг друга. Скобки с отступом от оператора после которого они идут и операторы внутри с отступом от них — строгая вложенность как в GNU. Но при этом как в K&R экономится строка (хотя это конечно не главное).
                                                                                                                                      • 0
                                                                                                                                        Звучит невероятно, но после того как я стал использовать пробелы, я действительно спустя 3 недели получил оффер с более высокой оплатой труда. Следующим шагом думаю проверить отключение автозамены таба на пробелы и проставление их вручную
                                                                                                                                        • +1
                                                                                                                                          Маяковский озолотился бы