그냥저냥

문제풀이 | The C Programming Language (K&R): Exercise 1-7

sync86 — Sun, 24 May 2026 09:48:12 +0900

책: The C Programming Language (K&R)

본문의 연습문제는 저작권 이슈로 그 내용을 직접적으로 언급하지 않습니다. 이점 양해 바랍니다.

Exercise 1-7. EOF 출력하는 문제입니다.

1. 이 문제를 해결하는데 필요한 사전 정보

이번 문제는 EOF 값을 출력해서 확인하는 문제입니다.

자세히 보니 Exercise 1-6에서 이미 풀었던 문제이더군요.

그래서 Exercise 1-6에서 풀었던 문제를 수정해서 풀어보겠습니다.

2. 소스코드

#include <stdio.h>

/**
 * copy input to output; 2nd version
 */

int main(int argc, char** argv)
{
  printf("%d\n", EOF);
}

3. 실행 및 검증

$ ./a.out 
-1
$

4. 마무리

EOF 값은 -1 입니다.

$ ./a.out
I'm a boy.I'm a boy.-1 0
$

이전에 Exercise 1-6에서 "I'm a boy. I'm a boy.-1 0"에서 -1이 EOF 값을 출력했던 것이었죠.

다음은 Exercise 1-8 풀어보겠습니다.

문제풀이 | The C Programming Language (K&R): Exercise 1-6

sync86 — Sat, 23 May 2026 15:01:36 +0900

책: The C Programming Language (K&R)

본문의 연습문제는 저작권 이슈로 그 내용을 직접적으로 언급하지 않습니다. 이점 양해 바랍니다.

Exercise 1-6. getchar() != EOF 확인하는 문제입니다.

1. 이 문제를 해결하는데 필요한 사전 정보

EOF (End of File)는 파일 끝을 의미합니다.

따라서 원래는 파일 입력을 받아야 하나, 책에서는 파일 입/출력을 하는 방법에 대해서는 언급하지 않았습니다.

때문에, UNIX의 기본 입출력 키보드 입력에 따라 파일을 입력해서 출력하는 방법으로 흉내를 내는 것 같습니다.

"모든 것은 파일이다."는 유닉스 철학이 있습니다. 이것은 키보드 입/출력력도 하나의 파일처럼 취급된다는 의미입니다.

운영체제마다 차이는 있겠지만, 키보드로 EOF를 표현하기 위한 방법은 아래와 같습니다.

유닉스/리눅스: CTRL+D
윈도우즈: CTRL+Z

2. 소스코드

#include <stdio.h>

/**
 * copy input to output; 2nd version
 */

int main(int argc, char** argv){

 int c = -1;

  while ((c = getchar()) != EOF)
  {
    putchar(c);
  }

  /* c가 EOF인지 확인하기 위한 코드 */
  if(c == EOF)
  {
    printf("%d %d\n", c, (c != EOF));
  }
}

3. 실행 및 검증

$ ./a.out # 엔터 입력 후 CTRL+D 입력
-1 0
$

4. 마무리

이 책에서 연습문제에서는 0 또는 1인지 확인하라고 적혀있습니다. EOF의 표준이 바뀌었던 것인지는 확실하지 않지만 -1이 맞습니다.

다만 원래 이 프로그램의 의도는 입력한대로 출력해주는 용도입니다.

파일을 복제하는 예제인 것이죠.

키보드를 입력하고, CTRL+D(유닉스/리눅스 기준) 입력하면 문자열이 출력되고 종료될 것으로 예상되지만, 대기중입니다.

이것은 출력 버퍼와 상관있는 이야기입니다.

$ ./a.out
I'm a boy.I'm a boy.

아직까진 이 이야기에 대해서 언급된 내용은 아닙니다.

정상 동작이라는 가정으로 CTRL+D (유닉스/리눅스 기준) 한번 더 입력하면 아래와 같이 프로그램이 종료됩니다.

$ ./a.out
I'm a boy.I'm a boy.-1 0
$

다음은 Exercise 1-7 풀어보겠습니다.

레드햇 오픈시프트(OpenShift) 초간단 선택 가이드: 내 상황엔 이거!

sync86 — Sat, 16 May 2026 12:47:25 +0900

이 내용은 AI (Gemini)의 도움을 받아 작성하였습니다.

얼마전에 레드햇 오픈시프트(OpenShift)를 구성해볼 기회가 있었어요. 처음 구성하는데 레드햇 홈페이지에 접속하니 알 수 없는 제품 목록이 나왔고 이 제품 목록을 구글 제미나이(Gemini)에게 던져서 빠르게 요약 정리를 할 수 있었어요.
당시 저와 비슷한 고민을 하셨던 분들이 계실 수도 있다고 생각해서 구글 제미나이(Gemini)에게 부탁해서 그림 그리고 정리해서 공유합니다. 단순 참고용으로만 확인해주세요.

1. OpenShift Container Platform (OCP)

한 줄 비유: 모든 가구가 빌트인된 '최고급 풀옵션 아파트'
핵심 목적: 일반적인 클라우드 네이티브 및 마이크로서비스(MSA) 개발·운영.
언제 고를까? "돈이나 리소스는 상관없으니, 모니터링·보안·배포 도구까지 레드햇이 싹 다 패키지로 세팅해 준 표준 플랫폼을 편하게 쓰고 싶을 때."

2. OpenShift Virtualization

한 줄 비유: 옛날 집에서 쓰던 큰 장롱을 그대로 들여온 '베란다 확장형 아파트'
핵심 목적: 기존의 가상머신(VM, 예: VMware)을 컨테이너와 동일한 방식으로 제어 및 인프라 통합.
언제 고를까? "새로운 컨테이너 환경도 도입해야 하지만, 기존에 쓰던 무거운 레거시 가상머신(VM) 인프라도 버릴 수 없어서 한 군데서 같이 관리하고 싶을 때."

3. OpenShift Sandboxed Containers

한 줄 비유: 아파트 안에 들여놓은 격리된 '최첨단 개인용 금고(Sandbox)'
핵심 목적: 보안 및 금융 규제 준수를 위해 가상머신(VM) 기술로 컨테이너를 한 번 더 감싸서 구동하는 방식.
언제 고를까? "특정 컨테이너의 보안 취약점이 우려되거나 금융권 규제 때문에 컨테이너끼리 물리적으로 완벽한 격리가 필요할 때." (하나가 해킹당해도 전체 서버나 이웃 컨테이너에 절대 영향을 주지 않음)

4. Single-Node OpenShift (SNO)

한 줄 비유: 주방과 화장실이 한 평에 다 들어간 실속형 '초소형 원룸'
핵심 목적: 서버 단 1대에 제어부(Master)와 작업부(Worker)를 모두 때려 넣은 경량화 구성.
언제 고를까? "거대 서버실이 아니라 스마트 팩토리 공장 내부, 무인 키오스크, 선박 안 같은 열악하고 좁은 환경(Edge)에서 오픈시프트를 실속 있게 돌리고 싶을 때."

5. OpenShift DevOps (GitOps / Pipelines)

한 줄 비유: 청소와 설거지를 알아서 해주는 '풀 자동화 로봇가전 옵션'
핵심 목적: GitOps 및 CI/CD 파이프라인 기반의 배포 자동화.
언제 고를까? "개발자가 코드를 업데이트하면, 사람이 수동으로 명령어 칠 필요 없이 테스트부터 실운영 서버 배포까지 고속도로처럼 착착 자동화하고 싶을 때."

문제풀이 | The C Programming Language (K&R): Exercise 1-5

sync86 — Mon, 4 May 2026 17:56:09 +0900

책: The C Programming Language (K&R)

본문의 연습문제는 저작권 이슈로 그 내용을 직접적으로 언급하지 않습니다. 이점 양해 바랍니다.

Exercise 1-5. 섭씨-화씨 역산과 연산 우선순위

Exercise 1-5 문제는 Exercise 1-3, Exercise 1-4에서 작성 예제를 코드를 역순으로 출력하는 문제입니다.

1. 사전 정보

다만, Exercise 1-3 이나 Exercise 1-4 어디서 작성한 코드를 기준으로 역순으로 출력하라는지 구체적인 언급은 없습니다.

여기서 저는 Exercise 1-4 문제를 가지고 풀어보겠습니다.

#include <stdio.h>

/** 
 * print Celsius-Fahrenheit table
 * for fahr = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   double fahr    = 0.0;
   int lower      = 1;
   int upper      = 30;
   int step       = 1;
   int celsius = lower;
   printf("============================\n");
   printf("| Celsius-Fahrenheit Table |\n");
   printf("============================\n\n");
   printf("----------------------------\n");
   printf("|    Celsius |  Fahrenheit |\n");
   printf("----------------------------\n");
   while (celsius <= upper) {
       fahr = ((9.0/5.0) * celsius) + 32.0;
       printf("| %10d | %11.2lf |\n", celsius, fahr);
       celsius = celsius + step;
   }
   printf("----------------------------\n");
   return 0;
}

2. 소스코드

#include <stdio.h>

/** 
 * print Celsius-Fahrenheit table
 * for fahr = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   double fahr    = 0.0;
   int lower      = 1;
   int upper      = 30;
   int step       = 1;
   int celsius = upper;
   printf("============================\n");
   printf("| Celsius-Fahrenheit Table |\n");
   printf("============================\n\n");
   printf("----------------------------\n");
   printf("|    Celsius |  Fahrenheit |\n");
   printf("----------------------------\n");
   while (celsius >= lower) {
       fahr = ((9.0/5.0) * celsius) + 32.0;
       printf("| %10d | %11.2lf |\n", celsius, fahr);
       celsius = celsius - step;
   }
   printf("----------------------------\n");
   return 0;
}

3. 실행 및 검증

$ ./a.out         
============================
| Celsius-Fahrenheit Table |
============================

----------------------------
|    Celsius |  Fahrenheit |
----------------------------
|         30 |       86.00 |
|         29 |       84.20 |
|         28 |       82.40 |
|         27 |       80.60 |
|         26 |       78.80 |
|         25 |       77.00 |
|         24 |       75.20 |
|         23 |       73.40 |
|         22 |       71.60 |
|         21 |       69.80 |
|         20 |       68.00 |
|         19 |       66.20 |
|         18 |       64.40 |
|         17 |       62.60 |
|         16 |       60.80 |
|         15 |       59.00 |
|         14 |       57.20 |
|         13 |       55.40 |
|         12 |       53.60 |
|         11 |       51.80 |
|         10 |       50.00 |
|          9 |       48.20 |
|          8 |       46.40 |
|          7 |       44.60 |
|          6 |       42.80 |
|          5 |       41.00 |
|          4 |       39.20 |
|          3 |       37.40 |
|          2 |       35.60 |
|          1 |       33.80 |
----------------------------

4. 마무리

위에서 작성한 코드에서 Exercise 1-4와 차이를 남겨보면 아래와 같습니다.

#include <stdio.h>

int main(int argc, char** argv)
{
   /* 생략 */
   
   int celsius = upper;
   
   /* 생략 */
   while (celsius >= lower) {
       /* 생략 */
       
       celsius = celsius - step;
   }
   
   /* 생략 */
}

이번 문제에서 섭씨를 순서를 역순으로 하기 위해서는 역으로 1씩 감소해야 합니다.

10 카운트 다운의 예가 적당하겠네요.

10, ... 5, 4, 3, 2, 1

때문에 celsius 초기값을 아래와 같이 lower -> upper로 수정하였습니다.

celsius = upper;

반복 조건을 수정하였습니다.

celsius가 1보다 크거나 같으냐!

while (celsius >= lower) {
   /* 생략 */
}

마지막으로 celsius의 값을 1씩 감소시켰습니다.

celsius = celsius - step;

Exercise 1-5 문제는 값을 역으로 출력하는 것을 통해서 반복문에 사용법을 익히라는 문제 같습니다.

문제의 앞 부분에 for, while 문에 대해 언급하고 있네요.

다음은 Exercise 1-6 풀어보겠습니다.

문제풀이 | The C Programming Language (K&R): Exercise 1-4

sync86 — Mon, 4 May 2026 16:09:26 +0900

책: The C Programming Language (K&R)

본문의 연습문제는 저작권 이슈로 그 내용을 직접적으로 언급하지 않습니다. 이점 양해 바랍니다.

Exercise 1-4. 섭씨-화씨 역산과 연산 우선순위

Exercise 1-4 문제는 Exercise 1-3에서 소개한 예제를 기반으로 섭씨에서 화씨로 역산하는 문제입니다.

1. 분석

섭씨에서 화씨를 구하는 공식

F = (9/5) * 섭씨(C) + 32

2. 소스코드

#include <stdio.h>

/** 
 * print Celsius-Fahrenheit table
 * for celsius = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   int fahr       = 0;
   int lower      = 0;
   int upper      = 300;
   int step       = 20;
   int celsius    = lower;
   printf("============================\n");
   printf("| Celsius-Fahrenheit Table |\n");
   printf("============================\n\n");
   printf("----------------------------\n");
   printf("|    Celsius |  Fahrenheit |\n");
   printf("----------------------------\n");
   while (celsius <= upper) {
       fahr = ((9.0/5.0) * celsius) + 32.0;
       printf("| %10d | %11d |\n", celsius, fahr);
       celsius = celsius + step;
   }
   printf("----------------------------\n");
   return 0;
}

3. 실행 및 검증

$ ./a.out         
============================
| Celsius-Fahrenheit Table |
============================

----------------------------
|    Celsius |  Fahrenheit |
----------------------------
|          0 |          32 |
|         20 |          68 |
|         40 |         104 |
|         60 |         140 |
|         80 |         176 |
|        100 |         212 |
|        120 |         248 |
|        140 |         284 |
|        160 |         320 |
|        180 |         356 |
|        200 |         392 |
|        220 |         428 |
|        240 |         464 |
|        260 |         500 |
|        280 |         536 |
|        300 |         572 |
----------------------------

4. 마무리

Exercise 1-4는 기존 코드를 기반으로 바뀐 부분만 남기자면 아래와 같습니다.

int main(int argc, char** argv)
{
   int fahr       = 0;
   
   /* 생략 */
   
   int celsius    = lower;
   
   /* 생략 */
   
   printf("| Celsius-Fahrenheit Table |\n");
   
   /* 생략 */
   
   printf("|    Celsius |  Fahrenheit |\n");
   
   /* 생략 */
   
   while (celsius <= upper) {
       fahr = ((9.0/5.0) * celsius) + 32.0;
       printf("| %10d | %11d |\n", celsius, fahr);
       celsius = celsius + step;
   }
   
   /* 생략 */
}

다만, 눈치채신 분들도 계시겠지만, (9.0 / 5.0) * calsius + 32.0 수식을 보면 부동 소수점이 사용된 것을 확인할 수 있습니다.

부동 소수점과 수학에서 실수와는 표현은 비슷하나 엄연히 다른 측면이 있습니다.
이에 대해서 설명하는 것은 자신 없습니다.

현대 컴파일러는 수식에서 타입이 다른 부분이 있다면, 범위가 큰 타입으로 형변환을 자동으로 실행합니다.
수학의 분자 더하기에서 문모가 다를 때 분모를 일치 시켜서 계산하는 것과 유사합니다.

위의 코드를 기반으로 다시 작성하였습니다.

#include <stdio.h>

/** 
 * print Celsius-Fahrenheit table
 * for fahr = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   double fahr    = 0.0;
   int lower      = 1;
   int upper      = 30;
   int step       = 1;
   int celsius = lower;
   printf("============================\n");
   printf("| Celsius-Fahrenheit Table |\n");
   printf("============================\n\n");
   printf("----------------------------\n");
   printf("|    Celsius |  Fahrenheit |\n");
   printf("----------------------------\n");
   while (celsius <= upper) {
       fahr = ((9.0/5.0) * celsius) + 32.0;
       printf("| %10d | %11.2lf |\n", celsius, fahr);
       celsius = celsius + step;
   }
   printf("----------------------------\n");
   return 0;
}

실행 결과는 아래와 같습니다.

$ ./a.out 
============================
| Celsius-Fahrenheit Table |
============================

----------------------------
|    Celsius |  Fahrenheit |
----------------------------
|          1 |       33.80 |
|          2 |       35.60 |
|          3 |       37.40 |
|          4 |       39.20 |
|          5 |       41.00 |
|          6 |       42.80 |
|          7 |       44.60 |
|          8 |       46.40 |
|          9 |       48.20 |
|         10 |       50.00 |
|         11 |       51.80 |
|         12 |       53.60 |
|         13 |       55.40 |
|         14 |       57.20 |
|         15 |       59.00 |
|         16 |       60.80 |
|         17 |       62.60 |
|         18 |       64.40 |
|         19 |       66.20 |
|         20 |       68.00 |
|         21 |       69.80 |
|         22 |       71.60 |
|         23 |       73.40 |
|         24 |       75.20 |
|         25 |       77.00 |
|         26 |       78.80 |
|         27 |       80.60 |
|         28 |       82.40 |
|         29 |       84.20 |
|         30 |       86.00 |
----------------------------

원래의 Celsius의 초기값이 0, Step이 20입니다.

실제 컴파일하고 실행해보니 차이가 나지 않아 조금 범위를 수정하였습니다.

참고바랍니다.

마지막으로 Celsius는 정수형을 유지하고, Fahrenheit의 값만 double 형으로 수정하였습니다.

Celsius는 통상적으로 영상/영하 몇도라는 단위로 많이 쓰입니다.

그래서 Celsius는 정수형 그대로 사용하였고, Fahrenheit만 double으로 부동 소수점으로 변환하였습니다.

다음은 Exercise 1-5 풀어보겠습니다.

문제풀이 | The C Programming Language (K&R): Exercise 1-3

sync86 — Tue, 28 Apr 2026 23:44:02 +0900

책: The C Programming Language (K&R)

본문의 연습문제는 저작권 이슈로 그 내용을 직접적으로 언급하지 않습니다. 이점 양해 바랍니다.

Exercise 1-3은 책속에 예제로 제공된 화씨 -> 섭씨 변환 테이블에 타이틀을 추가하는 문제입니다.

#include <stdio.h>

/** 
 * print Fahrenheit-Celsius table
 * for fahr = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   int fahr, celsius;
   int lower, upper, step;
   lower = 0;               /* lower limit of temperature scale */
   upper = 300;             /* upper limit */
   step = 20;               /* step size */
   fahr = lower;
   while (fahr <= upper)
   {
       celsius = 5 * (fahr-32) / 9;
       printf("%d\t%d\n", fahr, celsius);
       fahr = fahr + step;
   }
   return 0;
}

위 예제는 책에서 발췌한 소스코드입니다.

우선 이전에 Exercise 1-1 예제에서 언급했던 제가 선호하는 스타일로 코드를 수정하였습니다.

이것이 C99 표준입니다.

$ cc exercise1-3.c

위 명령으로 실행하면 a.out 파일이 생성되는데 아래와 같은 결과를 확인할 수 있습니다.

여담.

방해될 수 있는 요소가 있는 여담이지만, 또 하나 제가 선호하는 스타일은 아래의 코드와 같습니다.

아래와 같은 형태를 좀 더 선호합니다.

#include <stdio.h>

/** 
 * print Fahrenheit-Celsius table
 * for fahr = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   int lower   = 0;       /* lower limit of temperature scale */
   int upper   = 300;     /* upper limit */
   int step    = 20;      /* step size */
   int fahr    = lower;
   int celsius = 0;
   
   while (fahr <= upper)
   {
       celsius = 5 * (fahr-32) / 9;
       printf("%d\t%d\n", fahr, celsius);
       fahr = fahr + step;
   }
   return 0;
}

주석 (Comment)

가장 먼저 주석에 대해서 설명이 나옵니다.

주석은 코드에 추가로 설명을 다는 것인데, 이 주석은 컴파일할 때 코드로 변환되거나 그러지 않습니다.

때문에 주석에서는 일기를 작성하셔도 되고, 메모를 작성해도 됩니다.

주로 프로젝트에 투입되었다면, 혼자가 아닌 여러명이 작업을 할 경우가 많습니다.

이 때는 개인적인 이야기 보다 코드에서 전부 표현하기 어려운 내용을 위주로 기록하면 됩니다.

/* (내용) */

위 내용은 C언어에서 기본 주석 형태입니다.

// (내용)

간혹 위 형태의 주석을 보신적 있을텐데, 이것은 C++에서 지원하는 주석 형태입니다.

C표준으로 정식으로 포함된 것은 C99입니다.

ISO/IEC 9899:1999 (C99)

C언어에서 위 주석을 보신적 있으시다면, 아마도 Visual C++에서 확률이 큽니다.

Visual C++ 프로젝트를 생성하고 기본은 C++ 컴파일러가 선택됩니다.

따라서 위 주석은 C++ 컴파일러에 의해 번역되어 에러가 없었을 겁니다.

책에서 주석은 아래와 같습니다.

/* print Fahrenheit-Celsius table
   for fahr = 0, 20, ..., 300 */

다만, 주석의 형태를 제가 선호하는 형태로 아래와 같이 수정하였습니다.

/** 
 * print Fahrenheit-Celsius table
 * for fahr = 0, 20, ..., 300
 */

변수 (Variable)

변수는 값을 일시적으로 기억할 때 사용하는 언어의 기능으로, 컴퓨터 메모리의 특정 영역을 의미합니다. 세부적으로는 복잡한 메모리 주소에 사람이 이해하기 쉬운 이름을 붙여놓은 것이죠.

변수를 다룰 때 프로그래머가 반드시 이해해야 할 두 가지 필수 개념은 값의 범위와 생존 범위입니다.

값의 범위
생존 범위

값의 범위

변수에서 값의 범위는 숫자가 어디서부터 어디까지인지를 정하는 것입니다. 단순히 1~5, 0~1000 같은 범위를 지정한다고 보면 됩니다. 하지만 컴퓨터 메모리는 무한하지 않기 때문에 언어에서는 이를 더 세부적인 타입으로 관리합니다.

정수: 자연수, 0, 음수를 포함합니다. 사람은 인지적 제한으로 모든 연락처를 기억하지 못하듯, 컴퓨터도 메모리 제한으로 무한한 정수를 표현할 수 없습니다. 따라서 기본 제공 범위를 넘어서는 거대한 수를 다뤄야 한다면 별도의 외부 라이브러리를 고려해야 합니다.
실수: 수학의 실수와 유사하지만, 컴퓨터는 이를 근사치로 저장합니다.
- 정밀도: 단정밀도(float)와 배정밀도(double)로 나뉘며, 소수점 이하 몇 자리까지 정확하게 표현할 수 있는지를 다룹니다.
- 주의: 근사치 저장 방식 특성상 소수점 수치가 정확해야 하는 곳(금융권 계산, 정밀 물리 시뮬레이션 등)에서는 반드시 꼼꼼한 검증이 필요합니다. 더 깊은 내용은 IEEE 754 표준을 참고하세요. (영어입니다.)

생존 범위

메모리는 유한하기 때문에, 수명이 다한 변수를 즉각 소멸시켜야 다른 데이터가 들어올 공간이 생기기 때문이죠. 변수는 임시로 기억할 때 사용하는 언어의 기능입니다. 따라서 "이 데이터를 얼마나 오래 기억할 것인가?"가 중요합니다.

이는 변수가 메모리에서 언제까지 살아있을지를 결정하는 것이며, 프로그래머가 지정할 수 있습니다.
보통 { } 블록 안에서 선언되어 사용되다가, 블록이 끝나면 냉정하게 소멸하여 메모리 공간을 반납합니다.
이러한 생존 범위 제약 역시 유한한 메모리를 효율적으로 재사용하기 위한 규칙입니다.

루프 (Loop)

루프는 특정한 조건이 만족될 때까지 동일한 작업을 반복하여 결과를 얻어야 할 때 사용하는 문 입니다. 프로그래밍에서 반복문을 사용하는 이유는 단순히 코드를 줄이기 위함이 아니라 데이터의 양이 아무리 많아져도 동일한 로직으로 처리하기 위해서입니다.

C언어에서 대표적으로 사용하는 반복문은 for와 while입니다. 이번 챕터 예를 보면 while 문만 사용되었다는 점을 확인할 수 있습니다.

while 루프의 특징

조건 우선: while (조건) 형식을 취하며, 괄호 안의 조건이 '참'인 동안에만 블록 내부의 코드를 실행합니다.
유연성: 반복 횟수가 명확하지 않거나, 특정 상태에 도달할 때까지 계속 돌아야 하는 상황(예: 사용자 입력 대기, 네트워크 신호 대기 등)에 적합합니다.

while( {condition } )
{
}

루프 작성 시 주의할 점

종료 조건의 확실함: 루프 내부에서 조건을 '거짓'으로 만드는 장치가 없다면, 프로그램은 영원히 멈추지 않는 무한 루프(Infinite Loop)에 빠져 메모리와 CPU 자원을 갉아먹게 됩니다.
가독성: while은 자유도가 높은 만큼 코드가 지저분해지기 쉽습니다. 반복 횟수가 명확하다면 for문을, 조건에 따른 반복이 중요하다면 while문을 선택하는 안목이 필요합니다.

포맷 스트링 (Format String)

printf 함수에서 데이터를 어떤 모양으로 출력할지 결정하는 규격입니다. 큰따옴표 "" 안에 %로 시작하는 기호를 넣어 사용하며, 뒤에 오는 변수의 값을 해당 위치에 치환하여 보여줍니다.

대표적인 서식 지정자

구분	설명
%d	정수(Decimal)를 출력합니다.
%f	실수(Float)를 출력합니다.
%s	문자열(String)을 출력합니다.
%c	문자(Character) 한 개를 출력합니다.

※ 참고: 현대 언에서는 타입에 따라 %ld를 사용해야 하는 경우도 있습니다.

좀 더 '이쁘게' (폭 지정)

우리가 1-3 연습문제를 수정하면서 가장 공들여야 할 부분입니다. 숫자의 길이에 상관없이 줄을 맞추고 싶을 때 사용합니다.

%3d: 정수를 출력하되, 무조건 3칸의 공간을 확보하고 오른쪽으로 정렬합니다.
%6.1f: 실수를 출력하되, 전체 6칸의 공간을 확보하고 소수점 아래는 1자리만 표시합니다.

왜 중요한가?

컴퓨터는 기본적으로 왼쪽 정렬을 수행하지만, 숫자 데이터(특히 표 형태)는 우측 정렬이 되어 있어야 사람이 읽기 편합니다. 포맷 스트링은 바로 그 '가독성'을 위해 사용하는 서식입니다.

연산자 (Operaters)

연산자는 CPU의 가장 기본적이고 핵심적인 기능입니다. 이번 글에서는 사칙연산을 넘어선 '오칙연산'에 대해 소개합니다.

왜 5칙연산인가?

우리가 흔히 아는 사칙연산(+, -, *, /) 외에 프로그래밍에서는 아주 중요한 연산자가 하나 더 있습니다.

나머지 연산자 (%): 나눗셈을 하고 남은 '나머지' 값을 구합니다. 홀수/짝수 판별이나 특정 범위 내의 숫자를 순환시킬 때 필수적입니다.

= (대입 연산자)

수학에서 =은 좌변과 우변이 같다는 뜻이지만, 프로그래밍에서는 '연산자'입니다.

의미: "우변에 있는 값을 계산해서 좌변에 있는 메모리(변수)에 집어넣어라!"라는 동작을 수행합니다.
그래서 프로그래밍에서는 이를 대입 연산자(Assignment Operator)라고 부릅니다.

연산자 우선순위

연산자 사이에는 서열이 있습니다.

수학과 마찬가지로 곱셈, 나눗셈, 나머지가 덧셈, 뺄셈보다 먼저 계산됩니다.
주의할 점: 대입 연산자(=)는 우선순위가 매우 낮습니다. 우변의 모든 계산(사칙연산 등)이 다 끝나고 나서야 마지막에 변수에 값이 담기게 됩니다.

Exercise 1-3

위 코드를 컴파일하고 실행하면 화씨 -> 섭씨 변환 테이블 형태로 나옵니다.

이번 장에서 주석, 변수, 연산자, 반복문, printf 함수에서 사용할 수 있는 포맷 스트링에 대한 방대한 설명이 갑자기 나옵니다.

이렇게 짧은 구간에 방대한 내용이 압축되어 소개되는 것은 기존에 언어를 사용했다는 전제가 깔려 있는 것 같습니다.

/* (생략) */

int main(int argc, char** argv)
{
    /* (생략) */
    printf("Fahrenheit-Celsius Table\n");
    while (fahr <= upper)
    /* (생략) */
}

위 코드에서 while문 위 printf("..."); 만 추가하면 끝나는 문제입니다.

그래서 최종적으로 아래와 같이 코드를 작성하였습니다.

#include <stdio.h>

/** 
 * print Fahrenheit-Celsius table
 * for fahr = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   int lower   = 0;       /* lower limit of temperature scale */
   int upper   = 300;     /* upper limit */
   int step    = 20;      /* step size */
   int fahr    = lower;
   int celsius = 0;
   
   printf("Fahrenheit-Celsius Table\n"); 
   
   while (fahr <= upper)
   {
       celsius = 5 * (fahr-32) / 9;
       printf("%d\t%d\n", fahr, celsius);
       fahr = fahr + step;
   }
   return 0;
}

위 코드를 컴파일한 후 실행 결과는 아래와 같습니다.

$ ./a.out
Fahrenheit-Celsius Table
0	-17
20	-6
40	4
60	15
80	26
100	37
120	48
140	60
160	71
180	82
200	93
220	104
240	115
260	126
280	137
300	148

최종적으로 서식 문자열과 Escape Character을 활용하여 아래와 같이 소스코드를 작성하였습니다.

#include <stdio.h>

/** 
 * print Fahrenheit-Celsius table
 * for fahr = 0, 20, ..., 300
 */

int main(int argc, char** argv)
{
   int fahr, celsius;
   int lower, upper, step;
   lower = 0; /* lower limit of temperature scale */
   upper = 300; /* upper limit */
   step = 20; /* step size */
   fahr = lower;
   printf("============================\n");
   printf("| Fahrenheit-Celsius Table |\n"); // 제목 추가
   printf("============================\n");
   printf("\n");
   printf("----------------------------\n");
   printf("| Fahrenheit |     Celsius |\n");
   printf("----------------------------\n");
   while (fahr <= upper) {
       celsius = 5 * (fahr-32) / 9;
       printf("| %10d | %11d |\n", fahr, celsius);
       fahr = fahr + step;
   }
   printf("----------------------------\n");
   return 0;
}

실행 결과가 조금 더 이쁘게 꾸며봤습니다.

$ ./a.out 
============================
| Fahrenheit-Celsius Table |
============================

----------------------------
| Fahrenheit |     Celsius |
----------------------------
|          0 |         -17 |
|         20 |          -6 |
|         40 |           4 |
|         60 |          15 |
|         80 |          26 |
|        100 |          37 |
|        120 |          48 |
|        140 |          60 |
|        160 |          71 |
|        180 |          82 |
|        200 |          93 |
|        220 |         104 |
|        240 |         115 |
|        260 |         126 |
|        280 |         137 |
|        300 |         148 |
----------------------------

마무리

갑자기 이것저것 많은 내용이 한꺼번에 나오는데, 설명이 너무 압축적으로 되어 있어 당황했네요.

이래서 불친절하다고 했던 것 같네요.

다음은 "The C Programming Language: Exercise 1-4" 문제 풀어보겠습니다.

문제풀이 | The C Programming Language (K&R): Exercise 1-2

sync86 — Tue, 28 Apr 2026 02:54:21 +0900

책: The C Programming Language (K&R)

본문의 연습문제는 저작권 이슈로 그 내용을 직접적으로 언급하지 않습니다. 이점 양해 바랍니다.

Escape Character는 보이지는 않지만, 터미널 (콘솔)화면에서 각 특수한 기능을 가지고 있는 문자를 뜻합니다.

이번 문제는 Escape Character를 입력해서 어떤 결과가 나오는지 확인하라는 문제인 것 같습니다.

Escape Character는 ""(쌍따옴표) 안에 포함되며, \(역슬래쉬)로 시작합니다.

이후 이 문자로 시작한 다음 문자를 보고 그 기능을 결정하게 됩니다.

그래서 보기엔 2개의 문자지만, 단일 문자로 인식하게 됩니다.

책에서 언급하고 있는 Escape Character는 아래의 표와 같습니다.

Escape Character	설명
\n	줄바꿈
\t	탭
\b	백스페이스
\"	"(쌍따옴표) 문자를 출력
\\	\(역슬래쉬) 문자를 출력

\n - 줄바꿈

#include <stdio.h>

int main(int argc, char** argv)
{
  printf("hello,\n world\n");
  return 0;
}

"hello, word" 예제에서 ,(콤마) 다음에 \n Escape Character 문자로 수정하였습니다.

결과는 아래와 같습니다.

$ ./a.out 
hello,
 world

\t - 탭

#include <stdio.h>

int main(int argc, char** argv)
{
  printf("hello,\t world\n");
  return 0;
}

"hello, word" 예제에서 ,(콤마) 다음에 \t Escape Character 문자로 수정하였습니다.

결과는 아래와 같습니다.

$ ./a.out 
hello,	 world

\b - 백스페이스

#include <stdio.h>

int main(int argc, char** argv)
{
  printf("hello,\b world\n");
  return 0;
}

"hello, word" 예제에서 ,(콤마) 다음에 \b Escape Character 문자로 수정하였습니다.

결과는 아래와 같습니다.

$ ./a.out 
hello world

\" - "(쌍따옴표) 문자를 출력

#include <stdio.h>

int main(int argc, char** argv)
{
  printf("hello,\" world\n");
  return 0;
}

"hello, word" 예제에서 ,(콤마) 다음에 \" (쌍따옴표)을 Escape Character 문자로 수정하였습니다.

결과는 아래와 같습니다.

$ ./a.out
hello," world

\\ - \(역슬래쉬) 문자를 출력

#include <stdio.h>

int main(int argc, char** argv)
{
  printf("hello,\\ world\n");
  return 0;
}

"hello, word" 예제에서 ,(콤마) 다음에 \\ (쌍따옴표)을 Escape Character 문자로 수정하였습니다.

결과는 아래와 같습니다.

$ ./a.out 
hello,\ world

Exercise 1-2는 임의의 문자를 넣어서 테스트 해보라는 의미인 것 같습니다.

임의의 문자를 다 해보는 것은 의미가 없을 것 같습니다.

#include <stdio.h>

int main(int argc, char** argv)
{
  printf("hello,\c world\n");
  return 0;
}

Escape Character을 변경하고 실행했을 때 결과는 아래와 같습니다.

$ ./a.out 
hello,c world

제공되지 않는 문자는 위 처럼 "정의되지 않은 동작(Undefined Behavior)"으로 해당 문자를 그대로 출력합니다.

따라서 컴파일할 때 아래와 같은 경고 메시지를 볼 수 있습니다.

$ cc exercise1-2.c 
exercise1-2.c:5:17: warning: unknown escape sequence '\c' [-Wunknown-escape-sequence]
    5 |   printf("hello,\c world\n");
      |                 ^~
1 warning generated.

참고: 위 결과는 clang으로 컴파일 했을 때 발생한 경고 메시지입니다.

마무리

이것저것 Escape Character에 랜덤하게 문자를 넣어보고 실험해보면 될 것 같네요.

다음은 "The C Programming Language: Exercise 1-3" 문제 풀어보겠습니다.

문제풀이 | The C Programming Language (K&R): Exercise 1-1

sync86 — Sat, 25 Apr 2026 14:04:38 +0900

책: The C Programming Language (K&R)

본문의 연습문제는 저작권 이슈로 그 내용을 직접적으로 언급하지 않습니다. 이점 양해 바랍니다.

처음에 아무 생각없이 이 책을 펼쳤는데, The C Programming Language Exercise 1-1을 보며 생각보다 봐야할 게 많다는 사실에 깜짝 놀랐는데, 어떤 내용을 확인해야 하는지 간단하게 정리를 해보았습니다.

Exercise 1-1 풀기전에 확인해야 할 것!

이 책의 초판 발행 년도,

1978년, 제가 가지고 있는 것은 1988년 개정된 2판인데,

초판 발행년도를 감안하면 이 문제는 본인의 시스템에서 "hello, world" 소스코드를 작성하고 컴파일할 수 있는 환경을 직접 구성해보라는 주문에 더 가까운 것 같아요.

왠지 그런 느낌이 듭니다.

당시에는 컴파일러가 이 책의 저자들이 만든 컴파일러가 전부였던 것 같습니다.

책 내용 중에 컴파일러 설치하는 방법에 대해서는 다루지 않고 있습니다.

그런 의미에서 확실히 최근 출간된 책에 비해 불친절하다는 생각이 드네요.

$ cc hello.c

현재는 MSVC, gcc, clang 등 많은 컴파일러가 나와 있습니다.

그래서 이러한 컴파일러를 직접 설치하고 구성할 수 있어야 할 것 같습니다.

설명은 생략하겠지만, 구글에 "OOO에서 OOO 설치 방법", "OOO에서 OOO 컴파일 방법"이라고 검색하면 다 나옵니다.

위와 같이 명령어를 실행하고 컴파일이 정상적으로 잘 되었다면 아래와 같이 a.out 파일이 생성되는데, 이 파일명을 바꿀 수 있습니다.

여기서는 꼭 사용하고 계시는 컴파일러 메뉴얼을 확인해야 해요.

$ ls
a.out hello.c

사실 아래와 같이 -o (소문자) 옵션을 사용하여 원하는 출력되는 파일명을 작성하면 됩니다.

물론 출력되는 파일명 옵션에 대해서 알려드렸습니다.

다만, 책에서는 이 옵션에 대해 언급이 없었습니다.

그래서 이 옵션을 사용하지 않는다고 가정하겠습니다.

$ cc -o hello ./hello.c

C언어의 표준. C89 -> C99 이후 - 최신 표준은 C23 (ISO/IEC 9899:2024)

최근 컴파일러에서 컴파일할 때 오류가 생길 여지가 많아집니다.

책에서 소스코드는 무심하게 아래와 같이 되어 있는데, 최근 컴파일러가 C99 표준 이상을 지원하는 경우가 많습니다.

따라서 아래와 같이 작성하면 컴파일러가 투덜되거나 컴파일을 거절할 수 있다는 점 유의해야 합니다.

#include <stdio.h>

main()
{
    printf("hello, world\n");
}

아래와 같이 변경하는게 좋을 것 같습니다.

#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
    return 0;
}

아니면 아래의 스타일로 해야 합니다. 개인적으로 가장 선호하는 스타일입니다.

#include <stdio.h>

int main(int argc, char** argv)
{
    printf("hello, world\n");
    return 0;
}

main() 함수의 파라미터를 사용하지 않을 거면, 아래와 같은 가이드를 제공하는 곳도 있었습니다.

#include <stdio.h>

int main(int /*argc*/, char** /*argv*/)
{
    printf("hello, world\n");
    return 0;
}

다만, 제가 테스트 했을 때 결과는 아래의 표와 같습니다.

구분	내용
gcc	경고, 오류 없음
clang	경고 (아래 코드 블록 참고)

$ cc --version
Ubuntu clang version 18.1.3 (1ubuntu1)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
$ cc ./hello.c
hello.c:4:24: warning: omitting the parameter name in a function definition is a C23 extension [-Wc23-extensions]
    4 | int main(int /* argc */, char** /* argv */)
      |                        ^
hello.c:4:43: warning: omitting the parameter name in a function definition is a C23 extension [-Wc23-extensions]
    4 | int main(int /* argc */, char** /* argv */)
      |                                           ^
2 warnings generated.

과거 오픈소스 코드를 보다가 아래와 같은 코드를 봤던 기억이 있습니다.

gcc에서는 문제가 없을 것으로 보이지만, clang에서는 역시 유사하게 경고를 확인하였습니다.

#include <stdio.h>

int main(argc, argv)
    int argc;
    char** argv;
{
    printf("hello, world\n");
    return 0;
}

$ cc --version
Ubuntu clang version 18.1.3 (1ubuntu1)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
$ cc ./hello.c
./hello.c:4:5: warning: a function definition without a prototype is deprecated in all versions of C and is not supported in C23 [-Wdeprecated-non-prototype]
    4 | int main(argc, argv)
      |     ^
1 warning generated.

C언어 표준에 따른 main() 함수 변천

구분	K&R 스타일 (1978/1988)	현대적 스타일 (C99~C23)
반환 타입	main() (암묵적으로 int형 반환)	int main(void) (명시적)
파라미터	main(argc, argv) {}	int main(int argc, char** argv) {}
반환값	생략 가능 (Undefined)	return 0; (성공 반환 명시)

경고와 에러 메시지의 차이

컴파일러를 사용하여 컴파일할 때 종종 경고나 에러 메시지를 볼 수 있습니다.

차이는 아래의 표와 같습니다.

구분	설명
경고	경고 메시지만 출력되고, 컴파일은 진행됩니다. 다만, 경우에 따라서는 프로그램이 실행 중 의도하지 않는 동작을 하거나 중단될 수 있습니다.
에러	에러 메시지 출력되며 컴파일은 중단됩니다. 결과 파일인 a.out 파일이 만들어지지 않으므로 반드시 수정해야 합니다.

반환값 용도

아마도 main() 함수에서 반환값은 위에 작성한 코드와 같이 묻지도 따지지도 않고 return 0; 코드를 작성했을 겁니다.

하지만, 이 반환값 용도는 운영체제에서 어플리케이션 종료한 상태를 확인을 위한 용도이죠.

컴파일이 정상적으로 실행되고, 결과물을 실행한 후 쉘에서 아래와 명령어로 확인할 수 있습니다.

참고로 이 명령어 실행 결과에 해당되는 소스코드 및 컴파일 방법은 설명하지 않는데, 위에서 언급했으니 넘어가겠습니다.

$ ./a.out
$ echo $?
0

위의 결과는 당연히 return 0;에 해당되는 결과이구요. 만약에 return 1;로 했다면 echo $?의 결과는 1이 나올겁니다.

#include <stdio.h>

int main(int argc, char** argv)
{
	printf("hello, world\n");
	return -1;
}

그렇다면 return -1;로 수정하고 echo $? 명령을 실행하면 어떤 결과를 내줄까요?

$ ./a.out
$ echo $?
255

즉, 쉘에서 나타낼 수 있는 값의 범위는 0~255임을 확인할 수 있습니다.

근데 왜? 255까지일까요?

이 부분은 이번 내용에서 벗어난다고 생각해서 제외하겠습니다.

더 파야 하지만, 이번 포스팅에 내용에서 벗어나는 것 같습니다.

Exercise 1-1 두번째, 요구사항

망가뜨려라.

의도적으로 코드를 망가뜨렸들 때, 어떤 오류가 나오는지 확인해봐야 합니다.

첵에서는 아래와 같은 코드만 나오는 것 같습니다.

#include <stdio.h>

main()
{
    printf("hello, world\n
    ");
}

위의 코드는 책에서 소개된 코드이고, 실제로 코드는 아래와 같이 작성하였습니다.

#include <stdio.h>

int main(int argc, char** argv)
{
    printf("hello, world\n
    ");
    return 0;
}

이후 빌드와 컴파일, 2개의 경고, 2개의 에러로 실패하였습니다.

일단은 쌍따옴표 사이에 줄바꿈은 허용되지 않는다 정도로만 확이하면 될 것 같습니다.

$ cc --version
Ubuntu clang version 18.1.3 (1ubuntu1)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
$ cc ./hello.c
./hello.c:5:12: warning: missing terminating '"' character [-Winvalid-pp-token]
    5 |     printf("hello, world\n
      |            ^
./hello.c:5:12: error: expected expression
./hello.c:6:5: warning: missing terminating '"' character [-Winvalid-pp-token]
    6 |     ");
      |     ^
./hello.c:8:2: error: expected '}'
    8 | }
      |  ^
./hello.c:4:1: note: to match this '{'
    4 | {
      | ^
2 warnings and 2 errors generated.

마무리

과거 사회 초년생 때, C언어로 프로젝트 경험한 이력이 있습니다.

다만, 옛날에 봤다면 몰랐을 내용인데, 경력이 쌓이다 보니 기존에 보이지 않았던 부분들이 보이기 시작하네요.
다음은 "The C Programming Language: Exercise 1-2" 문제 풀어보겠습니다.

회상 | 약 24년 전, 제가 "수포자"가 된 이유를 드디어 알게된 것 같아요.

sync86 — Sat, 25 Apr 2026 10:49:54 +0900

약 24년 전, 구입했던 "수학의 정석"을 다시 보며

2026년 04월 25일 오늘, 책장을 둘러보다가 낡은 책 한 권이 눈에 들어왔어요.

그 책은 "수학의 정석" 이죠.

2002년 중학교를 졸업하고 고등학교 입학까지 한두 달 정도 여유가 있었는데, 당시 선생님이 이 책은 한번 읽어야 한다고 워낙 강조해서 구입했던 것 같아요.

당시 구입한 이 책을 버리지 않고 보관하고 있다 오늘 다시 꺼내보니 약 24년간 책장에서 빛이 바래버렸네요.

세월의 흔적일까요?

[그림 1] 약 24년 전, 구입한 "수학의 정석" 책 표지

저도 이 책 끝까지 다 보지는 못했지만, 앞 부분 만큼은 정말 열심히 읽었더라고요.

저만 그런건가요?

책장을 넘기며, 당시를 회상하고 있는 중,

집합 단원에 "보기 1" 집합이 될 수 있는 것과 아닌 것을 구분하는 예제를 다시 한번 풀어봤으나, 틀렸습니다.

이 책에서는 (4)가 정답이라고 하네요.

"왜, (4)번이지?"

[그림 2] 집합 보기 1, 상당히 상당히 지저분한 페이지.

고등학생이었을 당시의 제가 남긴 메모를 발견했습니다.

글씨체가 워낙 지저분해서 한눈에 알아보기 어려우시겠지만, "태어난 신생아도 포함? 변화의 요소가 다소 있음?"이라는 내용이었습니다.

다시 생각해도 이상합니다.

왜 (4)번 "한국 남자"가 정답이지?라는 의문이 따라옵니다.

착한 학생의 모임
아름다운 여인의 모임

위 "착한 학생"과 "아름다운 여인"는 확실히 개인별 차이가 있다는 것은 확실합니다.

하지만, 다른 항목들에 대해서 얼핏보면 집합이 아닌 것 같은데, 세부 조건이 있다면 조금 다르게 보였어요.

물론 "착한 학생"도 기준이 있다거나 "아름다운 여인"에 대해서도 최근 기술의 발전으로 기준이 있다고 반박하시면 님의 주장이 맞습니다.

힘센 사람의 모임 (100kgf 무게를 들 수 있는 사람)
빨간 사과의 모임 (빛의 스펙트럼으로 붉은색 파장이 특정 수치 이상인 사과)
한국 남자의 모임 (대한민국 국적을 보유 또는 취득한 남자)

물론 위에서 언급한 세부 조건은 오늘 풀어보다가 떠오른 생각이에요.

이렇게 세부조건이 있다면 "힘센 사람", "빨간 사과", "한국 남자" 모두 선택해야 정답이 아닌가? 싶었죠.

고등학생 입학 전 제가 남긴 메모는 "한국 남자의 모임"은 아마도 신생아이면서, 출생신고 전에 남자도 포함되는가? 였을 겁니다.

그 땐 생각이 더 짧았을 테니, 좀 더 포괄적인 생각은 못 했을거에요.

조금 더 생각해보면 어머니 뱃속에 있는 남자도 포함인가?라는 의문만 커져가는거에요.

마무리

2002년 당시의 모든 기억이 생생하진 않지만, 분명한 건 그때나 지금이나 제 생각은 같다는 점입니다.

"정답이 없다." 하지만, 세부 조건이 있다면 "힘센 남자의 모임", "빨간 사과의 모임", "한국 남자의 모임" 모두 복수 선택한 것이 정답이어야 한다고 생각합니다.

어쩌면 2002년 과거의 나, 지금의 나! 정답보다 내 머릿속에 떠오른 "의문을 해소"하는게 중요했을지도 모르겠다는 생각을 하게 되네요.
이 의문들이 납득되지 않았던 것이 제가 수학을 일찍이 포기하게 된 진짜 이유였을지도 모르겠습니다.

지금 생각해보면 단순히 "왜?" "이게 맞나?" 생각만 했었는데, 선생님께 질문해봐야 겠다는 생각을 1도 못했어요.

지금이라고 다를까요? "다르지 않다. 하지만, 이제는 질문할 수 있는 용기가 있다"라고 답할 것 같네요.

예상하신 반전은 없습니다.

2002년 과거의 나는 기준이 애매한 정의를 정답이라 믿고 넘어가야 하는 상황에서 멈췄으니까요.

후일담

[그림 3] 1966년 초판 발행

이런 내용에 후일담이라니, 상상도 못했죠? 아무 생각없이 마지막 페이지로 넘겨 판권지를 확인해 보았습니다.

1966 初版發行(초판발행)
總改訂第36版(총개정 제36판)

머리에 망치를 제대로 한방 맞은 느낌이 들었습니다.

바로 제가 태어나기도 전에 출간된 책이라는 점입니다.

1966년,

아마도 이 때는 해외여행 같은 것은 꿈도 못 꿀 시기였다는 점 '한국 남자'라는 정의는 지금보다 훨씬 정적이고 고정된 관념이었을지도 모르겠습니다.

그리고 빨간 사과를 색의 스펙트럼을 분석할 수 있다는 생각을 전혀 못했을 겁니다.

갑자기 생각이 복잡다난해집니다.

당시의 또는 지금의 제가 이해를 못했는지 24년이 흐른 지금에서야 조금은 알 것 같습니다.

수학적 머리가 부족한 것도 있었지만, 이 문장이 쓰인 당시의 '맥락'을 몰랐기 때문에 포기할 정도로 더 막막하게 느껴졌을 거라 생각합니다.

2002년 고등학교 진학을 앞둔 과거의 나, 그리고 2026년 세월이 흐른 지금의 나! 회상이 교차하는 오늘.

낡은 정석 책 한 권이 저에게 꽤 묵직한 질문을 던져준 하루였습니다.

기본기의 재정의 | "할 줄 아는 것"과 "끝낼 줄 아는 것"

sync86 — Sun, 8 Mar 2026 23:53:56 +0900

기본기란 무엇일까?

우리는 어떤 분야에서든 “기본기가 부족하다.”라는 말을 종종 하거나, 타인으로 부터 듣습니다.

하지만 문득 이런 생각이 들었습니다.

기본기란 무엇을 의미하는 것일까?

고민을 해봤습니다.

대부분의 경우 기본기는 단순히 기초 지식이나 기술을 의미하는 것처럼 사용됩니다.

하지만 오랫동안 이 일을 하며 느낀 것은 조금 다르다고 생각됩니다.

기본기는 단순히 아는 것이 아니라 "어떤 일을 끝까지 완료할 수 있는 능력"에 더 가깝다고 생각합니다.

"할 줄 아는 것"과 "끝낼 줄 아는 것"

“할 줄 아는 것”은 말 그대로 아는 것이죠.

어떤 명령어를 알고 있고, 어떤 기술을 사용할 수 있으며, 어떤 도구를 다룰 수 있다는 의미입니다.

하지만 실전에서는 할 줄 안다고 해서 일을 끝낼 수 있는 경우는 많지 않습니다.

현실의 작업 환경에서는 예상하지 못한 오류나 환경 변화, 시스템 충돌 같은 변수들이 끊임없이 발생합니다.

역할과 지식

예를 들어 봅시다.

프론트엔드 개발자

프론트엔드 개발자의 역할은 웹을 통해 접속한 사용자가 실제로 보게 되는 UI를 구현하는 것이라 생각합니다.

프론트엔드의 역할을 완료하기 위해서는 최근 React나 Vue 같은 프레임워크를 익히게 됩니다.

그러나 이것만으로 부족하죠.

이러한 기술을 안다고 해서 곧바로 사용자에게 제공할 수 있는 화면을 완성할 수 있는 것은 아니라는 사실을 알게됩니다.

그래서 HTML, CSS, JavaScript를 익히고,

나아가서는 HTML, CSS, JavaScript가 동작하는 브라우저에 대해서 공부하는 자신을 발견할 수 있을 겁니다.

익히면서 여러가지 시행착오를 거치고 나야 실제로 동작하는 결과물을 만들 수 있다는 사실을 알게됩니다.

시스템 엔지니어

프론트엔드나 백엔드 개발자가 만든 프로그램이 안정적으로 운영되는 시스템을 구축하고 운영하는 일이죠.

이를 위해 하드웨어에 대한 이해와 리눅스 같은 운영체제에 대한 지식과 경험이 필요합니다.

여기에 더해 실제 기업 환경에서는 네트워크, 방화벽, 스토리지 같은 지식들도 같이 필요하게 됩니다.

하지만 여기서도 단순한 지식만으로는 충분하지 않습니다.

서로가 유기적으로 연결되어 있다는 사실을 깨달아야 합니다.

지식은 그저 시작일 뿐입니다.

작업을 완료하기 위해 필요한 것

내가 생각하는 기본기는 세 가지 요소로 이루어져 있다고 생각합니다.

지식, 절차, 그리고 영향도

먼저 지식이 필요합니다.
하지만 지식만으로는 충분하지 않죠.

지식이 재료라면 절차는 레시피라 할 수 있는데, 전체 작업의 흐름을 이해하는 것을 뜻합니다.

작업의 흐름을 이해하지 못하면 멈추게 되겠죠.

그리고 마지막으로 중요한 것이 영향도입니다.

내가 수행한 작업이, 다른 시스템이나 다른 사람의 업무에 어떤 영향을 미칠지 예측할 수 있는 능력을 말합니다.

예를 들어 이런 질문들이다.

이 코드를 수정하면 다른 모듈에는 어떤 영향이 있을까?
이 설정을 변경하면 어떤 서비스들에 영향을 미칠까?

이런 판단은 결국 수많은 시행착오와 실패를 통해 얻어지는 경험일 것입니다.

이 과정 속에 수많은 시도와 고생을 하게되죠.

하지만 이 과정은 반드시 필요하다고 생각합니다.

영향도를 이해하지 못하면 언제 터질지 모르는 시한폭탄과 같습니다.

반대로 이를 이해하는 사람은 리스크를 최소화하면서 가장 효율적인 선택을 할 수 있죠.

이러한 ‘영향도’의 중요성을 실감했던 일이 얼마 전 있었습니다.

사례: 그래픽 드라이버 업그레이드하며 겪은 일

얼마전에 그래픽 드라이버를 업그레이드 작업을 진행하였습니다.

그래픽 카드가 장착된 서버였는데, 이 서버에 Ollama 서비스를 설치하는 작업이었죠.

이 서버는 운영되는 서비스가 있었어요.

운영되는 중간에 Ollama 설치하였으나 잘 동작하지 않았습니다.

당시 서버에 설치된 CUDA 버전이 11.4버전이었는데, 이 때문에 그래픽 드라이버 업데이트가 필요했습니다.

CUDA 12.2 버전을 설치하기로 결정했습니다.

당시 CUDA 13.1 버전이 최신이었으나, 기존에 서비스에 영향을 줄 것 같아 최신 버전으로 선택하지 못했습니다.

방문 일정을 다시 잡아 설치를 진행하였죠.

파일을 서버에 전송하고, 미처 확인하지 못한 것이 있었어요.

RPM(Redhat Package Manager)으로 설치되어 있었던 것이었죠.

그러나 제가 준비한 것은 NVIDIA에서 제공하는 스크립트 형태였어요.

NVIDIA에서 제공하는 스크립트로 설치를 했으나 커널 모듈에 로드된 모듈을 때문에 실패하였죠.

순간 긴장되고 손이 떨렸어요.

운영되는 서버라 조심해야 했거든요.

우선은 기존에 한번 재부팅이 필요하고 시간은 약 1시간 소요된다고 전달했는데, 서버 재부팅 한번 더 필요하다고 전달하였어요.

당시 담당자도 짧은 시간이라 그 자리에서 승인을 해준 것 같았어요.

커널 모듈을 제거하고 재부팅, 이후 NVIDIA 드라이버 설치 후 재부팅하여 설치를 진행했습니다.

이 외에도 순간순간 변수가 있었으나 적절히 대응하였고, 설치는 마무리할 수 있었어요.

마무리

저는 기본기를 이렇게 정의하고 싶습니다.

기본기는 '기술력'이 아니라 '완결력'이다.

단순히 기술을 익히는 것을 넘어 전체 맥락을 이해하고 작업을 끝까지 완수할 수 있는 힘입니다.

내가 만든 결과물이 어떤 영향을 만들지까지 책임질 수 있을 때 비로소 기본기가 있다고 말할 수 있을 것입니다.

여러분이 생각하는 진짜 기본기는 무엇일까요?