Вам стыдно за плохой код написанный вами

     

    Only registered users can participate in poll. Log in, please.

    Вам стыдно за плохой код написанный вами

    • 52.5%Очень стыдно, даже хотелось бы переписать1779
    • 30.1%Просто стыдно1023
    • 18%Нейтрально610
    • 13.5%Я не писал плохого кода, я не учился программированию, я был гуру с рождения459
    Share post

    Similar posts

    Comments 241

      +36
      Последний пункт опроса — это такой хитрый прием определения процента быдлокодеров? =)
        +1
        Именно
          +10
          Почему не поставили пункт «Я горжусь своим плохим кодом»?

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

          Но все равно горжусь тем фактом, что моя программа не просто работала, а служила людям лет 7.
            +1
            Последний пункт опроса — это, скорее, определение процента наиболее опытных программистов, которые иронически ухмыльнутся максимализму подрастающего поколения.
              –1
              Я проголосовал за все 4 пункта :)

          • UFO just landed and posted this here
              +17
              «Нейтрально», имхо — самая адекватная реакция когда тебе указывают на плохой код. Спокойно принял к сведению и перестал так писать. Не головой же биться о стену
                +1
                «перестал так писать»? )
                прикольно…
                  +10
                  Поддерживаю. Для хорошего программиста любой законченный модуль морально устаревает на момент релиза.
                    +2
                    Скорее даже на момент написания/закрытия редактора :) А в релиз уже поступает анахронический код.
                      +3
                      Ага. И его уже хочется переписать )
                      +1
                      у меня знакомый есть, который позицоионирует себя аццким программистом, отцом прямо, а меня называет дураком и неумехой. И вот, однажды, я попросил его. Говорю, покажи мне свой код, мне интересно, как пишут отцы? Он говорит — плати тыщщу баксов, и я тебе покажу.
                      Я ему — зачем мне весь твой код, мне хватило бы всего пары классов.
                      Он — так пара классов работать то не будет!
                      Я ему — да я и не собираюсь их запускать, я просто хочу посмотреть как пишут хорошие, аццкие программисты.
                      На что он ответил — тыщща баксов в месяц, и он научит меня так кодить, мол научит меня нарабатывать свой опыт самостоятельно, а то я якобы этого не умею.

                      В итоге все свелось как всегда к писькомереву, в котоорм я принял довольно нейтральную позицию.

                      Да, мой код не идеален, и я при возможности пытаюсь его переписать с учетом моего текущего опыта, и да, я не стыжусь показывать свой код. Проголосовал за 1 пункт)
                        0
                        и да, он считает плохим тоном постоянное чтение документации к ЯП.

                        Это правда плохо?
                          0
                          Настоящие админы маны не читают.
                          Настоящие админы маны уже прочитали.
                            +3
                            Настоящие админы читают маны каждый раз, когда они обновляются. Т.е. — всегда.
                            0
                            А где работает этот ваш знакомый? как то вы по тролльски описали его, по вашему описанию выходит что этот ваш знакомый — просто квинтэссенция заносчивого и наглого ламера.
                              0
                              Просто школоло наконец-то научилось держать в руках Visual Studio >2008 и пошло отрабатывать «диплом».
                                0
                                да не важно)
                                он для меня раньше, что то вроде авторитетного человека был, но вот после этого разговора я решил пересмотреть свое отношение к нему)
                                  0
                                  судя по тому как он себя повел, при просьбе показать свой код, он либо полный неадекват либо код у него убогий. Если код хороший то ИМХО им похвалиться можно, показав его другим
                                    0
                                    оффтопик:
                                    код свой я считаю почти идеальным(хотя иногда бывает говнокодю, иногда некоторые считают что он не идеальный), но при этом я его не стыжусь показать. мне наоборот интересно, что думают о его качепстве другие. Критику в этом плане люблю, т.к. хочу уметь писать true-идеальный код)
                          0
                          Мне — нейтрально. Все мы когда-то начинали учиться и делали глупые ошибки. Но не думаю, что стоит убиваться по этому поводу. Главное — не повторять их в будущем. Никто не родился аццким кодером.
                          0
                          В коде Чака Норриса никогда не бывает багов. Он никогда не ошибается. Если вы нашли баг в коде Чака — попробуйте поговорить с ним об этом — сразу поймете, что это на самом деле необходимая фича проекта.

                          habrahabr.ru/blogs/tdd/116514/
                            +7
                            начнём с того, что это не опрос, а утверждение
                            +12
                            Зачем чекбоксы?
                              +1
                              Первый опрос делал и не заметил выбора между чекбоксами и радиобоксами
                                +79
                                Не стыдно? Переделать не хочется?
                                  0
                                  а вы подскажите как.
                                    +13
                                    Простите, забыл тег <sarcasm>
                                +1
                                Да нормально, что нужно для такого вопроса.
                                –31
                                А почему мне должно быть стыдно за плохой код, в котором я сам лично хорошо разбираюсь даже через пол года после его написания?
                                  +1
                                  А кто вам сказал что вам должно быть стыдно? Это опрос, а не поучения о том что вам должно быть стыдно.
                                    –8
                                    Я расцениваю этот опрос именно как вопрос к каждому программисту. Стыдно ли ему за свой плохой код?
                                      +39
                                      Простите что не предусмотрел вариант для вас 'Я горжусь свом плохим кодом', в следующий раз обязательно учту.
                                        +2
                                        «Следующий раз» может нахватать минусов, а ссылка в первом комментарии будет вести сюда :)
                                          +4
                                          Люди не оценили шутку, жалко :(
                                          0
                                          А кто считает код плохим, я или вы?
                                            +3
                                            Простите что не предусмотрел вариант для вас 'Я горжусь свом плохим кодом', в следующий раз обязательно учту.

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

                                            Да, сейчас я пишу намного лучше и если бы я такой код писал сейчас, то мне было бы стыдно, но то, что я такой код писал через полгода обучения — я горжусь.
                                        +22
                                        Инженеры ВАЗ: «Почему нам должно быть стыдно за наши машины — у них же по-прежнему четыре колеса, даже через полгода их сборки?»
                                          –2
                                          … они по прежнему на ходу даже через пол года, после их сборки и покупки
                                            0
                                            не факт:)
                                            Я к тому, что если проект подразумевает развитие, то надо делать его хорошо
                                              –13
                                              развитие, пока мне за это платят, а что будет после меня в этом проекте, меня не должно волновать.
                                                +2
                                                Ну тогда вы как ни странно эгоист которому нужны только деньги и вы не хотите совершенствовать свои знания в области программирования
                                                  –4
                                                  нет, я не эгоист, я просто живу и питаюсь за счет написанного кода. А совершенствование приходит с будущими проектами, осознание предыдущих своих ошибок и не повторения их в будущих.
                                                  +3
                                                  Существует такое понятие как «репутация». Нет?
                                                    –10
                                                    репутация, карма, никнейм, бложики и т.д. Все это важно только в интернете если ты работаешь фрилансером или на удаленке в фирме. А я максимально стараюсь искать работу в офисе с 9 часовым рабочим графиком.
                                                    При приеме на работу всегда есть, что показать работодателю.
                                                      +5
                                                      Репутация в офлайне, конечно. Мне казалось, что любую работу надо делать хорошо, а не делить ее на (условно):
                                                      — показать код при приеме на работу
                                                      — написать «абы как», главное, чтобы работало
                                                        +2
                                                        к сожалению, далеко не все кодеры любят свою работу и хотят стать лучше
                                                    0
                                                    А как же рекомендации?
                                                      0
                                                      Если плохой код приняли, то большая вероятность того, что рекомендации будут основаны на функциональности кода, а не его качестве. Проще говоря часто работодатель не может оценить качество кода.
                                                    +2
                                                    … после их покупки и сборки
                                                +5
                                                Потому что Вы пишете код не для себя, не для компилятора, а для людей. Для людей, которые будут в дальнейшем с ним работать. С большой долей вероятности Вы не будете его вечно поддерживать, и когда-нибудь эта обязанность перейдет к другому человеку.

                                                Впрочем, это, конечно, зависит от специфики проекта, но в общем случае одни люди уходят — на их место приходят другие.
                                                  –2
                                                  я пишу код ради его конечной цели, которую желает видеть работодатель. И мне совершенно не интересны следующие после меня работники, которые сядут за модификацию этого кода. Мне за это не доплачивают. Обидно, неприятно, но это действительно так.
                                                    +7
                                                    это называется эгоизм :)
                                                      +5
                                                      Любую работу нужно делать хорошо. Вопрос сколько вы получаете или нет за эту работу плохой аргумент.
                                                        +8
                                                        Вам за это не доплачивают, а платят. Работодатель по-умолчанию желает получить код, который можно будет в дальнейшем поддерживать с минимальными затратами. Если же ему достаточно «чтобы работало и подешевле» — так и скажите ему, что из [«быстро», «дешево», «качественно»] можно выбрать только 2 пункта.

                                                        Впрочем, это всего лишь мое мнение, и я не хочу навязывать его Вам. Но на месте потенциального работодателя я бы не стал с Вами связываться.
                                                          –6
                                                          скорее все работодатели хотят быстро, дешево и чтоб работало, а что там внутри никого не волнует. Мржет и есть такие мифические работодатели, которых вы описываете, но я таких не встречал.
                                                            +11
                                                            Нельзя научиться писать хороший код, занимаясь написанием плохого. Вы это для себя должны делать, а не для работадателя, работодателю и правда часто пофиг. Писать хороший код — совсем не сложно ведь, когда привычка выработана и опыт есть. А привычку не выработать, и опыт не получить, занимаясь исключительно интересами работодателя и просто выполняя формально его хотелки. Лучше ведь всегда учиться чему-то, а не просиживать штаны и тратить свое время впустую на удовлетворение чужих интересов. Если писать плохой код, то у работадателя остается работающий продукт (будем считать, что это так), а у программиста не остается ничего. Если писать хороший код, то у работодателя остается работающий продукт (вероятно, работающий чуть лучше), а у программиста — ценный опыт и навыки. Всем ведь хорошо от этого, зачем же тогда ерундой страдать и делать что-то спустя рукава, зачем свое время просто вникуда выкидывать?
                                                              –2
                                                              полностью с вами согласен, виртуальный плюсик вам в карму. С каждым новым проектом растет опыт, делаешь все лучше и лучше уже на автомате. Но за бесплатно возвращаться к полугодовалым проектам, которые я не веду и что-то то там допиливать бесплатно я никогда не буду. Уж простите меня будущие программисты, столкнувшиеся с моим кодом. =)
                                                                0
                                                                Хотел спросить — а где бы найти примеры реально хорошего кода сложных систем? Теория-теорией, а практику можно набивать или на своих пробах и ошибках, или (отчасти) на чужих. Лазил по sourceforge, codeplex и иже с ними — очень тяжело найти хоть что-то с хорошим кодом, в топе зачастую висит вообще адский мрак (напр. farseer physics на codeplex). Желательно для платформы .net.
                                                                  0
                                                                  >примеры реально хорошего кода сложных систем?

                                                                  git.kernel.org. без шуток.
                                                                    0
                                                                    Можно привести конкретный проект? Т.к. далеко не все, что там есть — имеет сколько нибудь хороший код.
                                                                      –2
                                                                      Пробежался еще раз по репозиторию — открыл 5 наугад взятых проектов, во всех дочитывал до второго-третьего goto и закрывал. Так что похоже не без шуток (или это очень злые шутки).
                                                                        –2
                                                                        или и это очень злые шутки
                                                                          –1
                                                                          Я с удовольствием посмотрел бы, как вы бы реализовали на Си без goto вытесняющую многозадачность или async i/o. ☺
                                                                          0
                                                                          В системном програмированние как бы ни говорили туго без GOTO, все таки иногда абстракция блоков кода не так хороша.
                                                                            –3
                                                                            Где здесь необходимость в использовании goto?
                                                                            void sctp_generate_proto_unreach_event(unsigned long data)
                                                                            {
                                                                            	struct sctp_transport *transport = (struct sctp_transport *) data;
                                                                            	struct sctp_association *asoc = transport->asoc;
                                                                            
                                                                            	sctp_bh_lock_sock(asoc->base.sk);
                                                                            	if (sock_owned_by_user(asoc->base.sk)) {
                                                                            		SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
                                                                            
                                                                            		/* Try again later.  */
                                                                            		if (!mod_timer(&transport->proto_unreach_timer,
                                                                            				jiffies + (HZ/20)))
                                                                            			sctp_association_hold(asoc);
                                                                            		goto out_unlock;
                                                                            	}
                                                                            
                                                                            	/* Is this structure just waiting around for us to actually
                                                                            	 * get destroyed?
                                                                            	 */
                                                                            	if (asoc->base.dead)
                                                                            		goto out_unlock;
                                                                            
                                                                            	sctp_do_sm(SCTP_EVENT_T_OTHER,
                                                                            		   SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
                                                                            		   asoc->state, asoc->ep, asoc, transport, GFP_ATOMIC);
                                                                            
                                                                            out_unlock:
                                                                            	sctp_bh_unlock_sock(asoc->base.sk);
                                                                            	sctp_association_put(asoc);
                                                                            }
                                                                            
                                                                              –1
                                                                              А вы попробуйте сейчас без GOTO написать и поймете.
                                                                                –2
                                                                                if (something)
                                                                                {
                                                                                    // doWorkForSomething
                                                                                    goto end;
                                                                                }
                                                                                
                                                                                if (somethingAnother)
                                                                                {
                                                                                    // doWorkForSomethingAnother
                                                                                    goto end
                                                                                }
                                                                                
                                                                                //doSomeWork
                                                                                
                                                                                end:
                                                                                // doEndWork
                                                                                

                                                                                  +2
                                                                                  Сорри, отправилось раньше:

                                                                                  На входе имеем:
                                                                                  if (something)
                                                                                  {
                                                                                      // doWorkForSomething
                                                                                      goto end;
                                                                                  }
                                                                                  
                                                                                  if (somethingAnother)
                                                                                  {
                                                                                      // doWorkForSomethingAnother
                                                                                      goto end
                                                                                  }
                                                                                  
                                                                                  //doSomeWork
                                                                                  
                                                                                  end:
                                                                                  // doEndWork
                                                                                  


                                                                                  Без goto
                                                                                  if (something)
                                                                                  {
                                                                                      // doWorkForSomething
                                                                                  }
                                                                                  else if (somethingAnother)
                                                                                  {
                                                                                      // doWorkForSomethingAnother
                                                                                  }
                                                                                  else
                                                                                  {
                                                                                      // doSomeWork
                                                                                  }
                                                                                  
                                                                                  // doEndWork
                                                                                  
                                                                                    0
                                                                                    Это был очередной синтетический показатель убогости GOTO, а вот тот код вы можете написать элегантно без GOTO?
                                                                                      0
                                                                                      А чем тот код отличается от того, что я написал? Просто вместо кусков внутри if'ов того кода вставил комментарии, чтобы было наглядно и не стелить простыню кода.
                                                                                        0
                                                                                        Ок, пишу приблизительно то, как должен выглядеть код:

                                                                                          +2
                                                                                          Да чтож такое, опять автоотправление)

                                                                                          Тут кроме goto еще куча огрехов, типа залезания в кишки к Base из этой функции, непонятные сокращения, куча параметров у функций и т.д.

                                                                                          т.к. я не разбирался в том, что реально значат сокращения — то мог где-нибудь ошибиться, но это не меняет сути.
                                                                                          void SctpGenerateProtoUnreachEvent(unsigned long data)
                                                                                          {
                                                                                          	struct SctpTransport *transport = (struct SctpTransport *) data;
                                                                                          	struct SctpAssociation *stcpAssociation = transport->Asociation;
                                                                                          
                                                                                          	SctpBhLockSock(stcpAssociation->Base.Sk);
                                                                                          	
                                                                                          	if (SockOwnedByUser(stcpAssociation->Base.Sk))
                                                                                          	{
                                                                                          		SCTP_DEBUG_PRINTK("%s:Sock is busy.\n", __func__);
                                                                                          
                                                                                          		// Try again later.
                                                                                          		if (! ModTimer(&transport->ProtoUnreachTimer, jiffies + someConst))
                                                                                          		{
                                                                                          			SctpAssociationHold(asoc);
                                                                                          		}
                                                                                          	}
                                                                                          	else if (!(sctpAssociation->Base.Dead))  // Is this structure just waiting around for us to actually get destroyed?
                                                                                          	{
                                                                                          		auto sctpStOther = SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH);
                                                                                          		
                                                                                          		SctpDoSm(SCTP_EVENT_T_OTHER, sctpStOther, asoc, transport, GFP_ATOMIC);
                                                                                          	}
                                                                                          
                                                                                          	SctpBhUnlockSock(stcpAssociation->Base.Sk);
                                                                                          	SctpAssociation_put(stcpAssociation);
                                                                                          }
                                                                                          
                                                                                            0
                                                                                            это хуже читается. основной код уехал на один уровнь вложенности и теперь непонятно, что эта функция делает кроме каких-то проверок.

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

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

                                                                                            флаги состояний — это лишнее обращение к памяти и лишнее место на стеке там, где можно было сразу сделать один BL (jump) в нужную точку.
                                                                                              0
                                                                                              Еще раз повторю — что проблема в том числе в архитектуре, т.к. многие вещи должно вынести в отдельные функции, тогда и вложенность будет 1-2 уровня и код будет читабелен, и функции не будут простынками на 1000 строчек. Освобождение ресурсов тоже будет простым и понятным.
                                                                                              А уж экономить байт памяти и такты процессора (у нас же компилятор ничего не оптимизирует, или все же оптимизирует?;)) — это уже просто возврат в 80е года. Сейчас о таком можно говорить разве что в жестком embedded.
                                                                                                +1
                                                                                                А чем плох «goto» кроме того, что «люди говорят, что goto — плохо»? Никогда не приходилось им пользоваться, но я реально не могу понять. И я реально не могу понять, почему некоторые считают, что «извернуться через while-break» — это лучше, чем использовать goto.
                                                                                                  +1
                                                                                                  goto begin
                                                                                                  label1: что зачастую очень сильно goto label2
                                                                                                  label3: прыгнуть сразу в любую точку функции.
                                                                                                  begin: Goto плохо тем (goto label1)
                                                                                                  label2: запутывает понимание кода, позволяя goto label3

                                                                                                  Если по серьезному, то костыли через while-break ничуть не лучше, если в коде появляются такие костыли или goto — это говорит о том, что сам код организован неправильно. Зачастую там, где убирание goto приводит к увеличения уровня вложенности, или необходимости кучи дополнительных костылей — присутствуют более фундаментальные баги, а goto в этом случае — только симптом. Например зачастую такие функции имеют сотни строк длины, в них идет обращение через 3-4 уровня абстракции и т.д.
                                                                                                  В случае же, когда функция сама по себе без «smell», то в ней и не будет аргументированного goto, т.к. она будет выполняться линейно.

                                                                                                  Даже в случае отработки cleanup по goto в конце метода гораздо проще ошибиться, чем при аккуратном разбиении этого метода и очистки ресурсов без goto. (например — добавить новую ветку и в ней забыть сделать goto, чего не получится сделать при более безопасных методах организации кода).

                                                                                                  • UFO just landed and posted this here
                                                                                                      0
                                                                                                      int Foo_bar(
                                                                                                      Foo *f)
                                                                                                      {
                                                                                                      Boo *b;
                                                                                                      Moo *m

                                                                                                      b = Boo_new();
                                                                                                      if (b == NULL)
                                                                                                      {
                                                                                                      return MY_ERR;
                                                                                                      }
                                                                                                      m = Moo_new();
                                                                                                      if (m == NULL)
                                                                                                      {
                                                                                                      Boo_free(b);
                                                                                                      return MY_ERR;
                                                                                                      }
                                                                                                      if (Foo_baz(f, b, m) != MY_OK)
                                                                                                      {
                                                                                                      Moo_free(m);
                                                                                                      Boo_free(b);
                                                                                                      return MY_ERR;
                                                                                                      }

                                                                                                      return MY_OK;
                                                                                                      }
                                                                                                      Не?
                                                                                                      • UFO just landed and posted this here
                                                                                                        0
                                                                                                        Ну например так (далеко не идеал, первое что пришло в голову)
                                                                                                        int Foo_bar(Foo *f)
                                                                                                        {
                                                                                                            auto status = MY_ERR;
                                                                                                        
                                                                                                            auto b = Boo_new(&result);
                                                                                                            auto m = Moo_new(&result);
                                                                                                        
                                                                                                            auto fooBazStatus = Foo_baz(f, b, m);
                                                                                                                
                                                                                                            if (fooBazStatus == MY_OK)
                                                                                                            {
                                                                                                                status = MY_OK;
                                                                                                            }
                                                                                                        
                                                                                                            Moo_free(m);
                                                                                                            Boo_free(b);
                                                                                                            
                                                                                                            return status;
                                                                                                        }
                                                                                                        


                                                                                                        При этом при выделении ресурса первой строчкой стоит проверка выходного result и возврат, если он false, тоже самое в cleanup с проверкой на null.
                                                                                                          0
                                                                                                          Имхо, тут нельзя гарантировать, что Foo_baz не скрэшится, если в него затолкать нуллы в b и m.
                                                                                                            0
                                                                                                            Я пояснил снизу, что надо добавить две строки в методы работы с ресурсами, чтобы они проверяли входные параметры. Раз уж она возвращает статус — то пусть просто вернет ERROR.
                                                                                                              0
                                                                                                              Видимо, время сказывается, т.к. в Вашем сообщении не было ни одного слова «входной», ну да ладно, тут я с Вам полностью согласен и сам всегда проверяю входные параметры в методах, однако, это могут быть методы, которые мы (или не мы) не можем изменить, скомпиленная либа, например.
                                                                                                              И опять же возвращаемся к тому, что если уж выпиливать косяки в архитектуре и не только, то выпиливать их везде, а не в одном методе.
                                                                                                                0
                                                                                                                Когда я что-то пишу — обычно абстрагируюсь от предоставленного API, так потом гораздо легче что-то править.

                                                                                                                Что касается модификации уже существующего кода — то тут действительно зачастую удобнее вставить костыль, чем переписывать, т.к. к таким костылям разработчики решения скорее всего привыкли, а переписывание всего займет кучу времени и денег.
                                                                                                                Я в основном имею ввиду новые проекты.
                                                                                                          • UFO just landed and posted this here
                                                                                                      • UFO just landed and posted this here
                                                                                                          0
                                                                                                          А можно хоть один пример кода с грамотной архитектурой, в котором так необходим goto?

                                                                                                          Я никогда не видел таких примеров, на чем собственно и основывается моя позиция об отсутствии пользы goto.
                                                                                                          0
                                                                                                          Кстати говоря, в примерах, которые я приводил в замен goto — проще сделать статический анализ кода на предмет бранчей, гарантированно вызывающих ошибки, с goto же такой анализ производить труднее.
                                                                                                          • UFO just landed and posted this here
                                                                                                          0
                                                                                                          >многие вещи должно вынести в отдельные функции

                                                                                                          тогда он как раз будет хуже читаться.

                                                                                                          >компилятор ничего не оптимизирует, или все же оптимизирует?

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

                                                                                                          если писать код ногами, комрилятор не спасет.
                                                                                                            +1
                                                                                                            Ну если вас устраивают листинги кода по 200-500 строк на функцию — пожалуйста, к счастью мы работаем в разных сферах и мне никогда не придется иметь дело с вашим кодом.

                                                                                                            У меня интеловский компилер оптимизирует и инлайнит все что можно, но даже там, где он не сможет соптимизировать — это потеря считанных байт-килобайт и наносекунд, для меня гораздо важнее качество кода, чем мифические килобайты и наносекунды.
                                                                                                              0
                                                                                                              >листинги кода по 200-500 строк на функцию

                                                                                                              не фантазируйте.

                                                                                                              тем более, что с goto как раз код будет короче.

                                                                                                              и функция в 200 строк действительно бывает лучше 300, но размазанных хрен знает где.
                                                                                                                0
                                                                                                                Если функция красива и измеряется в десятках строк — в ней просто нет смысла ставить goto, т.к. ее логика должна быть прозрачной и линейной.
                                                                                                                Так я не спорю что 200 строк лучше трехсот, а еще лучше 20-40 строк)
                                                                                                                  0
                                                                                                                  функции в ядре линукса измеряются десятками строк, имеют малое количество отступов и за счет использования goto их выполнение более линейно.
                                                                                                                    0
                                                                                                                    Ну не надо лгать. Первый попавшийся пример из ядра: файл sched.c, функция __sched_setscheduler — под две сотни строк, и это далеко не одна такая функция.
                                                                                                                0
                                                                                                                >У меня интеловский компилер оптимизирует и инлайнит все что можно

                                                                                                                у меня нет под рукой интелевого, проверял на последнем армовом gc

                                                                                                                >потеря считанных байт-килобайт и наносекунд

                                                                                                                это запросто может стать ботлнеком

                                                                                                                >важнее качество кода

                                                                                                                с использованием goto получается как раз качественный, компактный и хорошо читаемый код.
                                                                                                                  0
                                                                                                                  Оптимизировать стоит то — что тормозит, а не все подряд, экономии байт и наносекунд уже проносили достаточно катастроф, в том числе с человеческими жертвами, и с огромными убытками, если речь об энтерпрайзе.
                                                                                                                  • UFO just landed and posted this here
                                                                                                                      0
                                                                                                                      Я честно — не понял суть комментария. Код нужно писать качественным и читабельным, а оптимизацию производить только в последнюю очередь, после профилирования.
                                                                                                  +3
                                                                                                  Обсуждалось это всё уже по 100 раз. Конкретно тут Вы правы, но вот представьте вложенность не 1-уровневую, а трех-четырех, да пару циклов вложенных, уже изнутри которых и делается goto. В этом случае не обойтись без кучи флагов или дублирования кода. Или goto к месту очистки ресурсов. А коли уж в одном месте проекта так сделали, то и в остальных (даже таких тривиальных как Ваш пример) решили иметь схожее поведения. Ради единообразия.
                                                                                                    –1
                                                                                                    Так здесь проблема в кривой архитектуре, которая жить не может без goto.
                                                                                                      0
                                                                                                      При чем тут архитектура? Куча алгоритмов на графах, матрицах и массивах предполагают двойную-тройную вложенность циклов. Если из внутренних циклов (да еще и из нескольких разных мест) нужно выйти на самый верх и после этого очистить ресурсы — вот вам и пример goto. У Макконнелла по этому поводу целый раздел в «Совершенном коде» есть.
                                                                                                        0
                                                                                                        А что мешает использовать функции вместо чудовищной вложенности?
                                                                                                          0
                                                                                                          Например, когда алгоритм бегает по строкам:
                                                                                                          bool success = true;
                                                                                                          
                                                                                                          for(uint row = 0; row < matrix.RowsCount, row++)
                                                                                                          {
                                                                                                              success &= ProcessRow(matrix.Row[row]);
                                                                                                          
                                                                                                              if (!success)
                                                                                                              {
                                                                                                                  break;
                                                                                                              }
                                                                                                          }
                                                                                                          
                                                                                                          return success;
                                                                                                          
                                                                                                            0
                                                                                                            Некоторые вообще сейчас пишут подобные вещи в стиле LINQ, тут конечно на любителя синтаксис, за пару недель привыкается и читается на ура. Главный плюс — возможность очень и очень просто распараллелить все это дело, и включать-отключать параллелизацию централизованно, изменением одной переменной:

                                                                                                            private static bool ProcessMatrix(Matrix matrix)
                                                                                                            {            
                                                                                                                var success = Enumerable.Range(0, matrix.RowsCount)
                                                                                                                                        .AsParallel()
                                                                                                                                        .WithDegreeOfParallelism(parallelismDegree)
                                                                                                                                        .All(x => ProcessRow(matrix.Row[x]));
                                                                                                            
                                                                                                                return success;
                                                                                                            }
                                                                                                            
                                                                                                              0
                                                                                                              Фы сами только что использовали флаг
                                                                                                                –1
                                                                                                                А что плохого в флаге, когда ясно видно для чего он используется? Выше пример с linq без флага.
                                                                                                                Альтернатива с goto совсем не катит, т.к. она абсолютно не гибко сшивает путь выполнения. Понадобится потом чутка изменить реализацию, или добавить ту же обработку ошибок — и что я буду с goto делать?
                                                                                                                  0
                                                                                                                  этот прием похож на отработку деструкторов в C++ коде
                                                                                                                    0
                                                                                                                    Который именно прием?
                                                                                                                –1
                                                                                                                чем break лучше goto?
                                                                                                                Очнитесь уже, break и goto это одно и то же.

                                                                                                                Кстати на хабре была хорошая статья про goto, почитайте:
                                                                                                                habrahabr.ru/blogs/cpp/114211/
                                                                                                                  0
                                                                                                                  break и goto это одно и то же.

                                                                                                                  А ещё while, if, for, foreach и даже вызов функции.
                                                                                                                    0
                                                                                                                    Я в курсе, да. Так если это одно и то же как можно утверждать что использовать break — хорошо, а goto — плохо?
                                                                                                                      0
                                                                                                                      Разница такая же, как налить кипяченую воду в стакан, или зачерпнуть ведро воды из водохранилища. И то и то — вода, более того, кипяченая вода из чайника — по сути тоже вода из какого-нибудь водоема. Чувствуете?
                                                                                                  0
                                                                                                  Ну и более того — почему кто-то делит ХЗ на 20? И почему на 20? Уж такой то магии в коде не должно быть.
                                                                                                    –1
                                                                                                    очень хороший и правильный код. goto в конец функции для освобеждения ресурсов при ошибке — общепринятая практика в системном программировании.

                                                                                                    просто воспринимайте это как блок try-catch-finally.
                                                                                                      –2
                                                                                                      К сожалению, goto-хейтеры обычно почему-то не понимают что все виды циклов, конструкции вроде switch{case break} и конструкции try-catch, а также break и return это фактически тот же самый ненавистный goto
                                                                                                  –3
                                                                                                  препод в пту сказал, что goto — плохо и вы ему поверили, да?
                                                                                                    –1
                                                                                                    И как с вами можно разговаривать, когда вы даже конструктивную беседу вести не можете, переходя на оскорбления? Пишите с goto, сколько вам угодно, только не надо выдавать свое мнение о прекрасном коде за общую истину, тем более что мнение это непопулярно.
                                                                                                      0
                                                                                                      >конструктивную беседу вести не можете,

                                                                                                      какая конструктивная беседа с человеком, который не знает о сложившихся практиках системного программирования и о том, что вообще живет на kernel.org?

                                                                                                      > мнение это непопулярно.

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

                                                                                                      % grep goto kernel -rn | wc -l 
                                                                                                      84048
                                                                                                      


                                                                                                      восемьдесятчетые тысячи случаев использования в отраслеобразующем проекте с адским процессом ревью кода.
                                                                                                        0
                                                                                                        Начнем с того, что я спрашивал источник совершенно не по системному программированию, это раз.
                                                                                                        Сложившиеся практики тут — это такой же миф, как выбор единственно правильной нотации именования и расстановки скобочек, в каждой компании он может быть свой.
                                                                                                        Три — Греп по этим сорцам мало что показывает, кроме того, что там есть 84 тысячи goto.
                                                                                                        Четыре — это какую отрасль образует этот проект? Там же вроде подавляющая часть касается линукса, а это далеко не 100% системного программирования.
                                                                                                          0
                                                                                                          >в каждой компании он может быть свой.

                                                                                                          если использование goto и испльзование кучи вложенных условий и флагов взаимозаменяемы и являются частью привычки так же, как и style guide, то из этого следует как раз обратное — использование goto не может считаться плохим кодом.

                                                                                                          еще раз пишу — goto в функциях инициализации — это не замена условиям, а некий аналог try-catch-finally.

                                                                                                          более того, конечно такой подход практикуется не только в линуксе.

                                                                                                          >Три — Греп по этим сорцам мало что показывает, кроме того, что там есть 84 тысячи goto.

                                                                                                          как вы догадались, не читайте мои мыслиманы!? конечно он показывает количество goto в коде.

                                                                                                          >Четыре — это какую отрасль образует этот проект?

                                                                                                          ядро линукса — отраслеобразующий проект для IT в целом. без него мир рухнет.
                                                                                                            –2
                                                                                                            ядро линукса — отраслеобразующий проект для IT в целом. без него мир рухнет.

                                                                                                            Ах. Так сказали бы сразу что вы тролль, я бы и не вступал в дискуссию.
                                                                                                              0
                                                                                                              То что у меня на аваторке смешная рожица и я тут немного ем еду, не делает указанный факт менее истинным.
                                                                                              +5
                                                                                              >Нельзя научиться писать хороший код, занимаясь написанием плохого

                                                                                              Нельзя научиться писать хороший код, НЕ занимаясь написанием плохого.
                                                                                                0
                                                                                                Ага, и это верно) Имелось в виду, что человек в данный конкретный момент может написать что-то получше, а может полениться думать и оттого написать похуже (не факт, кстати, что быстрее). В первом случае он узнает больше о проблеме и получит опыт (даже если выяснится потом, что его решение было неверным), во втором — не получит ничего. Ну и примерно те же рассуждения для более длинных промежутков времени.

                                                                                                Плохой и хороший — все равно ведь понятия относительные. Если не знаешь, что улучшить в своем коде годичной давности, то это уже повод задуматься, а не зря ли год прошел.
                                                                                            +3
                                                                                            Спрашивал не раз — большинство хотят как можно быстрее реализовать нужную им функциональность. В лучшем случае ограничивают бюджет не ограничивая (в разумных пределах) срок, но писать качественный код за оплату меньшую чем прожиточный минимум как-то не хочется.
                                                                                            0
                                                                                            Лучше не делай, если сделаеш плохо.
                                                                                        +17
                                                                                        Совсем не стыдно, но очень хочется переписать.
                                                                                          0
                                                                                          Действительно, не хватает такого пункта. Если человек сам осознает, в чем его код плохой, почему ему должно быть стыдно?
                                                                                          Первое, что пришло в голову, — старый плохой код, который можно было бы написать лучше. =)
                                                                                          +5
                                                                                          Очень стыдно. Прямо сейчас переделываю свое «творчество» двухлетней давности.
                                                                                            +2
                                                                                            Если делаю для решения каких-то своих небольших задач, то не стыдно, лишь бы быстро сделалось и работало как надо. А если для кого-то, а уж тем более за вознаграждение, то, конечно, стыд берет свое за плохой код.
                                                                                              +1
                                                                                              Осознание проблемы — верный путь к ее решению. Если человек способен осознать, что он написал плохой код, значит потенциально, он знает почему он таким получился, возможно исправит, а возможно не будет повторять своих ошибок в будущем.
                                                                                                +1
                                                                                                как ни странно, очевидный говнокод я никогда не писал, всегда было чувство стиля и времени на рефакторинг.
                                                                                                да, конечно есть неоптимальные решения, не особо красивые, хаки, но всегда это было в меру — не более какого-то небольшого процента от кода.
                                                                                                есть за которые стыдно, но на большинство — нейтрально.
                                                                                                так что чекбоксы мне пригодились :)
                                                                                                  +1
                                                                                                  Покажите свой самый первый код, попавший в продакшн :)
                                                                                                    +1
                                                                                                    Не верю! Все начинают с плохого кода.

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

                                                                                                    P.S. Это было в начальной школе и компьютера у меня не было вообще никакого.
                                                                                                    +3
                                                                                                    Меня спрашивали «как так? почему у тебя исходников не осталось?», я-то знаю, что если понадобится — смогу написать лучше :) Ответ — да, стыдно, по возможности стараюсь переделывать :)
                                                                                                      +2
                                                                                                      svn/git уследит :)
                                                                                                        0
                                                                                                        Ну это я про старые проекты говорил :) Когда в интернет еще по модему выходил :)
                                                                                                      +2
                                                                                                      Когда мне становится стыдно — я его переписываю.
                                                                                                        +11
                                                                                                        НЛО прилетело и написало код за меня
                                                                                                          +12
                                                                                                          Бывает откроешь свой код спустя года 3, берешься за голову и думаешь: «В рот мне ноги, это не я!»
                                                                                                            +1
                                                                                                            Это хорошо. Это показывает только то, что за это время вы выросли как специалист. Вас это должно только радовать.
                                                                                                              +1
                                                                                                              Недавно в аналогичной ситуации в шутку подумалось, что был гораздо умнее – ведь я в этом ужасе разбирался! :)
                                                                                                                0
                                                                                                                Самое ужасно, что спустя год я говорю тоже самое на уже переделанный код. Я понимаю это показатель профессионального роста, но осадок остается :)
                                                                                                              +2
                                                                                                              Написанный мною код, не вызывает у меня не стыда, не гордости, не радости. Просто так его не переписываю, только если нашел дыру в безопасности или способ оптимизировать его в разы.

                                                                                                                +6
                                                                                                                Может я какой-то не правильный, но мне всегда охота переписать код которому есть пару месяцев.
                                                                                                                  0
                                                                                                                  Раньше было очень стыдно, потом привык.:) Впрочем, весь актуальный код я время от времени рефакторю. Иногда удивляюсь, как я мог такое написать, но почти без эмоций.
                                                                                                                    +2
                                                                                                                    Тут еще вопрос стыдно перед кем. Вот не знаю, может у меня такая самокритика высокая, но когда я поднимаю какой-нибудь древний проект с написанным мной индусским кодом, мне стыдно прежде всего перед собой. А вот когда кто-то критикует мой код, я просто воспринимаю это как желание мне помочь и внимаю этой критике, но чувства стыда нет.
                                                                                                                      0
                                                                                                                      Стыдно, потому что себе же хуже сделал. Не нарочно, конечно. Но тем не менее. И переписать хочется. Но сроки, обычно, поджимают :(
                                                                                                                        +7
                                                                                                                        Стыдно — это эмоции.

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

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

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

                                                                                                                        Написал херово, поставил FIXME:, когда таких кусков в одном месте накопилось достаточно, сложился опыт и практические требования, и уже можно посмотреть на проблему более широко — вот тогда уже делать правильно.

                                                                                                                        Совершенно не понимаю, зачем тут чего-то стыдиться.
                                                                                                                          0
                                                                                                                          Поддерживаю. У меня было две основные ситуации:

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

                                                                                                                          2. Код пишется сейчас, но в спешке — т.е. иногда неоптимально, невылизанно. Это является конкретным решением для конкретного проекта с учетом сроков, планов по доработке и так далее. Почему должно быть стыдно — тоже непонятно. Иногда по коду планируется рефакторинг.
                                                                                                                          +2
                                                                                                                          я вот что скажу — если у вас хватило смелости самому себе признать, что код плохой, то надо гордиться а не стыдиться, ведь вы выросли как программист за время, прошедшее с написания.
                                                                                                                            +2
                                                                                                                            Я все понимаю, но почему без вопросительного знака?
                                                                                                                              +1
                                                                                                                              Либо добавьте "?", либо уберите опрос ;)
                                                                                                                                0
                                                                                                                                Отвечу за автора — опросы нельзя редактировать после публикации.
                                                                                                                                  0
                                                                                                                                  И запятую автор тоже пропустил :(
                                                                                                                                0
                                                                                                                                Просто ни за что не соглашусь, что мой код плох. :)

                                                                                                                                (Минусаторам: это я не о себе.)
                                                                                                                                  0
                                                                                                                                  Или так… Мне не хочется трогать свой старый код, потому что я не могу в нем разобраться.
                                                                                                                                  0
                                                                                                                                  Нашел код, за который стыдно? Перепиши, если можешь сделать лучше.
                                                                                                                                    0
                                                                                                                                    Если вам не хочется переписать код, значит, вы в тупике эволюции! Поверните назад или поменяйте свой путь.
                                                                                                                                      –2
                                                                                                                                      >'Поверните назад'
                                                                                                                                      Тоесть переписать свой код? Я наверно от вашего утверждения впаду в рекурсию.
                                                                                                                                        0
                                                                                                                                        Ближе к жизни. Тут ключевое слово тупик. Когда заходишь в тупик есть 2 выхода: лезть на многометровую стену — это худший вариант, ибо умный в гору не пойдет (с). Лучший — повернуть назад (посмотреть что вы упустили, мб какой поворот проглядели). Ну и, конечно, можно убиться об стену.

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

                                                                                                                                        Стремление переделать/улучшить есть у любого человека будь он программистом, дизайнером, писателем.

                                                                                                                                        Есть ещё момент. Если вам нравится ваш код 1-2 годичной давности, то вы тоже в тупике эволюции.
                                                                                                                                          0
                                                                                                                                          Я в своем коменте изображал ход мыслей программиста ответившего на 4й вариант тоесть он не считает что его код плох, тоесть вы этому персонажу советуете повернуться назад что он не хочет делать в итоге от раздумий он впадает в парную рекурсию функций которые проверяют последный раз результаты друг друга, тоесть этот программист если он искрене ответил на 4й вариант какраз в тупике так как он не знает что делать, в глубине процессора (души) он понимает что ему нужно совершенствоваться но ему лень и он оправдывается тем что он лучше некоторых других и может писать некоторые тупые вещи.
                                                                                                                                      +2
                                                                                                                                      Ну развели тут квази-философию и какой-то детский абсолютизм. Кривой код писать МОЖНО, если это просто и быстро и ключевой момент — ЛОКАЛЬНО. Т.е. если в этом кривом коде будет какая-то проблема, то его изменение никак не затронет все остальное. В общем, если снаружи метода не понятно, что этот метод — забыдлокоден, то все нормально. Главное иметь абстракцию хорошую. Вот если сделать что-то хреново, а потом начать это юзать везде-везде, то потом потребуется огромное количество усилий, что бы это исправить. А если это будет какой-нибудь метод-объектик, который хорошо абстрагирован, но пусть внутри какой-нибудь быдлокод, то это не плохо. Совсем не плохо.

                                                                                                                                      А по мне так вообще опрос странный. Стыдно — не стыдно. Программирование не то место, где д.б. стыдно или не стыдно за свой код — есть хороший код, а есть плохой и иногда лучше написать достаточно кривой и не очень красивый код, вместо траты кучи времени на мифическую красоту. В конце концов этот быдлокод можно откомментировать хорошо и все все поймут, пусть даже коммент будет больше кода.
                                                                                                                                        0
                                                                                                                                        >ключевой момент — ЛОКАЛЬНО

                                                                                                                                        вот! кривой интерфейс намнооого хуже кривой реализации. потомучто реализацию можно попилить постфактум.
                                                                                                                                        0
                                                                                                                                        Толи я живу в каком-то другом мире, толи лыжи не натер… Заказчики вроди такие же как и везде: «сделай это, это и это да побыстрей и подешевле», НО никто из круга моих знакомых не говорил: «мне за это не платят», а всегда пишут максимально качественный код, который возможен в конкретных условиях. И всем стыдно за каждый, даже самый маленький костыль. Увы, мы живем в несовершенном мире (но это смотря как посмотреть)) и условия не всегдя бывают благоприятными, но по крайней мере пытаться хорошо делать то, чем занимаешься — это достойно профессионала. На эту тему есть очень хорошая книга: «Дзэн и искусство ухода за мотоциклом», рекомендую.
                                                                                                                                        з.ы. сорри за сумбур, потоки мыслей кофликтуют за ресурс мозга)
                                                                                                                                          0
                                                                                                                                          >а всегда пишут максимально качественный код, который возможен в конкретных условиях

                                                                                                                                          Бюджет проекта, скажем, ваш месячный доход, сдать нужно (дедлайн) через два месяца. Есть вариант сделать за месяц «набор костылей», а дальше заниматься другим проектом или просто отдыхать, а есть за два месяца сделать нормальный проект, но получить оплату только за месяц работы. Функциональность не изменится ни на йоту. Выбор однозначен?
                                                                                                                                            0
                                                                                                                                            >Выбор однозначен?

                                                                                                                                            За интернет во втором месяце платит мама.
                                                                                                                                              0
                                                                                                                                              Вообще не всегда. Если проект интересный и подразумевает возможность красиво решить сложную задачу — я бы решил сделать это красиво.
                                                                                                                                              Почему? В первом случае я получаю N денег и теряю месяц впустую, зато имею свободный месяц. Во втором случае я получаю N денег и опыт реализации интересного проекта, который потом уж точно не будет лишним.
                                                                                                                                                0
                                                                                                                                                Простите не понял «сдать нужно (дедлайн) через два месяца», почему если проект рассчитан на два месяца и за это время сделать его нормально то «получить оплату только за месяц работы.»?
                                                                                                                                                  0
                                                                                                                                                  Проект нужно сдать через два месяца (запуск привязан к конкретной дате), сделать можно за месяц костылями (например есть уже какая-то основа), а можно за два красиво (например основу переписать).
                                                                                                                                                    0
                                                                                                                                                    Видимо имеется ввиду что или получаете за месяц стандартную месячную зарплату, или за два месяца по половинке месячной.
                                                                                                                                                      0
                                                                                                                                                      Угу, в общем от того сколько его реально будете делать бюджет не зависит.
                                                                                                                                                        0
                                                                                                                                                        Боже, я один дурак не понимаю? Почему в проекте на два месяца заложена зарплата на один месяц? Это вообще как? Или это к тому, что можно за месяц сделать и получить изначально рассчитаные на два месяца деньги?
                                                                                                                                                          0
                                                                                                                                                          Проект — на месяц. Но можно затянуть на два месяца.
                                                                                                                                                            0
                                                                                                                                                            Ай все, я отказываюсь спорить с человеком, который противоречит сам себе. Прочитайте пожалуйста свои комментарии по порядку.
                                                                                                                                                              +1
                                                                                                                                                              Это мой первый коммент в ветке. Сначала вам писал VolCh, потом — VenomBlood, после этого — я. У вас заказчик заказывает проект, предлагает зарплату за месяц, но результат может подождать два месяца. Ситуация реальная и очевидная. Не понимаю, что тут трудного.
                                                                                                                                                            +1
                                                                                                                                                            Не, не один. Я тоже не понимаю, что за планирование такое. На мой взгляд, планирование сроков должно быть таким, что бы на выходе получать нормальный поддерживаемый код, а не костыль-коллекшн. Судя по всему, для этого проекта это 2 месяца и оплата должна быть соответствующая, т.е. обсуждаемый проект стоит два человеко-месяца, так что решать тут заказчику, получить проект на один раз за половину стоимости или нормальный, но за полную.
                                                                                                                                                            А то, что любой проект можно сделать быстрее, но менее качественно, это очевидно.
                                                                                                                                                  • UFO just landed and posted this here
                                                                                                                                                      0
                                                                                                                                                      Это пункт нейтрально тоесть не стыдно и не радостно
                                                                                                                                                        0
                                                                                                                                                        А мне радостно. Радостно, что я — человек, а не сферический кодогенератор в вакууме.
                                                                                                                                                      0
                                                                                                                                                      Мне в такие моменты хочется достать с полочки запылившуюся машину времени, вернуться во время написания кода и хорошенько заехать себе по шее.
                                                                                                                                                        0
                                                                                                                                                        А помогло бы без объяснений? :)
                                                                                                                                                          0
                                                                                                                                                          На душе бы легче стало.
                                                                                                                                                        +1
                                                                                                                                                        Ну как бы стыдно, конечно, но это неизбежно, если программист растет. Часто даже код месячной давности уже не радует. Но не переписывать же рабочие проекты.
                                                                                                                                                          +1
                                                                                                                                                          Мне стыдно за то что я писал до сегодняшнего дня, и так каждый день. (с) Как то так оно звучало, мне понравилось.
                                                                                                                                                            0
                                                                                                                                                            Наверное большое счастье быть таким человеком, чтобы каждый день делать шаг вперед.
                                                                                                                                                              0
                                                                                                                                                              Ну не знаю, может быть просто я такой идеалист до мозга и костей, но я считаю что любой человек, чем бы он не занимался и что бы не делал — каждый день должен делать хотя бы небольшой шажок вперёд. Лично мне кажется это логичным и правильным, но за все не скажу.
                                                                                                                                                                0
                                                                                                                                                                Я к тому, что если «стыдно» каждый день — значит этот «шажок» очень даже широкий «шаг».
                                                                                                                                                                  0
                                                                                                                                                                  Ну это можно трактовать и по другому — стыдно, но просто человек не пытается что то улучшить и всё остаётся на своих местах. Такие тоже есть.
                                                                                                                                                            +1
                                                                                                                                                            Подскажите, как 100% определить что мой код — говно?
                                                                                                                                                              +1
                                                                                                                                                              Существуют, т. н. bad smells. Посмотрите в «Рефакторинге» у Фаулера.
                                                                                                                                                                0
                                                                                                                                                                А есть где-нибудь список этих душков, буквально по предложению на каждый?
                                                                                                                                                                  0
                                                                                                                                                                    0
                                                                                                                                                                    Спасибо!
                                                                                                                                                                      +2
                                                                                                                                                                      Разрешите полюбопытствовать. А вы часто сами с собой разговариваете?:)
                                                                                                                                                                        +1
                                                                                                                                                                        Это не разговор, а дерево комментариев. В нем один хабраюзер может поддерживать более одной стороны, почему нет!
                                                                                                                                                                          0
                                                                                                                                                                          мой воображаемый друг против как-бы негодуэ
                                                                                                                                                                0
                                                                                                                                                                Я не программист. Умею только найти чужой код/функции и подогнать их под себя. И я понятия не имею он плохой или хороший. Но когда это все работает, мне ни капельки не стыдно, я этим горжусь)
                                                                                                                                                                  +1
                                                                                                                                                                  Так уж случилось, что я работаю с ну очень плохим кодом в большинстве случаев. Я занимаюсь фиксами, пардон, высеров, простите, программистов. А еще я занимаюсь рефакторингом этого. И мне _очень_ стыдно когда мой код написан по глупому, когда некрасиво оформлен, когда в нем захаркодены некоторые параметры или плохо продумана расширяемость. Мне стыдно так, что я готов его переписывать каждый раз, как только появляется свободная минута, а у меня — новые знания.
                                                                                                                                                                  Пожалуй, только это меня и отличает от типичного быдлокодера, который на ура может написать SQL-запрос блокирующий 4 таблицы, хотя нужные данные можно получить элементарно.
                                                                                                                                                                  Улучшение собственного кода — это работа над своими же ошибками. А работая над ошибками(и исправляя их) получаешь новые знания.

                                                                                                                                                                  Предвкушая новый вопрос «как определить, что чужой код плохой» отвечаю: если код _плохой_, то это видно сразу. Если код отличный, то хочется стать подмастерьем у программиста, написавшего этот код.
                                                                                                                                                                    0
                                                                                                                                                                    Я дизайнер! Но решил, что мне нужен js и python на хорошем уровне.

                                                                                                                                                                    Сегодня написал первый код который мне нравится, посмотрите?

                                                                                                                                                                      0
                                                                                                                                                                      Вроде нормально.
                                                                                                                                                                        +1
                                                                                                                                                                        Мутулз используете не зря. Вместо new Array() лучше использовать []. Через new Array(length) пишите только тогда, когда необходимо явно указать длину массива. Это бывает крайне редко ;) Зачем в _initHtml использовать clazz вместо this кое-где? Или используйте везде (для того, чтобы сократить объем сжатого кода) или не используйте вообще)
                                                                                                                                                                        name: function () { var clazz = this;
                                                                                                                                                                        

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

                                                                                                                                                                        console.log(clazz.ALL_TAGS);
                                                                                                                                                                        

                                                                                                                                                                        Будет валить скрипты в некоторых браузерах без заглушки.

                                                                                                                                                                        _setTags: function (tags) {
                                                                                                                                                                                var all_tags = this.ALL_TAGS;
                                                                                                                                                                                tags.each(function (t) {
                                                                                                                                                                                    if (t) {
                                                                                                                                                                                        // code
                                                                                                                                                                                    }
                                                                                                                                                                                })
                                                                                                                                                                        


                                                                                                                                                                        _setTags: function (tags) {
                                                                                                                                                                                var all_tags = this.ALL_TAGS;
                                                                                                                                                                                tags.each(function (t) {
                                                                                                                                                                                    if (t) {
                                                                                                                                                                                        // code
                                                                                                                                                                                    }
                                                                                                                                                                                })
                                                                                                                                                                        

                                                                                                                                                                        В данном конкретном случае лучше заменить на
                                                                                                                                                                        _setTags: function (tags) {
                                                                                                                                                                                var all_tags = this.ALL_TAGS;
                                                                                                                                                                                tags.each(function (t) {
                                                                                                                                                                                    if (!t) return;
                                                                                                                                                                                    // code
                                                                                                                                                                                })
                                                                                                                                                                        

                                                                                                                                                                        Потому что уменьшится вложенность

                                                                                                                                                                                    clazz.CHECKBOXES.append([{"tag": tag[0], "checkbox": checkbox}]);
                                                                                                                                                                                    clazz.FIELD_SET.adopt(wrap);
                                                                                                                                                                        


                                                                                                                                                                        Выглядят как константы, хотя вы их измененяете во время исполнения приложения:
                                                                                                                                                                            ROWS:          new Array(),
                                                                                                                                                                            CHECKBOXES:    new Array(),
                                                                                                                                                                            ALL_TAGS:      new Array(),
                                                                                                                                                                            RECORDS:       new Array(),
                                                                                                                                                                            RECUIRED_TAGS: new Array(),
                                                                                                                                                                        


                                                                                                                                                                        RECUIRED_TAGS — правильно писать REQUIRED_TAGS.

                                                                                                                                                                        var missing = false;
                                                                                                                                                                        clazz.RECUIRED_TAGS.each( function(t, i) {
                                                                                                                                                                        	if (r.tags.indexOf(t) === -1) {
                                                                                                                                                                        		missing = true;
                                                                                                                                                                        	}
                                                                                                                                                                        });
                                                                                                                                                                        if (missing) {
                                                                                                                                                                        	$(r.tr).addClass("hidden");
                                                                                                                                                                        } else {
                                                                                                                                                                        	$(r.tr).removeClass("hidden");
                                                                                                                                                                        }
                                                                                                                                                                        


                                                                                                                                                                        Логичнее использовать some и contains:
                                                                                                                                                                        var missing = this.requiredTags.some(function () {
                                                                                                                                                                        	return !r.tags.contains(t);
                                                                                                                                                                        })
                                                                                                                                                                        if (missing) {
                                                                                                                                                                        	$(r.tr).addClass("hidden");
                                                                                                                                                                        } else {
                                                                                                                                                                        	$(r.tr).removeClass("hidden");
                                                                                                                                                                        }
                                                                                                                                                                        


                                                                                                                                                                        Можно пойти дальше и сразу присваивать имя метода

                                                                                                                                                                        var methodName = this.requiredTags.some(function () {
                                                                                                                                                                        	return !r.tags.contains(t);
                                                                                                                                                                        }) ? 'addClass' : 'removeClass';
                                                                                                                                                                        $(r.tr)[methodName]("hidden");
                                                                                                                                                                        


                                                                                                                                                                        По поводу объекта options — более в стиле JavaScript использовать camelCase

                                                                                                                                                                        Но на самом деле это мелкие придирки, а код — очень хорош. Как я уже сказал — MooTools используете не зря, очень хороший фреймворк.
                                                                                                                                                                          0
                                                                                                                                                                          Ого! Спасибо!

                                                                                                                                                                          Проблема с капсом (константами) стоит решить через _required_tags? (сейчас в голову пришло)

                                                                                                                                                                          очень понравилось вот это:
                                                                                                                                                                          var methodName = this.requiredTags.some(function () {
                                                                                                                                                                          return !r.tags.contains(t);
                                                                                                                                                                          }) ? 'addClass' : 'removeClass';
                                                                                                                                                                          $(r.tr)[methodName]("hidden");

                                                                                                                                                                          не знал про вызов метода через []
                                                                                                                                                                            +1
                                                                                                                                                                            Ну смотрите. Если это приват/протектет переменная, то стоит начать с подчеркивания.
                                                                                                                                                                            ПИСАТЬ_КАПСОМ стоит только константы.
                                                                                                                                                                            Использовать under_score в JavaScript вообще не стоит.
                                                                                                                                                                            Потому, есть два варианта:

                                                                                                                                                                            	// если свойства публичные
                                                                                                                                                                                rows:         [],
                                                                                                                                                                                checkboxes:   [],
                                                                                                                                                                                allTags:      [],
                                                                                                                                                                                records:      [],
                                                                                                                                                                                requiredTags: [],
                                                                                                                                                                            
                                                                                                                                                                            	// если свойства приватные
                                                                                                                                                                                _rows:         [],
                                                                                                                                                                                _checkboxes:   [],
                                                                                                                                                                                _allTags:      [],
                                                                                                                                                                                _records:      [],
                                                                                                                                                                                _requiredTags: [],
                                                                                                                                                                            


                                                                                                                                                                            Кстати, не знаю почему, но в документации я этого не видел. Нашел в исходниках. Вы можете делать protected методы в Мутулз:

                                                                                                                                                                                getRows: function () {
                                                                                                                                                                                    this.rows = this.element.getChildren("tbody tr");
                                                                                                                                                                                }.protect(),
                                                                                                                                                                            
                                                                                                                                                                                getCells: function (row, column) {
                                                                                                                                                                                    return row.getChildren("td:nth-child("+column+")");
                                                                                                                                                                                }.protect(),
                                                                                                                                                                            


                                                                                                                                                                            Их можно будет вызывать только из класса и его наследников.
                                                                                                                                                                            Кстати, почему getRows на самом деле ничего не возвращает, как подобает настоящему геттеру, а устанавливает this.rows?

                                                                                                                                                                            Еще мне не очень нравится этот кусок:

                                                                                                                                                                            	options: {
                                                                                                                                                                            		// ..
                                                                                                                                                                            
                                                                                                                                                                            		wrapper_id:                 'tbl_wrapper',
                                                                                                                                                                            		wrapper_class:              'tbl_c_wrapper',
                                                                                                                                                                            		form_id:                    'tbl_form',
                                                                                                                                                                            		form_class:                 'tbl_c_form',
                                                                                                                                                                            		fieldset_id:                'tbl_fieldset',
                                                                                                                                                                            		fieldset_class:             'tbl_c_fieldset',
                                                                                                                                                                            		legend_id:                  'tbl_legend',
                                                                                                                                                                            		legend_class:               'tbl_c_legend',
                                                                                                                                                                            		checkbox_id:                'tbl_checkbox',
                                                                                                                                                                            		checkbox_class:             'tbl_c_checkbox',
                                                                                                                                                                            		chk_wrapper_id:             'tbl_chk_wrapper',
                                                                                                                                                                            		chk_wrapper_class:          'tbl_c_chk_wrapper'
                                                                                                                                                                            	}
                                                                                                                                                                            


                                                                                                                                                                            Думаю, изящнее было бы переписать так:

                                                                                                                                                                            	options: {
                                                                                                                                                                            		// ..
                                                                                                                                                                            
                                                                                                                                                                            		wrapper    : { 'id' : 'tbl_wrapper'    , 'class' : 'tbl_c_wrapper'     },
                                                                                                                                                                            		form       : { 'id' : 'tbl_form'       , 'class' : 'tbl_c_form'        },
                                                                                                                                                                            		fieldset   : { 'id' : 'tbl_fieldset'   , 'class' : 'tbl_c_fieldset'    },
                                                                                                                                                                            		legend     : { 'id' : 'tbl_legend'     , 'class' : 'tbl_c_legend'      },
                                                                                                                                                                            		checkbox   : { 'id' : 'tbl_checkbox'   , 'class' : 'tbl_c_checkbox'    },
                                                                                                                                                                            		chkWrapper : { 'id' : 'tbl_chk_wrapper', 'class' : 'tbl_c_chk_wrapper' }
                                                                                                                                                                            	}
                                                                                                                                                                            


                                                                                                                                                                            Тем более, таким образом значительно сократится метод _initHtml

                                                                                                                                                                            initHtml: function () {
                                                                                                                                                                            	this.wrapper = new Element('div' , this.options.wrapper);
                                                                                                                                                                            	this.form    = new Element('form', this.options.form)
                                                                                                                                                                            		.set({
                                                                                                                                                                            			action: '',
                                                                                                                                                                            			events: {
                                                                                                                                                                            				'submit': function (e) { new Event(e).stop(); }
                                                                                                                                                                            			}
                                                                                                                                                                            		});
                                                                                                                                                                            	this.fieldSet = new Element('fieldset', this.options.fieldset)
                                                                                                                                                                            		.adopt(new Element('legend', clazz.options.legend).set({
                                                                                                                                                                            			'text': clazz.options.title,
                                                                                                                                                                            		}));
                                                                                                                                                                            
                                                                                                                                                                            	this.wrapper.adopt(this.form.adopt(this.fieldSet));
                                                                                                                                                                            
                                                                                                                                                                            	// this.options.container || document.body - не нужно, у нас и так по-умолчанию document.body
                                                                                                                                                                            	$(this.options.container).adopt(this.wrapper);
                                                                                                                                                                            }.protect(),
                                                                                                                                                                            
                                                                                                                                                                        +3
                                                                                                                                                                        А как же вариант: «не стыдно, но некоторый мой прошлый код — говно, я рассматриваю это как мой рост как программиста».
                                                                                                                                                                          0
                                                                                                                                                                          Мне иногда стыдно за чужой код.
                                                                                                                                                                            +1
                                                                                                                                                                            Ну стыдно или не стыдно это уже в прошлом, а в настоящем?

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

                                                                                                                                                                              0
                                                                                                                                                                              Я не программист, но мне стыдно, что мои скрипты зачастую написаны криво.
                                                                                                                                                                                –1
                                                                                                                                                                                Все врут.
                                                                                                                                                                                • UFO just landed and posted this here
                                                                                                                                                                                    0
                                                                                                                                                                                    govnokod.ru по колено в коде.
                                                                                                                                                                                    Кто не знает как выглядит плохой код, может ознакомиться с его примерами. =)
                                                                                                                                                                                      –1
                                                                                                                                                                                      А где же пункт «я знаю наизусть названия всех функций PHP»? :)
                                                                                                                                                                                        +1
                                                                                                                                                                                        Уточнение: «я знаю наизусть названия всех функций PHP и порядок их параметров» :)
                                                                                                                                                                                          0
                                                                                                                                                                                          Это ни как не связано с качеством кода.
                                                                                                                                                                                            0
                                                                                                                                                                                            привет кэп :)
                                                                                                                                                                                        +5
                                                                                                                                                                                        А Вам не стыдно, что вы в детстве ходили под себя? :)
                                                                                                                                                                                        Развитие — это правильно.
                                                                                                                                                                                          0
                                                                                                                                                                                          Именно это и хотел написать.
                                                                                                                                                                                          Если когда-то давно писали плохой код, то это одно. Человек постоянно совершенствуется и вполне логично, что прошлогодний код будет плохим. Но стоит ли из-за этого переживать и портить себе настроение?

                                                                                                                                                                                          С другой стороны, можно здесь и сейчас писать плохой код, зная что он плохой. Но я такую ситуацию могу представить разве что при горящих сроках.
                                                                                                                                                                                            0
                                                                                                                                                                                            А разве хороший код пишется дольше плохого? Особенно при горящих сроках. Или как всегда: «Нет времени сделать нормально, но есть время сделать дважды»?

                                                                                                                                                                                            Это ни в коем случае не претензия, и тем паче не к вам лично.
                                                                                                                                                                                            Просто при горящих сроках, по моему частному мнения, имеет смысл делать все сразу аккуратно, а лучше черезмерно аккуратно, дабы не поджигать сроки еще больше необходимостью переделок.
                                                                                                                                                                                              0
                                                                                                                                                                                              ИМХО. Плохой код можно сразу начать писать и он будет нормально работать в текущих условиях.
                                                                                                                                                                                              А чтоб сделать нормальную, развиваемую структуру, которая учтет все нюансы, понадобится время на подумать.

                                                                                                                                                                                              Блин, да самый простой пример — «костыли» и хотфиксы. Чтоб сейчас заработало как можно скорее, а дальше разберемся… если время будет.
                                                                                                                                                                                            0
                                                                                                                                                                                            В этом и дело, если вам стыдно за ранее написанный код, значит вы выросли, развиваетесь.
                                                                                                                                                                                              0
                                                                                                                                                                                              Мне не стыдно — меня просто старый код улыбает своей глупостью. :)
                                                                                                                                                                                              Научитесь над собой смеятся — полезно ;)
                                                                                                                                                                                              0
                                                                                                                                                                                              Тут есть разница очевидная разница: в детстве я пИсался неосознанно, а плохой код как правило писАлся осознано :)
                                                                                                                                                                                                0
                                                                                                                                                                                                Разница, конечно, есть. Но! Когда я писал плохой код — я писал его неосознанно, то есть я не осознавал, что он, этот код, плох и чем он плох. Когда я осознал в чём я был не прав, код стал лучше. :)
                                                                                                                                                                                                  0
                                                                                                                                                                                                  То есть всегда считал что твой код в данный момент хороший? :) (см последний пункт голосования) :)
                                                                                                                                                                                              0
                                                                                                                                                                                              если надо сделать быстро, можно и плохо сначала написать, а потом поправить
                                                                                                                                                                                                0
                                                                                                                                                                                                Нет ничего более постоянного чем временное. Лучше сразу писать хорошо, если позволяет время. Ошибки на этапе анализа — самые дорогие.
                                                                                                                                                                                                  0
                                                                                                                                                                                                  Блин, нафига писать плохо, если время позволяет писать хорошо? %)
                                                                                                                                                                                                  Я так понимаю, что имелось ввиду именно отсутствие времени.
                                                                                                                                                                                                    0
                                                                                                                                                                                                    да, когда скорость запуска важнее красоты кода. вроде, про это был топик на хабре
                                                                                                                                                                                                0
                                                                                                                                                                                                Есть стратегия по которой новый модуль пишется что бы работал, выстраивать архитектуру для каждого модуля программного продукта, весьма затратно.
                                                                                                                                                                                                Когда система развивается и появляется связь старого модуля с разрабатываемого, тогда полностью переписывается и старый код. Но в любом случае время потраченное на плохой код уже не вернуть.
                                                                                                                                                                                                  +1
                                                                                                                                                                                                  Я плохой код писал, пишу и буду писать ) так как есть люди которые писали пишут и будут писать лучше меня)
                                                                                                                                                                                                    0
                                                                                                                                                                                                    Плохой код обычно — побочный продукт обучения. Чем больше кода пишет человек, тем скорее код станет хорошим. Не надо его стыдиться.
                                                                                                                                                                                                      0
                                                                                                                                                                                                      Не надо демократию разводить — я уже насмотрелся на код бесстрашных программистов. Благими намерениями вымощена дорога в ад.
                                                                                                                                                                                                        0
                                                                                                                                                                                                        Я о том что у начинающих программистов вообще нет выбора — хороший код писать или плохой. Прежде чем они начнут писать хорошо, они произведут на свет кучу говнокода. Это неизбежно, и ныть по этому поводу бессмысленно.
                                                                                                                                                                                                          0
                                                                                                                                                                                                          Во-первых, где в моём комментарии вы нашли нытьё? Во-вторых, у начинающих есть выбор — учиться на своих ошибках или нет. Презумпция бесстыдства учёбу не очень-то стимулирует. В учении важна строгость. Если нет мастера, который даст отведать палки за плохую учёбу, нужно исполнить эту роль самому.
                                                                                                                                                                                                        0
                                                                                                                                                                                                        ну да, однако собственный старый код иногда хочется переписать, если он все еще доступен :)
                                                                                                                                                                                                        –1
                                                                                                                                                                                                        Рез-тат опроса вызывает у меня жуткий хохот, учитывая, что я постоянно на вопрос «как бы вы это переписали?» получаю ответ «та забей, напиши коммент о том, что это за говно и иди дальше».
                                                                                                                                                                                                          +1
                                                                                                                                                                                                          Примите искренние соболезнования. У нас в конторе после такого ответа на человека будут смотреть очень пристально, долго, задумчиво. Попутно набирая номер скорой. :) Не принято.

                                                                                                                                                                                                          Правда позиционирование конторы: «Долго и дорого» (с) по моему Лебедев.
                                                                                                                                                                                                            0
                                                                                                                                                                                                            По-моему меня как раз и наминусовали здесь те, кого я процитировал )
                                                                                                                                                                                                            Ибо им стало стыдно, что я их палю. Других объяснений придумать не могу.
                                                                                                                                                                                                          –1
                                                                                                                                                                                                          А где пункт: बुरा कोड क्या है?

                                                                                                                                                                                                          Only users with full accounts can post comments. Log in, please.