Skip to content

태그: 언어

총 80개의 글이 있습니다.

Go의 GC는 mark-sweep 방식으로 동작하며 두 가지 주요 단계로 나뉜다. 마킹: 메모리에서 살아있는 객체를 식별한다. 스윕: 죽은 객체를 해제하여 메모리를 반환한다. GC는 스윕 → 비활성 → 마킹 세 단계를 순회하며 주기적으로 진행된다. Go의 GC는 현시점의 Heap 크기와 직전 시점의 Heap 크기에 대한 증가율이 특정 정도에 다다르면 수행되는 로직으로 구현되었다. 이 때 그 정도를 정하는 변수는 GOGC라고 부른다. GOGC 값을 사용해 아래와 같이 목표 힙 메모리를 구한다. 목표 힙 메모리 = 살아있는 힙 메모리 + (살아있는 힙 메모리 + GC 루트) × GOGC / 100 예를 들어, 살아있는 힙이 8 MiB이고, GOGC가 100일 때, 목표 힙 메모리는 18 MiB이다. GO

golang에서 JSON 형태를 쓰고 싶을 때는 bson을 사용하면 된다. bson.D: 하나의 BSON 도큐먼트. MongoDB command 처럼 순서가 중요한 경우에 사용한다. bson.M: 순서가 없는 map 형태. 순서를 유지하지 않는다는 점을 빼면 D와 같다. bson.A: 하나의 BSON array 형태. bson.E: D 타입 내부에서 사용하는 하나의 엘리먼트.

슬라이스는 내부적으로 사용하는 배열의 부분 영역인 세그먼트에 대한 메타 정보를 가지고 있다. 슬라이스는 크게 3개의 필드로 구성되어 있다. 내부적으로 사용하는 배열에 대한 포인터 정보 세그먼트의 길이 세그먼트의 최대 용량(Capacity) append append()가 슬라이스에 데이터를 추가할 때는 슬라이스 용량(capacity)이 아직 남아 있는 경우: 용량 내에서 슬라이스의 길이(length)를 변경하여 데이타를 추가한다. 용량(capacity)을 초과하는 경우: 현재 용량의 2배에 해당하는 새로운 Underlying array를 생성하고, 기존 배열 값들을 모두 새 배열에 복제한 후 다시 슬라이스를 할당한다. 아래 예제는 길이 0, 용량 3의 슬라이스에 1부터 15까지의 숫자를 계속 추가하면

Go 1.21에서는 go command와 Go toolchain이 함께 제공되며, 이를 사용하여 라이브러리들을 컴파일할 수 있다. Go 1.21 이상의 버전이 필요한 라이브러리는 go.mod 파일에서 해당 버전을 명시해야 한다. 프로젝트의 go.mod 파일은 라이브러리의 최소 요구 버전을 자동으로 업데이트하며, 버전 관리는 자동으로 처리된다.

Go에서 하기 쉬운 실수

slice를 선언할 수 있는 방법은 매우 다양하다. var s []string // empty=true, nil=trues = []string(nil) // empty=true, nil=trues = []string{} // empty=true, nil=falses = make([]string, 0) // empty=true, nil=false 책의 권장사항 var s[]string: 최종 길이를 모르고 슬라이스가 빌 수도 있는 경우 []string(nil): nil 슬라이스이면서 empty슬라이스를 생성하는 편의 구문 make([]strign, length): 최종 길이를 아는 경우. &x3C;이 경우는 실제 성능적으로 slice 길이를 조절하지 않아도 되기 때문에 성능이 좋은 편이다. 슬라

Jcmd is a recommended tool from JDK 7 onwards for enhanced JVM diagnostics with no or minimum performance overhead. Jcmd is a utility that sends diagnostic command requests to a running JVM. It must be used on the same machine on which JVM is running. Additional details are available in its documentation. The command syntax is as follows: Terminal windowjcmd [&x3C;options>] [&x3C;vmid&x3C;argument

가상스레드

2023년 9월 19일에 릴리즈된 Java 21에서 ‘가상 스레드’ 라는 기능이 추가되었다. 가상 스레드란 기존의 전통적인 Java 스레드보다 가벼운 경량 스레드이다. 자바의 전통적인 스레드는 OS 스레드를 랩핑(wrapping)한 것으로, 플랫폼 스레드라고도 부르는데, 경량 스레드는 OS 스레드를 그대로 사용하지 않고 JVM 자체적으로 내부 스케줄링을 통해서 사용할 수 있도록 한다.는 낭비를 줄여야 할 필요가 있었다. 이 때문에 Non-blocknig 방식의 Reactive Programming이 발전하였다. 비동기 방식의 Reactive 프로그래밍을 사용하면 낭비되었던 스레드를 다른 요청을 처리하는데 사용할 수 있다. 하지만 이런 Reactive 코드는 이해하기 어렵고, 다른 라이브러리를 모두

temporary value is freed

메모리 참조

In Rust, the error temporary value is freed occurs when a temporary value is deallocated before it is expected to be used. This typically happens when the temporary value goes out of scope and its memory is deallocated. If there are still references to this value after deallocation, it leads to a runtime error. To avoid this error, it’s crucial to ensure that the lifetimes of values match th

대부분의 요즘 운영 체제에서, 실행되는 프로그램의 코드는 프로세스 내에서 실행되고, 프로그램 내에서도 동시에 실행되는 독립적인 스레드를 가진다. 계산 부분을 여러 개의 스레드로 쪼개는 것은 프로그램이 동시에 여러 개의 일을 할 수 있기 때문에 성능을 향상시킬 수 있지만, 프로그램을 복잡하게 만들기도 한다. 러스트 표준 라이브러리는 언어 런타임의 크기를 작게 유지하기 위해 1:1 스레드 구현만 제공한다. 스레드 생성 새로운 스레드를 생성하기 위해서는 thread::spawn 함수를 호출하고, 새로운 스레드 내에서 실행하기를 원하는 코드가 담겨 있는 클로저를 넘기면 된다. use std::thread;use std::time::Duration; fn main() { thread::spawn(|| {

FFI(Foreign Function Interface)는 한 프로그래밍 언어에서 다른 프로그래밍 언어의 코드를 호출하기 위한 인터페이스를 말한다. Rust에서는 toml에 lib 형태로 저장한 crate방식으로 사용할 수 있다. Rust에서 C 코드 호출하기 snappy라는 C 라이브러리를 참조하는 코드 예시를 살펴보자. use libc::size_t; [link(name = "snappy")]extern { fn snappy_max_compressed_length(source_length: size_t) -> size_t; fn snappy_compress(input: *const u8, input_length: size_t,

Using extern keyword, you can link to or import external code. The extern keyword is used in two places in Rust. One is in conjunction with the crate keyword to make your Rust code aware of other Rust crates in your project, i.e., extern crate lazy_static;. The other use is in foreign function interfaces (FFI). extern is used in two different contexts within FFI. The first is in the form of

repr(Rust) First and foremost, all types have an alignment specified in bytes. A value with alignment n must only be stored at an address that is a multiple of n. So alignment 2 means you must be stored at an even address, and 1 means that you can be stored anywhere. Alignment is at least 1, and always a power of 2. Primitives are usually aligned to their size, although this is platform-sp

멀티 스레드 웹 서버 만들기

Docs에 있는 예제를 따라 정리한 글임을 미리 밝힙니다. 요청했을 때 아래와 같은 웹 화면을 반환하는 웹 서버를 만들어보자! &x3C;img height=“200px” src= Rust 프로젝트는 아래와 같이 생성할 수 있다. Terminal window$ cargo new hello --bin Created binary (application) `hello` project$ cd hello TCP 연결

Closure는 변수에 저장하거나 다른 함수에 인자로 넘길 수 있는 익명 함수이다. 한 곳에서 Closure를 만들고 실제 실행은 다른 곳에서 하도록 코드를 구성할 수 있게 한다. 상위 스코프 변수 참조 함수와 다르게 Closure는 호출되는 스코프로부터 변수들을 캡처할 수 있다. 변수를 참조하는 Closure를 정의했을 때, 해당 변수에 대한 소유권은 Closure가 가져간다. fn main() { let x = 4; let equal_to_x = |z| z == x; let y = 4; assert!(equal_to_x(y));} 함수에서 상위 스코프의 변수를 참조하는 경우 에러가 발생한다. fn main() { let x = 4; fn equal_to_x(z: i32)

구조체 Condvar는 Condition Variable의 약자로, 이벤트가 발생할 때까지 스레드를 차단하여 CPU 시간을 소비하지 않도록 하기 위해 사용한다. 조건 변수는 일반적으로 boolean predicate, 뮤텍스와 함께 사용된다. 스레드를 차단해야 한다고 판단하기 전에 뮤텍스 내에서 항상 조건을 검증한다. 이 모듈의 함수는 현재 실행 중인 스레드를 차단한다. 동일한 조건 변수에 여러 뮤텍스를 사용하려고 시도하면 런타임 패닉이 발생할 수 있다. 예제 use std::sync::{Arc, Mutex, Condvar};use std::thread; let pair = Arc::new((Mutex:

CustomAnnotation

개발시 프레임워크를 사용하다보면 여러 Annotation들을 볼 수 있다. (ex: @NotNull, @Controller, @Data 등) 이러한 어노테이션들은 라이브러리에 미리 정의되어있는 것인데, 우리가 직접 이 어노테이션을 생성하여 AOP로 기능을 부여해줄 수 있다. Annotation class 정의 Annotation을 정의하고 싶다면, @interface를 클래스 키위드 뒤에 붙이면 된다. @Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MyAnnotation { String param() default "paramsPost.content"; Class&x3C;?> checkClazz() d

Command line argument, flag

Command Line Argument 사용 Go 프로그램의 main() 함수는 C,C 등의 다른 언어에서 갖고 있는 argument 파라미터를 갖지 않는다. 따라서, Command Line의 Argument를 얻기 위해서는 os.Args 를 사용해야 한다. os.Args는 문자열 슬라이스로 정의되어 있고, Args는 프로그램의 Command Line 정보를 순서대로 담고 있다. var Args []string 프로그램이 2개의 argument를 가진다고 가정했을 때, os.Args[0:1]는 실행되는 Go 프로그램 이름을 가지며, os.Args[1:2]는 첫번째 argument를, os.Args[2:3]는 두번째 argument를 갖는다. 아래 예제는 프로그래명과 2개의 Command Line argume

1. 지연실행 defer Go 언어의 defer 키워드는 특정 문장 혹은 함수를 나중에 (defer를 호출하는 함수가 리턴하기 직전에) 실행하게 한다. 마지막에 Clean-up 작업을 위해 사용된다. 아래 예제는 파일을 Open 한 후 파일을 Close하는 작업을 defer로 써서, 어떤 에러가 발생하더라도 항상 파일을 Close할 수 있도록 한다. package main --1:403F53""os" func main() { f, err := os.Open("1.txt") if err != nil { panic(err) } // main 마지막에 파일 close 실행 defer f.Close() // 파일 읽기 bytes := make([]byte,

go.mod Module is go support for dependency management. A module by definition is a collection of related packages with go.mod at its root. The go.mod file defines the: Module import path. The version of go with which the module is created Dependency requirements of the module for a successful build. It defines both project’s dependencies requirement and also locks them to their correct version.

Profiling은 메모리 사용량, 함수별 CPU 점유 시간, tracing 등 어플리케이션을 동적으로 분석하는 것을 말한다. 서비스를 운영하는데 메모리 누수가 점점 쌓이거나 혹은 특정 로직 실행이 너무 오래걸릴 때 등 문제의 원인 파악을 용이하게 해준다. pprof는 Go 어플리케이션 데이터를 profiling해 분석하는 도구이다. Callstack과 symbolization 정보가 담겨있는 프로토콜 버퍼를 분석한다. Go로 만든 어플리케이션은 pprof를 이용해 편리하게 profiling을 할 수 있다. 분석할 수 있는 정보 분석할 수 있는 항목들은 다음과 같다. allocs: 메모리 할당을 샘플링한다. bl

고루틴 스케줄링

Go 런타임은 프로그램이 실행되는 내내 고루틴을 관리한다. Go 런타임은 모든 고루틴을 다중화된 스레드들에 할당하고 모니터링하며, 특정 고루틴이 블록되면 다른 고루틴이 실행될 수 있도록 교체하는 일을 반복한다. 이 말은 고루틴이 블록 되더라도 다중화된 스레드는 블록 되지 않는다는 것을 의미한다. CPU Core가 존재하고 있으며 OS Scheduler에 의해서 다수의 Thread가 Scheduling되어 동작하고 있는 모습을 나타내는 그림이다. Network Poller는 Network를 처리하는 별도의 독립된 Thread를 의미한다. Run Queue에는 GRQ (Global Run Queue)와 LRQ (Local Run Queue)가 2가지가 존재한다. GRQ는 의미 그대로

메모리 관리

Go는 힙에서 동적 할당이 필요한 메모리를 암묵적으로 할당한다. 할당이 암묵적으로 이뤄지기 때문에 코딩이 쉽지만, 메모리 할당과 해제가 명확하지 않으니 메모리 사용량이 높아질 수 있는 부분을 놓칠 가능성이 있다. Go는 참조 지향이 아닌 값 지향적 언어이다. Go 변수는 절대 객체를 참조하지 않고, 항상 객체의 전체 값을 저장한다. (포인터가 없다는 의미는 아니다.) 모든 변수 선언(함수 인자, 반환 인자, 메서드 리시버 포함)은 해당 타입 전체를 할당하거나 그 포인터만 할당한다. new(&x3C;type>)은 &x26;&x3C;type>과 동일하며, 힙 상의 포인터 박스와 별도의 메모리 블록에 타입을 할당한다. Go 할당자는 특정 스팬에 하나 혹은 여러 8KB 페이지를 포함하는 메모리

Inner static class

클래스를 사용하면서 외부 인스턴스에 대한 참조가 필요없는 클래스를 선언 시 Inner class may be static이라는 경고가 뜬다. Inner class가 static으로 정의되어야 한다는 뜻인데, 그래야하는 이유가 무엇일까? ‘static’키워드가 붙은 내부 클래스는 메모리에 하나만 올라가는 인스턴스가 아니다. MyClass.InnerClass mic1 = new MyClass().new InnerClass();MyClass.InnerClass mic2 = new MyClass().new InnerClass(); if (mic1 == mic2) { System.out.println("내부 클래스는 새로만들어도 같은 참조지");} else { System.out.println("내부 클래

JAR Java Archive의 약자 자바에서 사용되는 압축 파일의 한 형태로, 작동 방식은 흔히 자료를 압축하는 .zip과 유사. .jar는 압축을 따로 해제하지 않아도 JDK(Java Development Kit)에서 접근하여 사용이 가능 (JDK에 포함되는 JRE(Java Runtime Environment)만 가지고도 실행이 가능) .jar 파일은 일반적으로 라이브러리, 자바 클래스 및 해당 리소스 파일(텍스트, 음성, 영상자료 …), 속성 파일을 담는다. WAR WAR는 Web Application Archive의 약자로 웹 애플리케이션을 압축하고 배포하는데 사용되는 파일 형태. (.war 파일도 압축파일의 일종으로 .jar와 유사) WAR는 JSP, Servlet, Java C

객체 지향 프로그래밍(OOP, Object-Oriented Programming) 모든 데이터를 객체(object)로 취급하여 객체의 상태와 행동을 구체화 하는 형태의 프로그래밍 클래스 (class) 객체를 정의하는 틀 또는 설계도 필드 = 클래스에 포함된 변수 메소드 = (class에 종속된) 함수 static 클래스 변수 혹은 클래스 메소드 앞에 붙는거 인스턴스 변수와 다르게 인스턴스하지 않아도 그냥 사용가능 (클래스가 메모리에 올라갈 때 메소드 영역에 바로 저장 되기 때문) A라는 클래스 안에 num이라는 static 변수가 있으면 그냥 A.num하고 쓰면 됨 함수도 그냥 메소드 이름.하고 파라미터만 넣어서 씀 반면, 인스턴스 변수는 new 해서 인스턴스로 만든담에 힙 영역에 저장돼야 사용 가

JDKProxy와 CGLibProxy

Proxy를 구현한 것 중 가장 많이 쓰이는 종류로는 JDK Proxy와 CGLib Proxy가 있다. 두 방식의 가장 큰 차이점은 Target의 어떤 부분을 상속 받아서 프록시를 구현하느냐에 있다. JDK Proxy는 Target의 상위 인터페이스를 상속 받아 프록시를 만든다. 따라서 인터페이스를 구현한 클래스가 아니면 의존할 수 없다. Target에서 다른 구체 클래스에 의존하고 있다면, JDK 방식에서는 그 클래스(빈)를 찾을 수 없어 런타임 에러가 발생한다. 우리가 의무적으로 서비스 계층에서 인터페이스 -XXXXImpl 클래스를 작성하던 관례도 다 이러한 JDK Proxy의 특성 때문이기도 하다. 또한 내부적으로 Reflection을 사용해서 추가적인 비용이 발생한다. public class Exa

JLink Java is one of the most used programming languages for enterprise application development globally. However, developers often struggle with the size of the Docker images when deploying Java applications in Docker containers. One of the ways to solve this problem is to use JLink, a tool introduced in JDK 9. JLink (Java Linker) is a command-line tool that assembles and optimizes a set of modul

Heap 영역 구조와 GC

런타임 데이터 영역은 크게 Method영역, Heap영역, Stack영역 등등으로 나뉘어있는데, 런타임중 가장 많은 메모리가 새로 할당되는 영역이 Heap영역이기 때문에, GC 또한 Heap영역을 위주로 실행된다. 이때, Heap 영역은 GC와 메모리 관리를 위해 저장되어있는 데이터를 내부에서 여러 유형으로 분류하여 저장한다. Heap영역은 크게 3가지의 영역으로 나뉜다. Young Generation 영역 자바 객체가 생성되자마자 저장되는 영역이다. 이름 그대로 생긴지 얼마 안되는 어린 객체들이 속하는 곳이다. Heap 영역에 객체가 생성되면 그 즉시 Young Generation 중에서도 Eden 영역에 할당되고, 이 영역에 데이터가 어느정도 쌓이게 되면 참조정도에 따라 Servivor의 빈 공간으로

JVM 구성요소

JVM 구성요소는 아래와 같은 것들이 있다. 클래스 로더(Class Loader) 실행 엔진(Execution Engine) 인터프리터(Interpreter) JIT 컴파일러(Just-in-Time) 가비지 콜렉터(Garbage collector) 런타임 데이터 영역 (Runtime Data Area) 각각에 대해서 자세히 알아보자. 클래스 로더 JVM 내로 클래스 파일(*.class)을 로드하고, 링크를 통해 배치하는 작업을 수행하는 모듈이다. 런타임시 동적으로 클래스를 로드하고 jar 파일 내에 저장된 클래스들을 JVM 위에 탑재한다. 즉, 클래스를 처음으로 참조할 때, 해당 클래스를 로드하고 링크하는 역할을 한다. 실행 엔진 클래스 로더가 JVM내의 런타임 데이터 영역에 바이트 코드를 배치시

Java는 JVM 이라는 가상머신을 거쳐서 OS에 도달하기 때문에 OS가 인식할 수 있는 기계어로 바로 컴파일 되는게 아니라 JVM이 인식할 수 있는 Java bytecode(*.class)로 먼저 변환된다. .java 파일을 .class 라는 Java bytecode로 변환하는 것은 Java compiler의 역할이다. (바이트코드로) 직접 컴파일 하는방법 아래는 Java Compiler에 의해 ‘java’ 파일을 ‘.class’ 라는 Java bytecode로 만드는 과정이다. Java Compiler는 JDK를 설치하면 javac.exe라는 실행 파일 형태로 설치된다. 정확히는 JDK의 bin 폴더에 ‘javac.exe’로 존재한다. Java Complier 의 javac 라는 명령어를 사용하면 .cl

Permanent to Metaspace

JAVA8에서부터, Permanent가 사라지고 Metaspace가 생김으로써 그 역할을 일부 대체하게 되었다. Permanent는 JVM에 의해 크기가 강제되었지만, Metaspace는 OS가 자동으로 크기를 조절할 수 있는 Native memory 영역이기 때문에 기존과 비교해 큰 메모리 영역을 사용할 수 있게 되었다. Perm 영역에는 주로 클래스, 메소드 정보와 클래스 변수의 정보, static 변수와 상수 정보들이 저장되었는데, 이게 Metaspace로 대체되면서 Perm에 있었던 대부분의 정보가 Metaspace에 저장되도록 바뀌었다. 다만, 기존 Perm 영역에 존재하던 static Object는 Heap 영역으로 옮겨져서 최대한 GC의 대상이 될 수 있도록 하였다고 한다. The propos

Runtime Data Area

런타임 데이터 영역(Runtime Data Area)은 JVM이 자바 프로그램 실행을 위한 데이터와 명령어를 저장하기 위해 OS로부터 할당받는 메모리 공간이다. Runtime Data Area는 크게 Method영역, Heap영역, Stack영역, PC 레지스터 영역, Native Method Stack으로 나눌 수 있다. Method 영역 클래스 로더에 의해 로드된 클래스, 메소드 정보와 클래스 변수의 정보가 저장되는 영역이다. 프로그램 시작부터 종료될때까지 메모리에 적재되지만 명시적 null 선언시 GC가 청소하도록 만들 수 있다. 데이터가 가장 먼저 저장되는 영역이며, 모든 스레드가 공유한다. Heap 영역 런타임시 결정되는 참조 자료형이 저장되는 영역이다. new 연산자를 통해 생성

1. TLAB(Thread Local Allocation Buffers) JVM에서는 Eden 영역에 객체를 빠르게 할당(Allocation)하기 위해 bump the pointer와 TLABs(Thread-Local Allocation Buffers)라는 기술을 사용하고 있다. bump the pointer란 Eden 영역에 마지막으로 할당된 객체의 주소를 캐싱해두는 것이다. bump the pointer를 통해 새로운 객체를 위해 유효한 메모리를 탐색할 필요 없이 마지막 주소의 다음 주소를 사용하게 함으로써 속도를 높이고 있다. 이를 통해 새로운 객체를 할당할 때 객체의 크기가 Eden 영역에 적합한지만 판별하면 되므로 빠르게 메모리 할당을 할 수 있다. Heap 메모리에 새로운 객체가 생성될 때, 만

메모리누수

CS적으로 보면, 컴퓨터 프로그램이 필요하지 않은 메모리를 계속 점유하고 있는 현상이다. 할당된 메모리를 사용한 다음 반환하지 않는 것이 누적되면 메모리가 낭비된다. 즉, 더 이상 불핑요한 메모리가 해제되지 않으면서 메모리 할당을 잘못 관리할때 발생한다. 자바에서 메모리 누수 더이상 사용되지 않는 객체들이 GC에 의해 회수되지 않고 계속 누적되는 현상을 말한다. 메모리 누수가 생기면 Old 영역에 계속 누적된 객체로 인해 Major GC가 빈번하게 발생하게 되면서, 프로그램 응답 속도가 늦어지고 성능이 저하된다. 이는 결국 OutOfMemory Error로 프로그램이 종료되게 한다. 가비지 컬렉션을 소멸 대상이 되기 위해서는 어떠한 reference 변수에서 가르키지 않아야 한다. 다 쓴 객체에 대한 참조를

변수 선언시에 자바의 volatile 키워드 또는 코틀린의 @Volatile 애노테이션을 지정해줄 수 있다. 사전적으론 ‘휘발성의’라는 뜻을 가지며, 변수 선언시 volatile을 지정하면 값을 메인 메모리에만 적재하게 된다. Annotate INSTANCE with @Volatile. The value of a volatile variable will never be cached, and all writes and reads will be done to and from the main memory. This helps make sure the value of INSTANCE is always up-to-date and the same to all execution threads. It means that

JVM은 쓰레드를 New, Runnable, Running, Wating, Terminate의 다섯가지 상태로 관리한다. 쓰레드의 상태는 getState() 메서드 호출로 반환받을 수 있다. New 객체를 생성한 뒤, 아직 start() 메서드 호출되기 전의 상태이다. Runnable start() 메서드를 호출하여 동작시킨 쓰레드 객체는 JVM의 쓰레드 스케줄링 대상이 되며 Runnable 상태에 돌입하게 된다. 한 번 Runnable 상태에 돌입한 쓰레드는 다시 New 상태가 될 수 없다. Running Runnable 상태의 쓰레드는 큐에 대기하게 되는데, JVM은 각 쓰레드의 우선순위에 따라서 Running 상태로 만들어 쓰레드를 동작시킨다. 쓰레드 스케줄러에 의해 Running 상태로 이동하게된

wait()과 notifyAll()

wait()과 notifyAll()을 사용하면 스레드의 순서를 제어할 수 있다. 간단하게 말하자면 wait은 스레드를 대기하게 만들고, notifyAll(또는 notify)는 대기중인 스레드를 꺠워주는 역할을 하는데, 자세한 것은 예시 코드를 보며 이해해보자. package voting; public class VotingPlace { private String voter1; private String voter2; private boolean isEmptyPlace1; private boolean isEmptyPlace2; public VotingPlace() { this.isEmptyPlace1 = true; this.isEmptyPlace2 = t

record란? 불변(immutable) 데이터 객체를 쉽게 생성할 수 있도록 하는 새로운 유형의 클래스이다. JDK14에서 preview로 등장하여 JDK16에서 정식 스펙으로 포함되었다. 묵시적으로 추상 클래스인 Record를 상속받는다. 기존의 불변 데이터 객체 public class Person { private final String name; private final int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAg

예외와 에러

프로그래밍에서 예외(Exception)란 입력 값에 대한 처리가 불가능하거나, 프로그램 실행 중에 참조된 값이 잘못된 경우 등 정상적인 프로그램의 흐름을 어긋나는 것을 말한다. 그리고 자바에서 예외는 개발자가 직접 처리할 수 있기 때문에 예외 상황을 미리 예측하여 핸들링할 수 있다. 한편, 에러(Error)는 시스템에 무엇인가 비정상적인 상황이 발생한 경우에 사용된다. 주로 자바 가상머신에서 발생시키는 것이며 예외와 반대로 이를 애플리케이션 코드에서 잡으려고 하면 안 된다. 에러의 예로는 OutOfMemoryError, ThreadDeath, StackOverflowError 등이 있다. Checked Exception과 Unchecked Exception Exception은 다시 Check

제네릭과 variance

코틀린에서 제네릭과 variance를 다루는 방법에 대해 알아보기 전에, 제네릭과 variance의 정의가 무엇인지 먼저 살펴보자. 제네릭 프로그래밍 언어들에서 제공해주는 기능 중 하나인 제네릭은 클래스나 인터페이스 혹은 함수 등에서 동일한 코드로 여러 타입을 지원해주기 위해 존재한다. 한가지 타입에 대한 템플릿이 아니라 여러가지 타입을 사용할 수 있는 클래스와 같은 코드를 간단하게 작성할 수 있다. 예시 class Wrapper&x3C;T>(var value: T) fun main(vararg args: String) { val intWrapper = Wrapper(1) val strWrapper = Wrapper&x3C;String>("1") val doubleWrapper: Wrappe

const curry = f => (a, ..._) =_.length ? f(a, ..._) : (..._) =f(a, ..._); const go1 = (a, f) =a instanceof Promise ? a.then(f) : f(a); const go = (...args) =reduce((a, f) =f(a), args); const pipe = (f, ...fs) =(...as) =go(f(...as), ...fs); (a, ..._) =_.length ? f(a, ..._) : (..._) =f(a, ..._);const go1 = (a, f) =a instanceof Promise ? a.then(f) : f(a);const go = (...args) =reduce((a, f) =f(

Lexical Scope와 Closure

Lexical scope 프로그래밍에서 scope란 변수의 유효범위를 나타내는 용어이다. JavaScript는 함수를 어디서 선언하였는지에 따라 상위스코프를 결정하는 Lexical Scope를 따르고 있다. 다른 말로, 정적 스코프(Static scope)라 부르기도 한다. var num = 1; function a() { var num = 10; b();} function b() { console.log(num);} a(); 위 예제를 살펴보자. a 함수 내에서 호출하는 b 함수에서 참조하는 num은, 전역의 num을 참조하는 것이기 때문에 1이 출력된다. Closure 클로저는 주변 상태(어휘적 환경)에 대한 참조와 함께 묶인 함수의 조합이다. 즉, 클로저는 내부 함수에서 외부 함수의 범위에 대한

Kleisli composition은 함수형 프로그래밍에서 두 개의 Kleisli 함수를 조합하는 기술을 가리킨다. Kleisli 함수는 모나드를 사용하는 함수로, 입력을 받아 모나드 값을 반환한다. 이러한 함수를 조합하여 모나드 내의 값을 연속적으로 처리하거나 변환하는 작업을 가능하게 하는 것이 바로 Kleisli composition이다. // 모나드 M의 Kleisli 함수 정의kleisliFuncA :: A -> M&x3C;B>kleisliFuncB :: B -> M&x3C;C> // Kleisli 함수 조합composedKleisliFunc :: A -> M&x3C;C>composedKleisliFunc = kleisliFuncA >=> kleisliFuncB MkleisliFuncB :: B

useEffect 안에서 setInterval 사용하기

setInterval은 일정 시간마다 작업을 수행하는 메서드다. 주기적으로 카운트를 증가시키기 위해 이런 코드를 작성할 수 있다. function Counter() { let [count, setCount] = useState(0); useEffect(() => { let id = setInterval(() ={ setCount(count + 1); }, 1000); return () => clearInterval(id); }, []); return &x3C;h1>{count}&x3C;/h1>;} const rootElement = document.getElementById("root");ReactDOM.render(&x3C;Counter />, rootElement)

절대경로 설정

특정 컴포넌트나 파일을 import할 시 경로의 depth가 깊어지면 깊어질수록 import하려는 파일의 위치에 따라 상대경로가 상당히 길어질 수 있다. --1:403F53"deep from '../../../../../../../A/B/C/file.js';--1:403F53"deep1 from '../../../../../../../A/B/C/file1.js';--1:403F53"deep2 from '../../../../../../../A/B/C/file2.js';--1:403F53"deep3 from '../../../../../../../A/B/C/file3.js';--1:403F53"deep4 from '../../../../../../../A/B/C/file4.js'; 이런 식으로 상대경로가 길어

프로토타입

JavaScript에는 객체라는 구조가 존재하고, 각 객체에는 다른 객체에 대한 링크를 보유하는 프로토타입이라는 비공개 속성이 있다. 그 프로토 타입 객체도 자신만의 프로토타입을 가지고 있으며, 프로토타입으로 null을 가진 객체에 도달할 때까지 이 연결은 계속된다. 예시 코드 닭의 프로토타입을 참새로 지정하면, 닭의 날개갯수와 날수있나 값을 참조했을 때 참새가 가지고 있던 값과 동일한 값이 반환된다. 이떄 날수있나 값을 false로 재지정하면 값이 바뀌게 된다. function 참새(){ this.날개갯수 = 2; this.날수있나 = true;}const 참새1 = new 참새();console.log("참새의 날개 갯수 : ", 참새1.날개갯수); // 2 function 닭() { th

화살표 함수

ES6가 도입되면서, js에 화살표 함수라는 문법이 등장했다. 화살표 함수는 말 그대로 화살표(=>) 표시를 사용해서 함수를 선언하는 방법이다. // 기존 함수const foo = function () { console.log('기존 함수');} // 화살표 함수const foo = () =console.log('화살표 함수'); console.log(&x27;화살표 함수&x27;);"> 두 코드는 기능적으로 완전히 동일하게 작동한다. 그러나, 두 코드는 this 바인딩에서 차이가 있다. this 바인딩 JS의 this는 상황에 따라 다르게 바인딩 된다. 대표적으로 this에 바인딩되는 값들은 이렇다. 전역 공간의 this : 전역 객체메소드 호출 시 메소드 내부의 this : 해당 메소드를 호출한 객체함

코틀린에서 아래와 같은 방식으로 컬렉션을 사용할 수 있다. val set = hashSetOf(1, 7, 53)val list = arrayListOf(1, 7, 53)val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three") 자바의 컬렉션(Set,List,Map)과 동일한 구조이기 때문에 서로 호환된다. 코틀린의 컬렉션은 자바보다 더 많은 기능을 지원한다. fun main(args: Array&x3C;String>) { val strings = listOf("first", "second", "fourteenth") println(strings.last()) // 리스트의 마지막 원소를 가져온다. val numbers = setO

InlineFuntion과 Reified

inline 키워드는 자바에서는 제공하지 않는 코틀린만의 키워드이다. 코틀린 공식문서의 inline function을 보면, 코틀린에서 고차함수(High order functions, 함수를 인자로 전달하거나 함수를 리턴)를 사용하면 패널티가 발생한다고 나와있다. 패널티란 추가적인 메모리 할당 및 함수호출로 Runtime overhead가 발생한다는 것으로, 람다를 사용하면 각 함수는 객체로 변환되어 메모리 할당과 가상 호출 단계를 거치는데 여기서 런타임 오버헤드가 발생한다. inline functions는 내부적으로 함수 내용을 호출되는 위치에 복사하며, Runtime overhead를 줄여준다. 객체로 변환되는 오버헤드란? 아래와 같은 고차함수(함수를 인자로 전달하거나 함수를 리턴하는 함수)를 컴파일 하

Kotlin은 loop에 label을 지정해 break, continue 스코프를 정할 수 있다. label은 @ 식별자를 통해 지정할 수 있고, @abc, fooBar@ 처럼 사용할 수 있다. 아래는 내부 for문에서 break 한 경우 -바깥의 for문 까지 종료 시키는 예제와, continue의 next iteration을 바깥 for문으로 지정하는 예제이다. fun labelReturnJump() { loop@ for (i in 1..10) { // label 지정 for (j in 1..10) { if (i + j > 12) { break@loop // label을 통해 break } } }} fu

Sequences는 Collections와 비슷하게 Iterable한 자료구조이다. 하지만 Eager evaluation으로 동작하는 Collections와 다르게 Sequences는 Lazy evaluation으로 동작한다. Lazy evaluation과 Eager evaluation의 차이 Lazy evaluation은 지금 하지 않아도 되는 연산은 최대한 뒤로 미루고, 어쩔 수 없이 연산이 필요한 순간에 연산을 수행하는 방식이다. val fruits = listOf("apple", "banana", "kiwi", "cherry") fruits .filter { println("checking the length of $it") it.length > 5 } .ma

JAVA에는 field 상속이라는 개념이 없다. 하지만 kotlin에서는 override val과 같이 쓰면 필드를 상속받은 것 처럼 사용할 수 있다. data class Teacher( val id: UUID = UUID.randomUUID(), val accountId: String, val password: String) : Domain 이렇게 Teacher라는 클래스를 만들고, 그걸 상속받은 TeacherEntity라는 클래스를 만들면, TeacherEntity 안에 private 필드가 따로 만들어지는 것을 볼 수 있다. private이기 때문에 외부에선 함부로 참조할 수 없고, 마치 그냥 override 받은 것 같이 편하게 사용할 수 있다. 그래서 이 특성을 사용해서 POJO인

람다 표현식

람다는 익명 함수이며, 함수형 프로그래밍에서 자주 사용하는 패턴이다. 코틀린은 객체지향 프로그래밍 뿐만 아니라 함수형 프로그래밍 또한 지원하는 언어이기 때문에 당연히 람다 표현식을 사용할 수 있다. 익명함수 생성 익명함수는 아래처럼 이름없이 정의되는 함수를 말한다. 변수 printHello에 할당되고 있는 내용이 바로 익명함수이다. // 익명함수를 생성하여 printHello에 할당 val printHello = fun(){ println("Hello, world!") } // 익명함수 호출 printHello() 실행결과 Hello, world! 람다를 이용하면 더 간단히 익명함수를 정의할 수 있다. 아래는 위와 동일한 코드를 람다로 재작성 한 것이다. // 익명함수를 생성하

범위 지정 함수

범위 지정 함수는 특정 객체에 대한 작업을 블록 안에 넣어 실행할 수 있도록 하는 함수이다. 특정 객체에 대한 작업을 블록으로 묶으면 수행할 작업의 범위를 지정함으로써, 코드의 가독성을 개선할 수 있다. 코들린에서는 let, run, apply. also, with로 총 5가지의 기본 범위 지정함수를 지원한다. 하나씩 알아보도록 하자. public inline fun &x3C;TT.apply(block: T.() -> Unit): Tpublic inline fun &x3C;T, RT.run(block: T.() -> R): Rpublic inline fun &x3C;T, Rwith(receiver: T, block: T() -> R):R T.apply(block: T.() -Unit): Tpublic in

List와 MutableList

List는 수정이 불가능한 리스트이고, MutableList는 수정이 가능한 리스트이다. 내부 코드는 어떤 차이가 있을까? public interface Collection&x3C;out E: Iterable&x3C;E{ public val size: Int public fun isEmpty(): Boolean public operator fun contains(element: @UnsafeVariance E): Boolean override fun iterator(): Iterator&x3C;E> public fun containsAll(elements: Collection&x3C;@UnsafeVariance E>): Boolean } public interface Mu

Kotlin에서는 코틀린은 원시 타입(primitive type)과 래퍼 타입(wrapper type)을 따로 구분하지 않고, Null일 수 있는 타입과, Null이 불가능한 타입으로 나누어 사용한다. 널이 될 수 있는지 여부를 타입 시스템을 통해 확실히 구분함으로써 컴파일러가 여러 가지 오류를 컴파일 시 미리 감지해서 실행 시점에 발생할 수 있는 예외의 가능성을 줄일 수 있다. 또, null 처리를 위한 다양한 연산자를 지원한다. NULL이 될 수 있는 타입 ? !! 코틀린의 모든 타입은 기본적으로 널이 될 수 없는 타입이다. 타입 옆에 물음표(?)를 붙이면 널이 될 수 있음을 뜻한다. 느낌표 2개(!!)를 변수 뒤에 붙이면 NULL이 될 수 있는 타입의 변수이지만, 현재는 NULL이 아님을 나타낼 수

코틀린을 사용할 때 변수를 선언하려면 아래와 같이 한다. val 변수명: 타입var 변수명: 타입 String을 써서 문자열 데이터를 집어넣는다면 아래와 같이 할 수 있다. val name1: String = "kimeunbin"val name2: String = "kimeunbin" 근데 val과 var의 차이는 무엇일까? val val이 붙은 변수는 읽을 수만 있고 수정할 수는 없는 변수가 된다. 자바로 치면 final 키워드가 붙은 변수와 비슷하다. fun main(args: Array&x3C;String>){ val a: String = "aaa" a = "bbb" //에러가 난다! Val cannot be reassigned}){ val a: String = &x22;aaa&x2

제네릭과 variance

프로그래밍 언어들에서 제공해주는 기능 중 하나인 제네릭은 클래스나 인터페이스 혹은 함수 등에서 동일한 코드로 여러 타입을 지원해주기 위해 존재한다. 한가지 타입에 대한 템플릿이 아니라 여러가지 타입을 사용할 수 있는 클래스와 같은 코드를 간단하게 작성할 수 있다. 예시 class Wrapper&x3C;T>(var value: T) fun main(vararg args: String) { val intWrapper = Wrapper(1) val strWrapper = Wrapper&x3C;String>("1") val doubleWrapper = Wrapper&x3C;Double>(0.1)}(var value: T)fun main(vararg args: String) { val in

@JvmField는 get/set을 생성하지 말라는 의미이다. 다음 코틀린 코드에서 프로퍼티 var barSize는 getter/setter를 생성한다. class Bar { var barSize = 0} 자바로 변환해보면 getter/setter가 생성된 것을 볼 수 있다. public final class Bar { private int barSize; public final int getBarSize() { return this.barSize; } public final void setBarSize(int var1) { this.barSize = var1; }} 이번엔 @JvmField를 붙여보자 class Bar { @JvmField var barSiz

함수와 프로퍼티에 static 하게 접근할 수 있도록 추가적인 메서드 또는 getter / setter 를 생성한다. 다음 Bar 클래스는 barSize라는 변수를 companion object에 선언함으로써, 전역변수를 만들었다. class Bar { companion object { var barSize : Int = 0 }} 자바로 변환해보면 Bar클래스에 barSize는 선언되었지만 getter/setter는 Bar.Companion 클래스에 등록된 것을 볼 수 있다. public final class Bar { private static int barSize; public static final class Companion { public final int g

코틀린에서 클래스를 정의하는 키워드는 class이다. 하지만 간혹 object 키워드로 클래스 정의하는 경우를 볼 수 있다. object로 클래스를 정의하면, 싱클턴(Singleton) 패턴이 적용되어 객체가 한번만 생성되도록 한다. 코틀린에서 object를 사용하면 싱글톰을 구현하기 위한 Boiler plate를 작성하지 않아도 된다. 또는, 익명 객체를 생성할 때 쓰이기도 한다. object의 용도 싱글턴 클래스로 만들 때 익명 클래스 객체를 생성할 때 싱글턴 클래스 정의를 위한 Object 아까도 말했듯, object로 싱글턴 클래스를 정의할 수 있다. 원래 클래스를 정의할때 class가 있는 자리에 object를 입력해주면 이 클래스는 싱글턴으로 동작하게 된다. object CarFactory {

Sealed Class, interface

Sealed Classe 와 Enum Classe 의 공통점 Sealed Classe와 Enum Class는 모두 하나의 클래스로 여러 가지 상태를 열거할 때 사용한다. 예를 들어, API 통신 결과를 핸들링하고 싶을 때 사용하는데 sealed class 경우 아래와 같이 소스코드를 작성한다. 예를 들어, sealed class를 사용하면 다음과 같이 API 통신 결과를 핸들링 하기 위해 사용할 수 있다. sealed class Resource&x3C;T>(val data: T? = null, val message: String? = null) { class Success&x3C;T>(data: T) : Resource&x3C;T>(data) class Loading&x3C;T>(data: T? =

생성자 주 생성자 (Primary Constructor) 코틀린에선 클래스를 선언하는 동시에 주생성자를 만든다. 주 생성자는 생성자 파라미터를 지정하고 그 생성자 파라미터에 의해 초기화되는 프로퍼티를 정의하는 두 가지 목적으로 쓰인다. (주 생성자에 넣는 파라미터는 자동으로 필드에 추가된다.) class User constructor(val username: String) constructor 키워드 생략 class User(val username: String) 접근 제어자 class User private constructor(val username: String) 접근 제어자를 설정하는 경우엔 constructor 키워드를 삭제할 수 없다. 부 생성자 (Secondary Constructor) 부 생

코틀린에서의 Static

코틀린에는 static 키워드가 없다. 자바와 같이 정적 변수 혹은 메서드를 사용하려면 다른 방법을 사용해야한다. 클래스 외 필드 선언 package foo.bar; class Foo { public static final String BAR = "bar"; public static void baz() { // Do something }} 자바에서 static을 사용해서 위와 같이 작성해야할떄, 코틀린에선 이렇게 사용할 수 있다. package foo.bar const val BAR = "bar" fun baz() { // Do something} 위와 같이 Foo.kt 파일에 정의한 속성 및 함수는 자바에서 각각 FooKt.BAR 및 FooKt.baz()로 접근할 수

클래스 상속

상속은 클래스의 기능을 확장하고자 할때 현재의 클래스의 기능을 모두 가지고 자신만의 기능이 추가된 새로운 클래스를 정의 하는 방법이다. 따라서 상속을 하게 되면 클래스가 상, 하의 계층구조를 가지게 된다. 코틀린에서 모든 클래스는 공통의 상위클래스(superclass)로 Any 클래스를 가진다. 클래스에 상위 클래스를 선언하지 않아도 기본적으로 Any가 상위 클래스가 된다. 마치 JAVA에서 Object가 클래스의 기본 상위 클래스가 되는 것괴 비슷하다. 하지만 클래스 내용이 같지는 않다. Any와 Object 비교 Kotlin의 Any보다 Java의 Object가 가지는 메서드의 수가 더 많다. public open class Any { public open operator fun equals(

필드와 접근자 메서드

주 생성자를 만들면 클래스의 필드가 알아서 생성된다. class User(var username: String) 정말 간단하다! 접근자 메서드인 getter와 setter는 코틀린이 알아서 만들어준다. class User( var name: String val age: Int) 읽기 전용 필드를 만들 수도 있다. var 대신 val을 앞에 붙여 선언하면, getter 함수만 생성된다. val은 수정할 수 없는 필드기 때문에, final과 비슷하다. 필드에 접근할 때는 그냥 변수에 접근하듯이 사용하면, 코틀린에서 내부적으로 접근자 메서드를 사용하는 것 처럼 작동한다. class User( var name: String val age: Int) fun main(args: Array&x3C

C++에는 기본인자라는 개념이 있다. include &x3C;iostream> int add(int a, int b=10) { return a + b;} int main(){ int res = add(5, 7); std::cout &x3C;&x3C; "res : " &x3C;&x3C; res &x3C;&x3C; std::endl; res = add(5); std::cout &x3C;&x3C; "res : " &x3C;&x3C; res &x3C;&x3C; std::endl; return 0;}int add(int a, int b=10) { return a + b;}int main(){ int res = add(5, 7); std::cout res: 12res: 15 add

String과 str fn main() { let s1: &x26;str = "World"; println!("s1: {s1}"); let mut s2: String = String::from("Hello "); println!("s2: {s2}"); s2.push_str(s1); println!("s2: {s2}"); let s3: &x26;str = &x26;s2[6..]; println!("s3: {s3}");} Rust에서 &x26;str은 문자열 슬라이스에 대한 (불변) 참조이다. (C++의 const char*와 유사하지만 항상 유효한 문자열을 가리킨다) String은 문자열을 담을 수 있는 버퍼이다. (문자열을 이루는 바이트에 대한 백터(Vec)이

여러 타입(type)의 공통된 행위/특성을 표시한 것을 Trait이라고 한다. Rust에서의 Trait는 (약간의 차이는 있지만) 다른 프로그래밍 언어에서의 인터페이스(interface)와 비슷한 개념이다. Trait는 trait 라는 키워드를 사용하여 선언하며, trait 블럭 안에 공통 메서드의 원형(method signature)을 갖는다 trait Draw { fn draw(&x26;self, x: i32, y: i32);} Rectangle 이라는 구조체에 Draw 라는 trait를 구현하기 위해서는 impl 트레이트명 for 타입명과 같이 정의하고 trait 안의 메서드들을 구현하면 된다. struct Rectangle { width: i32, height: i32} i

Rust에서 데이터를 표현하는 구조체(혹은 enum, trait 객체)의 맥락에서 그 구조체와 연관된 함수들을 정의할 수 있는데, 이렇게 연관되어진 함수들을 메서드라 한다. 메서드는 맥락이 되는 구조체 인스턴스로부터 호출되어 사용된다. Rust에서 구조체(struct)에 메서드들을 구현하는 구현 블럭(implementation block)은 “impl” 키워드를 사용하여 정의된다. impl 구현블럭 impl 키워드는 구현 블럭(implementation block)을 정의할 때 사용하는데, impl 뒤에 타입명을 적고 impl 블럭 안에 메서드(method) 혹은 연관 함수(associated function)를 넣게 된다. impl 안에 정의된 함수는 그 타입과 연관된 함수라는 의미에서 Associated

Rc 타입과 Weak 타입

메모리 참조

소유권 규칙에 따라 Rust에서 어떤 값은 여러 소유자를 가질 수 없다. Reference Counted를 의미하는 Rc는 힙 메모리에 할당된 타입 T 값의 소유권을 공유할 수 있게 해주는 타입이다. 즉, 스마트 포인터 Rc를 사용하면 타입 T의 값에 대한 여러 개의 소유자를 만들 수 있다. 기본적으로, Rc 타입은 Clone Trait을 구현하고 있고 clone을 호출해서 T 값에 대한 새로운 포인터를 생성하며, 모든 Rc 포인터가 해제되면 메모리에 할당된 T 값이 drop되는 구조이다. Rust에서 공유된 참조자는 수정할 수 없는데, Rc 타입 또한 예외가 아니며 일반적인 방법으로는 mutable한 참조를 얻을 수 없다. 만약, mutable 한 참조가 필요하면 Cell 타입이나 RefCel

메모리 참조

unwrap을 호출한 객체는 기본적으로 복사를 수행한다. 복사와 소유권 이동 둘다 가능한 시점에서 복사가 발생한다. fn main() { let s = Some(12); let a = s.unwrap(); println!("{}", a); let b = s.unwrap(); println!("{}", b);} 복사를 수행하기 위해서는 해당 타입이 Copy 트레잇을 구현해야 한다. 복사가 안된다면 메모리 소유권 이동이 발생한다. struct MyStruct{ x:i32, y:i32,} fn main() { let s = Some(MyStruct { x: 123, y: 1, }); let a = s.unwrap();//소유권 이

소유권과 Lifetime

메모리 참조

기본적으로 모든 변수 바인딩은 유효한 “범위(스코프)“를 가지며, 범위 밖에서 변수 사용하면 에러가 발생한다. 스코프가 종료되면 변수는 “삭제(drop)“되었다고 하며 그 변수의 데이터는 메모리에서 해제된다. Rust에서는 스코프가 종료될 때 다른 리소스를 해제하기 위해 소멸자가 호출되도록 하는 것을 변수가 값을 소유한다고 정의한다. 러스트의 각각의 값은 해당값의 오너(owner)라고 불리우는 변수를 갖고 있으며 한번에 딱 하나의 오너만 존재할 수 있다. fn main() { let s1: String = String::from("Rust"); let s2: String = s1;} 위 코드는 "Rust"라는 String 값에 대한 소유권을 s1에서 s2로 이전한다. s2에 s1을 대입

스마트 포인터 활용

메모리 참조

스마트 포인터(Smart Pointer)는 포인터처럼 작동하지만 추가적인 메타데이터와 능력들도 가지고 있는 데이터 구조이다. String과 Vec&x3C;T>는 스마트 포인터이다. 스마트 포인터는 보통 구조체를 이용하여 구현되어 있다. 스마트 포인터가 일반적인 구조체와 구분되는 특성은 스마트 포인터가 Deref와 Drop 트레잇을 구현한다는 것이다. Deref 트레잇은 스마트 포인터 구조체의 인스턴스가 참조자처럼 동작하도록 하여, 참조자나 스마트 포인터 둘 중 하나와 함께 작동하는 코드를 작성하게 해준다. 스마트 포인터가 평범한 참조자처럼 취급될 수 있도록 구현한다. Deref를 구현한 구조체에 대해 *로 값을 참조하면, deref 함수를 호출한 후 *를 한번 호출하는 것으로 대치된다.

Anyhow는 일반화된 Error 타입을 이용해 코드에서 발생하는 에러를 한 가지 타입으로 처리할 수 있게 도와주는 라이브러리이다. Rust에서는 엄격하게 타입을 검사하기 때문에, 여러 라이브러리에서 사용하는 서로 다른 에러 타입을 처리하기 위해서는 map_err로 에러를 변환해 통일하거나 Box&x3C;dyn std::error::Error>를 이용해 타입을 일반화하거나 타입의 제약조건을 덜어내는 방법을 사용한다. map_err을 사용할 때는, 문자열로 에러를 변환하거나 새로운 에러 타입을 만들어 통일한다. fn stringify(x: u32) -> String { format!("error code: {}", x) } let x: Result&x3C;u32, u32= Err(404);x.map

조건문과 반복문

조건문 일반적인 if 조건문은 다른 언어와 비슷하게 사용할 수 있다. fn main() { let number = 6; if number % 4 == 0 { println!("number is divisible by 4"); } else if number % 3 == 0 { println!("number is divisible by 3"); } else if number % 2 == 0 { println!("number is divisible by 2"); } else { println!("number is not divisible by 4, 3, or 2"); }} match match라는 흐름 제어 연산자를 사용할

타입과 변수

변수 정의 변수를 정의할 때는 let 키워드를 사용한다. 타입 추론을 지원하기에 타입 정의 부분을 생략해도 된다. let thing1: i32 = 100;let thing2 = 200 + thing1; // mut은 mutable을 의미하는 것으로, 수정 가능한 변수인지를 표현한다.let mut changing_thing = true;changing_thing = false; let (part1, part2) = ("first", "second"); struct Example { a: bool, b: u64,} let Example { a, b: _ } = Example { a: true, b: 10004,};assert!(a); // 변수 이름을 shadowing 해서 정의할 수도

함수와 메서드

함수 fn main() { print_fizzbuzz_to(20);} fn is_divisible(n: u32, divisor: u32) -> bool { if divisor == 0 { return false; } n % divisor == 0} fn fizzbuzz(n: u32) -> String { let fizz = if is_divisible(n, 3) { "fizz" } else { "" }; let buzz = if is_divisible(n, 5) { "buzz" } else { "" }; if fizz.is_empty() &x26;&x26; buzz.is_empty() { return format!("{n}"); } f

자바<？>와 코틀린<*>

자바 코드를 코틀린으로 변환하던 중 이슈가 발생했다. 자바 코드 private final ConcurrentMap&x3C;String, EventEntry&x3C;?>eventListeners = ConcurrentHashMap(); ... public void onEvent(NamespaceClient client, String eventName, List&x3C;Object> args, AckRequest ackRequest) { EventEntry entry = eventListeners.get(eventName); Queue&x3C;DataListenerlisteners = entry.getListeners(); for (DataListene

직렬화 serialVersionUID

가끔 자바코드에서 이런 코드를 발견할 때가 있다. private static final long serialVersionUID = 3487495895819393L; 이 serialVersionUID라는 long 타입의 상수는 직렬화할 객체의 버전이 바뀌었는지 식별하기 위한 클래스의 고유 식별자이다. 직렬화와 역직렬화 할때 이 값이 동일하면 동일한 클래스의 데이터라는 것을 확인할 수 있고, 그렇지 않은 경우에는 다르거나 바뀐 클래스라고 생각하여 오류를 throw할 수 있다. 자바 스펙에 따르면, serialVersion을 명시적으로 선언해놓지 않았을 땐 직렬화 런타임이 기본 serialVersion을 클래스의 기본 해쉬값을 가지고 자동으로 계산해준다고 한다. 하지만 JVM에 의한 default ser