Как прокачиваешь hard скилы

# Как я развиваю hard скилы

Развитие технических навыков — это постоянный процесс. За 10+ лет разработки я выработал систему, которая действительно работает.

1. Learn by Doing (основной метод)

Теория без практики бесполезна. Я изучаю новые технологии через реальные проекты:

Пример: Изучение Redis

Вместо просмотра туториалов я:

1. Взял реальную задачу — оптимизировать кэширование в проекте
2. Выбрал Redis как инструмент
3. Поставил себе challenge — снизить время ответа API на 50%
4. Изучил документацию Redis, но только нужные части
5. Имплементировал кэширование результатов поиска
6. Мониторил результаты — метрики, нагрузку, hit rate
7. Оптимизировал на основе данных

Результат: не только выучил Redis, но и понял его применение в реальных сценариях.

2. Глубокое изучение одной технологии

Я не гонюсь за тем, чтобы "знать все". Вместо этого глубоко изучаю то, что использую:

Spring Framework — углубленное изучение

// Уровень 1: Базовое использование @Autowired
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
}

// Уровень 2: Понимание scopes и BeanFactory
@Service
@Scope("singleton")
public class UserService {
    // Понимаю, когда Spring создаёт один экземпляр на всё приложение
}

// Уровень 3: Кастомные BeanFactoryPostProcessor
@Component
public class CustomBeanProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Модифицирую определения бинов до их создания
    }
}

// Уровень 4: AOP и dynamic proxies
@Aspect
@Component
public class PerformanceMonitoringAspect {
    @Around("@annotation(Monitored)")
    public Object monitor(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long duration = System.currentTimeMillis() - start;
        System.out.println("Method " + joinPoint.getSignature() + " took " + duration + "ms");
        return result;
    }
}

3. Чтение исходного кода

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

Процесс

1. Выбираю интересующую функцию — например, как Spring обрабатывает @Transactional

2. Читаю исходный код на GitHub

// Открываю spring-framework на GitHub
// Файл: org.springframework.transaction.interceptor.TransactionAspect

public class TransactionAspect extends AbstractAspectJAdvice {
    @Override
    protected Object invokeWithinTransaction(Method method, Class<?> targetClass, 
                                           final InvocationCallback invocation) {
        // Вижу, как Spring управляет транзакциями
        // Понимаю, когда откатывает изменения
        // Узнаю про RuntimeException vs checked exceptions
    }
}

1. Делаю заметки о ключевых моментах

2. Применяю знания в своих проектах

Проекты, которые стоит читать

• Spring Framework — архитектура, pattern-ы, качество кода
• Hibernate — работа с ORM, SQL генерация, lazy loading
• Apache Kafka — concurrency, performance, distributed systems
• Guava — утилиты, Collections, functional programming
• JUnit — интеграция с Java runtime, reflection, meta-программирование

4. Экспериментирование и Proof of Concepts

Я регулярно создаю небольшие проекты для изучения:

POC: Как оптимизировать queries в Spring Data JPA

// Проблема: N+1 problem
@Entity
public class User {
    @OneToMany(fetch = FetchType.LAZY)  // По умолчанию LAZY
    private List<Order> orders;
}

// ❌ N+1 queries: 1 для юзеров + N запросов для каждого заказа
List<User> users = userRepository.findAll();
for (User user : users) {
    System.out.println(user.getOrders().size());  // Здесь каждый раз SELECT
}

// ✅ Решение 1: Eagerly load с JOIN FETCH
@Query("SELECT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();

// ✅ Решение 2: Использовать EntityGraph
@EntityGraph(attributePaths = "orders")
List<User> findAll();

// ✅ Решение 3: Batch loading
@BatchSize(size = 10)
@OneToMany
List<Order> orders;

Я создал небольшой POC проект, где сравнил все три подхода по performance.

5. Участие в code reviews

Обучение через review чужого кода:

// Code review comment: "Почему здесь N+1 problem не очевидный?"
// Это заставляет меня разобраться глубже

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    public List<OrderDTO> getOrderSummaries() {
        // Запрос: это будет N+1 problem?
        List<Order> orders = orderRepository.findAll();
        
        return orders.stream()
            .map(order -> new OrderDTO(
                order.getId(),
                order.getTotal(),
                order.getCustomer().getName()  // ← N+1 problem!
            ))
            .collect(toList());
    }
}

6. Решение сложных проблем

А не только простых задач. Когда встречаю сложность, копаю глубже:

Пример: Память утекает в приложении

1. Заметил, что heap растёт со временем
2. Взял JProfiler / YourKit
3. Снял heap dump
4. Нашёл утечку в кэше (не удаляютсястарые объекты)
5. Изучил, как работает GC
6. Реализовал правильную стратегию кэширования
7. Понял про Weak/Soft references

Теперь я гораздо лучше понимаю memory management в Java.

7. Сертификации (полезны, но не главное)

Я прохожу сертификации не ради галочки, а ради систематизации знаний:

Рекомендуемые сертификации для Java

1. OCP (Oracle Certified Associate) — базовый Java синтаксис
2. Advanced Java — concurrency, streams, generics
3. Spring Framework Certification — Spring ecosystem
4. AWS Solutions Architect — если работаю с облаком

Но помните: сертификация ≠ мастерство. Я видел людей с 5 сертификатами, которые не могут написать потокобезопасный код.

8. Документирование и объяснение

Когда я объясняю тему другому человеку, я лучше её усваиваю:

Процесс

1. Выбираю тему — например, как работают annotations в Java
2. Пишу статью или объясняю коллеге
3. Обнаруживаю пробелы в своём понимании
4. Исправляю пробелы

Это гораздо эффективнее, чем просто читать.

9. Следование лучшим практикам

Я не просто копирую best practices, я их понимаю:

// Практика: "Immutable объекты потокобезопасны"

// Прочитал это в книге, но почему?
final class ImmutableUser {
    private final String email;
    private final int age;
    
    public ImmutableUser(String email, int age) {
        this.email = email;
        this.age = age;
    }
    
    // Нет setters - не изменяется
    // final поля - не меняются на уровне JVM
    // Поэтому несколько потоков могут читать одновременно без синхронизации
}

// Я понимаю, что final защищает не только от случайного изменения,
// но и от race conditions

10. Актуальность в своей области

Я подписан на:

• Java-focused blogs — DZone, Baeldung, Spring Blog
• Podcasts — Jungle Cast, Java Podcast
• GitHub trends — смотрю, что выходит нового
• Tech conferences — JConf, Spring IO (online сейчас часто)
• Twitter — следю за мнениями экспертов

Мой стек для развития

Книги:
- "Effective Java" by Joshua Bloch (читал 3 раза)
- "Java Concurrency in Practice" by Goetz
- "Clean Code" by Robert Martin

Онлайн ресурсы:
- YouTube: Vladik Khononov, Baeldung
- Courses: Pluralsight (paid subscription)
- Leetcode: для алгоритмов (2-3 часа в неделю)

Практика:
- Side projects (GitHub)
- Участие в open source
- Code reviews в work
- Teaching/mentoring junior developers

Резюме

Мой подход к развитию hard скилов:

1. Learn by Doing — реальные проекты, не туториалы
2. Глубина, а не ширина — выбираю несколько технологий и изучаю их глубоко
3. Читаю исходный код — самое мощное обучение
4. Решаю сложные проблемы — это развивает систем thinking
5. Объясняю другим — лучший способ проверить понимание
6. Экспериментирую — POC проекты
7. Слежу за трендами — но не гонюсь за каждым новым фреймворком
8. Читаю книги — классика переживает времена лучше, чем блог посты

Главное: развитие — это марафон, не спринт. Я не торопился и сейчас комфортно читаю и пишу на разных технологиях, потому что понимаю фундаментальные принципы, а не просто синтаксис.