… И есть даже информация про Украинские компании, хотя, очень мало. Работа сайта базируется на анонимных анкетах пользователей. Можно оценить компанию, дать отзыв, рассказать о зарплате и.т.д. Такие анонимные анкеты, по моему субъективному мнению, могут быть довольно точными.
понедельник, 24 января 2011 г.
< link > GlassDoor – сервис, на котором можно узнать про зарплаты в Google, Microsoft, Facebook, Yahoo
суббота, 22 января 2011 г.
Неофициальная история конструирования ПО
Два яруса . Благодаря Биллу Гейтсу, компьютеры, в комплекте с их собственными процессорами, ушли в массы, а в конце 80-х и начале 90-х я был разработки клиент-серверных приложений с "толстым клиентом" — часть расчетов осуществлялась на локальной машине, а данные находились в базе данных на уделенном сервере. Жизнь была легкой и простой. И резюме разработчиков были точно такими же легкими и простыми. Вам было только необходимо знать SQL для работы с данными и какой-нибудь язык программирования. Вот, например C++… Ах, Вам тяжело его изучить? Используйте SQLWindows, PowerBuilder, Visual Basic или даже Delphi!
Основной темой для обсуждения была: где реализовывать бизнес-логику — на стороне клиента или в базе данных, как набор хранимых процедур? В последнем случае, вы были вынуждены мастерски владеть процедурными языками СУБД, например, такими как T-SQL или PL/SQL. Но, больше от Вас ничего не требовалось.
Архитектура приложений по-прежнему оставалась простой. При запуске, приложение не требовало от вас подключения к Интернету, и это было хорошо. Приложения запускались на локальном компьютере, и работало в локальной сети. Конечно же, если сервер баз данных падал или слишком многие пользователи одновременно хотели получить данные, то в работе Вашего локального приложения могли бы возникнуть проблемы и перебои. Но, это было единственное узкое место, да и случалось такое не каждый день.
Три яруса. В середине девяностых годов, создание веб-браузеров, открыло Интернет для общественности. Предприятия с нетерпением переделывали их проверенные и надежные клиент-серверные системы для того, чтобы просто сделать их доступными в Интернете. Зачем? Потому что они могли это сделать. Именно с этого момента все начало усложнятся. Тонкий HTML клиент взаимодействовал веб-сервером, либо мог предоставлять статический контент (тексты, изображения), не используя для этого к помощи стороннего ПО, а при необходимости, можно легко передать управление на другой сервер для более продуктивной работы. Интернет провайдеры предлагали пропускную способность для продажи. Сетевые соединения были медленными. Тонкие клиенты выглядели очень плохо по сравнению с толстыми клиентами на Visual Basic или PowerBuider.
Вопрос остался прежним: «Где размещать бизнес-логику?» Уж точно не на тонком клиенте. Теперь выбор был либо где-то веб-сервере или в СУБД. Одного только веб-сервера уже было недостаточно. Так как я сам из мира Java, то хочу объяснить Вам, что же там происходило.
Множество ярусов . Средний ярус превратился в несколько уровней. Веб сервер взаимодействовал со Сервлет-контейнером, который в свою очередь взаимодействовал с контейнером EJB, который либо работал с СУБД непосредственно либо просто помещает сообщение в очередь Message-Oriented Middleware. Чтобы сделать это еще более гибким, добавьте в коктейль несколько служб контроля доступа, так чтобы Java сначала посмотрела туда, перед тем как поместить сообщение в очередь. Давайте не будем забывать и о демилитаризованных зонах (DMZ), которые увеличивают общее число ярусов.
Вот когда появилось Новое Поколение Разработчиков. Эти люди, называющие себя Архитекторами программного обеспечения. Они требовали чтобы логические слои были специфичны и заточены под разрабатываемый проект. И они хотели их сейчас! Книга по шаблонам проектирования от «банды четырех» была легко доступна, — и шабаш начался.
Это было время расцвета фреймворков для создания ПО.
Если разработчик Java не знал Struts в начале этого века, то его шансы быть нанятым для разработки Enterprise проектов были близки к нулю. Сейчас все больше и больше людей понимают, что Struts был еще одним недопеределанным бесполезным MVC фреймворком, который усложнял архитектуру тысяч приложений. Но само существование таких фреймворков получило теплый прием и даже овации в легионах быдлокодеров (Code monkey), которые поняли, что они могут зарабатывать на жизнь, вставляя if и else в шаблоны, предоставленные местными архитекторами. Заканчивать ВУЗ для получения диплома по компьютерным наукам уже не нужно.
Первое десятилетие 21-го века подходит к концу, и мы все еще живем в очень хрупком мире программного обеспечения с дести ярусными архитектурами. Каждый дополнительный уровень (как движущуюся часть) делает архитектуру еще более хрупкой. Каждая подвижная часть покупается с дополнительными расходами — технической поддержкой. Но в мутной воде многоуровневых архитектур, команды поддержки довольно быстро начинают играть в игру перевода стрелок друг на друга.
Бюджет первоначально выделенных на проект, получает опустошается довольно быстро, владелец проекта начинает урезать функционал для экономии средств, что оставляет ему несколько кое-как работающих приложений. Это здорово, что наши офшорные партнеры готовы протянуть руку помощи! Мы в ней нуждается. Это как присланные деньги от родителей для студента, живущего в общежитии.
Два яруса . Вот уже прошло две недели, как началось второе десятилетие 21-го века. Я очень надеюсь, что мы вернемся назад к двухуровневой архитектуре. Как же так? Клиенты взаимодействуют облаком, это и создает всего два яруса. Вы можете утверждать, что облако само по себе содержит несколько уровней внутри, но это все немного по другому. Облако может поддерживаться одним поставщиком, а с точки зрения клиента это единая часть программного обеспечения.
Приложение клиента запускается локально, оно имеет локальное хранилище, что позволяет работать как в онлайн, так и в офлайн режиме. И данных и код находятся настолько близко к пользователю, насколько это возможно. Вы думаете, почему Microsoft Excel является наиболее популярным программным обеспечением среди бизнес-пользователей на предприятиях? Потому что Excel позволяет пользователю иметь свой маленький кусочек данных и любительский, но рабочие код (формулы) очень близко. Прямо на рабочем столе. Нет необходимости просить этих Всемогущих Админов о милости и помощи. Нет зависимости от сетевого подключения или каких-то таинственных серверов, которые могут работать медленно или падать. Наиболее продвинутые пользователи даже научиться работать с базами данных MS Access, чтобы уменьшить зависимость от отдела IT. Так держать!
Один ярус. Шансы довольно высоки, что через 10-15 лет мы снизим число уровней архитектуры обратно в один ярус превратить наши смартфоны в немые терминалы.
«Да, возможно я и мечтатель. Но я такой не один»
Джон Леннон
Оригинал: The Unofficial History of Software Engineering
Про эту замечательную статью я узнал из подкаста автора статьи Якова Файна (Будама). За что что ему спасибо. ;)
Америчка: #267 Неофициальная история конструирования ПО
Перевод статьи с английского на русский: Дмитрий Жарий
Вы хотите быть Специалистом или Генералистом?
Эта мысль, без сомнения, на том или ином этапе жизни посещает каждого из нас. В какой-то момент вы чувствуете, что подошли к перекрестку судьбы, и задаете себе вопрос: “Должен ли я углубить свои знания и навыки в моем любимом языке программирования или фреймворке и изучить в нем каждую мелочь?” Или я должен расширить свой кругозор и изучить смежные инструменты и технологии или даже изучить новые языки программирования и платформы? Этот вопрос может, действительно, ввести вас в заблуждения при поиске правильного пути. Есть слишком много аргументов за и против. Даже если вы обратитесь к кому-нибудь за советом, этого не сделает дорогу ясной для вас, и, более того, перед вами откроется ряд новых путей, которые усложнят выбор.
Давайте рассмотрим аргументы в поддержку этих альтернатив более детально.
Рассматривая возможность стать специалистом, вы, вероятно, думаете о превращении в какого-то гуру, который будет знать все о какой-либо технологии, фреймворке или продукте. Специалистов не много, так что вы могли бы, потенциально, найти высокооплачиваемую работу в компании, которая не может жить без вашего опыта. Правильно? Ну… теоретически да, логика здесь есть. Но, реальность, конечно же, сильно отличается от теории. Истинна заключается в том, что большинство компаний никогда не доводят свои проекты до такой степени сложности и размера, что присутствие гуру на проекте становиться жизненно необходимым. Чем более вы позиционируете себя как специалиста, тем более сужается выбор мест, куда вы потенциально можете идти. И, возможно, что в регионе, в котором вы живете, такой ниши может не оказаться вовсе.
Это не означает, что вы не должны изучать ваши инструменты в глубину, а должны знать их только поверхностно. Совсем наоборот, вы должны знать все, что вам необходимо сейчас, и даже за пределами своих сегодняшних потребностей. Это увеличит ваше понимание внутренней работы инструментов. Вы будете писать лучший код. Вы найдете ошибки более легко. Вы сможете найти выход из нестандартных ситуаций. Вы будете знать больше способов того, как забить гвоздь вашим молотком. Но в какой-то момент, вам придется прекратить копать и посмотреть вокруг. Ведь есть много других, интересных и не менее полезных вещей для изучения.
Есть еще одна очевидная опасность для специалиста. В сфере разработки ПО все меняется чрезвычайно быстро. Новые великолепные языки и фреймворки появляются из ниоткуда, вспыхивают как яркая звезда и, погружаются в небытие. Инструменты стареют, заменяются новыми версиями, которые, в свою очередь, стареют и, в итоге, выходят из употребления. Все движется вперед. Если вы делаете ставку не на ту лошадь, если вы вкладываете все время в обучение одной конкретной технологии, вы рискуете потерять ставку, если лошадь не победит.
Так что, генералистом быть лучше? Ответ обычный: все зависит от ситуации, от рынка, и от вас. Однако этот подход имеет свои сильные стороны.
Во-первых, подход генералиста расширит границы ваших знаний. Вас не загонит в тупик ситуация, когда конкретная технология начинает доставлять массу проблем. Знание различных технологий и инструментов дает возможность сравнить возможные решения, которые позволяет реализовать каждая из них, и выбрать ту технологию, которая наилучшим образом соответствует вашим задачам. Если мы говорим не о сопоставимых либо конкурирующих технологиях, а про различные навыки, которые находят свое применение в рамках одного проекта, это даст вам возможность увидеть проблему в различных слоях технологии и проанализировать ее на различных уровнях абстракции. Вы можете сравнить варианты реализаций, и сделать вывод: где и как необходимо решать конкретную проблему. Предположим, мы говорим о классическом многоуровневом приложении, где есть база данных, уровень бизнес-логики и слой пользовательского интерфейса. Если вы будете компетентны в разработке каждого их этих слоев – это позволит решить проблему намного быстрее и легче. Вместо оптимизации каждого байта приложения, вы можете посмотреть на проблему с другой точки зрения: просто собрать и настроить готовое приложения, которое просто выполняет свою задачу. Вам не всегда жизненно необходимо настраивать сверх оптимальное кеширование на стороне сервера? А как на счет тонкой настройки пользовательского интерфейса, чтобы избежать запуска сложных запросов несколько раз? Или это надуманная проблема, и, скорее всего, ваш пользователь совершенно не нуждается в этой фиче? Видите? Вы можете думать о различных условиях, в которых будет работать ваше приложение, и это дает вам определенную свободу духа, чтобы найти наиболее эффективное и элегантное решение.
Но, давайте пойдем дальше. Если вы являетесь специалистом по различным технологиям, то ваш набор знаний и навыков становиться все более отшлифованным. И это превращает вас в эффективную команду из одного человека. Вы самодостаточны, знакомы со всеми аспектами текущего проекта, вы способны завершить практически самостоятельно, без посторонней помощи со стороны специалистов и гуру. И это уже является минимальным требованием для веб-разработчиков: каждому необходимо иметь практические знания всех составных частей веб-проекта. Вы должны знать ваш фреймворк, быть знакомым с базами данных и иметь возможность создавать HTML разметку для пользовательского интерфейса. У нас есть данные, которые необходимо собирать и хранить? Вот, здесь я разработал модель данных, создал индексы, написал необходимые запросы и оптимизировал работу с базой данных для нашего конкретного сценария. Нам необходимо приложение для взаимодействия с базой данных? Подождите минутку, вот код, реализация ввода данных, их проверка, бизнес-правила и разграничение уровня доступа к данным – все готово. Чудесно. А где же наш яркий и сияющий пользовательский интерфейс? Всё тут же, это валидный HTML и CSS. Хотите еще Ajax? Дайте мне пять минут. Готово, проверяйте!
Узнали себя? Вы можете делать все это и многое другое, и вам это нравиться. Либо вы один и тех, кто посвятил большую часть своей жизнь тому, чтобы стать гуру базы данных? Или вы интерфейсный разработчик, владеющий HTML, CSS и семантической разметкой, но вы никогда не работали с базами данных. Что? Вы боитесь баз данных? Нет, это действительно не страшно, обязательно попробуйте, когда ни будь.
Поймите меня правильно. Я очень уважаю специалистов и профессионалов. Их глубокие знания технологий, могут оказаться очень полезными. Иногда они могут дать вам такое решение, к которому вы бы не пришли самостоятельно. Я всегда чувствую, небольшое, но в то же время просвещения после получения совета от них. И я бесконечно благодарен им за откровенность и затраченное на меня время.
Несмотря на это, я понимаю, что большая часть проектов может быть завершена без этих продвинутых знаний. И мы не приносим в жертву качество приложения или создаем уродливые хаки для исправления того, что мы не могли обойти нормальным путем. У нас все в порядке. У нас просто не было каких-либо серьезных проблем. Не в этом проекте. И не в прошлом. И серьезных проблем не было даже в том проекте, который мы завершили в прошлом году. И мы можем уверенно сказать, что мы не ожидаем серьезных проблем и в нашем следующем проекте.
Ладно, вы не можете быть настолько уверены в будущем. Но, знаете что? Вы всегда можете узнать все, что вам необходимо тогда, когда это вам потребуется. Зачем же раньше времени бить тревогу? Рядом со мной есть необходимая книга. Когда я чувствую, что мне не хватает знаний в некоторых конкретных областях – я прочитаю необходимые главы. Или просто найду ответ в Google. Сегодня, вы сможете найти почти все в Интернете. И это быстро. И очень часто вы найдете ответ быстрее, чем волосатый парень Боря, гуру, сидящий за столом в углу, допьет свою чашку кофе и соблаговолит подойти к вам.
Кроме того, в Сети храниться колоссальный объем знаний и опыта других разработчиков. С большой вероятностью, вы можете наткнуться на такое, уже готовое решение, которое вам не вычитать и в двух тысячах страниц умной книги. Да, гуру тоже появляются в Интернете. Последний раз я принимал участие в одной технической дискуссии, так один опытный парень из Microsoft появился из ниоткуда и принес нам неожиданное, но столь необходимое просветление.
И можете не беспокоиться по поводу путей развития вашей карьеры. Быть генералистом может быть действительно лучше. Есть много небольших и средних компаний, которым необходим человек, имеющий делать многое. И это не значит, что они просто хотят заменить целый отдел разработчиков на одного многофункционального разработчика для того, чтобы сократить расходы. Скорее всего, для их проектов вполне достаточно человека с широкими навыками, у которого руки растут из правильного места. Там нет настолько нетипичных ситуаций, необычных сценариев или граничных случаев, в которых может работать только гуру. По сути, эти компании не могут предоставить работу необходимой сложности для столь высококвалифицированных специалистов. И, если гуру попадет в такую компанию, без работы особой сложности, то, скорее всего первый месяц ему будет очень скучно, а со следующего – он просто уволиться. Вы – универсальный разработчик, и вы можете решить очень широкий круг задач. На самом деле, будучи универсальным разработчиком, вы свободно можете оставить свое сегодняшнее место и стать контрактером, фрилансером, или даже открыть свою собственную небольшую компанию по разработке ПО. Это не сложно теперь, когда вы ознакомились со всем аспектам разработки продукта.
Когда я вспоминаю свои первые годы в программировании, моим самым интересным и в то же время депрессивным периодом было именно начало. Я просто знал слишком мало. Я мог писать программы, которые работали, но, потом я застревал в чем-то таком, что я действительно не знал. Я хотел бы сохранить некоторые данные в базу данных, но у меня не было опыта работы с базами данных. Хорошо было бы хранить настройки в XML, но я никогда не работал с ним. Собственно, аппаратное ускорение может дать нам прорыв, но я еще не программировал 3D-графику. Создать свой собственный сетевой протокол? Это же настолько сложно, могу ли я это сделать? Создание веб-сайта? Я знаю только несколько HTML тегов. Да, мне было действительно сложно сделать что-либо.
Теперь, программирование приносит мне намного больше удовольствия, ведь я могу сделать много разных вещей. Что более важно, я могу начать и решить задачи без постоянной помощи на каждом шагу. Я могу играть свою игру. GDI работает слишком медленно? Я сделаю это через 3D. Да, с полигонами, освещением и текстурами, они все будут там. Необходимо сохранить и извлечь информацию, введенную пользователем? Я сделаю это по средствам базы данных. Вот, я разработал модель данных для этого. Создать новое нужное приложение? Конечно, прямо сейчас же возьмусь, со всеми теми слоями, ООП, и еще много чем. Создать пользовательский интерфейс? Вот, валидный HTML, CSS, безтабличная верстка и семантическая разметка. А вот тут необходимо сделать слишком много действий, это может отвлекать пользователей. И чтобы добраться до непроходимого места, они должны нажать эту кнопку для открытия диалога. Но все они, вероятно, будут пользоваться такой-то фичей довольно часто. Давайте поставим ее прямо на главной странице. Подумайте о юзабилити. Кто-то нарисовал ярко-красной кнопки рядом с голубой панелью инструментов с серым фоном вокруг? На не приятно смотреть, это не вписывается в нашу цветовую схему. Исправьте дизайн. Где мы находимся, если кто-то ищет эти конкретные ключевые слова в Google? Недостаточно высоко. Давайте подвинем эти слова ближе к началу страницы и удалим ненужные ключевые слова из названия страницы. Мы можем сделать немного поисковой оптимизации собственными силами.
Работа доставляет огромное удовлетворение, когда вы можете многое сделать сами. Вы разрабатываете гибкую архитектуру и пишите качественный код. Когда вы открываете базу данных – для вас все известно и знакомо. Нет необходимости в эксперте по базам данных. Вы можете создать пользовательский интерфейс и без эксперта по фронт-энд разработке. Вы даже можете создать приятный дизайн и выбрать набор цветов и без тех дорогих веб-студий. Нет, ваш дизайн не получит премию «Дизайн года». Но это будет выглядеть красиво и будет достаточно хорошим. Вы можете организовать элементы управление и структуру меню так, чтобы интерфейс был простым и интуитивно понятным для пользователей. И да, вы можете сделать это сами, без тех юзабилити экспертов, которые будут стоить вам в половину бюджета.
Пока вы любите то, что вы делаете и стремитесь быть лучше – вы сможете реализовать любое ваше желание.
Я также верю, что хороший разработчик должен быть квалифицированным в различных техниках. Не существует веских причин для того, чтобы вы застревали в вопросах баз данных и игнорировали архитектуру приложения. Вы, конечно же, не знаете всего по вопросу производительности баз данных. Но, нет оправдания для системного программиста, если он смеется над front-end разработчиками. Конечный пользователь не увидит ваши фантастические методы распределения памяти. А разработчик интерфейсов не должен прибывать полной темноте, по отношению к тому, как действительно работает программное обеспечение, какие алгоритмы и структуры данных используются и каким образом мы могли бы повысить эффективность наших запросов. Или должен ли веб-программист выбрасывать из внимания аспекты SEO и маркетинга, как несущественные? Нет, конечно же! Это ваша задача: разрабатывать веб-приложение с учетом SEO. А насколько нормально для прикладного программиста создавать сумасшедший пользовательский, который будет отпугивать нормальных пользователей? Нет, спасибо тебе, пожалуйста, отложили свои диаграммы классов и шаблоны проектирования и какое-то время подумай о юзабилити, что и как нужно сделать либо переделать.
Я часто жалел тех разработчиков, которые закрылись своим футляром и не желают смотреть вокруг или признаться, что есть еще важные и интересные вещи.
Вы не можете делать все самое лучшее, пока вы не видите всю картину в целом. И если вы действительно не видите всего, то ваша работа и близко не будет настолько хорошей, как могла бы быть.
Оригинальный (англ) пост: Going specialist or generalist.
Этот текст перевел: Дмитрий Жарий
3 простых правила, которые сделают из вас Суперзвезданутого Программиста
И вы можете! Следуйте следующим 3-м простым правилам, и в течение 12 месяцев все это и многое другое будет вашим.
Правило 1: Пишите много кода. Вам нужно исправить небольшую ошибку на участке кода, написанного кем-то другим? Не теряйте времени, пытаясь понять код или мотивацию человека, создавшего его. Просто перепишите большую его часть, и сделайте, чтобы код работал так, как это удобно вам. Назовите это рефакторингом, если, вдруг, кто-то спросит.
Правило 2: Пишите код быстро. Затроньте наибольшее количество файлов, и не забудьте включить каждый из них в ChangeLog. Не беспокойтесь о случайном создании трудно находимых ошибок; они помогут вам в будущем, потому что их, на самом деле, трудно найти. Избегайте создания тривиальных ошибок.
Правило 3: Не тратьте время для документирование кода, или добавления небольших комментариев, объясняющих потенциальные ловушки, связанные с изменением нечетких участков кода. Вам это не нужно – вы пишете код.
Усердно следуйте этим трем правилам – и вы станете суперзвездой вашей команды в течение 12 месяцев. Выпишете их и приклейте на видном месте. Только не в офисе! А где-нибудь в скрытом от посторонних глаз месте. И повторяйте их каждый день, перед началом работы. Они могут показаться вам спорными, но поверьте мне, все это имеет очень глубокий смысл.
Вы задаете вопрос: откуда я знаю, что это работает? – Потому что я сделал это сам, и потому, что я видел, как это делают другие. Конечно, я не понимал, что придерживался Трех правил – в то время, я был молодым и наивным и думал, что я просто пытаюсь сделать все возможное для проекта. И только теперь, спустя много лет, опираться на мудрость и опыт, я могу вот так просто поделиться ими с вами.
Система 3-х Великих Правил Программирования основана на Двух Фундаментальных Принципах: техническом и социальном.
Технический принцип: Вы работаете в 10 раз продуктивней над вашим кодом, по сравнению с тем кодом, который писали не вы.
Каждый понимает свой собственный код лучше. Это часть вашей памяти, часть ваших соглашений — весть этот код соответствует вашим убеждениям. Вы знаете, как работает функция, которая называется X и знаете все тонкости ее работы. Вы смотрите в класс Y, чтобы найти вашу функциональность и, конечно же, она там есть. Даже если вы находитесь в нижней части файла, вы прекрасно знаете какой код находиться сверху. Все эти мелкие детали понятны вам. Теперь вам не нужно так беспокоиться о случайных побочных эффектах, когда вы что-то изменили, потому что вы помните о тех местах, которые были немного рискованными и интуитивно знаете, где вы можете писать код небрежно, а где – нет.
Короче говоря: если вы написали код, у вас есть почти идеальная модель кода в вашей голове, потому что это то, что вы использовали, чтобы написать его.
Социальный принцип: то, насколько хороши вы в программировании, судят по тому, сколько строчек кода вы написали, насколько быстро вы можете завершить необходимые фичи и пофиксить критические баги, и насколько ваше понимание сути дела необходимо для решения проблем.
Эти два принципа определяют пространство задачи – или, как мы называем это – Игру. Вы победите, если улучшите свою репутацию суперзвезды до уровня гуру. Чтобы улучшить свою репутацию, вам нужно увеличить скорость, с которой вы пишете код, исправляете ошибки и помогаете другим. Технический принцип говорит нам о том, как достичь этого — работайте в своем собственном коде как можно больше. Именно так, захватывайте как можно большую часть проекта своим собственным кодом.
Система 3-х правил – это безупречная стратегия для достижения этой цели.
Следуя правилу 1, вы быстро ознакомитесь с большим количеством кода. Самое главное, вы не будете тратить время, пытаясь понять чужой код, ведь это является сложным и трудоемким процессом.
Соблюдая правилам 2 и 3, вы увеличиваете вашу долю захвата, избегая наиболее трудоемких частей написания хорошего кода. Это жизненно важно, чтобы вы контролировали больше кода, чем остальные участники команды вместе взятые.
Кроме того, есть и социальные выгоды работы подобным образом:
Выгода 1: все увидят, как быстро вы пишите огромные куски кода и начнут уважать вас – особенно ваш босс, который не имеет другого критерия, чем оценивать вас по частоте и объему вносимых изменений.
Выгода 2: Хоть вы и вносите множество новых ошибок, все равно пройдут еще несколько месяцев, перед тем как они вылезут, а к тому времени вы уже приобретете репутацию программиста-эксперта. И даже сейчас Вы можете получить выгоду от всех этих багов во второй раз, ведь вы же можете исправить эти проблемы быстрее, чем кто-либо другой. Ваши коллеги будут затрачивать в 10 раз больше времени, по сравнению с вами, для отслеживания каждой из этих проблем. Все чаще они будут приходить к вам за советом или помощью, потому что именно вы написали этот кусок кода. Будьте дружелюбным, скромным, помогайте с удовольствием. Вы определите место ошибки очень быстро. Ваша репутация великого Гуру будет расти день ото дня.
Относитесь к этому процессу, как будто это игра в стратегию реального времени. Карта мира – это код вашего проекта. Участки кода, которыми владеете вы – это ваши ресурсы, а чужой код – производит ресурсы другим. Но, главный ваш ресурс – это ваша десятикратная эффективность, так как вы в 10 раз продуктивней при работе, как с вашим собственным кодом, так и с чужим. Ваша десятикратная продуктивность улучшает вашу репутацию, которая является валютой в Игре.
Очевидно, что если вы владеете очень небольшим участком кода, вам не удастся поднять большое количество репутации, поскольку большую часть времени вы будете работать с чужим кодом такими же темпами, как и любой другой. Пришло время изменить эту ситуацию.
Правило 1 – это основа вашей экономики. Вы станете суперзвездой, если захватите наибольший участок кода, больший, чем у кого-либо еще. Создавая новый код, или преобразуя чужой код в ваш собственный – вы инвестируете в экономику, ведь каждый участок вашего кода генерирует вам производительность и репутацию.
Правило 2 — это агрессивность. Захватывайте владения других людей и изменяйте их код так, чтобы он был понятен вам. Пусть люди видят, что вы затрагиваете много кода — это хорошо для вашей репутации. Однако вы должны быть осторожными при переходе в атаку. Переписывание кода влечет за собой возможное урезание репутации, но об этом позже.
Правило 3 — это защита. Затрудняйте другим людям работать с вашим кодом или исправить в нем ошибки. За каждый час, который они тратят на исправление ошибок вы инвестируете час на создание свежего кода или переписывания существующего чужого, тем самым расширяя границы вашего влияния.
Никогда не забывайте, что это все это делается ради получения репутации. Тут самое главное – не переусердствовать, иначе, вашей команде и менеджеру может показаться, что вы вредите проекту. Не менее важно сохранять хорошие отношения с вашими противниками – коллегами. Старайтесь всегда казаться вежливым, полезным и скромным. Ваша репутация определяет какое количество и какие части кода вы можете переписать под себя, не вызывая негативной реакции.
Для этого вы должны начать с малого, в самой ненавистной, уродливой области кода в проекте. Просто зайдите туда и перепишите там все, чтобы все стало понятным вам. Не беспокойтесь о всех тех ошибках, которые вы внесете. Люди будут благодарны за то, что вы такой смелый и достаточно дерзкий, чтобы бросить вызов старому коду проекта. Они согласятся с тем, что это необходимо сделать, и что исправление ошибок нового кода будет проще, чем поддержка старого.
Когда вы закончите – то обнаружите, что ваша репутация возросла. И вот теперь вы сможете переписать чуть менее отвратительные участки кода, без занудных вопросов о том, действительно ли это необходимо было сделать. В конечном итоге ваша репутация вырастит и станет настолько огромной, что вы сможете переписать любую часть основной функциональности приложений по своему усмотрению. К тому времени, вы будете знать гораздо больше об остальных частях системы, чем кто-либо другой, и будете допускать на удивление мало ошибок. Это обеспечит ваш статус Гуру.
Теперь вы – суперзвезда команды. Это завершение вашей игры.
Вы выиграли!
Постскриптум для наивных: Этот пост – легкая сатира на программирование в составе команды. Эти три правила – зло, хотя, несомненно, очень эффективны. Они принесут вред общему прогрессу проекта ради вашей собственной выгоды. Они не сделают вас лучшим программистом по сути, только по сравнению с остальной частью вашей команды. Вы, как я и многие другие, могли невинно делать нечто подобно этому в вашем прошлом, когда вы не знали, как делать это лучше. Теперь вы знаете.
Постскриптум для руководителей проектов: Если ваша обстановка соответствует Двум Фундаментальным Принципам, то ваши программисты будут играть в Игру, и ваш проект будет страдать. Меняйте правила. Убедитесь в том, что программисты признают и хорошо играют кодом друг с друга, для успешной работы небольших групп, которые решают большие проблемы. Переписывание кода, из-за появления ошибок приводят к появлению новых ошибок, из-за которых код будет опять переписан. И я не знаю хорошего способа избавиться от этого. И если вы знаете, то, пожалуйста, ради всех проектов во всем мире, оставьте комментарий!
Англ. оригинал:3 Simple Rules That Will Make You a ‘Superstar’ Developer
Автор оригинала: Mark O’Connor
Перевод: Дмитрий Жарий
четверг, 26 ноября 2009 г.
10 простых правил, чтобы лучше писать приложения на ASP.NET
Код UI должен использовать такие принципы ООП, как наследование и инкапсуляция, ровно как код любого другого слоя. Кроме того, некоторые принципы SOLID, могут и должны быть применены при разработке наших юзер-контролов и веб-страниц. Так как ASP.NET WebForms по-прежнему широко используется, и я полагаю, что так продлится еще долгое время, в этой статье, я предлагаю тот набор правил для программирования и проектирования, который я использую в своих ASP.NET проектах. Надеюсь, что следующие правила помогут вам сделать ваш UI код более чистым и и облегчат его поддержку в дальнейшем.
1. Используйте собственный базовый класс для классов пользовательского интерфейса
Начинайте проект со создания крайней мере двух базовых классов BasePage и BaseUserControl и наследовать от них все ваши веб-формы и юзер-контролы. Это считается хорошим стилем. Причина в том, что у вас непременно возникнет необходимость реализовать общий код для всех или части ваших веб-форм или юзер-контролов.
К примеру, все страницы вашего сайта должны иметь название и, в дальнейшем, некоторым мета-теги. Добавление свойства PageID, а также метода, который вернет название страницы и ее мета-теги будет довольно легко достигнуть при помощи наследования, а поддерживать код, очевидно, станет намного легче.
Другим распространенным случаем является необходимость показать / скрыть элементы веб-формы, в зависимости от определенного условия. Добавив виртуальный метод в базовый класс, который вызывается при возникновении события OnPreRender, вы сможете реализовать механизм скрытия и отображения элементов веб-формы. И весь этот код будет удобно расположен в одном методе и работать для всех классов-наследников, пока вы не переопределите его. Следующий код демонстрирует все вышесказанное, используя дизайн-паттерн "Шаблонный метод"
Пример:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Collections.Specialized;
using System.Data;
public class BasePage : System.Web.UI.Page
{
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
DoEnableDisableControls();
SetTitleFromCMS();
SetMetaTagsFromCMS();
}
public string PageID
{
get;
set;
}
/// <summary>
/// Overwrite this method to enable or disable controls
/// depending on the state of the page.
/// </summary>
protected virtual void DoEnableDisableControls()
{
}
private void SetTitleFromCMS()
{
if (String.IsNullOrEmpty(PageID))
return;
//Queries the CMS for the page title
this.Title = "Whatever we got from the CMS";
}
private void SetMetaTagsFromCMS()
{
//Queries the CMS for the MetaTags
//add the meta tags
}
}
Странице, которая наследуется от базового класса, будет просто необходимо установить свойство PageID – и она будет иметь заголовок и мета-теги (обратите внимание на возможность задать PageID непосредственно в директивах .aspx файла страницы).
<% @ Page Language = "C #" PageID = "DefaultPage" AutoEventWireup = "True" CodeBehind = "Default.aspx.cs" Inherits = "% ExtRefWebApp._Default">
Использование такого базового класса, позволит вам внедрить общий код в любое время процесса разработки, и это будет очень полезно при будущей доработке всех страниц-наследников.
2. Скрывайте переменные сессии
Ниже перечислены причины, почему я никогда не использую переменные сессии непосредственно в коде, а инкапсулирую в отдельные классы:
- Переменные сессии широко используется в веб-приложениях. Они очень полезны, но мы не должны забывать, что переменная Session, с точки зрения ООП – это ничто иное, как глобальная переменная.
- При отладке или поддержке веб-приложений, мы часто сталкиваемся с участками кода, которые используют значения, хранящиеся в Session, и нам необходимо проверить, где эти значения были установлены. И это не легко выяснить.
- Session может содержать любой тип. Если мы заменим тип значения, хранящегося в определенном ключе Session, нам придется проверить весь код и изменить все приведения типов (мы делаем это с помощью поиска/замены текста в коде).
- Конкретного ключа Session может не существовать, либо он может иметь значение null. Не существует способа для того, чтобы получить по умолчанию для несуществующего ключа Session и, таким образом, всякий раз, когда мы используем переменную сессии, мы должны проверить ее значение (на null) перед использованием.
Лучший способ избежать этих проблем – создать набор классов, по средствам установки свойств которых мы и будем изменять значения Session. При помощи функции Visual Studio "Find all references"/"Find Usages", из контекстного меню при клике на сеттере свойства, вы найдете все объекты, которые устанавливают переменную сеанса. С другой стороны, если мы изменим тип значения в переменной Session, то код, использующий старый тип просто выдаст ошибку компиляции, следовательно, эти ошибки будет очень легко найти и сделать все изменения или оценить объем работы, необходимой, чтобы сделать изменения. Это ужесточает контроль типов и делает наш код более безопасным.
Доступ к значениям Session должен быть инкапсулирован в разных классах, и если их будет слишком много, то, желательно, чтобы они принадлежали одному пространству имен и находились в одной папке, это облегчит их поддержку.
Можно еще много всего сказать об использовании Session. Например, если сессии используются в чистом виде (без обвертки в специальный класс) не только в слоях пользовательского интерфейса, но и слоях бизнес-логики приложения; то уже излишне говорить, что в этом случае мы нарушим принцип инкапсуляции и принцип изоляции слоев приложения. Ведь теперь слой бизнес-логики зависит от HTTP контекста (мы больше не можем повторно использовать его в не HTTP приложениях).
3. Не создавайте глубокой иерархии UI-контролов
Пользовательские элементы управления в ASP.NET являются очень хорошим средством для повторного использования кода пользовательского интерфейса. Однако, когда мы начинаем вставлять одни юзер-конролы в другие, то, в конце концов мы получаем бесконечное дерево вложенных друг в друга элементов управления . Это превращает поддержку приложения в настоящий ад.
Обычно, это хорошая привычка ограничить дерево максимум на 2 или 3 уровня. Страница содержит элементы управления, которые могут содержать другие элементы управления. Но внутренние элементы должны содержать только базовые элементы управления .NET Framework (или элементы управления веб-сервером). И даже на одном уровне, мы должны ограничивать число юзер-контролов, включенных в родительский юзер-контрол. В том смысле, что создание одного большого юзер-контрола, который содержит множество внутренних юзер-контролов – это не всегда хорошая идея. Имейте в виду, что сама страница может содержать столько контролов, сколько вы пожелаете: я заметил, что очень часто разработчики не используют базовые контролы ASP.NET, а встраивают все в пользовательский Сверх-элемент управления, который в свою очередь, содержит дочерние элементы. Зачем нам добавлять этот уровень косвенности и сложности? Страница – это прекрасный контейнер для элементов управления.
4. Не все должно быть включено в отдельный пользовательский элемент управления
Если мы не уделим этому должного внимания, то, вскоре, мы получим огромное количество лишних юзер-контролов в веб-приложении. Чтобы избежать этого, я обычно следую следующим правилам, с тем чтобы определить, действительно ли функциональность интерфейса должна быть в отдельном элементе управления:
- Повторное использование: если мы знаем, что этот контрол будет использоваться в другом месте, надо вставлять его в пользовательский элемент управления,
- Правило комплексности: Иногда лучше отделить некоторые части пользовательского интерфейса, потому что мы хотим инкапсулировать некоторые сложные участки кода в отдельный класс и файл. Это не что иное как принцип эдиной ответственности, применяющийся для компонентов пользовательского интерфейса.
Например, крупную форму, которая содержит несколько разделов, значения которых которые могут зависеть друг от друга. Она будет реализована эффективней, если мы выделим эти разделы в отдельные контролы и заставим их обмениваться данными по средствам событий так, как описано в следующем пункте.
5. Используйте события для обмена данными между юзер-контролами и их контейнерами
Использование свойств пользовательских элементов управления, чтобы сообщить о своем состоянии своему контейнеру – это типичная схема, которую мы видим в веб-разработке. В большинстве случаев разработчики устанавливают переменную сессии, когда что-то случается в пользовательском элементе управления, и контейнер (будь то страница или другой пользовательский элемент управления) проверяет значение переменной сессии для того, чтобы определить, действительно ли что-то случилось или нет. Это обычно делается в событие "OnLoad". Наверное, вы заметили, что очень быстро, мы, в итоге, получаем довольно беспорядочный код в этом обработчике событий.
Во-первых, мы должны гарантировать, что код, который устанавливает переменную сессии выполняется перед кодом, который проверяет ее значение. Кроме того, мы должны гарантировать, что значение переменной сбрасывается: в противном случае, в следующий раз, когда мы попадаем на ту же страницу, мы можем спровоцировать событие, без всяких на то причин.
Один элегантный способ уведомить об изменение статуса одного элемента другому – это создать событие, на которое можно будет подписаться (прим.: public event в C#). Есть много преимуществ такого подхода:
- Чистый код, который реагирует на конкретные события с внутренних контролов,
- Один и тот же механизм может быть использован для стольких контролов, сколько мы пожелаем,
- Мы будем уверены в том, что наш контрол будет извещен только в том случае, если событие действительно произошло; в то время как использование переменных сессии добавляет неопределенности, поскольку мы не знаем, какой код выполняется первым: код, который установил значение Session, или код, который проверяет его.
- Мы не должны заботиться о переменной сессии и сбрасывать его после событий, поскольку мы больше не используем их.
- Мы не используем значения Session просто для того, чтобы поставить/считать флаг (а это экономия памяти и уважение основных принципов ООП).
6. Избегайте встраивания C#/VB кода в файлах ASPX
Лучшее место, чтобы добавить программный код в веб-формы – это code-behind файл. Внедрение кода в файлы ASPX делает его грязным и очень трудно поддерживаемым, как в старые времена ASP.
7. Используйте декларативный стиль программирования как можно чаще
Если вам необходимо настроить пользовательский или любой другой серверный элемент управления – сделайте это по средствам свойств в ASPX-файле вместо code-behind. Конечно же, бывают ситуации, когда у нас нет выбора, где настроить элемент управления (условные значения, например), но, в общем, это делает код HTML более четким и облегчает его поддержку, поскольку мы знаем многое о контроле, просто взглянув на один ASPX файл (и нет необходимости смотреть в code-behind файл).
8. Будьте осторожны при использовании статических переменных
Статические члены являются общими и сохраняют свое значение до тех пор, пока работает процесс ASP.NET. Это означает, если вы используете статические члены, вы потребляете память, которая не будет освобождена, пока вы не сделаете это явно.
Один пример я видел в прошлом, проект хранил пользовательскую информацию в виде статического словаря (между прочим, это может быть любой тип коллекции). При нагрузочном тестировании, использование памяти приложения выросло до 12 ГБ на пару сотен пользователей. Так как словарь хранился в статической переменной, ее размер увеличивался при добавлении новых пользователей и, в конце концов, мы получили исключение "Out of memory".
В данном конкретном случае, мы должны были использовать таймер и метод, который очищает время от времени словарь, чтобы избежать ситуации, описанной выше. Хотя, мы все таки удалили словарь и получали информацию из базы данных каждый раз когда это было необходимо коду, (без кэширования).
9. Рассматривайте производительность с точки зрения клиента
Когда мы говорим о производительности, то часто фокусируемся только на код, который выполняется на сервере, и пренебрегаем пропускной способностью сети и количеством загрузок страницы. Хотя процессор и память дешевле увеличения пропускной способности сети, с другой стороны, пропускная способность является более широкой при работе в контролируемой среде интранет, но мы не имеем никакого контроля на имеющуюся пропускную способность для пользователей веб-сайта в сети Интернет.
Существуют различные средства и способы, чтобы сделать производительность страницы лучше на клиентской стороне (хорошей отправной точкой, будет эта статья: http://www.codeproject.com/KB/aspnet/PeformanceAspnet.aspx).
В коде на серверной стороне, мы не должны допускать чрезмерного использования ViewState. С одной стороны, хранение дерева объектов в ViewState может показаться полезной и более эффективным техникой, чем сохранять его в сессии, ведь объект не будет висеть на неопределенное время в памяти. Но, эффективность будет еще хуже, поскольку на самом деле ваше дерево объектов будет сериализовано и передано как часть ответа в браузер клиента. И когда клиент отправит форму, сериализованный объект отправляется обратно на сервер.
Другой проблемой является количество Javascript файлов, которые загружаются вместе со страницей. Мы должны объединить их с помощью ScriptManager (см. http://bellouti.wordpress.com/2008/09/14/combining-javascript-files-with-ajax-toolkit-library/ ).
Существует слишком много тем, посвященных оптимизации на стороне клиента, которые просто не реально раскрыть в одной статье, и приведенные выше две ссылки послужат вам хорошей отправной точной, если вы никогда раньше не рассматривали этот момент.
10. Используйте кэширование, где это только возможно
Пользовательские элементы управления можно кэшировать с помощью директивы OutputCache. При создании пользовательских элементов управления, которые должны показываться содержание, взятое из БД или внешних источников, следует рассмотреть возможность использования этой директивы.
Мы также можем кэшировать данные в статических членах или пользования объектами кэширования EnterpriseLibrary. Если мы сделаем это, мы должны гарантировать, что мы создаем кэш в форме, ближайшей к той, что будет выводиться в интерфейсе пользователя. Например, если вы получаете XML из базы данных и трансформируете его по правилам XSLT в HTML, который и будет отображаться, то кэшировать следует результирующий HTML, а не XML. Кэширование HTML позволит избежать повторных преобразований XML в следующий раз, когда будет запрошена страница.
Автор статьи: Samir Bellouti
Оригинал: 10 simple rules to write better ASP.NET applications
Перевод: Дмитрий Жарий
суббота, 24 октября 2009 г.
10 типов программистов, с которыми вы обязательно столкнетесь
#01: Гендальф
#02: Мученик
#03: Фанатик
#04: Винс Нил
Винс – веселый человек и работать с ним – одно удовольствие, и на самом деле он очень опытный человек, но просто... никогда не взрослеет. Но Винс доставляет хлопоты, когда он или она пытается жить в стиле Rock-n-Roll; с длинными волосами на голове, и с берцами на ногах. И… достаточно сложно работать с теми, кто приходит на работу с похмелья каждый день.
#05: Ниндзя
Ниндзя настолько скрытный, что вы даже можете не знать их имена, но вы знаете, что каждый проект с их участием получается более и более гладким. Однако, будьте осторожны. Ниндзя – одинокий воин; не пытаются принудить его или ее на работу с рядовыми участниками вашей команды.
#06: Теоретик
Теоретики легко увлекаются. Простая задача на один час, может занять у Теоретика 3 месяца, так как они считают, что существующих технологий и инструментов не достаточно для решения задачи, и они создают новые инструменты для создания новых библиотек, которые соответствуют их высоким стандартам. Теоретиков можно превратить лучших игроков вашей команды, для этого вам необходимо научить их играть в границах проекта и прекратить тратить рабочее время над Самым Совершенным алгоритмом сортировки.
#07: Ковбой
Код Ковбоя – это беспорядочное месиво из спагетти кода, потому что он или она работает настолько быстро, что необходимость рефакторинга даже не возникала. Скорее всего, семь страниц кода основной функциональности выглядит как примеры кода с пометкой "Никогда не делайте так!" из учебника по программированию, но, о чудо, оно работает. Ковбой не может хорошо взаимодействовать с другими. А если вы вовлечете двух Ковбоев для работы над одним проектом, то проект гарантировано обречен на провал, поскольку они будут топтать изменения друг друга и стреляют друг другу в ногу.
Отправьте Ковбоя на проект, в котором дедлайн более важен, чем аккуратность кода, и код будет сдан незадолго до дедлайна. Ковбой, на самом деле, это просто громкая, шумная версия Ниндзя. Но, если Ниндзя выполняет работу с хирургической точностью, то Ковбой -- это свирепый бык, который сносит все, что попадается на его пути.
#08: Десантник
#09: Посредственный Человек
Когда вы интервьюируете этот тип людей, они могут рассказать вам много интересно о проектах, в которых они принимали участие, но, совсем не много об их непосредственной работе. Выявить ПЧ довольно просто: спросите у них конкретно о работе, которую они делали, и, неожиданно они впадают в амнезию. Пустите их в свою организацию, и процесс избавление от них, у вас может занять годы.
#10: Евангелист
Евангелист, в душе, – это тайный руководитель проекта или отдела, но у него не хватает знаний или опыта, чтобы сделать такой прыжок по карьерной лестнице. Так что, пока Евангелист не достигнет чисто управленческой роли, все остальные должны будут мириться с его или ее попытками революций на рабочем месте.
Оригинал статьи: 10 types of programmers you'll encounter in the field
Автор: Justin James
Перевод: Дмитрий Жарий
воскресенье, 16 августа 2009 г.
C# и Java – это языки будних дней, а Python и Ruby для выходных?
Как оказалось, на протяжении всей рабочей недели, лидируют C# и Java, в то время, как на выходных активность идет на спад. В тоже время, на выходных активность вопросов по Ruby и Python возрастает.

Прочитать пост можно здесь:
StackOverflow Experiment Results