(구현) KGrep

📝 작성 배경

최근에 이런저런 이유로 라이브 코딩테스트에 관심을 갖게 되었는데, 쿠키런으로 유명한 데브시스터즈 라는 회사에 라이브 코테가 유명하다고
어디서 들어서 어떤 식으로 진행되는지 궁금하여 찾아보던 중 데브시스터즈에서 22년도에 작성된 게시글을 하나 발견하게 되었고,
해당 게시글에 있는 문제중 grep 을 직접 구현해보는 문제가 있어 주말에 잠깐 풀어봤는데 재미있게 풀었던 기억이 있어
해당 내용에 대해 작성해보려고 한다.

문제에 대한 자세한 내용 및 궁금한 내용은 아래 데브시스터즈 게시글을 참고하면 좋을것 같다.

---

👓 선 3줄 요약

• Kotlin으로 grep과 유사한 기능을 하는 문자열 검색 도구를 먼저 싱글스레드로 구현한 후 멀티스레드로 개선하였다.
• 파일 탐색과 문자열 검색을 분리하고 파일 단위로 스레드를 할당하는 방식으로 병렬 처리를 구현하였다.
• 멀티스레드 버전(KGrepV2)은 원본 grep보다 약 88% 빠른 속도(1.16초 vs 9.69초)를 보였으나, CPU 자원은 약 8.5배(832% vs 98%) 더 많이 사용한다.

---

🔍️ 문제 요구사항

쿠키런 회사 답게 문제에도 쿠키가 등장 하는걸 볼 수 있다.

용감한 쿠키는 평소 사용하는 파일 내 문자열 검색 툴 grep보다 더 빠른 속도를 자랑하는 ack나 ag같은 다양한 툴들이 있다는 것을 들었다.
자신만의 dgrep을 만들어 널리 세상을 이롭게 하고 싶다고 생각하게 된 용감한 쿠키는 그 첫 단계로 멀티스레드로 동작하는 grep을 직접 만들어보기로 결심하였다.
원하는 스펙에 맞는 파일 내 문자열 검색 툴을 만들어보자.

입력 형식
 - dgrep {keyword} {relative path}

출력 형식
 - 파일의 각 line에 keyword가 있는 경우, 해당 파일과 줄 번호를 출력한다.

조건
1. relative path가 디렉토리인 경우 디렉토리 내 모든 파일에 대해 검사를 진행한다.
2. relative path 내에 또 다른 디렉토리가 존재하는 경우, 각 디렉토리 내 모든 파일에 대한 검사 또한 진행한다.
3. 멀티 스레드를 이용하여 최대한 빠르게 작업을 완료하도록 작성한다.
4. 동일한 파일에 대한 검사 결과는 한 번에 출력되어야 한다.
5. Directory 내 symlink는 없다고 가정한다.
6. 파일들은 모두 UTF8 인코딩으로 작성된 Text파일이라고 가정한다.

많이 사용되는 grep 이라는 툴 보다 조금 더 빠르게 문자열을 검색할 수 있는 기능을 갖은 dgrep 을 만들라는 요구사항이다. grep 의 많은 기능들 중 심플한 keyword 조회 기능에 대해 구현 하면 되는 문제라고 생각했다.

➡️ 접근 방향

grep 은 평소에도 많이 사용하고 있는 툴이라 요구사항을 이해하는데 어려움이 있진 않았다.

가장 먼저 생각한 부분은 어떻게 하면 내가 주력으로 사용하는 언어에서 grep 과 같은 동작을 하는 프로그램을 만들수 있을지에 대한 부분이였다. 당연히 grep 보다 빨라야 하는데, 처음부터 빠름에 집중을 하면 거기에 너무 매몰될것 같아. 우선 grep 처럼 동작하는 프로그램을 만들고 속도를 개선시키는 방향으로 진행하는게 좋을것 같다고 생각했다.

✨ 구현

싱글 스레드

kotlin 을 사용해서 구현했다. 이름도 살짝 변경해봤다.(dgrep -> kgrep

class KGrep(
    private val keyword: String,
    private val path: String
) { }

fun main(args: Array<String>) {
    val keyword: String = args[0]
    val path: String = args[1]
    val kGrep = KGrep(keyword, path)
}

우선 KGrep 이라는 클래스를 선언했다. 해당 클래스는 keyword와 path 두개의 properties 를 갖고 있다. 그 이후 main 함수를 만들어줬다. KGrep 애플리케이션을 실행 했을때 동작의 주체가 되는 함수다. Java 도 그렇고 Kotlin 도 그렇고 main 함수에서 args 즉 arguments 리스트를 파라미터로 받을 수 있는데 이 부분을 적극 활용했다. 이렇게 선언을 하게되면 jar 파일을 실행 했을때 뒤에 파리미터를 띄어쓰기로 구분하여 넘겨줄 수 있게 된다.

java -jar KGrep.jar "keyword" "path"

위의 예시처럼 KGrep.jar 파일을 실행 시킬때 뒤에 keyword 와 path 를 넣어줄 수 있고, 이걸 main 함수에서 사용할 수 있게 된다.

다음으로는 main 함수에서 호출 할 KGrep 내부의 search 메서드를 선언했다.

class KGrep(
    private val keyword: String,
    private val path: String
) {
    fun search() {
        val startPath = File(path)
    }
}

// ...

여기서 부터 고민되는 부분이 있었는데, 요구사항을 보면 디렉토리 내부에 또 다른 디렉토리가 있을 수 있으며, 내부적으로 들어있는 디렉토리에 대해서도 문자열 검색을 해야한다는 내용이 있다.

여기서 들었던 고민이 있었다.

1. path 안에 있는 모든 디렉토리에 대해 file 탐색을 먼저 진행하고, 해당 file 들에 대해 순차적으로 문자열 검색을 할지
2. file 탐색과 문자열 검색을 함께 진행할지

나는 1번 방법을 선택하기로 했다. 가장 큰 이유로는 글을 좀더 보다보면 나올텐데 멀티 스레드에 대한 고려를 안할 수 없었기 때문이다.
단순 CLI 롤 통해 동작하는 프로그램을 만드는 거라면 2번 방법이 더 적합 하다 생각했고 그렇게 구현을 했을것 같은데
멀티 스레드 환경에서 구현을 빠르고 간단하게 하기 위해 1번 방법을 선택하게 되었다.

단순 CLI 를 통해 동작하는 프로그램은 2번을 선택했을거라 했는데 그 이유는 1번 방법을 사용하면 아래와 같은 부분이 마음에 걸렸기 때문이다.

1. 디렉토리 내부의 모든 file 을 메모리에 적재 시켜야 한다.
2. file 탐색이 끝날때까지 문자열 탐색을 진행하지 않기 때문에 결과물 출력이 느리다.

다시 돌아가서 search 메서드의 내부를 확인해 보자.

private val filesToProcess: Queue<File> = LinkedList()

fun search() {
    val startPath = File(path)
    collectFiles(startPath)
}

private fun collectFiles(startPath: File) {
    when {
        startPath.isFile -> filesToProcess.add(startPath)
        startPath.isDirectory -> startPath.listFiles()?.forEach { collectFiles(it) }
        else -> println("Cannot process this path: ${startPath.absolutePath}")
    }
}

Queue에 디렉토리를 탐색하여 file 을 저장하는 collectFiles 메서드를 추가했다.
startPath 를 조사해서 파일이라면 Queue 에 적재를, 디렉토리면 listFiles 메서드를 통해 해당 디렉토리에 있는 모든 file 및 디렉토리를 갖고 온 뒤 forEach 와 재귀를 통해 file 리스트를 다시 한번 탐색하게된다.

다음으로는 저장한 file에 대해 문자열을 검색하는 searchInFile 메서드를 추가했다.

private val results = HashMap<String, List<Pair<Int, String>>>()

private fun searchInFile(file: File) {
    if (!file.isFile || !file.canRead()) {
      return  
    }
    val matchingLines: MutableList<Pair<Int, String>> = mutableListOf()
    file.useLines { lines ->
        lines.forEachIndexed { index, line ->
            if (line.contains(keyword)) {
                matchingLines.add((index + 1) to line.trim())
            }
        }
    }
    if (matchingLines.isNotEmpty()) {
        results[file.path] = matchingLines
    }
}

파라미터로 넘겨 받은 file 에 대해 간단하게 검증을 진행 한 뒤 특정 포멧에 맞게 결과물을 출력하기 위해 matchingLines 리스트에 값을 저장하고 있다.
kotlin 에서는 기본적으로 정말 다양한 함수들이 제공되고 있는데 해당 메서드에서 여러 함수들을 사용하여 손쉽게 구현이 가능했다.

• useLines : file 을 bufferedReader 로 라인단위로 처리하여 각 라인 마다 Sequence<String> 형태로 접근할 수 있도록 해주는 함수이다. 내부에서 use 를 사용하고 있기 때문에 별도로 리소스 정리를 할 필요가 없어 매우 편리하다.
• forEachIndexed : 순회를 하면서 값과 index 를 함께 사용할 수 있게 해주는 함수이다.
• contains : 특정 값을 포함하고 있는지 확인할 수 있도록 해주는 함수이다. 위 3개의 함수를 사용했고, 탐색을 통해 검색하고자 하는 문자열이 포함되어 있으면 결과물을 담는 results 에 저장하도록 동작하고 있다.

마지막으로 살펴볼 메서드는 결과물을 출력해주는 메서드다.

private fun printResults() {
    results.keys.sorted().forEach { filePath ->
        println("File: $filePath")
        results[filePath]?.forEach { (lineNumber: Int, line: String) ->
            println("Line $lineNumber: $line")
        }
    }
}

searchInFile 메서드에서 results 에 저장한 결과물에 대해 모든 탐색이 끝나고 한번에 출력을 해주는 메서드이다. 결과물에 대해 순차적으로 보여질 수 있도록 sorted를 활용했고, results 에 있는 Paire<Int, String> 에 대해 lineNumber 와 line 을 출력하도록 만들었다.

여기까지가 싱글 스레드로 동작하는 KGrep 의 구현 내용이다. 이걸 앞으로 KGrepV1 으로 명칭하자.
그럼 이제 성능 테스트를 진행해보자. 먼저 성능 테스트를 위해 몇가지 작업이 필요하다.

1. 테스트 데이터 생성
2. 구현한 KGrepV1 을 컴파일하고 .jar 파일로 만들자.
3. 만든 .jar 파일을 실행시키는데 time 명령어를 통해 어느정도 시간이 소요 되었는지 확인해보자.
4. grep 과 KGrepV1 을 각각 실행 시키고 성능을 비교해보자.

테스트 데이터는 아래와 같다.(여러 파일 중 총 6개의 파일만이 “keyword” 라는 단어를 갖고 있다.)

test-data/
├── test.json
├── dir_0/
│   ├─ file_0.txt # 100만줄의 텍스트 데이터
│   ...
│   └─ file_9.txt
...
└── dir_9/
     ├─ file_0.txt
     ...
     └─ file_9.txt

성능 비교 결과는 아래와 같다.

kotlinc KGrepV1.kt -include-runtime -d KGrepV1.jar # .jar 파일 생성
time java -jar KGrepV1.jar "keyword" "test-data"   # time 을 통한 성능 측정

# result (m3 pro 12 core 12 thread, RAM 18GB 기준)
## KGrepV1
File: test-data/dir_1/file_0.txt
Line 501: Line 500 in file_0.txt of dir_1. Contains keyword.
File: test-data/dir_3/file_7.txt
Line 501: Line 500 in file_7.txt of dir_3. Contains keyword.
File: test-data/dir_4/file_2.txt
Line 501: Line 500 in file_2.txt of dir_4. Contains keyword.
File: test-data/dir_5/file_5.txt
Line 501: Line 500 in file_5.txt of dir_5. Contains keyword.
File: test-data/dir_8/file_0.txt
Line 501: Line 500 in file_0.txt of dir_8. Contains keyword.
File: test-data/test.json
Line 2: "name": "keyword"
java -jar KGrepV1.jar "keyword" "test-data"  3.37s user 0.81s system 95% cpu 4.365 total

## grep
test-data/dir_5/file_5.txt:Line 500 in file_5.txt of dir_5. Contains keyword.
test-data/dir_4/file_2.txt:Line 500 in file_2.txt of dir_4. Contains keyword.
test-data/dir_3/file_7.txt:Line 500 in file_7.txt of dir_3. Contains keyword.
test-data/test.json:  "name": "keyword"
test-data/dir_1/file_0.txt:Line 500 in file_0.txt of dir_1. Contains keyword.
test-data/dir_8/file_0.txt:Line 500 in file_0.txt of dir_8. Contains keyword.
grep --color=auto --exclude-dir={.bzr,CVS,.git,.hg,.svn,.idea,.tox,.venv,venv  8.81s user 0.36s system 99% cpu 9.245 total

KGrepV1 과 grep 비교 결과

항목	KGrepV1.jar	grep
사용자 시간 (user)	3.37s	8.81s
시스템 시간 (system)	0.81s	0.36s
CPU 사용률	95%	99%
총 소요 시간	4.365s	9.245s

KGrepV1 이 리소스는 적게 사용하지만, 빠르게 처리하는 모습을 볼 수 있었다. KGrepV1 과 grep 모두 CPU 를 100% 내외로 사용하고 있는 모습이다.(중요!)

이제 여기에 멀티 스레드를 도입하여 성능을 개선시켜 보자.

KGrepV1 의 전체 코드는 아래와 같다. 간단한 예외 처리등을 추가했다.

package com.crispinlab.kgrep

import java.io.File
import java.util.LinkedList
import java.util.Queue

class KGrepV1(
    private val keyword: String,
    private val path: String
) {

    private val filesToProcess: Queue<File> = LinkedList()
    private val results = HashMap<String, List<Pair<Int, String>>>()

    fun search() {
        val startPath = File(path)
        collectFiles(startPath)
        val fileCount: Int = filesToProcess.size
        for (count: Int in 0 until fileCount) {
            val file: File = filesToProcess.poll() ?: break
            searchInFile(file)
        }
        printResults()
    }

    private fun collectFiles(startPath: File) {
        when {
            startPath.isFile -> filesToProcess.add(startPath)
            startPath.isDirectory -> startPath.listFiles()?.forEach { collectFiles(it) }
            else -> println("Cannot process this path: ${startPath.absolutePath}")
        }
    }

    private fun searchInFile(file: File) {
        if (!file.isFile || !file.canRead()) return
        val matchingLines: MutableList<Pair<Int, String>> = mutableListOf()
        file.useLines { lines ->
            lines.forEachIndexed { index, line ->
                if (line.contains(keyword)) {
                    matchingLines.add((index + 1) to line.trim())
                }
            }
        }
        if (matchingLines.isNotEmpty()) {
            results[file.path] = matchingLines
        }
    }

    private fun printResults() {
        results.keys.sorted().forEach { filePath ->
            println("File: $filePath")
            results[filePath]?.forEach { (lineNumber: Int, line: String) ->
                println("Line $lineNumber: $line")
            }
        }
    }
}

fun main(args: Array<String>) {
    if (args.size < 2) {
        println("Usage: kgrep <keyword> <relative path>")
        return
    }

    val keyword: String = args[0]
    val path: String = args[1]

    val kGrep = KGrepV1(keyword, path)
    kGrep.search()
}

멀티 스레드

싱글 스레드로 구현한 KGrepV1 에서 변경된 부분만 빠르게 살펴보자.

우선 사용하던 자료구조들을 멀티 스레드 환경에서 사용가능하도록 지원해주는 자료구조로 변경했다.

private val results = ConcurrentHashMap<String, List<Pair<Int, String>>>()
private val filesToProcess = ConcurrentLinkedQueue<File>()

코틀린에서 멀티 스레드를 사용하는 방법에는 여러가지 방법이 있는데 나는 java 에서 지원하면서 kotlin 에서 바로 사용 가능한 ExcutorService api 를 사용했다. 멀티 스레드를 사용함에 있어 스레드 관리가 중요한데 내부적으로 그걸 해주면서도 thread pool 을 사용할 수 있어 선택하게 되었다.

thread pool 의 개수는 현재 runtime 에서의 사용가능한 CPU 코어 수 만큼 지정해줬다.

private val threadPool: ExecutorService = Executors.newFixedThreadPool(
    Runtime.getRuntime().availableProcessors()
)

그리고 위에 선언한 thread pool 을 사용하기 위해 search 메서드를 변경해줬다.
여기서도 고민되는 부분이 있었는데, thread 를 어떤 단위로 할당할 것인가 에 대한 고민이였다.
여기서 나는 굳이 하나의 파일을 여러 thread 에서 조회할 필요는 없을거라 생각했다. 물론 큰 파일이 많은 경우라면 하나의 파일을 두개 이상의 thread 를 사용하여 탐색하는 방법도 있을것 같은데 일단 구현 자체가 매우 복잡할 수 있고(동시성 처리 등), 처음에는 간단하고 빠르게 구현하는게 먼저라고 생각했기 때문이다.
그래서 나는 file 단위로 thread 를 할당하는 방식을 선택했다.
이미 file 목록을 Queue 에 담고 있었기 때문에 해당 Queue 에서 file 을 하나씩 꺼내면서 해당 file 을 탐색할때 thread 를 각각 할당 하는 방식으로 작업하면 간단하게 멀티 스레드를 사용할 수 있을거라 생각했기 때문이다.
아래는 선택한 방식대로 동작하기 위해 변경한 search 메서드다.

fun search() {
    val startPath = File(path)

    if (!startPath.exists()) {
        println("Path does not exist: $path")
        return
    }

    collectFiles(startPath)

    val fileCount: Int = filesToProcess.size
    for (count: Int in 0 until fileCount) {
        val file: File = filesToProcess.poll() ?: break
        threadPool.submit { searchInFile(file) }
    }
    threadPool.shutdown()
    threadPool.awaitTermination(1, TimeUnit.HOURS)
    printResults()
}

동작 방식은 아래와 같다.

1. threadPool.submit 을 통해 searchInFile 메서드를 각각의 thread 에서 동작하도록 할당한다.
2. threadPool.shutdown 을 통해 모든 thread pool 에 있는 thread 가 작업을 마칠때 까지 기다린다.
3. 만약을 대비하여 threadPool.awaitTermination 을 통해 timeout 을 설정
4. threadPool 에 있는 모든 thread 가 작업을 마치면 결과물을 출력한다.

그럼 이제 KGrepV2 에 대한 성능 테스트를 진행해 보자. 테스트 데이터와 측정 방식을 KGrepV1 을 측정 했을때와 같다.

kotlinc KGrepV2.kt -include-runtime -d KGrepV2.jar # .jar 파일 생성
time java -jar KGrepV2.jar "keyword" "test-data"   # time 을 통한 성능 측정

# result (m3 pro 12 core 12 thread, RAM 18GB 기준)
## KGrepV1
File: test-data/dir_1/file_0.txt
Line 501: Line 500 in file_0.txt of dir_1. Contains keyword.
File: test-data/dir_3/file_7.txt
Line 501: Line 500 in file_7.txt of dir_3. Contains keyword.
File: test-data/dir_4/file_2.txt
Line 501: Line 500 in file_2.txt of dir_4. Contains keyword.
File: test-data/dir_5/file_5.txt
Line 501: Line 500 in file_5.txt of dir_5. Contains keyword.
File: test-data/dir_8/file_0.txt
Line 501: Line 500 in file_0.txt of dir_8. Contains keyword.
File: test-data/test.json
Line 2: "name": "keyword"
java -jar KGrepV1.jar "keyword" "test-data"  3.33s user 0.81s system 94% cpu 4.376 total

## KGrepV2
File: test-data/dir_1/file_0.txt
Line 501: Line 500 in file_0.txt of dir_1. Contains keyword.
File: test-data/dir_3/file_7.txt
Line 501: Line 500 in file_7.txt of dir_3. Contains keyword.
File: test-data/dir_4/file_2.txt
Line 501: Line 500 in file_2.txt of dir_4. Contains keyword.
File: test-data/dir_5/file_5.txt
Line 501: Line 500 in file_5.txt of dir_5. Contains keyword.
File: test-data/dir_8/file_0.txt
Line 501: Line 500 in file_0.txt of dir_8. Contains keyword.
File: test-data/test.json
Line 2: "name": "keyword"
Search completed in 1091 ms
java -jar KGrepV2.jar "keyword" "test-data"  8.26s user 1.40s system 832% cpu 1.162 total

## grep
test-data/dir_5/file_5.txt:Line 500 in file_5.txt of dir_5. Contains keyword.
test-data/dir_4/file_2.txt:Line 500 in file_2.txt of dir_4. Contains keyword.
test-data/dir_3/file_7.txt:Line 500 in file_7.txt of dir_3. Contains keyword.
test-data/test.json:  "name": "keyword"
test-data/dir_1/file_0.txt:Line 500 in file_0.txt of dir_1. Contains keyword.
test-data/dir_8/file_0.txt:Line 500 in file_0.txt of dir_8. Contains keyword.
grep --color=auto --exclude-dir={.bzr,CVS,.git,.hg,.svn,.idea,.tox,.venv,venv  9.12s user 0.41s system 98% cpu 9.685 total

KGrepV1,KGrepV2, grep 비교 결과

항목	KGrepV1.jar	KGrepV2.jar	grep
사용자 시간 (user)	3.33s	8.26s	9.12s
시스템 시간 (system)	0.81s	1.40s	0.41s
CPU 사용률	94%	832%	98%
총 소요 시간	4.376s	1.162s	9.685s

KGrepV2 가 속도 측면에서는 매우 빠른걸 볼 수 있다.
멀티 스레드를 사용했기 때문에 CPU 를 100% 이상 사용하는걸 볼 수 있다.
확실히 멀티 스레드를 사용하니 속도적인 부분에서는 매우 개선된걸 볼 수 있다. 다만, 리소스는 그 만큼 사용하지만..

KGrepV2 의 전체 코드는 아래와 같다.

package com.crispinlab.kgrep

import java.io.File
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ConcurrentLinkedQueue
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import kotlin.system.measureTimeMillis

class KGrepV2(
    private val keyword: String,
    private val path: String
) {
    private val results = ConcurrentHashMap<String, List<Pair<Int, String>>>()

    private val filesToProcess = ConcurrentLinkedQueue<File>()

    private val threadPool: ExecutorService = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors()
    )

    fun search() {
        val startPath = File(path)

        if (!startPath.exists()) {
            println("Path does not exist: $path")
            return
        }

        collectFiles(startPath)

        val time: Long = measureTimeMillis {
            val fileCount: Int = filesToProcess.size
            for (count: Int in 0 until fileCount) {
                val file: File = filesToProcess.poll() ?: break
                threadPool.submit { searchInFile(file) }
            }
            threadPool.shutdown()
            threadPool.awaitTermination(1, TimeUnit.HOURS)
        }
        printResults()
        println("Search completed in $time ms")
    }

    private fun collectFiles(startPath: File) {
        when {
            startPath.isFile -> filesToProcess.add(startPath)
            startPath.isDirectory -> startPath.listFiles()?.forEach { collectFiles(it) }
            else -> println("Cannot process this path: ${startPath.absolutePath}")
        }
    }

    private fun searchInFile(file: File) {
        try {
            if (!file.isFile || !file.canRead()) return
            val matchingLines: MutableList<Pair<Int, String>> = mutableListOf()
            file.useLines { lines ->
                lines.forEachIndexed { index, line ->
                    if (line.contains(keyword)) {
                        matchingLines.add((index + 1) to line.trim())
                    }
                }
            }
            if (matchingLines.isNotEmpty()) {
                results[file.path] = matchingLines
            }
        } catch (e: Exception) {
            System.err.println("Error processing file ${file.path}: ${e.message}")
        }
    }

    private fun printResults() {
        results.keys.sorted().forEach { filePath ->
            println("File: $filePath")
            results[filePath]?.forEach { (lineNumber: Int, line: String) ->
                println("Line $lineNumber: $line")
            }
        }
    }
}

fun main(args: Array<String>) {
    if (args.size < 2) {
        println("Usage: kgrep <keyword> <relative path>")
        return
    }

    val keyword: String = args[0]
    val path: String = args[1]

    val kGrep = KGrepV2(keyword, path)
    kGrep.search()
}

---

💡 마무리

오늘은 라이브 코딩 테스트 예시 문제를 풀어봤다.
웹 개발을 하다보면 요구사항에 맞는 API 를 많이 구현하지, 이렇게 요구사항에 맞는 애플리케이션을 구현할 일이 생각보다 많지 않은데 오랜만에 이런저건 고민을 하면서 요구사항에 맞는 애플리케이션을 구현하니 재미있었다.
이번 기회에 파일 처리 및 멀티 스레드에 대해 다뤄볼 수 있어 경험적으로 많이 도움이 되었다.

속도가 빠르다고 해서 무조건 좋은 애플리케이션을 아니다. 리소스를 한정적으로 사용해야 하는 환경에서 KGrepV2 는 그리 좋은 애플리케이션이라 할 수 없을거다. 다만 기존에 많이 사용하던 grep 의 속도적인 한계를 어떻게 극복할 수 있을지에 대해 문제를 통해 잠시나마 생각할 수 있어서 너무 좋았다.

기회가 된다면 해당 문제를 다른 개발자분들은 어떻게 풀었는지 내가 구현한 내용과는 어떤 부분이 다를지 비교해보고 싶다.

---

🔖 REFERENCE

• 데브시스터즈 서버 직군은 왜 코딩 면접을 볼까?