우리나라 고등학생의 70% 이상은 대학에 진학한다. 대부분의 학부모와 학생들은 “어느 대학교에 갈 수 있을까”를 가장 주요하게 신경쓴다. 우리나라 대학교는 서열이 있고, 그들은 이 서열에 민감하다.
나도 대학 진학을 희망하는 70%의 고등학생 중 하나였다. 그러나 나의 관심은 달랐다.
어느 학과로 진학하지?
고등학교 학년이 하나씩 올라갈수록 진학할 수 있는 대학이 어디인지는 비교적 명확해진다. 성적과 생활기록부로 겨냥할 수 있는 대학을 가늠할 수 있기 때문이다. 따라서 대학교 서열 표와 같은 자료를 뒤적이던 나의 친구들과는 달리, ‘어느 대학에 갈 수 있는지’는 나의 주된 관심사가 아니었다.
나에게 중대한 문제는 ‘어느 학과로 진학해야 하는가’였다. 이건 성적과 생활기록부로 파악할 수 없는 문제였다.
🚩 내가 내린 판단은 다음과 같다.
내가 사회복지학과를 전공했다고 하면 흔하게 볼 수 있는 반응이 있다.
이런 반응들의 공통점이 있다. 감정이나 성품에 기반한 반응이라는 것.
“사회복지학과”라고 했을 때 흔히 떠올리는 이미지는 “친절하게 미소 짓는 봉사자가 형편이 어려운 어르신께 연탄을 드리는”… 이런 이미지다.
물론 내게도 어려운 이들을 돕고자 하는 사명감이 있다. 나 하나가 아닌 공동체 전체를 위한 삶을 지향한다. 나는 여름마다 홍수로 인해 큰 피해를 입은 지역의 농경지를 복구하는 수해 복구 봉사활동을 3년 간 개근하고 있다.
그러나 사회복지의 관점에서 나의 주된 관심사는 그런 감성적인 것들이 아니었다. 지극히 이성적인, 측정 가능하고 객관적인 것들이었다.
-> 지원 대상자가 지닌 욕구 중 가장 시급하며 중요한 욕구를 파악하는 방법
-> 욕구를 실현 가능한 요구사항으로 설계하는 전략
-> 성과에 대한 명확하고 객관적인 지표(자기기입식 설문지, 측정한 지표 등)
사람에 대한 관심도 좋고, 어려운 분들을 돕는 것도 좋다. 그러나 그건 감성적으로 막연하게 이뤄져서는 안 된다. 사회복지사는 사회적 약자의 삶의 질을 끌어올리고 보편적 복지를 실현하는 전문가다. 전문가에게는 니즈를 파악하는 역량, 달성 가능한 목표로 치환하는 능력, 프로젝트 계획 능력, 프로젝트의 효과/효율을 측정하는 능력이 필요하다.
혹자는 나에게 “사회적 약자들을 돕는 숭고한 일을 돈벌이 사업처럼 바꾸려는 거냐!”라고 반문할지도 모르겠다. 나의 관점을 더욱 펼치기 전에 오해를 풀 필요성을 느낀다.
나는 사회적 약자를 돕고 전반적인 삶의 질을 높이는 숭고한 활동을 “돈벌이 같은 활동”이라고 한 적이 없다. 그런 활동들이 얼마나 효과가 있었는지, 투입한 자원 대비 효율이 어땠는지는 반드시 측정해야 한다고 말할 뿐이다. 나는 그렇게 반문하는 사람들에게 묻고 싶다.
“가용한 자원은 한정되어 있고, 그렇기에 복지를 실현하는 활동에 신중하게 접근해야 한다. 이성적이고 객관적인 측정 방법이 없으면 그 활동이 정말로 가치가 있었는지 어떻게 증명할건가?”
감정보다 논리나 이성에 기반하여 판단하고 행동하는 나의 모습은 같은 학과의 친구들 내에서 “별종” 취급을 받았다.
-> 너는 상황을 논리적으로 판단하는 것 같다.
-> 감정적인 다른 친구들과는 다르다.
때로는 이런 반응도 보였다. (나의 무엇을 보고 그렇게 생각하나?라고 물었을 때 뚜렷한 답을 한 친구가 없었다. 말로 설명하기 어려운 나의 인상인 듯 하다.)
-> 인상은 새내기인데 말하는 건 4학년이다.
-> 말하는 단어에서 지성이 느껴진다.
내 관점이 사회복지에 대한 일반적인 이미지와 다소 다르다는 것은 안다. 그러나 어쩌겠나. 분명 필요한 관점인 것을.
나와 다른 학교를 나온 친구 중에서 개발자를 준비하던 친구가 있다. 그 친구는 내가 어떤 성격의 사람인지 잘 안다. 그렇기에 내게 “마침 유행하는데 논리적 사고력도 필요한” 개발자를 권유했다.
코로나가 유행했던 시기라 Youtube를 조금만 둘러봐도 “00언어 기초 문법”같은 영상이 많았던 시기였다. 나는 패기롭게 C언어를 독학하기 시작했다. 가장 어려운 언어를 해도 재미가 있고 이해할 수 있으면 할 만 하겠지. 라는게 나의 생각이었다.
-> 처음으로 “Hello, World!”를 출력했다.
-> 간단한 사칙연산을 수행했다.
-> 터미널로 입력값을 넣은 뒤 의도했던 출력값을 얻었다.
수치와 정해진 종류로 한정된 입력과 출력. 논리적인 로직 설계. 추상적인 요구를 구체적인 코드로 바꾸는 구조. 매력적이었다! 더 발전시키고 싶었다. 그런데 뭔가 부족했다. 직관적으로 봐도 이건 “프로그램”이 아니었다.
당시에는 ChatGPT를 필두로 하는 LLM이 갓 등장한 시기였다. 환각도 지금보다 월등히 많았고, 초보적인 수준의 나는 아직 스스로 학습할 수 있는 관점을 기르지 못했다. 나 스스로 학습하고 성장할 수 있는 개발자가 되기 위해서는 “프로젝트 전체의 맥락과 개발자의 감각”을 학습해야 했다.
그게 “풀스택 개발자 학원”에 등록하게 된 이유였다. 프로그램의 전체 흐름을 이해하기에는 6개월도 짧다는 것을 알았으나, 내게는 충분히 가치 있는 시간이었다.
나는 프론트엔드도, 백엔드도 좋다. 둘 다 데이터를 다루고, 검증하고, 결과를 산출하는 논리적이고 정확하며 객관적인 성격이 가미되어 있다.
나는 아무래도 백엔드가 더 좋기는 하다.
단순한 기능 개발 뿐 아니라 인프라, 횡단 관심사를 개발하는 것도 좋다.
습득하고 싶은 역량이 많아서 우선순위 조정 후 차근차근 익히려고 한다.
나는 너무 섵부른 계획까지는 세우지 않는다. 위의 항목들을 거친 후에는 자연히 또 새롭게 익힐 역량들이 나타나리라고 생각한다. 기능 개발에서 인프라/횡단 관심사까지 나아간 나의 발자취처럼 말이다.
]]>취업을 고민하는 신입 개발자라면 누구나 떠올리는 질문이다.
AI도 있고, 시니어 개발자도 많은데. 신입인 당신을 왜 뽑아야 합니까?
“너가 어떤 가치를 창출할 수 있는가?”라는 질문은 매우 합당하다. 모든 일에는 이유가 있고, 개발자의 구인 구직도 “이유”가 있다. </br>
따라서 관련 생각을 정리해보았다.
AI는 개발자에게 필요한 정보를 매우 신속하게 제공한다. 이는 시니어의 인지 에너지를 빠르게 고갈하는 원인이다.
사람이 하루에 활용할 수 있는 인지적 에너지는 AI로 늘어난 생산성과 같이 늘어나지 않는다. 사람의 신체 구조는 예전이나 지금이나 비슷하기 때문이다. 이 상황에서 AI가 고도의 판단이 필요한 정보를 쉴 새 없이 전달해주면?
| 시니어 | 신입 | 경감되는 부분 |
|---|---|---|
| 비즈니스 요구사항 해석, 구조 결정 | 관련 기술 스택의 최신 문서 및 AI로 사례조사 | 자료 조사 및 대안 탐색 시간 |
| 핵심 로직 리뷰, 보안 및 성능 가이드 | AI를 활용한 로직 및 테스트 코드 작성 | 단순 코딩 및 반복 작업 |
| 최종 아키텍처 적합성 판단 | AI 결과물의 런타임 오류 수정 | 디버깅 및 Edge Case 확인 |
신입 개발자는 당장의 실무자이기도 하지만, 3~5년 뒤 회사를 지탱할 미래 자산이기도 하다.
과거 어셈블리어를 하던 세대는 C언어를 ‘학습’해야 했다.
수동으로 코드를 작성하던 세대는 AI로 코드 작성을 대리하는 방법을 ‘학습’해야 한다.
AI가 ‘학습의 대상’이 아닌 ‘기본적으로 주어진 환경’인 신입 개발자는 시니어가 되었을 때 어디를 자동화하고, 어디에 인간의 리소스를 투입해야 하는지 본능적으로 알 수 있다.
AI 친화적인 코드를 작성하는 능력을 길러 AI를 적극 활용하여 얻는 생산성을 극적으로 높일 수 있다.
| 특징 | 설명 | 창출하는 가치 |
|---|---|---|
| 사고 방식 | 코드 작성보다 문제 정의와 시스템 설계에 집중 | 복잡한 비즈니스 문제를 기술적 솔루션으로 빠르게 치환 |
| 개발 프로세스 | 프롬프트 엔지니어링을 통한 빠른 프로토타입 개발 | 개발 속도의 혁신적 향상 |
| 품질 관리 | 자동화된 테스트 케이스 생성, 실시간 코드 리뷰 | 인간의 실수를 조기에 발견하여 전체적인 시스템 안전성 향상 |
AI가 도래한 이후의 기술 변화 속도는 확연하게 빨라졌다. 신입 개발자들이 개발을 배우는 시기가 이러한 세상의 흐름과 맞물린다.
즉, 신입 개발자는 빠른 흐름에 익숙하며, 그것을 적용하는 것도 익숙하다.
📢 나의 경험담
프롬프트 엔지니어링으로 단순 반복 작업을 빠르게 처리하고, 개발자 자신은 서비스 로직 설계와 비즈니스 요구사항 분석에 더 많은 시간을 할애할 수 있다.
신입 개발자는 시니어의 숙련도를 이길 수 없다. 다만, AI와 함께 개발한 인원들이니만큼 투자 대비 효율을 얻을 수 있다.
📢 나의 경험담
공신력 있는 지식 채널에서 “요즘은 배워가는 것 보다 버리는 것이 더 중요할 때가 있다”는 말을 들은 적이 있다. 과거의 경험이 현재의 발목을 잡을 수 있다는 통찰에서 비롯된 말이었다.
신입 개발자는 버려야 할 지식이 없다. 새로운 패러다임이 등장했을 때, 신입은 기존의 지식과의 갈등 없이 신기술을 흡수해 활용하는 민첩성이 있다.
AI는 방대한 정보를 바탕으로 가장 확률이 높은 방안을 제시하는 능력이 뛰어나다. AI 시대에 생산성이 비약적으로 늘어난 이유이다.
대신 AI는 특정 의견에 동조하거나 환각을 일으킬 위험이 있다. 신입 개발자는 팀의 맥락 + 클라이언트 요구사항 + 애플리케이션의 관례의 맥락을 더해 논리적/객관적인 근거를 바탕으로 소통할 수 있다.
📢 나의 경험담
public class BankAccount {
private double balance; // Only accessible inside BankAccount
private void logTransaction() { // A helper method only for this class
// ...
}
}
class Logger { // No modifier = default access
String format; // Accessible within the 'com.utilities' package
void logMessage(String msg) { // Accessible within the package
// ...
}
}
public class Vehicle {
protected String engineType; // Accessible in package and to subclasses
protected void startEngine() {
// Subclasses like Car or Bike can use or override this.
}
}
public class Calculator {
public int add(int a, int b) { // Accessible from anywhere
return a + b;
}
}
➕ 두 메서드들을 오버라이딩하는, 권장되는 방식
HashMap의 내부적인 구조
// Simplified HashMap bucket structure
HashMap<K, V> {
Node<K, V>[] table; // Array of buckets
// Each bucket can contain multiple entries (linked list or tree)
class Node<K, V> {
final int hash;
final K key;
V value;
Node<K, V> next; // For collisions
}
}
Chaining
// What happens during a collision
HashMap<String, String> map = new HashMap<>();
map.put("Aa", "Value1"); // Hash 2112 -> Bucket 0
map.put("BB", "Value2"); // Hash 2112 -> Same bucket 0 (collision!)
// Internally, bucket 0 becomes a linked list:
// ["Aa" -> "Value1"] -> ["BB" -> "Value2"]
좋은 해시 함수 (충돌이 덜 남)
Bucket 0: [Entry1]
Bucket 1: [Entry2]
Bucket 2: [Entry3]
...
// O(1) operations
나쁜 해시 함수 (충돌이 자주 남)
Bucket 0: [Entry1] -> [Entry2] -> [Entry3] -> [Entry4] -> ...
Bucket 1: [Entry5]
Bucket 2: []
...
// Degrades to O(n) operations in worst case
String a = "Aa";
String b = "BB";
System.out.println(a.hashCode()); // 2112
System.out.println(b.hashCode()); // 2112 - Same hash code!
System.out.println(a.equals(b)); // false - Different objects
Person@15db9742
// 개발자: 뭐라는거야?
User@1a2b3c
// 개발자: 이해 완료!
User[id=101, name=John, role=ADMIN]
// User 레코드의 toString() 값 예시
User[id=101, name=John, role=ADMIN]
// 모든 Java의 Exception들이 상속하는 Throwable도
// 자신만의 toString()이 있음을 확인할 수 있다.
public String toString() {
String s = getClass().getName();
String message = getLocalizedMessage();
return (message != null) ? (s + ": " + message) : s;
}
// 테스트를 실패했는데 이런 메시지가 뜬다면
// 뭐 어쩌라고? 라는 생각이 들 것이다.
// 필드의 값이 달랐다던지, 예상한 값이 아니었다던지 등을 보여야지.
Expected: User@1a2b3c but was: User@4d5e6f
class Animal {}
class Dog extends Animal {}
Dog dog = new Dog();
Animal animal = dog; // Upcasting (implicit)
// OR
Animal animal = (Animal) dog; // Upcasting (explicit)
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof User)) return false;
// Downcasting is required here to access .username
User other = (User) obj;
return this.username.equals(other.username);
}
Animal animal = new Dog();
Dog dog = (Dog) animal; // Downcasting (explicit, safe here)
Animal animal2 = new Animal();
Dog dog2 = (Dog) animal2; // Runtime error: ClassCastException
➕ extends와 implements가 물려주는 요소의 차이
✅ 클래스가 필수적 요소를, 인터페이스가 선택적 요소를 물려주는 모습
// 필수적인 요소를 물려주는 클래스
class Animal {
void eat() { System.out.println("Eating..."); }
}
// 선택적인 요소를 물려주는 인터페이스
interface Climbable {
void climb();
}
// Cat is an Animal이고 Cat can do Climbing임
class Cat extends Animal implements Climbable {
public void climb() { System.out.println("Climbing high!"); }
}
// Dog is an Animal임. 그러나 Climbing은 못 함
class Dog extends Animal {
void bark() { System.out.println("Woof!"); }
}
❌ 클래스가 선택적인 요소를 물려주는 모습
class Animal {
// 필수적 요소
void eat() { System.out.println("Eating..."); }
// 선택적 요소
void makeSound() { System.out.println("I'm making sound!"); }
}
// Cat은 eat과 makeSound 모두 할 수 있음
class Cat extends Animal {
public void eat() { System.out.println("Eating meat!"); }
public void makeSound() { System.out.println("Meow!"); }
}
// Fish is an Animal은 맞음
// 그러나 Fish는 소리를 내지 못함
class Fish extends Animal {
public void eat() { System.out.println("Eating seaweed!"); }
public void makeSound() { System.out.println("??"); }
}
❌ 인터페이스가 필수적인 요소를 물려주는 모습
➕ extends는 implements보다 덜 쓰인다?
Generic에 범위를 지정하는 등 타입 안전성을 유지하는 역할을 한다.
// This means "T must be a type that implements List"
public <T extends List> void processList(T list) { ... }
코드 예시
// Base class
class Vehicle {
void start() {
System.out.println("Vehicle starting");
}
}
// Derived class - Car IS-A Vehicle
class Car extends Vehicle {
void drive() {
System.out.println("Car driving");
}
}
// Interface example
interface Flyable {
void fly();
}
// Bird IS-A Flyable
class Bird implements Flyable {
public void fly() {
System.out.println("Bird flying");
}
}
코드 예시
// Engine class
class Engine {
void ignite() {
System.out.println("Engine ignited");
}
}
// Car HAS-A Engine (Composition)
class Car {
private Engine engine; // Composition
public Car() {
this.engine = new Engine(); // Engine created with Car
}
void start() {
engine.ignite();
}
}
// Department class
class Department {
private String name;
public Department(String name) {
this.name = name;
}
}
// University HAS-A Department (Aggregation)
class University {
private List<Department> departments; // Aggregation
public University(List<Department> departments) {
this.departments = departments; // Departments exist independently
}
}
상속 대신에 인터페이스 또는 컴포지션 방식을 택한다.
// Instead of inheritance, use interfaces and composition
interface FlyBehavior {
void fly();
}
interface QuackBehavior {
void quack();
}
class FlyWithWings implements FlyBehavior {
public void fly() {
System.out.println("Flying with wings");
}
}
class FlyNoWay implements FlyBehavior {
public void fly() {
System.out.println("Can't fly");
}
}
class Duck {
private FlyBehavior flyBehavior;
private QuackBehavior quackBehavior;
public Duck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
this.flyBehavior = flyBehavior;
this.quackBehavior = quackBehavior;
}
void performFly() {
flyBehavior.fly();
}
void performQuack() {
quackBehavior.quack();
}
// Dynamically change behavior at runtime
void setFlyBehavior(FlyBehavior fb) {
this.flyBehavior = fb;
}
}
// Usage
Duck mallard = new Duck(new FlyWithWings(), new LoudQuack());
Duck rubberDuck = new Duck(new FlyNoWay(), new Squeak());
유연성 및 런타임 행동의 변화 가능
class Character {
private WeaponBehavior weapon; // Composition
void setWeapon(WeaponBehavior weapon) {
this.weapon = weapon; // Change behavior at runtime
}
void fight() {
weapon.useWeapon();
}
}
// Character can switch weapons dynamically
character.setWeapon(new Sword());
character.fight(); // Uses sword
character.setWeapon(new Bow());
character.fight(); // Now uses bow
상속보다 나은 캡슐화
// Inheritance exposes protected members
class Base {
protected String internalData; // Exposed to subclasses
}
// Composition keeps implementation hidden
class Container {
private Base base; // Internal implementation hidden
public void doSomething() {
// Use base internally
}
}
클래스의 과도한 추가 방지
// Without composition: combinatorial explosion
// class FlyingSwordWieldingElf extends Elf {}
// class FlyingAxeWieldingElf extends Elf {}
// class WalkingSwordWieldingElf extends Elf {}
// ... and so on
// With composition: combine behaviors
class GameCharacter {
private MovementBehavior movement;
private WeaponBehavior weapon;
private Race race;
// Combine independent behaviors
GameCharacter elfArcher = new GameCharacter(
new FlyingMovement(),
new BowWeapon(),
new ElfRace()
);
}
Strategy 패턴 (행동적인 구성)
interface PaymentStrategy {
void pay(double amount);
}
class CreditCardPayment implements PaymentStrategy {
private String cardNumber;
public void pay(double amount) {
System.out.println("Paid " + amount + " using credit card");
}
}
class PayPalPayment implements PaymentStrategy {
private String email;
public void pay(double amount) {
System.out.println("Paid " + amount + " using PayPal");
}
}
class ShoppingCart {
private PaymentStrategy paymentStrategy;
public void setPaymentStrategy(PaymentStrategy strategy) {
this.paymentStrategy = strategy;
}
public void checkout(double amount) {
paymentStrategy.pay(amount);
}
}
Decorator 패턴 (구조적인 구성)
interface Coffee {
double getCost();
String getDescription();
}
class BasicCoffee implements Coffee {
public double getCost() { return 5.0; }
public String getDescription() { return "Basic coffee"; }
}
abstract class CoffeeDecorator implements Coffee {
protected Coffee decoratedCoffee;
public CoffeeDecorator(Coffee coffee) {
this.decoratedCoffee = coffee;
}
}
class MilkDecorator extends CoffeeDecorator {
public MilkDecorator(Coffee coffee) {
super(coffee);
}
public double getCost() {
return decoratedCoffee.getCost() + 1.5;
}
public String getDescription() {
return decoratedCoffee.getDescription() + ", Milk";
}
}
// Usage: Compose features dynamically
Coffee myCoffee = new MilkDecorator(
new SugarDecorator(
new BasicCoffee()));
의존성 주입 (생성자 구성)
class DataProcessor {
private final Repository repository;
private final Validator validator;
// Dependencies injected via constructor
public DataProcessor(Repository repo, Validator validator) {
this.repository = repo;
this.validator = validator;
}
public void process(Data data) {
if (validator.isValid(data)) {
repository.save(data);
}
}
}
공유하는 정체성이 있는 실제 “is-a” 관계
// Good inheritance: Shape hierarchy
abstract class Shape {
abstract double area();
abstract double perimeter();
}
class Circle extends Shape { // Circle IS-A Shape
private double radius;
double area() {
return Math.PI * radius * radius;
}
}
위계 구조가 필요한 프레임워크 / API 디자인
// Java Collections Framework
public abstract class AbstractList<E> implements List<E> {
// Provides skeletal implementation
// Subclasses fill in specifics
}
Template Method 패턴
abstract class DataParser {
// Template method with fixed algorithm
public final void parse() { // final to prevent overriding
readData();
processData(); // Abstract - subclass implements
saveData();
}
protected abstract void processData();
}
인터페이스의 default 메서드
interface Logger {
void log(String message);
// Default implementation - like inheritance but composable
default void logError(String error) {
log("ERROR: " + error);
}
}
// Multiple interfaces can be composed
class FileLogger implements Logger, AutoCloseable {
public void log(String message) { /* write to file */ }
public void close() { /* close file */ }
}
데이터 구성을 위한 레코드
// Records automatically compose equals(), hashCode(), toString()
record Point(int x, int y) {}
record Line(Point start, Point end) { // Composition
double length() {
return Math.hypot(end.x() - start.x(),
end.y() - start.y());
}
}