Есть ли вредные привычки?

Есть ли вредные привычки

Честный подход

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

Вредные привычки разработчика, которые я имею и исправляю

1. Откладывание рефакторинга "на потом"

Проблема:

// ❌ Плохо — я часто делаю код "работающим" и откладываю рефакторинг
function processData(data) {
  const result = [];
  for (let i = 0; i < data.length; i++) {
    if (data[i].type === 'question') {
      if (data[i].difficulty !== 'easy') {
        const obj = { ...data[i] };
        obj.processed = true;
        result.push(obj);
      }
    }
  }
  return result;
}

Что я делаю:

• Осознаю, что "потом" часто не наступает
• Стараюсь рефакторить по ходу разработки
• Выделяю время на техдолг в каждом спринте
• Использую code review для выявления проблем на ранней стадии

Как исправляю:

// ✅ Хорошо — чистый, понятный код сразу
function getHardQuestions(data: Question[]): ProcessedQuestion[] {
  return data
    .filter(q => q.type === 'question' && q.difficulty !== 'easy')
    .map(q => ({ ...q, processed: true }));
}

2. Слишком много console.log для отладки

Проблема:

// ❌ Привычка оставлять debug консоли
const fetchQuestions = async () => {
  console.log('Starting fetch'); // Забываю удалить
  const response = await fetch('/api/v1/questions');
  console.log('Response:', response); // Оставляю для отладки
  const data = await response.json();
  console.log('Data:', data); // Попадает в production
  return data;
};

Что я делаю:

• Использую DevTools вместо console.log для отладки
• Удаляю все console.log перед commit'ом (eslint помогает)
• Если нужен logging — делаю правильный logger с уровнями
• Использую debugger statement и DevTools

Как исправляю:

// ✅ Правильно — чистый код, используем инструменты
const fetchQuestions = async () => {
  const response = await fetch('/api/v1/questions');
  if (!response.ok) throw new Error('Failed to fetch');
  return response.json();
};

// Если нужен logging:
const logger = {
  info: (msg) => console.log(`[INFO] ${msg}`),
  error: (msg) => console.error(`[ERROR] ${msg}`)
};

3. Копирование-вставка кода вместо рефакторинга

Проблема:

// ❌ Копипаст — нарушает DRY принцип
function getEasyQuestions(questions: Question[]) {
  const result = [];
  for (let i = 0; i < questions.length; i++) {
    if (questions[i].difficulty === 'easy') result.push(questions[i]);
  }
  return result;
}

function getHardQuestions(questions: Question[]) {
  const result = []; // Копипаст
  for (let i = 0; i < questions.length; i++) {
    if (questions[i].difficulty === 'hard') result.push(questions[i]);
  }
  return result;
}

Что я делаю:

• Сразу вижу, когда код повторяется
• Выношу общую логику в утилиту или функцию высшего порядка
• Использую higher-order functions (HOF)
• Code review помогает выявить копипасты

Как исправляю:

// ✅ DRY — общая функция
function filterByDifficulty(
  questions: Question[],
  difficulty: 'easy' | 'medium' | 'hard'
) {
  return questions.filter(q => q.difficulty === difficulty);
}

const easyQuestions = filterByDifficulty(questions, 'easy');
const hardQuestions = filterByDifficulty(questions, 'hard');

4. Работа поздно ночью и спешка

Проблема:

• Работаю ночью, потому что вроде остаётся время
• Спешу завершить задачу к дедлайну
• Результат: баги, плохой код, усталость

Что я делаю:

• Планирую работу с запасом по времени
• Стараюсь работать в продуктивные часы
• Если устал — лучше остановиться, чем делать код спешно
• Использую Pomodoro технику

Принцип:

Правильно: 2 часа концентрированной работы днём
Ошибочно: 6 часов спешной работы ночью

Результат на выходе: 
- Меньше багов
- Лучшее качество кода
- Быстрее спринт в целом (за счёт code review, тестирования)

5. Пропуск тестирования "для экономии времени"

Проблема:

// ❌ Я писал код без тестов, говоря "напишу потом"
function calculateScore(questions, answers) {
  let score = 0;
  for (let i = 0; i < questions.length; i++) {
    if (questions[i].answer === answers[i]) score++;
  }
  return score;
}
// Потом баг попал в production: неправильно считал очки!

Что я делаю:

• Применяю TDD — пишу тесты первыми
• Понимаю, что тесты экономят время (на отладку и рефакторинг)
• Стараюсь покрыть edge cases
• Code coverage >= 90%

Как исправляю:

// ✅ Правильно — тесты + код
import { describe, it, expect } from 'vitest';

describe('calculateScore', () => {
  it('должен считать правильные ответы', () => {
    const questions = [{ id: '1', answer: 'A' }];
    const answers = ['A'];
    expect(calculateScore(questions, answers)).toBe(1);
  });

  it('должен обрабатывать пустые массивы', () => {
    expect(calculateScore([], [])).toBe(0);
  });

  it('должен обрабатывать несовпадающие размеры', () => {
    const questions = [{ answer: 'A' }, { answer: 'B' }];
    const answers = ['A']; // Меньше ответов
    expect(() => calculateScore(questions, answers)).not.toThrow();
  });
});

function calculateScore(
  questions: Array<{ answer: string }>,
  answers: string[]
): number {
  if (questions.length !== answers.length) {
    throw new Error('Mismatch between questions and answers');
  }
  return questions.filter((q, i) => q.answer === answers[i]).length;
}

Вредные привычки в процессе разработки

1. Игнорирование типов в TypeScript

// ❌ Вредная привычка
const data: any = await fetch(url).then(r => r.json());
const title = data.title; // Может быть undefined!

// ✅ Исправляю
interface Question {
  id: string;
  title: string;
}

const data: Question = await fetch(url).then(r => r.json());
const title = data.title; // TypeScript гарантирует что это string

2. Игнорирование ошибок в API запросах

// ❌ Вредная привычка
const questions = await fetch('/api/v1/questions').then(r => r.json());
// Что если запрос упадёт? Что если сервер вернёт ошибку?

// ✅ Исправляю
try {
  const response = await fetch('/api/v1/questions');
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  const questions = await response.json();
  // Работаем с questions
} catch (error) {
  console.error('Failed to fetch questions:', error);
  showUserError('Could not load questions. Please try again.');
}

3. Игнорирование accessibility (a11y)

// ❌ Вредная привычка — забываю про доступность
<button onClick={handleClick}>Like</button>

// ✅ Исправляю
<button
  onClick={handleClick}
  aria-label="Add this question to favorites"
  className="btn btn-primary"
>
  <HeartIcon aria-hidden="true" /> Like
</button>

Как я работаю над привычками

1. Осознание:

✓ Признаю, что привычка вредит качеству
✓ Понимаю, почему нужно измениться

2. Инструменты и системы:

// ESLint конфиг помогает избежать многих ошибок
{
  "rules": {
    "no-console": "warn", // Напоминает удалить console.log
    "@typescript-eslint/no-explicit-any": "error", // Запрещает any
    "no-duplicate-imports": "warn" // Помогает видеть копипасты
  }
}

3. Code Review:

✓ Коллеги указывают на проблемы
✓ Я получаю обратную связь
✓ Вместе улучшаем качество кода

4. Автоматизация:

# Pre-commit hooks помогают проверить код
# перед тем как я его запушу
npm run lint
npm run test

Мой ответ на собеседовании

Интервьюер: "Есть ли вредные привычки?"

Мой ответ:
"Да, есть. Как любой разработчик, я время от времени:

1. Откладываю рефакторинг на потом (но учусь делать его по ходу)
2. Забываю удалить console.log (ESLint помогает)
3. Пропускаю тесты при спешке (стараюсь применять TDD)

Что важно: я осознаю эти вредные привычки и активно с ними работаю:
- Использую инструменты (ESLint, TypeScript strict)
- Прошу code review
- Выделяю время на техдолг
- Регулярно учусь новому

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

Заключение

Вредные привычки есть у всех. Ключ — это:

1. Осознание — признаёшь проблему
2. Система — создаёшь инструменты и процессы для борьбы
3. Непрерывное улучшение — постоянно работаешь над собой
4. Честность — говоришь об этом открыто

Интервьюер это оценит — видит, что ты рефлексивный разработчик, который растёт.