Как учился программированию

История обучения программированию

Программирование — это не только профессия, но и форма мышления. Путь от новичка к опытному Java Developer требует системного подхода, постоянного обучения и практики. Вот как обычно выглядит эта траектория.

1. Первые шаги: основы языка

Фаза 1: Синтаксис и базовые концепции

// Мой первый "Hello World"
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

// Затем изучал:
// - Переменные и типы данных
// - Операторы (арифметические, логические, сравнения)
// - Управление потоком (if-else, switch, loops)
// - Массивы и строки

Фаза 2: ООП (Object-Oriented Programming)

// Осознание: код состоит из объектов, которые взаимодействуют

// Классы и объекты
public class Car {
    private String brand;
    private int year;
    
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }
    
    public void drive() {
        System.out.println(brand + " is driving");
    }
}

// Наследование
public class SportsCar extends Car {
    public void turbo() {
        System.out.println("Turbocharged!");
    }
}

// Полиморфизм
public interface Vehicle {
    void drive();
}

public class Truck implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Truck is driving");
    }
}

// Инкапсуляция
public class BankAccount {
    private double balance;  // private — доступ только изнутри
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public double getBalance() {
        return balance;
    }
}

2. Фундамент: паттерны проектирования

Фаза 3: Design Patterns

// Singleton — хотел гарантировать единственный экземпляр
public class DatabaseConnection {
    private static DatabaseConnection instance;
    
    private DatabaseConnection() {}
    
    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

// Builder — когда у класса слишком много параметров
public class User {
    private String name;
    private String email;
    private int age;
    
    private User(UserBuilder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
    }
    
    public static class UserBuilder {
        private String name;
        private String email;
        private int age;
        
        public UserBuilder name(String name) {
            this.name = name;
            return this;
        }
        
        public UserBuilder email(String email) {
            this.email = email;
            return this;
        }
        
        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }
        
        public User build() {
            return new User(this);
        }
    }
}

// Strategy — выбор алгоритма в runtime
public interface PaymentStrategy {
    void pay(BigDecimal amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Paying " + amount + " with credit card");
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Paying " + amount + " with PayPal");
    }
}

public class PaymentProcessor {
    private PaymentStrategy strategy;
    
    public PaymentProcessor(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void checkout(BigDecimal amount) {
        strategy.pay(amount);
    }
}

3. Уровень intermediate: фреймворки

Фаза 4: Spring Framework

// Когда понял, что вручную управлять бинами неудобно

// Spring Boot Application
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// REST контроллер
@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @PostMapping
    public ResponseEntity<UserResponse> createUser(
        @Valid @RequestBody CreateUserRequest request
    ) {
        User user = userService.createUser(
            request.getName(),
            request.getEmail()
        );
        return ResponseEntity.status(HttpStatus.CREATED)
            .body(new UserResponse(user));
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<UserResponse> getUser(
        @PathVariable Long id
    ) {
        return userService.findById(id)
            .map(user -> ResponseEntity.ok(new UserResponse(user)))
            .orElse(ResponseEntity.notFound().build());
    }
}

// Service layer
@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(String name, String email) {
        User user = new User(name, email);
        return userRepository.save(user);
    }
    
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }
}

// Repository (ORM)
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

Фаза 5: Базы данных и SQL

// Понял важность понимать SQL

// JPA аннотации
@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @Column(nullable = false)
    private String name;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders = new ArrayList<>();
    
    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;
}

// Native SQL queries для сложных операций
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    @Query(value = """
        SELECT * FROM orders 
        WHERE user_id = :userId 
        AND created_at >= :startDate
        AND status = 'COMPLETED'
    """, nativeQuery = true)
    List<Order> findCompletedOrdersSince(
        @Param("userId") Long userId,
        @Param("startDate") LocalDateTime startDate
    );
}

4. Advanced: тестирование и качество

Фаза 6: Unit и Integration тестирование

// Осознал: код без тестов — это неработающий код

// Unit тесты с JUnit и Mockito
@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
    
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    public void testCreateUser() {
        // Arrange
        CreateUserRequest request = new CreateUserRequest("John", "john@example.com");
        User expected = new User(1L, "John", "john@example.com");
        
        when(userRepository.save(any(User.class)))
            .thenReturn(expected);
        
        // Act
        User result = userService.createUser("John", "john@example.com");
        
        // Assert
        assertNotNull(result);
        assertEquals("John", result.getName());
        assertEquals("john@example.com", result.getEmail());
        verify(userRepository, times(1)).save(any(User.class));
    }
    
    @Test(expected = DuplicateEmailException.class)
    public void testCreateUserWithDuplicateEmail() {
        when(userRepository.findByEmail("john@example.com"))
            .thenReturn(Optional.of(new User()));
        
        userService.createUser("John", "john@example.com");
    }
}

// Integration тесты
@SpringBootTest
public class UserControllerIntegrationTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    public void testCreateUserEndpoint() {
        CreateUserRequest request = new CreateUserRequest("John", "john@example.com");
        
        ResponseEntity<UserResponse> response = restTemplate.postForEntity(
            "/api/v1/users",
            request,
            UserResponse.class
        );
        
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        assertNotNull(response.getBody().getId());
        
        // Проверяем, что сохранилось в БД
        User savedUser = userRepository.findByEmail("john@example.com").get();
        assertEquals("John", savedUser.getName());
    }
}

5. Production опыт: архитектура и лучшие практики

Фаза 7: Clean Code и SOLID

// Когда понял стоимость поддержки кода

// Single Responsibility Principle
public class EmailSender {
    public void sendEmail(String to, String subject, String body) {
        // Только отправка email
    }
}

public class UserRegistrationService {
    
    private UserRepository userRepository;
    private EmailSender emailSender;
    
    public void registerUser(String email, String password) {
        // Валидация
        if (!isValidEmail(email)) {
            throw new InvalidEmailException();
        }
        
        // Сохранение
        User user = new User(email, hashPassword(password));
        userRepository.save(user);
        
        // Отправка email
        emailSender.sendEmail(
            email,
            "Welcome!",
            "Thank you for registering"
        );
    }
}

// Dependency Inversion
public interface NotificationService {
    void notify(String message);
}

public class SlackNotificationService implements NotificationService {
    @Override
    public void notify(String message) {
        // Отправить в Slack
    }
}

public class OrderService {
    private NotificationService notificationService; // Зависим от интерфейса
    
    public OrderService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }
    
    public void completeOrder(Order order) {
        order.complete();
        notificationService.notify("Order " + order.getId() + " completed");
    }
}

6. Непрерывное обучение

Ресурсы и привычки

// Что помогло мне расти:

// 1. Чтение чужого кода
// - GitHub Open Source projects
// - Spring Framework исходный код
// - Google's coding style guide

// 2. Регулярная практика
// - LeetCode и HackerRank для алгоритмов
// - Side projects для экспериментов
// - Code kata на Codewars

// 3. Обучение от ошибок
public class LessonsLearned {
    // Ошибка 1: N+1 query problem
    // Решение: @EntityGraph или JOIN FETCH
    
    // Ошибка 2: Синхронизация в многопоточном коде
    // Решение: AtomicLong, ReentrantLock, ThreadLocal
    
    // Ошибка 3: Циклические зависимости между бинами
    // Решение: Refactor архитектуру, использовать ObjectProvider
    
    // Ошибка 4: Отсутствие обработки исключений
    // Решение: @ControllerAdvice, try-catch в нужных местах
    
    // Ошибка 5: Небезопасный код
    // Решение: SQL injection prevention, XSS protection
}

7. Текущий уровень: Senior/Lead

// Сейчас учу других и фокусируюсь на:

// 1. Архитектурном мышлении
public class ArchitectureThinking {
    // - Как масштабируется система при 10x нагрузке?
    // - Где будут узкие места?
    // - Как тестировать эту архитектуру?
}

// 2. Менторстве
public class Mentoring {
    // - Code review с объяснениями
    // - Помощь junior'ам в разборе паттернов
    // - Документирование лучших практик команды
}

// 3. Новых технологиях
public class ContinuousLearning {
    // - GraalVM и native images
    // - Project Loom (virtual threads)
    // - Project Panama (FFI)
    // - Reactive programming (Project Reactor)
}

Итоги

Путь от новичка к опытному Java Developer:

1. Основы (месяцы 1-3): синтаксис, ООП, базовые структуры данных
2. Паттерны (месяцы 3-6): Design Patterns, лучшие практики
3. Фреймворки (месяцы 6-12): Spring, Hibernate, основы веба
4. Профессионализм (год 1-2): тестирование, архитектура, производительность
5. Экспертиза (год 2+): ментор, лидерство, системное мышление

Ключевые привычки:

• Писать код как будто его будет читать твой преемник
• Тесты писать ДО кода (TDD)
• Регулярно учиться и экспериментировать
• Делиться знаниями с командой
• Никогда не останавливаться в развитии

Помни: программирование — это не пункт назначения, а путешествие бесконечного обучения!