Hello World!

[❄️회고] 대학교 졸업했습니다

최연재 — Sun, 8 Mar 2026 14:34:19 +0900

안녕하세요, 정말 오랜만에 올리는 글입니다. 제목 그대로 대학을 졸업했습니다. 졸업한 지금 생각해 보면 어느 학기보다 8학기가 가장 힘들고 지쳤던 것 같습니다. 여러 일을 겪고, 여러 도전을 했으며 그 결과 취업준비도 종지부를 찍게 되었습니다.

취업과 관련된 이야기는 추후 별도의 글로 올릴 예정이라 이번 글에서는 대학 졸업에 대한 이야기만 해보겠습니다.

입학

저는 22학번으로 숙명여자대학교 소프트웨어융합전공에 입학했습니다. 그때까지만 해도 여전히 코로나 상황으로 인해 대면 입학식을 하지 못했습니다.

이전까지 말한 적은 없었는데 면접형 수석으로 대학에 붙었었습니다! 졸업까지 했으니 한 번 언급해봅니다.

학기별 후기

학기가 끝날 때마다 간단하게 회고를 적었는데, 성적과 함께 학기별 수강 후기를 적어보겠습니다.

1학년 1학기 (2022-1학기)

4.3/4.3

저는 대학원에 가는 걸 목표로 대학에 입학했었기에 성적에 신경을 썼었습니다. 이때 4.3으로 학기 최우등생 상장을 받았습니다.

1학년 2학기 (2022-2학기)

4.3/4.3

1학기까지는 코로나로 인해 비대면이 혼용되었는데, 해당 학기부터 전면 대면수업으로 진행되었습니다. 이때까지도 교양을 많이 수강했는데 제 대학생활 중 가장 좋아했던 교양인 <신화의 이해>를 들었습니다. 그리스 로마 신화를 다루고 신화 속 이야기의 의미를 배우는 수업인데 제가 그리스 로마 신화를 어릴 때부터 많이 읽어서 더욱 재밌었습니다. 당시 중간고사를 잘 봤는데 교수님께서 "중간고사 서술형을 잘 썼던데 수강생들 앞에서 읽어줄 수 있는지" 여쭤보시기도 했습니다.

학기우등생으로 상장을 받았습니다.

2학년 1학기 (2023-1학기)

4.2/4.3 (4.45/4.5)

2학년 때부터 본격적으로 동아리 활동을 많이 하기 시작했습니다. 이때 처음으로 A0를 받았는데 아쉽다기보다는 성적에 대한 부담을 내려놓았던 것 같습니다.

2학년 2학기 (2023-2학기)

4.24/4.3 (4.47/4.5)

4학년을 제외하고 1학기와 4학기가 가장 적은 학점을 들은 학기입니다. 이전 학기보다 시간이 남아서 제 진로에 대해서 고민을 많이 했습니다. 이때까지는 대학원만 생각하며 다른 활동을 안 했었는데, 다양한 분야로부터의 도전을 계획했습니다.

제가 학기 성적을 기준으로 우등생 상장을 받은 마지막 학기이기도 합니다.

️ 3학년 1학기 (2024-1학기)

4.12/4.3 (4.41)

해당 학기는 ALGOS 동아리 회장으로 SMUPC 출제 및 총괄을 학기 내내 병행하면서 6전공을 했습니다. 당시 회장이라는 직책에서 오는 부담도 있었고, 화목 시간표가 9-6 전공 4개였습니다. 그래서 학교 어디에서든지 앉기만 하면 1분 안에 잠드는 스킬을 얻었고, 커피도 정말 많이 마셨던 학기입니다. 동기랑 공강 때마다 소파 찾아서 자고, 출퇴근길 지하철에 힘들었던 기억이 많이 납니다.

중간고사 일주일 전에 심한 열몸살감기에 걸려서 시험 직전 주말에 병원 가서 주사 맞고 시험기간 내내 아팠습니다. 그래서 몇 과목 중간고사 성적이 개인적으로 아쉬웠기에 기말을 진짜 열심히 준비했었습니다. 최종적으로는 위와 같은 성적을 받았습니다.

❄️ 3학년 2학기 (2024-2학기)

4.15/4.3 (4.43/4.5)

제 인생에 3학년 1학기만큼 힘든 학기는 없을 거라 생각했는데 2학기에는 ALGOS, ICPC Sinchon 2개의 동아리에서 회장을 맡았습니다. 학기 중에 대회를 주최한 건 아니었고, 3-1학기에 비해 과목을 적게 들어서 괜찮을 거라고 생각했는데, 3-1학기의 여파가 영향을 미친 학기였습니다.

중간고사 기간에 또 감기에 걸렸고, 시험 내내 편두통이 심했습니다. 중간고사 마지막 일정이 하루에 두 과목을 보는 일정이었는데, 첫 과목을 보고 머리가 너무 아파서 두 번째 시험 강의실을 잘못 찾아갔습니다. 시험 시작 3분 전에 알아서 바로 짐 챙겨서 강의실 옮겨가서 시험을 봤습니다. 인원을 나눠서 보는 시험이라 바로 옆 강의실인 덕분에 지각입실 등의 문제는 없었는데, 시험 끝나고 동기들이 괜찮냐고 많이 걱정해 줬습니다. 시험에 모든 기력을 다 쓰고 기숙사 돌아오자마자 긴장 풀려서 코피 터졌습니다. 결과적으로는 이 날 봤던 두 과목 모두 A+ 나왔습니다.

기말고사 기간에는 학회 일들도 겹쳐서 일주일 내내 하루 수면량 2시간 + 1일 1 식 하면서 공부했습니다. 종강이 21일 토요일이었는데 오후 12시에 기말고사를 보고 바로 도서관에 가서 프로젝트 팀플수업 최종 정리를 했습니다. 오후 8시에 최종 보고서 내고 밤 10시부터 학회 회의가 있어서 기숙사 가는 길에 서브웨이 하나 포장해 가서 회의 끝나고 먹었던 기억이 납니다. 시험 보기 전 아침에 찹쌀볼 하나 먹은 뒤 처음 먹는 밥이었는데 배도 안 고파서 절반 먹지도 못했습니다.

⛄4학년 1학기 (2025-1학기)

4.13/4.3 (4.42/4.5)

3학년을 힘들게 보내서 4학년 때는 힘을 뺐습니다. 졸업프로젝트와 SMUPC 출제를 병행한 학기였습니다. 제가 지금까지 들었던 모든 전공 중 가장 어렵다고 말할 수 있는 컴파일러를 들었는데, 과제하다가 스스로가 답답해서 울었습니다.

☃️4학년 2학기 (2025-2학기)

4.05/4.3 (4.35/4.5)

마지막이라 12학점을 들었습니다. 사실 6학기까지 120학점을 들어서 졸업학점은 10학점만 남았었는데 욕심을 내서 4학년을 보냈습니다. 딥러닝개론 중간을 미끄러져서 기말고사로 복구하려고 노력을 많이 했습니다.

1학년 때의 성적 덕분에 한동안 전체 석차 1등이었는데 최종 2등으로 마무리합니다.

졸업

2026년 2월 20일에 졸업을 했습니다.

그리고 졸업하는 김에 스냅도 찍었습니다!

이렇게 제 대학생활이 끝났네요! 숙명에서의 4년이 정말 행복했고, 멋진 퀸송이가 될 수 있게 저도 노력하겠습니다.

[ 자격증/정보처리기사] 2025년 정보처리기사 2회 필기/실기 합격 후기

최연재 — Sat, 13 Sep 2025 22:22:42 +0900

시험 정보

- 시험명 : 2025년 정기 기사 2회 (필기) [정보처리기사], 2025년 정기 기사 2회 (실기) [정보처리기사]
- 시험일 : 2025.05.10. , 2025.07.19.

필기 합격 후 응시자격을 증명하는 서류를 제출하셔야 합니다.

응시 계기

워낙 유명한 자격증이고 대학교 4학년이 되었으니 응시 자격이 주어져서 응시 여부에 대한 고민은 없었습니다. 전공자라면 대부분 취득하는 자격증이기도 하고, 배운 내용을 복습할 좋은 기회라고 생각해서 응시했습니다.

✍️공부 기록 - 필기

필기의 경우 시나공 기출문제집을 구매했습니다. 공부기간은 3일 이하이고, 문제은행의 비중이 꽤 돼서 기출 문제집만 풀어봤습니다.

시험 후기 - 필기

5월 10일 아침 시험으로 선린인터넷고등학교에서 응시했습니다! 신분증, 수험표, 필통을 챙겨서 출발했습니다. 참고로, 정보처리기사 필기는 시험 기간 내에 응시 가능한 일정 리스트가 주어지고, 리스트 내에서 선택해서 접수 가능합니다. 또한 시험지역에 따라 분할접수하니 본인 지역을 잘 확인하여 열리는 시간에 맞게 접수하시면 됩니다.

필기는 CBT라 컴퓨터실에서 응시하게 됩니다. 비가 많이 오는 날이라 바닥이 미끄러울까 걱정했는데 선린인터넷고등학교 컴퓨터실은 학교에 구비된 슬리퍼를 신고 들어가는 형태라 쾌적했습니다

시험의 경우 100문제를 풀면 되는데, 이론 쪽은 문제은행 형식이라 빠르게 풀 수 있었습니다.

무난하게 합격했습니다ㅎㅎ

✍️공부 기록 - 필기

실기를 위해 이론 비중이 크고, 최신 기출이 포함된 시나공 기본서를 구매해서 2주 정도 공부했습니다.

저는 손으로 써야 암기가 되는 편이라 한 번에 제대로 공부한다는 마음으로 이론 필기에 큰 비중을 두었습니다. 개념의 경우 한글 + 영어 풀네임 + 영어 축약 이름 전부 다 한 번씩은 보시는 걸 추천합니다.

자료구조 + 프로그래밍 언어 파트는 전공자라 별도로 공부하지 않았고 이론서에 수록된 문제는 풀지 않았습니다. 최종적으로는 하루에 1~3개의 챕터를 공부하고 시험 전날에 기출문제집을 풀었습니다.

열품타 기록입니다!

실질적으로 공부한 기간은 위 사진보다 적은데 기간 내에 졸업프로젝트 개발도 조금씩 하고, 소설도 5권 정도 읽었습니다. 시험 당일(19일)에는 일찍 일어나서 1시간 정도 필기를 읽어봤습니다.

시험 후기 - 실기

필기에 이어 실기 시험 당일에도 비가 많이 왔습니다. 참고로 실기의 경우에는 시험을 보는 날이 하나로 고정이고, 미리 확인 가능합니다!

실기의 경우 본가인 대전에서 응시했습니다. 신분증, 필통, 수험표를 챙겨서 용전중학교에 다녀왔습니다. 시험방식이 시험지를 받아서 볼펜으로 푸는 형태이기에 컴퓨터실이 아닌 평범한 반에서 진행되며 볼펜을 꼭 챙기셔야 합니다!

비가 와서 신발 위에 덧신을 신고 해당하는 고사장에서 시험을 봤습니다. 시험 문제는 20문제, 시험 시간은 2시간 30분, 시험 시작 후 1시간부터 퇴실이 가능합니다. 문제를 생각해보면 이론의 경우 기출과 유사한 문제가 꽤 나왔습니다. 프로그래밍 파트는 2022년~2024년 기출보다는 어려웠습니다. (끝나고 후기를 찾아보니 2025년 1회보다는 쉬웠다고 합니다.)

프로그래밍 파트는 주로 C, Java코드를 보고 출력문의 출력결과를 묻는 문제입니다. C에서는 주로 구조체, 포인터를 다루고, Java는 상속관계, static 이 나오는 편인 것 같습니다.

참고로 실기 문제지가 큰 편인데 한 페이지 내 상단에는 문제, 하단에는 연습할 수 있는 란이 넉넉하게 주어집니다. 문제지 내 답란에 답을 적으면 되고, 시험지를 걷어가는 시험이라 답안지와 시험지가 별도로 있는 시험은 아닙니다.

9월 12일에 최종 결과가 나왔고 한 번에 합격했습니다!

2개 틀렸네요

전공에서 배운 내용을 한 번 전체적으로 복습할 수 있어서 좋았습니다. 이제 기사 자격증 보유자가 되었어요!

최근에는 영어 자격증 공부 중인데 결과가 잘 나오면 후기를 올리겠습니다.

[프로그래밍언어론 ] 6장 자료형

최연재 — Sun, 31 Aug 2025 09:44:02 +0900

출처 : 프로그래밍 언어론 : 원리와 실제 (창병모, 인피니티북스, 2021)

6.1 자료형 개요

1) 자료형의 의미

- 자료형

해당 타입의 변수가 가질 수 있는 값들의 집합
그 값들에 적용 가능한 연산들의 모음

2) 기본 자료형

- 사전 정의된 기본 자료형 : boolean, char, int, float, double, ...

- 사용자 정의 기본 자료형

열거형 : 열거된 값들로 이루어진 타입

3) 부분 타입 (subtype)

- 부분 타입

기반 타입(base type)의 일부분 값들로 정의된 자료형
기반 타입의 모든 연산을 부분 타입에 적용 가능
Ada, Pascal

6.2 복합 타입

1) 타입 구성자

- 기본 자료형으로부터 더 복잡한 자료형(복합 타입)을 구성하는 방법

배열 타입 (Array type)
리스트 타입 (List type)
레코드 타입 (Record type)
공용체 (Union type)
포인터 타입 (Pointer type)

- 사용자 정의 타입

2) 구조체(레코드) 타입

- 구조체 : 여러 개의 (필드) 변수들을 묶어서 구성하는 자료형

struct in c
record in Pascal, Ada, ...

- C++의 class

C의 struct를 확장
데이터뿐만 아니라 연산(함수)들을 포함하도록 확장한 자료형

3) 배열 타입

- 배열 타입

같은 타입의 연속된 변수들로 구성하는 자료형
배열 요소(element), 인덱스

- 이차원 배열

선언 : 자료형 배열이름[][]
행 우선(row major order) 배치 : 행부터 배치
열 우선(column major order) 배치 : 열부터 배치

- C의 배열 : 배열의 크기가 정적 결정

- Java의 배열

자료형[] 배열이름 or 자료형 배열이름[]
배열 변수는 참조 변수 ➡️ 배열 변수의 선언 != 배열의 자동 생성
동적 배열 : 배열 크기가 실행 시간에 결정됨

4) 리스트 (list)

- 리스트

항목들의 모음으로 다수의 항목을 집합적으로 처리하는 데 용이
파이썬의 대표적인 자료 구조
원소가 같은 타입일 필요가 없음.

- 부분 리스트 (slicing)

하나의 리스트를 인덱스를 이용해 부분 리스트로 분리
ex) python ➡️ list[start:end]

- Java의 ArrayList

일반적인 배열 : 배열의 크기가 한 번 결정되면 그 크기가 고정
리스트 혹은 동적 배열 : 배열의 크기가 동적으로 변함
Java의 ArrayList : 동적 배열이며, 다양한 타입의 객체를 저장할 수 있음.

5) 포인터 타입 (pointer type)

- 메모리의 위치(주소)를 값으로 사용하는 자료형

- 포인터 변수 관련 구문

T *p; // 포인터 변수 선언
p = E; // 포인터 변수에 대입
*p = E; // 포인터가 참조하는 변수에 대입

- 포인터 관련 연산

malloc(n) : 크기 n의 메모리 할당 및 시작 주소 반환
&x : 변수 x의 포인터 (주소)
*p : 포인터 변수 p에 저장된 포인터 주소 참조

6) 재귀 타입 (Recursive type)

- 타입 정의에 자신의 이름을 사용

6.3 형 변환

1) 자동 형변환 (automatic type conversion)

- 자동으로 형을 변환하는 묵시적 형변환 (implicit type conversion)

- 이항 연산에서 두 피연산자의 자료형이 다른 경우 (C/C++, Java)

- 확정 변환 (widening conversion)

표현 범위가 더 넓은 쪽으로 변환하는 상향 변환 (promotion)
Java에서 자동 형변환은 거의 대부분 확장 변환

2) 축소 변환 (narrowing conversion)

- 확장변환의 반대로 표현 범위가 더 작은 자료형으로 변환

- 대입 변환 (assignment conversion)

대입문의 경우에도 확장 변환인 경우에만 자동으로 수행
축소 변환인 경우에는 자동으로 수행되지 않음.
예외적으로 int 상수에 대해서 byte, short, char에 대입할 때 정보 손실이 없으면 자동 변환

3) 형변환 연산자

- 타입 캐스팅 연산자 (type casting operator) 또는 캐스트(cast)

(자료형) 수식

- 수식에 의해 계산된 값을 명시된 자료형의 값으로 변환

- 정보 손실 발생 가능

6.4 타입과 언어 분류

1) 정적 타입 언어 (statically typed language)

- 변수의 타입이 컴파일 시간에 결정되어 고정되는 언어

- 컴파일 시간에 타입 검사 진행

- Java, C, C++, FORTRAN, Pascal, Scala

2) 동적 타입 언어

- 변수의 타입이 저장되는 값에 따라 실행 중에 바뀔 수 있는 언어

- 실행 시간에 타입 검사 진행

- Perl, Python, Scheme, JavaScript

3) 타입 규칙 (typing rule)

- 타입 규칙 (typing rule)

언어를 설계할 때 프로그램 구성요소의 타입 사용 규칙도 정함
타입 규칙의 엄격성에 따라 강한/약한 타입 언어로 분류

- 강한 타입 언어 (strongly typed language)

엄격한 타입 규칙을 적용하여 (모든) 타입 오류를 찾아낼 수 있는 언어
Java, C#, Python

- 약한 타입 언어 (weakly typed language)

느슨한 타입 규칙을 적용한 언어
C, C++, PHP, JavaScript, Perl

[프로그래밍언어론 ] 5장 의미론

최연재 — Sat, 30 Aug 2025 09:13:15 +0900

출처 : 프로그래밍 언어론 : 원리와 실제 (창병모, 인피니티북스, 2021)

5.0 의미론

1) 의미론의 개요

- 프로그램의 의미와 정확한 정의 및 이해

- 소프트웨어의 정확한 명세

- 소프트웨어 시스템에 대한 검증 혹은 추론

- 컴파일러 혹은 해석기 작성의 기초

2) 의미론의 종류

- 작동 의미론 (Operational Semantics)

프로그램의 의미를 프로그램 실행(작동) 과정으로 설명

- 표기 의미론 (Denotational Semantics)

프로그램의 의미를 함수 형태로 정의하여 설명

- 공리 의미론 (Axiomatic Semantics)

프로그램의 시작 상태와 종료 상태를 논리적 선언(assertion) 형태로 정의하여 설명

5.1 수식의 의미

1) 수식

- 상태에서 수식의 값

- V : (State, Expr) → Value

2) 연산자 우선순위

- 연산자를 실행하는 순서

3) 연산자 결합성

- 동일한 우선순위를 갖는 연산자가 두 개 이상 인접한 경우 무엇을 먼저 수행하느냐에 대한 규칙

4) 결합성

- 좌결합 (left associative)

왼쪽부터 우선 결합하는 규칙으로 왼쪽에서 오른쪽으로 수행
대부분의 이항 연산자가 따르는 규칙
좌순환 규칙(left recursive rule)으로 표현

- 우결합 (right associative)

오른쪽부터 우선 결합하는 규칙
대부분의 단항 연산자들과 대입 연산자들이 따르는 규칙
우순환 규칙(right recursive rule)으로 표현

5.2 구조적 프로그래밍

1) 구조적 프로그래밍

- 기본 아이디어

goto문을 사용하지 않고 시작과 끝 지점이 일정한 구조적 구문 사용
프로그램에 있는 각각의 구조와 그 사이의 관계를 이해하면 프로그램 전체를 보다 십게 이해 가능

- 구조적 프로그램 정리

어떤 계산함수든 순차, 서택, 반복의 3가지 제어 구조로 표현 가능

2) 설탕 구문 (Syntactic sugar)

- 프로그래밍 편의를 위해 제공하는 부가적인 문장

ex)

do while 문 ➡️ while문 사용
for 문 ➡️ while문 사용
switch문 ➡️ if문 사용

5.3 문장의 의미

1) 작동 의미론 (Operational Semantics)

- 기본 아이디어

프로그램의 의미를 프로그램 실행 과정을 설명
실행 과정을 상태 변환 (state transform) 과정으로 설명
각 문장 s마다 상태 변환 함수 정의

2) 문장의 의미

- 문장 S의 의미

문장 S가 전상태 s를 후상태 s'으로 변경시킨다.
상태 변환

- 상태 변환 함수 (state transform function)

Eval : (State, Statement) → State
Eval(s,S) = s' for each statement S

ex) 대입문, 복합문의 의미

3) let 문

- 실행 과정

변수 선언을 만남 ➡️ 변수가 유효해짐
- 이 변수를 위한 엔트리를 실행 전상태 s에 추가
이 상태에서 문장 S를 실행
실행이 끝나면
- 선언된 변수는 유효하지 않으므로 실행 수 상태 s'에서 해당 엔트리 제거
- 이 상태가 let문을 실행한 후의 상태

4) 조건문의 의미

5) 반복문의 의미

5.4 언어 S의 인터프리터

1) 인터프리터

- 인터프리터

프로그램의 AST를 순회(traverse)하면서 수식의 값을 계산하고 문장의 의미에 따라 각 문장에 대한 해석(interpret)을 수행

- 인터프리터 함수 Eval : (Statement, State) → State

2) print 문 구현

State Eval(Print p, State state) {
    System.out.println(V(p.expr, state));
    return state; 
}

3) read 문 구현

State Eval(Read r, State state) {
    if (r.id.type == Type.INT) {
        int i = sc.nextInt();
        state.set(r.id, new Value(i));
    } 

    if (r.id.type == Type.BOOL) {
        boolean b = sc.nextBoolean();   
        state.set(r.id, new Value(b));
    }

    return state;
}

4) 복합문 구현

State Eval(Stmts ss, State state) {
    for (Stmt s : ss.stmts) {
        state = Eval(s, state);
    }
    return state;
}

5) if 문 구현

State Eval(If c, State state) {
    if (V(c.expr, state).boolValue( ))
        return Eval(c.stmt1, state);
    else
        return Eval(c.stmt2, state);
}

6) while 문 구현

State Eval(While l, State state) {
    if (V(l.expr, state).boolValue( ))
        return Eval(l, Eval(l.stmt, state));
    else 
        return state;
}

[프로그래밍언어론 ] 4장 변수 및 유효범위

최연재 — Fri, 29 Aug 2025 23:23:41 +0900

출처 : 프로그래밍 언어론 : 원리와 실제 (창병모, 인피니티북스, 2021)

4.1 변수 선언

1) 변수 선언과 유효범위

- 변수 선언 : 사용 전 선언

- 변수의 유효범위 (scope) : 선언된 변수가 유효한(사용될 수 있는) 프로그램 내의 범위/영역

- 정적 유효범위(Static scope) 규칙

선언된 이름은 선언된 블록 내에서만 유효함
대부분의 언어에서 표준 규칙으로 사용됨

2) 변수 선언

- 변수 id는 <type>타입 변수이며 초기화가 가능하다.

- 변수 id는 지역 변수로 유효범위는 선언된 블록 내이다.

<stmt> → ... | let <decls> in <stmts> end;
<decls> → {<type> id [=<expr>];}

3) 블록의 중첩

- let 블록 내의 문장 S에 다시 let 블록이 나타날 수 있다.

4) 언어 S의 전역 변수

- 지역 변수 : let문 내에서 선언된 변수

- 전역 변수 : let문 밖에서 선언된 변수

5) 타입 없는 변수 선언

- 동적 타입 언어 (dynamically typed language)

변수의 타입을 선언하지 않고 바로 사용
변수에 어떤 타입의 값이든지 서장 가능
Lisp/Scheme, JavaScript, Python 등

4.2 블록 구조 언어

1) 블록

- 블록

서로 연관된 선언문과 실행문들을 묶어놓은 프로그래밍 단위
블록은 변수나 함수를 선언하는 선언문들과 실행문들로 구성됨

- 블록을 나타내는 기호

중괄호 : C
begin-end : Ada
프로시저 또는 함수 : C, Pascal 등

2) 블록 구조 언어

- 블록의 중첩을 허용하는 언어

- 대형 프로그램을 여러 블록으로 나눠 작성 ➡️ 복잡한 수행 내용을 단순화하며 프로그램의 해독성을 높여줌.

- 프로그램의 오류 발생 ➡️ 범위가 블록 단위로 한정되므로 수정이 쉬워짐.

- 블록의 첨가, 수정, 삭제 등이 용이

- 블록 내에 선언된 변수들은 그 안에서만 유효하며 실행이 종료되면 기존에 선언되었던 변수들은 모두 무효화됨.

- 사용자로 하여금 변수의 사용과 기억장소의 할당에 대한 경계를 명확히 할 수 있음.

3) C언어의 유효범위 규칙

- 핵심 아이디어

사용 전 선언
선언의 유효범위는 선언된 지점~선언된 블록 끝까지.

- 지역 변수의 유효 범위 : 선언된 지점 ~ 함수 끝까지

- 전역 변수의 유효 범위 : 선언된 지점 ~ 파일 끝까지

4.3 변수의 상태와 의미

1) 변수의 의미

- 변수 : 메모리 위치(주소)를 나타내는 이름

- 대입문의 예

x = x + 1;

- 오른쪽 변수 x의 의미 : 메모리 위치에 저장된 값 (r-value)

- 왼쪽 변수 x의 의미 : 메모리 위치 (l-value)

2) 상태

- 상태 (state) : 변수들의 현재 값

- 모든 가능한 상태들의 집합

State = Identifier → Value

- 상태 s에서 변수 값 : s(x)

- 상태 갱신 : s' = s[y ↦ v]

s'(x) = s(x) if x != y
s'(x) = v if x == y

3) 수식

- 상태에서 수식의 값

- V(State, Expr) → Value

4) 문장의 의미

- 문장 S의 의미

문장 S가 상태 s를 후상태 s'으로 변경시킨다.
상태 변환

- 상태 변환 함수 (state transform function)

Eval : (State, Statement) → State
Eval(s, S) = s' for each statement S

- 의미론

각 문장 S마다 상태 변환 함수 정의
프로그램의 실행 과정을 상태 변환 과정으로 설명

ex)

대입문 id = E
- Eval(s, id) = s[id ↦ V(s, E)]
복합문 S;S
- Eval(s, S1;S2) = Eval(Eval(s, S1), S2)

4.4 변수의 유효범위 관리

1) 블록 구조를 위한 상태 관리

- 블록 시작을 만났을 때

블록 내에 선언된 변수는 유효해짐
선언된 변수에 대한 상태 정보를 새로 생성

- 블록 내 문장을 만났을 때

유효한 변수들의 상태 정보를 이용해서 문장들을 해석(실행)

- 블록 끝을 만났을 때

블록 내의 선언된 변수들은 더 이상 유효하지 않음
블록 내의 선언된 변수들의 상태 정보를 제거

- 상태(state)를 스택(stack) 형태로 유지 관리

4.5 구현

1) 상태 구현

- 상태 구현 : 변수의 값을 나타내는 <변수 이름, 값> 쌍들의 집합으로 표현

class Pair {
   Identifier id;
   Value val;
   
   Pair (Identifier id, Value v) {
     this.id = id;
     this.val = v;
   }
}

- 스택의 형태로 유지 관리

class State extends Stack<Pair> {
    // 
}

2) 수식의 값 계산

Value V(Expr e, State state) {
    if (e instanceof Value) 
        return (Value) e;

    if (e instanceof Identifier) {
        Identifier v = (Identifier) e;
        return (Value)(state.get(v));
 }

    if (e instanceof Binary) {
        Binary b = (Binary) e;
        Value v1 = V(b.expr1, state);
        Value v2 = V(b.expr2, state);
        return binaryOperation (b.op, v1, v2); 
    }

    if (e instanceof Unary) {
        Unary u = (Unary) e;
        Value v = V(u.expr, state);
        return unaryOperation(u.op, v); 
    }
}

Value binaryOperation(Operator op, Value v1, Value v2) {
    switch (op.val) {
    case "+":
        return new Value(v1.intValue() + v2.intValue());
    // ...
    }
}

3) 대입문 실행

State Eval(Assignment a, State state) {
    Value value = V(a.expr, state);
    return state.set(a.id, value);
}

4) let 문 실행

State Eval(Let l, State state) {
    State s = allocate(l.decls, state);
    s = Eval(l.stmts,s);
    return free(l.decls, s);
}

5) let 블록 실행

- allocate 함수

State allocate (Decls ds, State state) { ... }
선언된 변수들을 위한 엔트리들을 상태에 추가
엔트리 추가 함수 : State push(Identifier id, Value val)

- free 함수

State free (Decls ds, State state) { ... }
선언된 변수들의 엔트리를 상태에서 제거

6) 전역 변수 선언

State Eval(Command c, State state) {
    if (c instanceof Decl) {
        Decls decls = new Decls();
        decls.add((Decl) c);
        return allocate(decls, state);
    }

    if (c instanceof Stmt)
        return Eval((Stmt) c, state);
}

[프로그래밍언어론 ] 3장 언어 설계와 파서 구현

최연재 — Sat, 23 Aug 2025 06:36:31 +0900

출처 : 프로그래밍 언어론 : 원리와 실제 (창병모, 인피니티북스, 2021)

3.1 프로그래밍 언어 S

1) 샘플 프로그래밍 언어

- 대화형 인터프리터 방식으로 동작 가능
- 블록 중첩을 허용
- 실행 전에 타입 검사를 수행하는 강한 타입 언어
- 어휘분석기, 파서, AST, 타입 검사기, 인터프리터 순차 구현

2) 언어 S의 문법

<program> → {<command>}
<command> → <decl> | <stmt> | <function>
<decl> → <type> id [= <expr>];
<stmt> → id = <expr>;
| '{' <stmts> '}'
| if (<expr>) then <stmt> [else <stmt>]
| while (<expr>) <stmt>
| read id; | print <expr>; | let <decls> in <stmts> end;

<stmts> → {<stmt>}
<decls> → {<decls>}
<type> → int | bool | string

3) 프로그래밍 언어 S

- 언어 S의 프로그램 : 명령어(<command>)들로 구성
- 명령어

변수 선언 : <decl>
함수 정의 : <function>
실행 문장 : <stmt>

- 실행 문장

대입문, 조건 if문, 반복 while문
입력 read문, 출력 print문
복합문 : 괄호로 둘러싸인 일련의 실행 문장들
let문 : 지역 변수 선언과 일련의 실행 문장들

- 변수 선언 : 정수, 부울, 스트링 타입

3.2 추상 구문 트리

1) 파서와 AST

- 어휘 분석기 (lexical analyzer)

입력 스트링을 읽어서 토큰 형태로 분리하여 반환

- 파서(parser)

입력 스트링을 재귀 하강 파싱
해당 입력의 AST를 생성해 반환

- 추상 구문 트리 (abstract syntax tree ; AST)

입력 스트링의 구문 구조를 추상적으로 보여주는 트리

- 인터프리터 (intepreter)

각 문장의 AST를 순회하면서 각 문장의 의미에 따라 해석하여 수행

2) 유도 트리

3) 추상 구문 트리

- 입력 스트링의 구문 구조를 추상적으로 보여주는 트리
- 실제 유도 트리에 나타나는 세세한 정보를 모두 나타내지는 않음
- 수식의 AST : 연산을 중심으로 요약해서 표현

4) 수식의 AST

- 이항(Binary) 수식과 단항연산(Unary) 수식으로 구분하여 구현

class Binary extends Expr { // 이항 연산 수식의 AST 구현
    Operator op;
    Expr expr1, expr2;
    
    Binary (Operator o, Expr e1, Expr e2) {
        op = o; expr1 = e1, expr2 = e2;
    }
}

- 식별자(Identifier), 값(Value)도 하나의 수식이 될 수 있다.
- Expr = Identifier | Value | Binary | Unary

5) 변수 선언의 AST

- 구문법 : <type> id = <expr>
- AST : Type type; Identifier id; Expr expr;

6) 대입문 Assignment의 AST

- 구문법 : id = <expr>;
- AST : Assignment = Identfier id; Expr expr

class Assignment extends Stmt {
    Identifier id;
    Array ar = null;
    Expr expr;

    Assignment (Identifier t, Expr e) {
        id = t;
        expr = e;
    }
}

7) Read 문, Print 문의 AST

- 구문법

read id;
print <expr>;

- AST

8) 복합문의 AST

- 구문법 : <stmts> → {<stmt>}
- AST : Stmts = Stmt*

class Stmts extends Stmt {
    public ArrayList<Stmt> stmts = new ArrayList<Stmt>();
}

9) If 문의 AST

- 구문법 : if (<expr>) then <stmt> [else <stmt>]
- AST : Expr expr; Stmt stmt1; Stmt stmt2

10) While 문의 AST

- 구문법 : while (<expr>) <stmt>
- AST : Expr expr; Stmt stmt;

11) Let 문의 AST

- 구문법 : let <decls> in <stmts> end
- AST : Decls decls; Stmts stmts;

3.3 어휘 분석기 구현

1) 어휘분석과 토큰

- 어휘분석 (lexical analysis)

소스 프로그램을 읽어들여 토큰(token)으로 분리
어휘 분석기(lexical analyzer) 또는 스캐너(scanner)

- 토큰

문법에서 터미널 심볼에 해당하는 문법적 단위
식별자 (identifier)
상수 리터럴 (constant)
예약어 (keyword)
연산자 (operator)
구분자 (delimiter)

2) 예약어

- 예약어 또는 키워드 : 언어에서 미리 그 의미와 용법이 지정되어 사용되는 단어
ex)

BOOL("bool"),TRUE("true"), FALSE("false"), IF("if"), THEN("then"), STRING("string"),
WHILE("while"), VOID("void"),  FUN("fun"), RETURN("return"), LET("let"),
IN("in"), END("end"), READ("read"), PRINT("print")

3) 식별자

- 식별자

ID : 변수 혹은 함수의 이름을 나타내며 토큰 이름
식별자 : 첫 번째는 문자이고 이어서 0개 이상의 문자 혹은 숫자들로 이루어진 스트링

- 정규식(regular expression) 형태로 표현

ID : letter(letter | digit)*
letter = [a-zA-Z]
digit = [0-9]

4) 정규식

-정의 1 : M과 N이 정규식이면 다음은 모두 정규식이다.

x : 문자 x
M | N : M 또는 N
MN : M 다음에 N이 나타나는 집합
M* : M이 0번 이상 반복됨
M+ : MM*을 나타내며 M이 한 번 이상 반복
M? : M이 0번 또는 1번 나타남
[..] : 문자 집합

5) 연산자/구분자

- 연산자

ASSIGN("="), EQUAL("=="),  LT("<"), LTEQ("<="), GT(">"),  
GTEQ(">="),  NOT("!"),    NOTEQ("!="), PLUS("+"), MINUS("-"), 
MULTIPLY("*"), DIVIDE("/"), AND("&"), OR("|")

- 구분자

LBRACE("{"), RBRACE("}"), LBRACKET("["), RBRACKET("]"),
LPAREN("("), RPAREN(")"), SEMICOLON(";"), COMMA(","), EOF("<<EOF>>")

6) 토큰 구현

enum Token {
     BOOL("bool"),CHAR("char"), ELSE("else"), FALSE("false"), FLOAT("float"), 
     STRING("string"), IF("if"), INT("int"),  TRUE("true"), WHILE("while"), 
     RETURN("return"), VOID("void"), FUN("fun"),  THEN("then"), LET("let"), 
     IN("in"), END("end"), READ("read"), PRINT("print"), DO("do"),  FOR("for"), 
     EOF("<<EOF>>"), 
     LBRACE("{"), RBRACE("}"), LBRACKET("["), RBRACKET("]"),
     LPAREN("("), RPAREN(")"), SEMICOLON(";"), COMMA(","),
     ASSIGN("="), EQUAL("=="),  LT("<"), LTEQ("<="), GT(">"),  
     GTEQ(">="),  NOT("!"),    NOTEQ("!="), PLUS("+"), MINUS("-"), 
     MULTIPLY("*"), DIVIDE("/"), AND("&"), OR("|"), ID(""), 
     NUMBER(""), STRLITERAL(""); 

    private String value; 

    private Token (String v) {
        value = v;
    }

    public String value( ) { return value; }
}

7) 어휘분석기 getToken 메소드

- getToken() 메소드 : 호출될 때마다 다음 토큰(token)을 인식하여 리턴
- 읽은 문자가 알파벳 문자 : 식별자 이나면 예약어

다음 문자가 알파벳 문자나 숫자인 한 계속해서 다음 문자를 읽는다.
읽은 문자열이 식별자인지 예약어인지 구별하여 해당 토큰을 리턴한다.

- 읽은 문자가 숫자 : 정수리터럴

다음 문자가 숫자인 한 계속해서 읽어 정수리터럴을 인식하고 이를 나타내는 NUMBER 토큰을 리턴

- 나머지는 읽은 문자에 따라 연산자, 구분자 등을 인식하여 리턴

8) 어휘 분석

- Lexer

입력을 읽어서 호출될 때마다 하나의 토큰을 변환
키워드, 수, 변수 이름, 기타 문자를 처리

3.4 파서 구현

1) 파서

- 입력 스트링을 명령어 단위로 파싱하면서 AST를 생성해 반환

Commond command()
- 명령어(변수 선언, 함수 정의, 문장)를 읽고 파싱하면서 해당 AST를 구성하여 반환한다.
- <command> → <decl> | <stmt> | <function>
Decl decl() : 변수 선언을 읽고 파싱하면서 해당 AST를 구성하여 반환
Stmt stmt() : 각 문장을 읽고 파싱하면서 해당 AST를 구성하여 반환
Expr expr() : 수식을 읽고 파싱하면서 해당 AST를 구성하여 반환

public class Parser {
    Token token;   
    Lexer lexer;
    
    public Parser(Lexer scan) { 
        lexer = l;		  
        token = lexer.getToken(); 
    }
    
    public static void main(String args[]) {
        parser  = new Parser(new Lexer());
        System.out.print(">> ");
        do {
            command = parser.command();
            System.out.print("\n>> ");
        } while (true);
    }
}

2) 파서 구현 : 명령어

public Command command() {
    // <command> ->  <decl> | <function> | <stmt>
    if (isType()) {
	    Decl d = decl();
	    return d;
    }
    if (token == Token.FUN) {
	    Function f = function();
	    return f;
    }

    if (token != Token.EOF) {
	    Stmt s = stmt();
        return s;
    }
    
    return null;
}

3) 파서 구현 : 변수 선언

private Decl decl() {
    // <decl>  -> <type> id [=<expr>]; | <type> id[n]
    Type t = type();
    String id = match(Token.ID);
    Decl d = null;

    if (token == Token.ASSIGN) {
        match(Token.ASSIGN);
        Expr e = expr();
        d = new Decl(id, t, e);
    } 
    else d = new Decl(id, t);

    match(Token.SEMICOLON);
    return d;
}

4) Statment 파싱

private Stmt stmt() {
    // <stmt> -> <block> | <assignment> | <ifStmt> | <whileStmt> | ...
    Stmt s = new Empty();
    switch (token) {
    case ID:    // assignment
        s = assignment(); return s;
    case LBRACE:          
        match(Token.LBRACE);      
        s = stmts();
        match(Token.RBRACE);    
        return s;
    case IF:    // if statement 
        s = ifStmt(); return s;   
    case WHILE:      // while statement 
        s = whileStmt(); return s;
    case LET:  // let statement 
        s = letStmt(); return s;
    ...
    default:  
        error("Illegal stmt"); return null; 
 }
}

5) 파서 구현 : Assignment 문

private Stmt assignment() { 
    // <assignment> -> id = <expr>;
    Identifier id = new Identifier(match(Token.ID));
    match(Token.ASSIGN);
    Expr e = expr();
    match(Token.SEMICOLON);
    if (ar == null) return new Assignment(id, e);
    return new Assignment(ar, e);
}

6) match 함수

- 현재 토큰을 매치하고 다음 토큰을 읽는다.

private String match(Token t) {
    String value = token.value();
    if (token == t)
        token = lexer.getToken();
    else
        error(t);
    return value;
}

7) 파서 구현 : 복합문

private Stmts stmts () { // <stmts> -> {<stmt>} 
    Stmts ss = new Stmts();
    while((token != Token.RBRACE) && (token != Token.END))
        ss.stmts.add(stmt());
    return ss;
}

8) 파서 구현 : If 문

private If ifStmt () { // <ifStmt> -> if (<expr>) then <stmt> [else <stmt>]
    match(Token.IF);
    match(Token.LPAREN);
    Expr e = expr();
    match(Token.RPAREN);
    match(Token.THEN);
    Stmt s1 = stmt();
    Stmt s2 = new Empty();
    if (token == Token.ELSE){
        match(Token.ELSE);
        s2 = stmt();
    }
    return new If(e, s1, s2);
}

9) 파서 구현 : While 문

private While whileStmt () {
    // <whileStmt> -> while (<expr>) <stmt>
    match(Token.WHILE);
    match(Token.LPAREN);
    Expr e = expr();
    match(Token.RPAREN);

    Stmt s1 = stmt();
    return new While(e, s1);
}

10) let-문 파싱

private Let letStmt () {
    // <letStmt> -> let <decls> in <block> end
    match(Token.LET);
    Decls ds = decls();
    match(Token.IN);
    Stmts ss = stmts();
    match(Token.END);
    match(Token.SEMICOLON);
    return new Let(ds, null, ss);
}

11) 파서 구현 : 수식

private Expr aexp () {
    // <aexp> -> <term> { + <term> | - <term> }
    Expr e = term();
    while (token == Token.PLUS || token == Token.MINUS) {
        Operator op = new Operator(match(token));
        Expr t = term();
        e = new Binary(op, e, t);
    }
    return e;
}

12) 파서 구현 : term 함수

private Expr term () { // <term> -> <factor> { * <factor> | / <factor>}
    Expr t = factor();
    while (token == Token.MULTIPLY || token == Token.DIVIDE) {
        Operator op = new Operator(match(token));
        Expr f = factor();
        t = new Binary(op, t, f);
    }
    return t;
}

13) 파서 구현 : factor 함수

private Expr factor() { 
    // <factor> -> [-](id | id'['<expr>']' | <call> | literal | '('<aexp> ')')
    Operator op = null;
    if (token == Token.MINUS)
        op = new Operator(match(Token.MINUS));

    Expr e = null;
    switch(token) {
        case ID:
            Identifier v = new Identifier(match(Token.ID));
            e = v;
            break;
        case LPAREN:
            match(Token.LPAREN);
            e = aexp();
            match(Token.RPAREN);
            break;
        default:
            error("Identifier | Literal");
    }

    if (op != null)
        return new Unary(op, e);
    else return e;
}

[프로그래밍언어론 ] 2장 구문법 (Syntax)

최연재 — Fri, 22 Aug 2025 09:53:05 +0900

출처 : 프로그래밍 언어론 : 원리와 실제 (창병모, 인피니티북스, 2021)

2.1 구문 및 구문법

1) 구문법 (Syntax)

- 문장 혹은 프로그램을 작성하는 방법
- 자연어(영어, 한국어)의 문법처럼 프로그래밍 언어의 구문법이 있다.
- 프로그래밍 언어의 이론적 기초

2) 재귀적 정의 : 이진수의 구문법

- 숫자(D)는 0, 1 중 하나이다.
- 이진수 구성 방법

숫자(D)는 이진수(N)이다.
이진수(N) 다음에 숫자(D)가 오면 이진수(N)이다.

3) 수식의 구문법

5) 프로그래밍 언어의 구문 구조

6) 문맥-자유 문법 CFG

- 넌터미널 심볼은 보통 대문자로, 터미널 심볼은 소문자로 표기

7) 생성 규칙

2.2 유도

1) 유도 (Derivation)

- 구문검사 : 입력된 문장 혹은 프로그램이 문법에 맞는지 검사하는 것
- 입력된 스트링이 문법에 맞는지 검사하려면 문법으로부터 유도(derivation)해 보아야 함.

2) 좌측 유도와 우측 유도

- 좌측 유도 (leftmost derivation)
: 각 직접 유도 단계에서 가장 왼쪽 넌터미널을 선택하여 이를 대상으로 생성 규칙을 적용

- 우측 유도 (rightmost derivation)
: 각 직접 유도 단계에서 가장 오른쪽 넌터머널을 선택하여 이를 대상으로 생성 규칙을 적용

3) 문법 G 언어

- 문법 G에 의해서 정의되는 언어 L(G)

문법 G에 의해서 유도되는 모든 스트링들의 집합

4) 유도 트리 (Derivation Tree)

- 유도 트리

유도 과정 혹은 구문 구조를 보여주는 트리
유도 트리 = 파스 트리 = 구문 트리

- 유도는 시작 심볼로부터 시작하여 연속적으로 직접 유도
- 좌측 유도와 우측 유도 모두 같은 파스 트리를 가짐

2.3 모호성 (Ambiguity)

1) 모호성

- 모호한 문법 (ambiguous grammer)

어떤 스트링에 대해 두 개 이상의 좌측 유도를 가짐
어떤 스트링에 대해 두 개 이상의 우측 유도를 가짐
어떤 스트링에 대해 두 개 이상의 파스 트리를 가짐

2) 모호성 처리 방법 1

- 문법 재작성 : 원래 언어와 같은 언어를 정의하면서 모호하지 않도록 문법 재작성
- 예 : 우선순위를 적용하여 모호하지 않도록 재작성

(1) 모호성 예 : The Dangling Else

3) 모호성 처리 방법 2

- 언어 구문 일부 변경 : 원래 언어와 약간 다른 언어를 정의하도록 언어의 구문을 일부 변경하여 모호하지 않는 문법 작성

2.4 BNF와 구문 다이어그램

1) BNF/EBNF

2) 구문 다이어그램

- 구문 다이어그램

각 생성 규칙을 다이어그램으로 표현
넌터미널 : 사각형
터미널 : 원
순서 : 화살표

- EBNF에서 중괄호로 나타낸 반복 -> 다이어그램에서는 루프를 사용

2.5 재귀 하강 파서

1) 재귀 하강 파싱 (recursive-descent parsing)

- 파싱 : 입력 스트링을 유도하여 문법에 맞는지 검사
- 파서 : 입력 스트링을 유도하여 문법에 맞는지 검사하는 프로그램
- 재귀 하강 파서의 기본 원리 : 입력 스트링을 좌측 유도(leftmost derivation)하도록 문법으로부터 직접 파서 프로그램을 만듦

2) 재귀 하강 파싱 구현

- 각 넌터미널 : 하나의 프로시저(함수, 메소드)를 구현한다.
- 프로그시저 내에서 생성규칙 우변을 적용하여 좌측 유도 하도록 작성

프로시저 호출 : 생성 규칙을 적용하여 좌측 유도
match(문자); : 다음 입력 심볼(토큰)이 문자와 일치하는지 검사

3) 예제

- 수식을 재귀-하강 파싱

int getToken() { // 다음 토큰 (수 or 문자)을 읽어서 리턴
    while (true) {
    	try {
            ch = input.read();
            if (ch == ' ' || ch == '\t' || ch == '\r');
            else if (Character.isDigit(ch)) {
            	value = number();
                input.unread(ch);
                return NUMBER;
            }
            else return ch;
        } catch (IOException e) {
        	System.err.println(e);
        }
}

void match(int c) { // 현재 토큰 확인 후 다음 토큰 읽기
    if (token == c) token = getToken();
    else error();
}

void expr(void) { // <expr> -> <term> { + <term>}
    term();
    while (token == '+') {
    	match('+');
        term();
    } 
}

void command(void) { // <command> -> <expr> '\n'
    int result = expr();
    if (token == '\n') 
    	printf("The result is %d\n", result);
    else error();
}

void parse(void) {
    token = getToken();
    command();
}

main() {
    parse();
    return 0;
}

4) 수식 값 계산기

- 수식 값 계산 : 재귀 하강 파싱하면서 동시에 수식의 값을 계산

int expr(void) { // <expr> -> <term> { + <term>}
    int result = term();
    while (token == '+') {
    	match('+');
        result += term();
    } 
    return result;
}
 
int term(void) { // <term> -> <factor> {* <factor>}
    int result = factor();
    while (token == '*') {
        match('*');
        result *= factor();
    }
    return result;
}

[프로그래밍언어론 ] 1장 서론

최연재 — Thu, 21 Aug 2025 20:49:16 +0900

출처 : 프로그래밍 언어론 : 원리와 실제 (창병모, 인피니티북스, 2021)

1.1 프로그래밍 언어란?

1) 프로그래밍언어

- 계산 과정을 기계가 읽을 수 있고 사람이 읽을 수 있도록 기술하기 위한 일종의 표기법
- 계산 (computation) : 데이터 조작, 텍스트 처리, 알고리즘
- 기계 읽기 (machine readability) : 효율적인 번역 또는 실행
- 사람 읽기 (human readability) : 프로그래밍 편의성, 컴퓨터 연산들의 이해하기 쉬운 추상화

2) 프로그래밍 언어의 중요성

- 언어에 따라 상이한 프로그래밍 방식

절차형(명령헝) 언어 (procedural langauge)
함수형 언어 (functional langauge)
논리 언어 (logic language)
객체지향 언어 (object-oriented language)

1.2 프로그래밍언어의 종류

1) 프로그래밍 패러다임

- 명령형 프로그래밍 (imperative programming)

문제를 해결하는 절차(명령)를 기술하는 방식의 프로그래밍
언어 : C, pascal, Ada, Python

- 함수형 프로그래밍 (functional programming)

프로그래밍의 계산 과정을 수학 함수 형태로 프로그래밍
프로그램은 함수 정의들로 구성
언어 : Lisp, Scheme, ML, Haskell

- 논리 프로그래밍 (logic programming)

정형 논리 (formal logic)를 기반으로 한 프로그래밍
프로그램은 문제에 대한 사실/규칙을 표현하는 논리 문장
언어 : Prolog

- 객체지향 프로그래밍 (object-oriented programming)

객체 개념을 기반으로 하는 프로그래밍
프로그램 실행은 객체 사이의 상호작용에 의해 이루어짐
언어 : C++, Java, C#, Objective-C, Swift, Python, Visual Basic

2) 함수형 언어 (Functional language)

- 기본 모델 : 수학 함수를 기반으로 하는 언어
- 프로그램 : 매개변수로 입력을 받아 처리한 후에 반환값을 출력하는 함수
- 함수

함수 정의 (definition)
함수 호출 (application)
매개변수 (parameter)
반환값 (return value)

- 특징

변수 및 대입문이 없음
자기호출에 의한 반복
루프 같은 반복문이 없음

- 장점

기계 모델과 무관
수학을 기반으로 프로그램의 언어를 명확하게 정의할 수 있음

- 예시 : Lisp, Scheme, ML, Haskell

3) 논리 언어 (Logic language)

- 기본 모델

p -> q 형태의 술어 논리(predicate logic)를 기반으로 함
선언적으로 프로그래밍하는 언어

- 프로그램 : 문제를 해결하는 방법보다 문제가 무엇인지 논리 문장들로 표현
- 증명하는 것을 계산하는 것으로 간주
- 특징

루프나 선택문 등의 제어 추상화가 없다
제어는 하부 시스템(해석기)에 의해 제공된다.
변수는 메모리 위치가 아니라 부분 결과 값에 대한 이름

- 장점

기계-독립적이고 정확한 의미구조를 가지고 있다.
선언적 프로그래밍이 가능하다

- Prolog

대표적인 논리 언어
인공지능, 자연어 처리 등의 분야에서 많이 사용

4) 객체지향 언어 (Object-oriented language)

- 객체지향 언어의 시작

실세계를 모의실험하기 위한 언어로 고안
객체 개념을 기반으로 하는 프로그래밍 스타일

- 객체 (object) : 속성과 관련 행동(함수, 메소드)들의 모음으로 표현
- 계산과정 (computation) : 객체들 사이의 상호 작용 (메소드 호출)
- 클래스 (class)

클래스는 객체에 대한 타입 정의
객체는 클래스의 한 실체(instance)

1.3 프로그래밍 언어의 역사

1) 1950년대 : 고급 프로그래밍 언어의 시작

- FORTRAN (FORmula TRANslation)

과학응용 분야를 위한 효율성을 강조한 최초의 고급 언어
설계 목표 : 매우 빠르게 실행되는 코드 생성
주요 기능 : 배열 (array), FOR 반복문, 분기 IF-문 등

- COBOL (COmmon Business-Oriented Langauge)

사무용으로 설계된, 영어와 비슷한 구문을 갖는 명령형 언어 (범용, 비즈니스)
주요 기능 : 레코드 구조, 프로그램의 실행부와 분리된 자료구조
다양한 출력 기능 등

- LISP (List Processor)

리스트 자료구조와 함수 적용을 기반으로 함
재귀호출 (recursive call)이 매우 일반적임
LISP와 후속 언어 Scheme은 인공지능 분야에서 많이 사용됨

2) 1960년대 : 프로그래밍 언어의 다양성

- Algol60/68

알고리즘을 기술하기 위한 강력한 범용 언어
Pascal, C, Modula-2, Ada 같은 현대의 명령어 언어에 영향을 줌
주요 특징
- 구조적 문장, begin-end 블록
- 자유 양식 (free format), 변수의 타입 선언
- 재귀 호출, 값 전달 매개변수

- Algol68

Algol60을 향상하여 더 표현력 있고 이론적으로 완전히 일관성 있는 구조를 생성하려고 함.

- PL/I

일반적이고 보편적인 언어, 즉 모든 언어를 통합하는 언어
- FORTRAN, COBOL, Algol60의 가장 좋은 특징을 모두 결합
- 병행성과 예외처리 기능 추가
배우기도 어렵고 사용하는 데 오류 발생이 많음
- 너무 복잡해서 언어 기능들 사이에서 예측할 수 없는 상호작용이 많음

- Simula-67

최초의 객체지향 언어로 모의실험(simulation)을 위해 설계됨
객체와 클래스 개념을 소개함으로써 공헌함

- BASIC

단순한 언어로 PC로 이전되어 교육용 언어로 많이 사용됨
이후 마이크로소프트사에 의해 Visual Basic 형태로 발전됨.

3) 1970년대 : 단순성 및 새로운 언어의 추구

- PASCAL

교육용 언어로 Algol의 아이디어를 작고, 단순하고, 효율적이고 구조화된 언어로 세련되게 만듦
대표적인 블록 구조 언어

- C 언어

유닉스 운영체제 개발을 위해 개발된 시스템 프로그래밍 언어
기계에 대해 많은 접근을 제공하는 중급 언어 (middle-level)
모든 컴퓨터 시스템에서 사용할 수 있도록 설계된 언어

- Prolog

술어 논리를 사용하는 대표적인 논리 프로그래밍 언어
증명하는 것을 계산하는 것으로 간주
인공지능, 자연어 처리 등의 분야에서 많이 사용됨

- Scheme : 더 형식적이고 람다 계산에 더 가깝게 설계된 향상된 LISP 버전
- ML : Pascal과 가까운 구문을 가지고 다형 타입 검사 매커니즘을 제공하는 함수형 언어

4) 1980년대 : 추상 자료형과 객체 지향

- Ada

미 국방성(DoD)의 후원으로 개발된 영향력 있고 포괄적인 언어
주요 기능
- 패키지 (추상 자료형), 태스크(병행 프로그래밍 기능)
- 예외처리 등과 같은 새로운 기능을 포함

- Modula-2

범용 절차형 언어이면서 시스템 프로그래밍 언어로 개발
Pascal처럼 가능한 한 작고 단순한 언어로 설계
주요 기능
- 모듈 (추상 자료형), 코루틴 (부분적인 병행성)

- Smalltalk

순수한 객체지향 언어
Ruby, Objective-C, Java, Python, Scala 등의 언어에 영향을 줌
최초로 GUI를 제공하는 언어

- C++

C언어를 확장함.
- C언어의 구조체 - 클래스 형태로 확장
C언어의 효율성을 유지하면서도 객체지향 프로그래밍 가능
포인터와 같은 C언어의 중요한 특징을 그대로 포함하고 있음.

5) 1990년대 : 인터넷 언어와 새로운 시도

- Python

대화형 인터프리터 방식의 프로그래밍 언어
플랫폼 독립성, 객체지향, 동적 타입(dynamic type)
교육용 및 빅데이터를 비롯한 다양한 분야에서 응용되고 있음

- Java

인터넷 환경을 위한 객체지향 언어
웹 애플리케이션, 모바일 앱 개발 등에 가장 많이 사용하는 언어
플랫폼 독립성 : 컴파일된 바이트 코드가 JVM이 설치된 어느 플랫폼에서도 실행 가능

- JavaScript

웹 브라우저 내에서 실행되는 클라이언트 프로그래밍에 주로 사용
Node.js와 같은 런타임 환경과 같이 서버 프로그래밍에서도 사용

6) 2000년대 : 새로운 미래를 향하여

- C#

Java를 모방한 마이크로소프트 버전
닷넷 프레임워크를 기반으로 함.

- Scala

객체지향과 함수형 언어의 요소가 결합된 다중패러다임 언어
자바 바이트코드를 사용하기 때문에 JVM에서 실행 가능
Java 언어와 호환 : 대부분의 자바 API를 그대로 사용 가능

- Objective-C와 Swift

Swift는 기존의 Mac용 언어인 Objective-C와 함께 공존
Objective-C처럼 LLVM으로 빌드되고 같은 런타임 시스템을 공유
특징 : 클로저, 다중 리턴 타입, 네임스페이스, 제너릭, 타입 유추

1.4 추상화와 명령형 언어의 발전

1) 프로그래밍 언어 발전 과정

- 컴퓨터 : Von Neuman model computer (폰 노이만 모델 컴퓨터)
- 초창기 프로그램 : 컴퓨터에 명령하는 기계어 명령어들로 작성

2) Von Neuman 모델 컴퓨터

- 프로그램 내장 방식 컴퓨터

stored-program computer
메모리에 프로그램(명령어와 데이터) 저장

- 메모리에 저장된 명령어 순차 실행

CPU sequentially execute instructions in memory
PC : 다음 실행할 명령어를 가리키는 레지스터

- 명령어

메모리에 저장된 값을 조작 혹은 연산
instructions operate on values stored in memory

- 컴퓨터 프로그램 실행 : CPU의 인출-해석-실행 (fetch-decode-execute) 주기 반복

CPU는 메모리 내에 저장되어 있는 프로그램의 명령어를 한 번에 하나씩 가져와서 해석하고 실행

3) 명령형 언어 (Imperative language)

- 명령형 언어의 발전

Imperative programming languages began by imitating and abstracting the opreations of von Neuman model computer

- 폰 노이만 모델 컴퓨터의 특징을 많이 가지고 있음.

순차적 명령어 실행
메모리 위치를 나타내는 변수 사용
대입문을 사용한 변수 값 변경
사람의 필요보다는 켬퓨터 모델을 기반으로 한 언어

4) 추상화 (Abstraction)

- 추상화 : 실제적이고 구체적인 개념들을 요약하여 보다 높은 수준의 개념을 유도하는 과정
- 명령형 언어는 아래 내용을 추상화

컴퓨터의 데이터, 연산, 명령어 등을 추상화
데이터 추상화
제어 추상화

(1) 데이터 추상화 (Data Abstraction)
- 데이터 추상화

저수준의 데이터나 자료형들을 요약하고 추상화하여 보다 고차원의 새로운 자료형 또는 자료구조를 만드는 과정을 의미

- 기본 추상화

기본 데이터 관련 요약
ex.
- 변수 (variable) : 데이터 값을 저장하는 메모리 위치
- 자료형 (data type) : 값들의 종류에 대한 이름

- 구조적 추상화 : 관련된 여러 값/변수들의 모음을 요약

배열 : 같은 타입의 연속된 변수들의 모음
레코드 (구조체) : 다른 타입의 연관된 변수들의 모음

- 프로그래밍 언어와 추상화

프로그래밍 언어는 이러한 추상화된 개념을 제공
프로그래머는 이러한 개념을 기반으로 프로그래밍

(2) 제어 추상화 (Control Abstraction)
- 제어 추상화

실행 흐름을 나타내는 저수준 명령어들을 요약하고 추상화하여 보다 높은 수준의 제어 구조를 만드는 과정

- 기본 추상화

몇 개의 기계어 명령어들을 하나의 문장으로 요약
대입문
goto 문 : jump 명령어의 요약

- 구조적 제어 추상화

테스트 내의 중첩된 기계어 명령어들을 하나의 문장으로 요약

- 예

if-문, switch-문
for-문, while-문

- 장점

기계에 대한 추상화(요약된) 관점
다른 제어 문장들과 중첩되어 사용될 수 있음

- 프로시저 (함수, 메소드)

선언 : 일련의 계산 과정을 하나의 이름으로 요약해서 정의
호출 : 이름과 실 매개변수를 이용하여 호출

(3) 추상 자료형 (Abstract Data Type)
- 추상 자료형

데이터 + 관련 연산
데이터와 관련된 연산들을 캡슐화하여 정의한 자료형

- 예

Modula-2의 모듈
Ada의 패키지
C++, Java 등의 클래스

1.5 프로그래밍 언어의 정의 및 구현

1) (프로그래밍) 언어 정의

- 어휘 구조 (lexical structure) : 언어 구조에서 사용하는 단어의 구조, 철자법
- 구문법 (syntax)

구성 요소를 이용하여 문장/프로그램을 구성하는 방법
문법을 이용하여 기술할 수 있음
Context-free grammer in BNF(Backus-Naur Form)

- 의미론

문장/프로그램의 의미를 정하는 것
자연어 혹은 수학적으로 기술

2) 프로그래밍 언어 구현

- 프로그래밍 언어 구현 : 입력 프로그램 ➡️ Syntax ➡️ Semantics ➡️ Interpret/Compile
- 프로그래밍 언어 구현

입력 받은 소스 프로그램이구문법에 맞는지 검사
그 의미에 맞게 동작하도록 해석 or 기계어 명령어들로 번역

[혼공학습단 14기✍️] 회고록 : 6주동안의 딥러닝 학습을 마치며

최연재 — Wed, 13 Aug 2025 17:14:08 +0900

혼공학습단을 10기부터 참여해서 어느덧 5번째 활동이었습니다! 대학교 2학년 여름방학에 시작한 활동이었는데 벌써 4학년 여름방학을 맞이하다니 시간이 참 빠른 것 같습니다.

다음 학기에 딥러닝 관련 수업을 들을 예정이라 <혼자 만들면서 공부하는 딥러닝> 책을 선택해서 6주동안 공부했습니다. 6주동안의 커리큘럼을 마쳤지만, 책을 완전히 1회독 했다는 생각은 들지 않아서 천천히 다시 한 번 읽어보는 시간을 가지려고 합니다.

다들 수고 많으셨습니다!

[혼공학습단 14기 혼만딥 ] 혼자 만들면서 공부하는 딥러닝 week6

최연재 — Wed, 13 Aug 2025 15:03:20 +0900

기본 숙제

Ch.04(04-2) KerasNLP 또는 허깅페이스 BERT 모델로 영화 리뷰 감성 분석 후 결과 캡처하기

아래 내용 정리에서 확인하실 수 있습니다!

추가 숙제

Ch.04(04-2) 감성 분석에 사용된 토큰화 과정 살펴보고 입력과 출력 비교해 보기

토큰화가 일어나는 코드

prep_data = classifier.preprocessor(feature)

토큰화 입력 : 원래 문장의 앞 100글자 출력

print(feature.numpy()[:100])

토큰화 출력 : 토큰 ID 출력

print(len(prep_data['token_ids']), prep_data['token_ids'][:10])
prep_data['token_ids'][-10:]

토큰화 출력 : 토큰 ID ➡️ 토큰 (단어) 변환

tokens = []
for id in prep_data['token_ids'][:10]:
    tokens.append(bert_tokenizer.id_to_token(id))
print(tokens)

토큰화 출력 : 토큰 ➡️ ID 확인 (역변환)

for token in tokens:
    print(bert_tokenizer.token_to_id(token), end=' ')

직접 문자열 토큰화 테스트

bert_tokenizer.tokenize('"pandemonium" is a horror movie')

️ 내용 정리

Chap04-1 트랜스포머 인코더 모델 이해하기

1. 어텐션 매커니즘

1) 어텐션
- 모델에 입력된 데이터의 모든 단어들 중에서 특정 단어와 관련이 높은 단어에 집중해 데이터를 처리하도록 설계된 기법
- 셀프 어텐션 (self attention) : 문장의 모든 단어가 서로를 참고해 각각 다른 단어와의 관련성을 파악하는 방법
- 멀티 헤드 어텐션 (multi-head attention) : 여러 개의 셀프 어텐션(헤드)을 동시에 수행해 이 관련성을 다양한 관점에서 깊이 이해할 수 있도록 확장
- 문맥 벡터(context vector) : 기계 번역에서 인코더 RNN은 먼저 입력된 문장을 처리해 최종 은닉 상태(hidden state)로 만듦
- 디코더 RNN이 인코더로부터 받은 문맥 벡터를 이용해 새로운 문장(번역된 문장)을 만듦.

- 긴 문장일수록 문맥 벡터만으로는 오래된 단어의 정보를 기억하기 어려움 = 그레이디언트가 타임스텝에 걸쳐 전파되며 점점 약해짐
- 인코더의 마지막 타임스텝에서 얻은 은닉 상태뿐만 아니라 인코더의 모든 은닉 상태를 디코더가 텍스트를 생성할 때마다 참고하도록 만듦. = 디코더가 모든 타임스텝에서 인코더의 은닉 상태를 참고해 문맥 벡터를 만듦.

Chap04-2 전이 학습으로 영화 리뷰 텍스트의 감정 분류하기

1. 트랜스포머 인코더 기반 언어 이해 모델 - BERT

- BERT : 트랜스포머 인코더 기반의 대규모 언어 모델 (LLM)
- 훈련

마스크드 언어 모델링(MLM) : 입력 데이터의 일부 토큰을 가린(마스킹) 다음, 모델이 가려진 단어를 예측
다음 문장 예측(NSP) : 두 문장이 제시됐을 때 두 번째 문장이 첫 번째 문장에 이어지는 다음 문장인지를 예측

- 백본(backbone) : 학습된 출력 벡터를 기반으로 수행되는 별도의 분류기

- KerasNLP

2. KerasNLP로 영화 리뷰 텍스트의 감성 분류하기

(1) KerasNLP로 BERT 모델 로드하기

(2) BERT 모델 미세튜닝하기

(3) 텍스트 전처리하기 - BERT 토크나이저
- 토큰화 : 언어 모델이 텍스트 문자열을 모델이 처리할 수 있는 작은 부분(토큰)으로 분리하는 과정
- 어휘사전 : 고유한 토큰의 집합
- 토크나이저 : 토큰화를 수행하는 방법 또는 객체
- BERT 토크나이저는 워드피스 토큰화를 사용

3. 허깅페이스로 영화 리뷰 텍스트의 감성 분류하기

1) 네이버 영화 리뷰 데이터셋 준비하기

여기에서 에러가 났었는데 !pip install -U datasets 해주고 나니까 잘 됐습니다!

2) 백본 모델 선택하기

3) 입력 데이터 토큰화하기

4) BERT 모델 미세 튜닝하기

4. 미세 튜닝된 모델로 감성 분석하기

Chap04-3 BERT 후속 모델로 영화 리뷰 텍스트의 감성 분류하기

1. BERT의 성능 개선 모델 - RoBERTa

1) RoBERTa
- BERT의 사전 훈련 방식을 재구성해 더 많은 데이터를 활용하고, 훈련 설정을 최적화함으로써 성능을 크게 개선
- 사전 훈련 방식에서 다음 문장 예측(NSP) 작업을 제거하고, 마스크드 언어 모델링만 사용하여 모델을 훈련
- BERT의 워드피스 토크나이저 대신, 바이트 수준의 바이트 페어 인코딩(BPE) 토크나이저를 사용

2) KerasNLP로 RoBERTa 모델 만들기

3) RoBERTa 모델 미세 튜닝하기

2. BERT의 경량화 모델 - DistilBERT

1) DistilBERT
- BERT의 경량화 모델
- 지식정제 (knowledge distillation) : 더 큰 모델인 티처 모델이 학습한 지식을 더 작은 모델인 스튜던트 모델에 전달
- 마스크드 언어 모델링 작업에서 스튜던트의 출력이 티처의 출력에 가까워지도록 스튜던트를 훈련하는 것이 지식 정제의 핵심
- 정제 손실 : 두 모델의 출력 차이로 인한 손실

2) 티처 모델 이해하기 - MLM을 위한 BERT

3) 정제 손실 이해하기
- 티처와 스튜던트 모델의 출력 값을 소프트맥스 함수에 통과시켜 확률분포로 변환한 뒤에 비교 ➡️ 쿨백-라이블러 발산(KLD) 손실

teacher_pred = softmax(teacher_output)
student_pred = softmax(student_output)
KLD_loss = teacher_pred * log(teacher_pred / student_pred)

4) 스튜던트 모델 DistilBERT 사용하기

5) DistilBERT로 IMDB 영화 데이터 리뷰 텍스트의 감성 분류하기

3. KerasNLP로 DistilBERT 모델 만들기

느낀 점

후반부라 그런지 지금까지 혼공학습단 스터디하면서 가장 많은 공부 시간을 들인 주차였습니다.. 이렇게 6주 활동이 끝났는데 수고 많으셨습니다!