jam 블로그

LLM 추론 엔진 최적화: 효율성과 성능 향상을 위한 심층 분석

jmkim87 — Thu, 8 May 2025 09:30:14 +0900

논문 내용을 팟캐스트처럼 ai로 만들었습니다.

대규모 언어 모델(LLMs)은 이제 챗봇, 코드 생성, 검색 엔진 등 다양한 분야에서 광범위하게 활용되고 있습니다. 하지만 LLM 추론(Inference) 과정은 모델 크기가 커짐에 따라 막대한 계산 비용과 높은 지연 시간(Latency)을 수반하는 핵심적인 과제입니다. 특히 Chain-of-Thought, 복잡한 추론, 에이전트 서비스와 같은 작업 부하는 모델을 반복적으로 호출하면서 추론 비용을 크게 증가시킵니다.

논문 A Survey on Inference Engines for Large Language Models: Perspectives on Optimization and Efficiency는 이러한 문제를 해결하기 위해 등장한 LLM 추론 엔진들에 대한 포괄적인 조사를 제공합니다. 다양한 추론 엔진의 최적화 전략과 효율성 관점을 중심으로 현재의 기술 동향과 미래 연구 방향을 제시하고 있습니다.

LLM 추론 과정과 주요 성능 지표

논문은 주로 디코더 전용 Transformer 아키텍처에 기반한 LLM 추론 과정(Prefill 단계와 Decode 단계)을 설명하며, 추론 성능의 핵심 지표로 Latency (특히 첫 토큰 생성 시간인 TTFT와 토큰 간 시간인 TBT)와 Throughput을 강조합니다.

이러한 지표들은 사용자의 응답 속도 체감 및 시스템의 전체 처리 용량과 직결되기 때문입니다.

LLM 추론 효율화를 위한 주요 최적화 기법

다양한 최적화 전략이 논문에서 다음과 같이 정리되어 있습니다:

배치 최적화 (Batch Optimization)
- 여러 요청을 묶어 동시에 처리하여 하드웨어 활용도를 높입니다.
- Dynamic Batching, Continuous Batching, Chunked-prefills 등이 포함됩니다.
모델 압축 (Model Compression)
- 모델의 크기와 계산량을 줄입니다.
양자화(Quantization)
- 모델 가중치나 활성값을 INT8, INT4 등의 낮은 정밀도로 표현
가지치기(Pruning)
- 중요도가 낮은 연결 제거
스파스성 최적화 (Sparsity Optimization)
- 모델 또는 계산의 희소성을 활용합니다.
- MoE(Mixture-of-Experts) 모델이나 동적 토큰 스파스성 기법이 여기에 포함됩니다.
PEFT (Parameter-Efficient Fine-Tuning)
- 전체 모델이 아닌 일부 파라미터만 조정하여 효율성을 높입니다.
- LoRA, QLoRA 등이 이에 해당합니다.
캐싱 (Caching)
- 이전 계산 결과를 저장하여 재사용합니다.
KV 캐싱(Key and Value Caching)
- 이전 Key/Value 벡터를 저장하여 반복 계산 최소화
- PagedAttention, RadixAttention, Prompt Caching, Prefix Caching
어텐션 최적화 (Attention Optimization)
- 어텐션 메커니즘의 계산 비용을 줄입니다.
- FlashAttention
- Multi-Query Attention (MQA)
- Grouped-Query Attention (GQA)
- Multi-Head Latent Attention (MLA) 등
샘플링 최적화 (Sampling Optimization)
- 다음 토큰 생성 과정을 가속화합니다.
투기적 디코딩(Speculative Decoding)
- 작은 Draft 모델로 여러 토큰을 예측 후 Target 모델이 검증
구조화된 출력 (Structured Outputs)
- JSON Schema나 문법 기반 출력 제어를 통해 응답 형식을 통제합니다.
- Constrained Decoding이 이에 해당됩니다.

주요 LLM 추론 엔진 비교

논문은 다음과 같은 오픈 소스 및 상용 추론 엔진들의 특징과 성능을 비교 분석합니다:

Ollama
llama.cpp
vLLM
DeepSpeed-FastGen
TensorRT-LLM
TGI
PowerInfer
LMDeploy
LightLLM
SGLang

이들은 각기 다른 최적화 기법, 하드웨어 호환성, 추론 성능을 제공하고 있어 실제 시스템 구축 시 유용한 비교 자료로 활용될 수 있습니다.

결론

이 논문은 LLM 추론의 효율성과 성능 향상을 위한 핵심 과제와 다양한 최적화 기법들을 체계적으로 정리하고 있습니다. 또한 현재 활용되는 주요 추론 엔진들의 기술적 역량을 분석함으로써, LLM 서비스를 개발하거나 운영하는 연구자와 개발자에게 매우 실질적인 가이드라인을 제공합니다.

논문 주소 : https://arxiv.org/abs/2505.01658

#LLM #거대언어모델 #추론 #인퍼런스 #LLM추론

#LLM인퍼런스 #추론엔진 #인퍼런스엔진 #LLMOptimization #LLM최적화

#LLM효율성 #AI반도체 #GPU최적화 #TTFT #TBT

#Latency #Throughput #KV캐시 #KV캐싱 #PagedAttention

#FlashAttention #양자화 #Pruning #가지치기 #투기적디코딩

#SpeculativeDecoding #구조화된출력 #ConstrainedDecoding #vLLM #llama_cpp

초보 개발자를 위한 MCP(Model Context Protocol) 가이드: Claude 플랫폼 활용 예제

jmkim87 — Thu, 27 Mar 2025 19:00:27 +0900

최근 생성형 AI 기술이 발전하면서, AI 모델이 실시간으로 외부 데이터와 효율적으로 상호작용하는 방법이 중요해졌습니다.

이런 환경에서 주목받는 것이 바로 MCP(Model Context Protocol)입니다.

이번 글에서는 MCP의 개념과 필요성을 쉽게 이해하고 Claude 플랫폼과 함께 실습해 볼 수 있도록 안내합니다.

MCP(Model Context Protocol)란 무엇인가?

MCP는 간단히 말해 AI 모델과 외부 데이터 및 도구 간의 원활한 통신을 위한 개방형 표준 프로토콜입니다.

USB-C가 다양한 장치를 하나로 통합하는 것처럼, MCP는 AI가 여러 데이터 소스에 간편하게 접근할 수 있도록 표준화된 인터페이스를 제공합니다.

예컨대 회사 내부 데이터베이스나 웹 API 등을 AI 챗봇에 쉽게 연결하여 실시간 데이터를 제공하거나 AI의 기능을 더욱 확장할 때 MCP를 활용할 수 있습니다.

MCP가 필요한 이유

기존 방식에서는 AI 모델이 외부 데이터에 접근하려면 매번 개별적인 코드를 작성해야 했습니다.

이는 유지보수와 확장에 큰 부담이 되었습니다.

MCP를 도입하면 이 문제가 해결됩니다. 개발자는 데이터를 제공하는 MCP 서버만 한 번 구축하면, 다양한 AI 모델과 애플리케이션에서 손쉽게 이를 재사용할 수 있습니다.

결과적으로 개발 생산성과 유지보수성이 크게 향상됩니다.

MCP의 기본 작동 방식

MCP는 클라이언트(AI 애플리케이션)와 서버(외부 데이터를 제공하는 프로그램)로 구성되며, JSON-RPC 프로토콜을 이용해 요청과 응답을 교환합니다.

클라이언트가 특정 데이터를 요청하거나 작업 수행을 요청하면, MCP 서버가 이를 처리한 후 결과를 반환하는 형태로 동작합니다.

MCP 실습 예제: Claude 플랫폼 활용하기

다음 예제는 MCP를 실제로 구현해보고 이해하는 데 도움을 줍니다.

클라이언트는 TypeScript, 서버는 Python을 사용해 간단히 구현합니다.

Python 기반의 MCP 서버 구축

from mcp.server.fastmcp import FastMCP

app = FastMCP("DemoServer")

@app.tool()
def add(a: int, b: int) -> int:
    return a + b

@app.resource("greeting://{name}")
def greet(name: str) -> str:
    return f"안녕하세요, {name}님!"

if __name__ == "__main__":
    app.run()

이 서버는 간단한 덧셈과 인사 메시지를 제공하는 두 가지 기능을 MCP 표준으로 노출합니다.

TypeScript 기반의 MCP 클라이언트 구축

import { Client } from "@modelcontextprotocol/sdk/client";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio";

const client = new Client();
const transport = new StdioClientTransport({ command: "python3", args: ["server.py"] });

await client.connect(transport);

const result = await client.request({ method: "add", params: { a: 5, b: 3 } });
console.log("덧셈 결과:", result);

const greeting = await client.request({ method: "getResource", params: { uri: "greeting://민수" } });
console.log(greeting);

실행 결과:

덧셈 결과: 8
안녕하세요, 민수님!

이 과정을 통해 MCP가 AI 애플리케이션과 데이터 간의 소통을 얼마나 간단하게 만들어주는지 확인할 수 있습니다.

Claude 플랫폼에서의 MCP 활용법

Claude 플랫폼에서 MCP를 활용하면 사용자의 자연스러운 질문에 따라 자동으로 관련 데이터를 가져와 응답할 수 있습니다.

예를 들어, Claude에게 "최근 분기 보고서를 보여줘"라고 요청하면, MCP 서버와 연동하여 최신 보고서를 즉시 제공받는 방식입니다.

Claude Desktop에서는 개발자가 구축한 MCP 서버를 등록하기만 하면, 사용자는 별도의 설정 없이 자연스럽게 MCP의 기능을 활용할 수 있습니다.

마치며

MCP는 AI 개발의 효율성과 확장성을 획기적으로 향상시켜주는 중요한 프로토콜입니다.

앞으로의 AI 애플리케이션 개발에서 MCP 활용이 더욱 확대될 것으로 기대됩니다.

이 글을 통해 MCP에 대한 이해를 넓히고 직접 활용해보는 기회를 가지시길 바랍니다.

[내돈내산] 똑똑한 사람은 어떻게 생각하고 질문하는가 – 사고력 실종의 시대, 앞서가는 사람의 생존 전략

jmkim87 — Mon, 24 Mar 2025 21:27:40 +0900

똑똑한 사람은 어떻게 생각하고 질문하는가

질문을 잘하면 세상이 다르게 보인다고 합니다.

특히 ChatGPT 같은 인공지능과 협업하는 시대에는 ‘좋은 질문’이야말로 경쟁력입니다.

그런 의미에서 이시한 작가의 『똑똑한 사람은 어떻게 생각하고 질문하는가』는 지금 시대에 꼭 필요한 책이었습니다.

저자: 이시한 | 출판사: 북플레저 | 출판년도: 2024.01.24 | 페이지: 328쪽

책을 선택한 이유

요즘 ChatGPT나 Claude 같은 대화형 인공지능을 활용하면서 ‘질문을 잘 던지는 능력’이 정말 중요하다는 걸 느꼈습니다.

답변의 퀄리티도 결국 질문의 퀄리티에서 나옵니다.

그러다 보니 자연스럽게 ‘질문을 잘하는 사람들은 어떻게 사고할까?’에 대해 궁금해졌고, 이 책 제목이 딱 마음에 들어 선택하게 됐습니다.

똑똑한 사람은 어떻게 생각하고 질문하는가

책 소개

이 책은 단순히 질문의 스킬을 넘어서, 질문하는 뇌로 전환하는 방법을 알려줍니다.

• 왜 질문하는 능력이 중요한지

• 질문하는 사고방식을 어떻게 뇌에 장착할 수 있을지

• 사람들과의 대화에서 어떤 식으로 질문해야 원하는 답을 얻는지

• 혼자 공부할 때 스스로 질문을 던지는 법

• ChatGPT 같은 AI에게 효율적인 프롬프트를 작성하는 팁까지

질문은 단지 정보를 얻기 위한 도구가 아니라, 생각의 도약을 만드는 핵심 도구라는 걸 강조합니다.

특히 5Why 기법, 질문하는 뇌 구조 바꾸기(뭐야? → 진짜? → 좀더? → 왜?) 등 실전에서 바로 써먹을 수 있는 도구들을 제공해 줍니다.

주요 문구

“5 Why 기법: 문제의 원인을 파악하려면 최소 5번 ‘왜?’를 던져라.”

“질문하는 뇌를 만들기 위해선 평소에도 ‘뭐야?’, ‘진짜?’, ‘좀더?’, ‘왜?’라는 질문 습관을 갖는 것이 중요하다.”

질문은 단순한 기술이 아니라 사고방식이며, 스스로의 생각을 깊이 있게 확장시켜주는 엔진이 된다는 메시지가 마음에 와닿았습니다.

감상 및 느낀 점

✔ 회의나 소통 자리에서 질문을 정리 못해 스트레스를 받았는데, 이 책을 통해 질문 정리하는 틀을 배워서 실제로 도움이 되고 있습니다.

✔ ChatGPT처럼 AI를 쓸 때도 점점 더 정교한 질문을 던지게 되었고, 그만큼 더 좋은 답을 받을 수 있었습니다.

✔ 무엇보다 이 책을 읽고 나니, 사람과의 대화뿐만 아니라 자기 자신에게 던지는 질문도 굉장히 중요하다는 걸 느꼈습니다.

✔ 개인적인 목표로는 소개팅 자리에서 좋은 질문을 던지는 걸 연습해보고 싶다는 생각까지 들었습니다

총평 – 질문은 최고의 사고 훈련이자 AI 시대의 필수 역량!

질문이 단순한 대화 기술이 아니라 지성과 창의성의 출발점이라는 사실을 깨닫게 해주는 책이었습니다.

질문하는 사람이 앞으로의 시대를 이끌어간다는 말, 이제는 정말 실감이 납니다.

✔ AI를 더 잘 활용하고 싶은 분

✔ 업무 커뮤니케이션에서 질문으로 주도권을 잡고 싶은 분

✔ 생각을 정리하고 깊이 있게 사고하는 연습이 필요한 분

이 책으로 질문 근육을 키워보세요!

구매한 곳

https://www.yes24.com/Product/Goods/124574383

[내돈내산] 초역 부처의 말

jmkim87 — Sun, 16 Mar 2025 11:07:38 +0900

초역 부처의 말

요즘 회사생활을 하다 보면 스트레스를 받는 순간이 많아 마음을 다스릴 방법을 찾게 됩니다.

그러던 중 유퀴즈에서 아이브 장원영님이 힘들 때마다 읽는다는 책으로 소개한 『초역 부처의 말』을 접하게 되었습니다.

이 책에는 불교 경전에서 발췌한 190개의 구절이 수록되어 있으며, 이를 현대적으로 해석한 초역(超譯) 방식으로 소개하고 있습니다.

저자: 코이케 류노스케 | 역자: 박재현 | 출판사: 포레스트북스 | 출판년도: 2024.05.30 | 페이지: 256쪽

책을 선택한 이유

• 유퀴즈에서 아이브의 장원영님이 힘들 때마다 꺼내본다고 해서 관심이 생겼습니다.

• 회사 생활을 하며 마음이 힘들 때가 많아 위로가 될 책이 필요했습니다.

초역 부처의 말

책 소개

『초역 부처의 말』은 불교 경전 속 문구들을 현대적 해석을 더해 쉽게 풀어낸 책입니다.

• 초역(超譯)이란?

저자는 원문의 의미를 최대한 보존하면서도 현대인이 이해하기 쉽게 번역하는 방식을 사용했습니다.

• 책의 구성

190개의 구절을 12가지 주제로 나누어 구성하였으며, 처음에는 감정을 다스릴 수 있는 문장부터 시작하여 점차 깨달음으로 나아가는 방식입니다.

• 주요 주제

화(분노), 비교, 갈망, 선(善), 친구, 행복, 자신, 신체, 자유, 자비, 깨달음, 죽음

• 부록

책의 마지막에는 부처의 일생을 간략히 정리하여 그의 삶과 가르침을 이해할 수 있도록 돕습니다.

주요 문구

책을 읽으며 특히 인상 깊었던 문장을 몇 가지 소개합니다.

마음의 예절이라는 것은

단시간에 몸에 배는 게 아닙니다.

오랜 시간에 걸쳐

차분히 마음의 예절을 몸에 익히고

그로 인해 험담이나

자랑이나 난잡한 행동을 하지 않을 때

자연스럽게 당신 주변에는 기품이 감돕니다.

경집

자주 불같이 화내는 사람.

언제까지고 원망을 잊지 않는 사람.

자신의 결점을 감추려고 하는 사람.

자신을 실제보다 좋게 보이려고

친절을 가장하는 위선자.

이런 사람들은 저속하다는 걸 알고,

그들과 어울리지 않도록 하세요.

경집

저 사람이 나를 비판했다.

저사람이 내 마음을 짓밟았다.

저 사람이 나를 호되게 깎아내렸다.

저사람이 내 아이디어를 훔쳤다.

이런식으로 화를 지피는걸 멈추고,

반복되는 감정에서 벗어나면,

그 원망은 고요히 잔잔해지고

당신의 마음을 마침내 편안해집니다.

법구경

‘자, 보아라. 나는 대단하다.’

이렇게 자만하는 사람이 되지 마세요.

입 밖으로 노골적인 자랑을 꺼내지 않아도

태도나 행동에서 자만심이 묻어 나옵니다.

‘나는 좀 알아줘’

라는 마음을 내보이듯

지나치게 자신을 자랑하지 마세요.

마음이 조금 성장했다고 해서

잘난 듯 굴지 마세요.

부디 자신도 모르는 사이에

잘난 척하고 타인에게 상처 주는 말을 내뱉지 않기를

경집

‘역시 하지 말았어야 했다’

며 나중에 후회하고 고통받을 일을 저질렀다면,

그 일은 악업으로써 마음에 쌓입니다.

그 악업의 부정적인 에너지가

마음속에서 무르익어 이윽고 울면서

고통의 인과응보를 받게 됩니다.

법구경

감상 및 느낀 점

✔ 단순히 종교적인 책이 아니라, 누구나 쉽게 읽고 적용할 수 있는 문장들

✔ 현대인의 고민과 맞닿아 있어 위로가 됨

✔ 스트레스가 쌓였을 때 마음을 다스리는 방법을 배울 수 있음

✔ 부처의 삶을 간략하게 정리한 부록도 흥미로움

종교를 따로 믿지 않더라도 이 책에서 전하는 메시지는 삶을 돌아보는 데 많은 도움이 됩니다.

책을 읽으며 감정적으로 휩쓸리지 않고 차분히 마음을 다스리는 법을 배울 수 있었습니다.

총평 – 마음을 다스리는 데 도움을 주는 책!

✔ 마음이 힘들고 스트레스받을 때 위로가 필요하다면?

✔ 감정을 다스리고 삶의 균형을 찾고 싶다면?

✔ 깊은 철학적 사유 없이도 쉽게 읽을 수 있는 책을 원한다면?

『초역 부처의 말』을 추천합니다! ✨

구매한 곳

https://www.yes24.com/Product/Goods/126590468

[내돈내산] 주식 투자 책: 비기너 편

jmkim87 — Sun, 9 Mar 2025 12:16:42 +0900

주식 투자 책

부제 : 더 이상 미룰 수 없어서 시작했지만 뭐부터 해야 할지 몰라 고른 첫 번째 머니북

저자: 최광자 | 출판사: 경이로움 | 출판년도: 2024.11.15 | 페이지: 360

책을 선택한 이유

주식을 시작했지만, 기초 지식 없이 투자하다 보니 어려움을 많이 겪었습니다.

✔ 좋은 회사인지 판단하는 기준이 모호하고

✔ 주식 용어가 익숙하지 않아 관련 대화에서도 어려움을 느꼈습니다.

그래서 기초부터 다시 다지고 싶어 이 책을 선택했습니다.

책 소개

주식 시장에 들어선 순간, 우리는 이미 실전에 투입된 것입니다. 하지만 기본 개념을 모르고 투자하면 손실을 볼 가능성이 높죠.

이 책은 투자 전 반드시 알아야 할 필수 개념을 정리해 줍니다.

주식이란 무엇인가?

주식은 어떻게 사고파는가?

재무제표의 핵심 용어와 의미

배당주, 공모주, ETF 투자 이해하기

무엇보다 실제 주식 데이터를 기반으로 설명해 주기 때문에, 직접 주식 창을 보면서 따라 하기 좋습니다.

✔ 완전 초보자라면 처음부터 차근차근

✔ 기본 개념이 있는 사람이라면 필요한 부분만 읽어도 OK!

주요 문구

책의 뒷표지 문구를 대신 정리합니다.

주식 투자 책

이 책은 투자가 처음인 사람들을 위한 가장 기초적인 주식 책입니다.

막상 공부하려니 어디서부터 어떻게 해야 할지 모르겠다면 이 책을 읽어 보세요.

읽는 순서는 없습니다.

책의 처음부터 순서대로 읽어도 되고, 목차를 보며 필요한 페이지를 먼저 읽어도 됩니다.

한번에 다 읽을 필요도 없습니다. 조금씩 필요에 따라 읽으세요. 투자를 하다 궁금한 내용이 생기면 해당 내용을 찾아 읽으면 됩니다.

1부를 읽고 나서 그 즉시 주식 한 주를 매수하세요.

내 계좌에 주식이 있는 것만으로도 공부 의욕이 달라집니다.

시간이 걸리더라도 처음부터 끝까지 완독하세요.

대충이라도 아는 것과 아예 모르는 것은 천지 차이니까요.

단단한 기본기를 갖췄다면 이제 활용하고 응용할 차례입니다.

자신감을 가지고 투자를 시작하세요.

감상 및 느낀 점

✔ 주식 용어를 명확하게 이해할 수 있게 되었다.

✔ ETF, 채권 등에 대한 관심이 생겼다.

✔ 단순한 감이 아닌, 지식 기반 투자로 발전할 수 있는 계기가 되었다.

✔ 노후 대비 및 자산 운용에 대해 더 깊이 고민할 기회가 되었다.

이제는 막연한 투자에서 벗어나, 보다 안정적으로 돈을 관리할 수 있을 것 같아요.

총평 – 주식 초보라면 꼭 읽어야 할 첫 번째 책!

이 책은 주식 초보자가 반드시 알아야 할 기본 개념을 쉽게 정리해 줍니다.

✔ 주식 용어가 어렵게 느껴진다면?

✔ 차트를 보며 투자하는 법을 알고 싶다면?

✔ ETF, 채권 등 다양한 투자 방식이 궁금하다면?

이 책이 당신의 첫 번째 투자 가이드가 되어 줄 것입니다!

구매한 곳

https://search.shopping.naver.com/book/catalog/51209459632?query=%EC%A3%BC%EC%8B%9D%20%ED%88%AC%EC%9E%90%EC%B1%85%20%EB%B9%84%EA%B8%B0%EB%84%88%ED%8E%B8&NaPm=ct%3Dm811umxs%7Cci%3D8049a7d2127120ae2325be05204e6f8b32d1978f%7Ctr%3Dboksl%7Csn%3D95694%7Chk%3D88aee71e615cc06bf0bc9089d939622f99c3b800

[내돈내산] 트럼프 2.0 시대 – 트럼프의 재선과 세계 질서의 변화

jmkim87 — Sat, 1 Mar 2025 15:32:10 +0900

미국 역사상 가장 논란이 많았던 대통령 중 한 명, 도널드 트럼프가 다시 백악관에 돌아왔다. 그의 재선이 글로벌 경제와 국제 관계에 미치는 영향은 과연 무엇일까? 『트럼프 2.0 시대』는 트럼프의 정치 철학과 앞으로의 세계 전략을 분석한 책이다.

책을 선택한 이유

2024년 11월 5일, 도널드 트럼프가 재선에 성공하면서 그의 정책 방향과 세계에 미칠 영향을 파악하고 싶었다.

특히 미국 주식시장과 국제 정세가 어떻게 변화할지 궁금하여 이 책을 읽게 되었다.

책 소개

이 책은 도널드 트럼프가 재선에 성공한 이후, 그의 정책 방향과 세계 질서에 미치는 영향을 분석한다.

왜 미국인들은 다시 트럼프를 선택했을까?

트럼프 1기에서 그는 미국 우선주의(America First)를 내세우며 보호무역 정책을 강화했다.

하지만 2기에서는 더욱 강경한 입장을 취하고 있다.

트럼프 2기의 핵심 키워드

• 역사상 최강의 미국 우선주의

• 중국과의 AI 패권 전쟁

• 글로벌 관세 정책 변화

• 해상 패권을 둘러싼 미국과 중국의 대립

• 대만 문제와 미국의 국제 전략 변화

트럼프 2기에서는 중국과의 경쟁이 더욱 치열해지고, 대만 문제에 대한 미국의 개입이 가시화될 가능성이 크다. 이 책은 트럼프 정부가 추진할 경제, 외교, 군사 정책을 예측하며 앞으로의 세계 정세를 분석한다.

주요 소제목

더 강력해진 트럼프가 온다

역사상 최강의 미국 우선주의

누가 해상 패권을 차지할 것인가?

이 소제목만 봐도 트럼프 2기의 정책 기조가 1기보다 더 강력해질 것임을 예측할 수 있다.

감상 및 느낀 점

✔ 트럼프 1기와 2기의 차이점을 명확하게 비교 – 단순한 연임이 아니라 완전히 새로운 국면으로 들어섰음을 실감할 수 있다.

✔ 정책이 실현될 경우, 글로벌 시장과 한국 경제에 미치는 영향 분석이 인상적 – 특히 한국이 직면할 문제와 해결 방안을 제시한다.

✔ AI 패권 경쟁, 해상 패권 등 미국과 중국의 갈등을 구체적으로 다룸 – 국제 정세에 관심 있는 사람이라면 반드시 읽어야 할 책.

총평 – 트럼프 시대의 변화를 알고 싶다면 꼭 읽어야 할 책!

이 책은 트럼프 2기의 정책 기조를 분석하고, 글로벌 경제와 국제 관계에 미치는 영향을 다룬다.

특히 미·중 경쟁, 대만 문제, 해상 패권 등을 중심으로 향후 미국의 행보를 예측한다.

✔ 트럼프의 정책 변화가 시장과 국제 관계에 미칠 영향을 알고 싶은 사람

✔ 미국 우선주의가 더욱 강해지는 시대, 한국의 대응 전략을 고민하는 사람

✔ 미·중 패권 전쟁과 AI 경쟁의 향방을 알고 싶은 사람

트럼프 2.0 시대를 제대로 이해하고 싶다면, 꼭 읽어봐야 할 책!

구매한 곳

https://www.yes24.com/Product/Goods/136734901

[내돈내산] 디자인 구구단 – 디자인이 필요한 순간, ‘툭’ 튀어나오는 디자인 공식

jmkim87 — Sun, 16 Feb 2025 12:20:03 +0900

디자인 구구단

디자인을 배우고 싶지만 어렵게만 느껴지는 분들에게, 또는 디자인이 필요한 순간 쉽게 활용할 수 있는 공식이 있다면 얼마나 좋을까요?

에이핫 작가의 『디자인 구구단』은 디자인을 ‘구구단’처럼 쉽게 익힐 수 있도록 도와주는 책입니다.

책을 선택한 이유

이 책은 회사 팀장님의 추천으로 접하게 되었고, 개인적으로도 디자인에 대한 관심이 있어서 읽게 되었습니다. 웹 개발을 하면서 디자인 감각이 중요하다고 느꼈고, 좀 더 체계적으로 배우고 싶던 차에 딱 맞는 책이었어요.

책 소개

디자인, 어렵게만 느껴지시나요?

이 책은 디자인을 처음 접하는 사람들도 부담 없이 배울 수 있도록 설명합니다. 디자인을 ‘메시지를 전달하는 다리’라고 정의하며, 이를 9가지 공식(구구단)로 쉽게 풀어줍니다.

9단 이론

무엇보다 이 책의 큰 장점은 만화 형식으로 구성되어 있다는 점!

딱딱한 이론서가 아니라 실제 예시와 그림으로 쉽게 설명하기 때문에 읽는 내내 지루하지 않습니다.

이 책에서 익힌 디자인 감각은 웹 디자인뿐만 아니라 사진, PPT, 인테리어, 광고 등 다양한 분야에 적용할 수 있습니다.

주요 문구

제 목표는 디자인의 힘을 디자이너뿐만 아니라
모든 사람이 쓸 수 있도록 만드는 것입니다.

디자인이 가진 힘은 여러분이 생각하는 것보다 훨씬 강력합니다.
여러분의 잠재력과 디자인이 만나면가능성이 무한대로 펼쳐질 것입니다.

사람들에게 메시지를 던지고 있다면당신은 이미 크리에이터다.

디자인 구구단 프롤로그 - 에이핫 -

이 문장들에서 알 수 있듯이, 저자는 디자인을 단순한 미적 요소가 아니라 강력한 커뮤니케이션 도구로 바라봅니다. 그리고 이 도구를 누구나 활용할 수 있도록 돕고 싶어 합니다.

감상 및 느낀 점

✔ 쉽고 재미있게 읽힘 – 만화 형식이라 부담 없이 술술 읽을 수 있음.

✔ 실제 사례와 그림이 많아 이해가 빠름 – 디자인 이론이 아니라, 실제 적용할 수 있도록 설명.

✔ 웹디자인뿐만 아니라 사진, 광고, 포스터 등에도 활용 가능 – 단순히 ‘디자인 공부’가 아니라, 다양한 분야에서 응용할 수 있음.

✔ 업무와 취미생활에도 도움이 됨 – 디자인 감각을 키우고 싶다면 누구에게나 추천하고 싶은 책.

이 책을 읽고 나니, 단순히 웹디자인뿐만 아니라 사진을 찍을 때, 광고나 포스터를 볼 때, PPT를 만들 때도 ‘이 디자인이 어떤 메시지를 전달하려고 하는지’ 생각하게 되었습니다.

총평 – 누구에게나 추천하고 싶은 디자인 입문서!

이 책은 디자인을 전공하지 않았어도 누구나 쉽게 이해하고 활용할 수 있도록 구성되어 있습니다. 회사에서 웹 디자인이 필요해서 읽기 시작했지만, 읽다 보니 디자인이 단순한 ‘예쁜 꾸밈’이 아니라 강력한 메시지 전달 수단이라는 걸 깨달았습니다.

✔ 디자인이 어렵게만 느껴졌다면?

✔ 색감과 구도를 어떻게 활용해야 할지 모르겠다면?

✔ PPT, 사진, 광고 등에서 감각을 키우고 싶다면?

이 책이 디자인 감각을 키우는 최고의 입문서가 될 것입니다! ✨

구매한 곳

https://www.yes24.com/Product/Goods/129392318

HTTP/3 (HTTP Protocol 발전 과정)

jmkim87 — Sun, 10 Dec 2023 11:34:49 +0900

HTTP/3

2019년 9월 정도에 새로운 웹 표준인 HTTP/3에 대한 지원을 발표하였습니다.
파트 내에서 웹 로딩 및 접근 속도를 위해서 조사를 하였습니다.

HTTP Protocol 발전 과정

요약

HTTP/0.9

HTTP 초기 버전에는 버전 번호가 없지만 추후 버전과 구별을 위해 붙여졌습니다.

특징
1. GET 메소드만 존재
2. HTTP 헤더가 존재하지 않음

HTTP/1.0

0.9버전에서 브라우저와 서버 모두 융통성을 가지도록 확장되었습니다.

특징
1. 버전 정보가 각 요청 사이내로 전송되기 시작 (HTTP/1.0 GET ~)
2. HTTP Status code가 라인 또는 시작 부분에 붙어 전송
  1. 브라우저의 요청에 대한 성공 실패 여부 확인 및 그에 따른 동작
3. HTTP 헤더 개념이 요청, 응답 모두에 도입
  1. 메타 데이터 전송을 허용
  2. 프로토콜을 극도로 유연하고 확장 가능
4. HTML 파일들 외에 다른 문서들을 전송하는 기능 추가 (Content-Type)

HTTP/1.1

1.0이 나온지 몇달 안되고 나서 발표 되었으며, 많은 개선 사항을 도입되었습니다.

특징
1. 커넥션 재사용
  1. 탐색된 단일 원본 문서 내로 임베드된 리소스들을 디스플레이하기 위해 사용된 커넥션을 다시 열어 시간 절약
2. 파이프라이닝 추가
  1. 커뮤니케이션 레이턴시를 낮춤
    1. 첫번째 요청에 대한 응답이 완전히 전송되지 전에 두번째 요청 전송을 가능케 함
3. 청크된 응답 지원
4. 캐시 제어 메커니즘 도입
5. 언어, 인코딩 혹은 타입을 포함한 컨텐츠 협상 도입
  1. 클라이언트와 서버로 하여금 교환하려는 가장 적합한 컨텐츠에 대한 동의를 가능케 함
6. Host 헤더 추가
  1. 동일 IP 주소에 다른 도메인을 호스트 하는 기능
기타
1. HTTPS
  1. SSL(Secure Sockets Layer, 보안 소켓 계층) : 웹사이트와 브라우저 사이에 전송된 데이터를 암호화하여 보안을 유지하는 표준 기술
  2. TLS(Transport Layer Security, 전송 계층 보안) : SSL의 상위 기술, SSL 3.0버전에서 취약점을 고친 버전으로 버전이 올라갈 때마다 암호화 알고리즘을 강력한 것으로 변경합니다. (현재는 1.3버전 진행 중)
2. REST
  1. API에 의해 유도되는 액션들은 새로운 HTTP 메소드 뿐만 아니라, 기초적인 HTTP/1.1 메소드를 이용
3. Same-Origin 정책
  1. 웹 보안을 위해 CORS(Cross-Origin Resources Share) or CSP(Contents Security Policy)

HTTP/2

Google에서 응답 속도를 개선을 위해서 SPDY 프로토콜을 구현하였으며, 속도 개선의 가능성과 데이터 중복에 관한 문제를 해결하면서 HTTP/2로 거듭 납니다.

특징
1. 바이너리 프레이밍 계층
  1. 1.1버전은 줄바꿈으로 구분되는 일반 텍스트로 인코딩
  2. 2.0은 더 작은 메시지와 프레임으로 분할되며, 각각은 바이너리 형식으로 인코딩
3. 스트림, 메시지 및 프레임 교환 방식
  1. 스트림 : 구성된 연결 내에서 전달되는 바이트의 양방향 흐름
    1. 모든 통신은 단일 TCP을 통해 수행
    2. 양방향 스트림의 수는 제한이 없음
    3. 각 스트림에는 양방향 메시지 전달에 사용되는 고유 식별자, 우선순위 정보가 존재
  2. 메시지 : 논리적 요청, 응답 메시지에 매핑되는 프레임의 전체 시퀀스
    1. 각 메시지는 하나의 논리적 HTTP 메시지 이며, 하나 이상의 프레임으로 구성
  3. 프레임 : HTTP/2에서 통신의 최소 단위이며, 하나의 프레임 헤더가 포함
    1. 특정 유형의 데이터(HTTP 헤더, 메시지 페이로드 등)를 전달
    2. 다름 스트림들의 프레임을 interleaving 한 다음, 각 프레임의 헤더에 삽입된 스트리 식별자를 통해 재조립 가능
5. 요청 및 응답 다중화
  1. HTTP 메시지 프레임 세분화 및 재조립
    1. 1.1에서 병렬 요청 시 여러 TCP 연결 사용에 대한 동작 해결
    2. HOL(Head-of-Line) 차단, 기본 TCP 연결의 비효율 사용 해결
  2. Interleaving
    1. 여러 요청을 하나도 차단하지 않고 병렬로 interleaving할 수 있음
    2. 여러 응답을 하나도 차단하지 않고 병렬로 interleaving할 수 있음
    3. 단일 연결을 사용하여 여러 요청과 응답을 병렬로 전달할 수 있음
    4. 연결된 파일, 이미지 스프라이트, 도메인 분할과 같은 불필요한 HTTP/1.x 임시 방편을 제거합니다.
    5. 불필요한 지연 시간을 제거하고 가용 네트워크 용량의 활용도를 개선하여 페이지 로드 시간을 줄입니다.
7. 스트림 우선순위 지정
  1. 각 스트림에 가중치와 종속성 할당
    1. 스트림의 종속성 및 가중치 조합을 이용하여 클라이언트가 우선순위 지정 트리를 구성
    2. 트리는 서버에서 CPU, 메모리 및 기타 리소스의 할당하거나 대역폭을 할당
8. 출처당 하나의 연결
  1. 동일한 연결에 대해서 재사용 하기에 전반적인 프로토콜 오버헤드를 대폭 감소
  2. 또한 더 적은 연결을 하기 때문에 메모리와 처리량이 감소
9. 흐름 제어
  1. 송신기의 데이터가 불필요하거나 처리가 불가능하여 수신기에 부담을 주는 것을 막음
    1. 흐름 제어는 양방향
    2. 흐름 제어는 크레딧 기반
    3. 흐름 제어는 비활성화 할 수 없음
    4. 흐름 제어는 종단간(End-to-End) 방식이 아닌 홉(Hop-by-Hop)방식
10. 서버 푸시
  1. 서버가 단일 클라이언트 요청에 대해 여러 응답이 가능
    1. 클라이언트가 명시적으로 요청하지 않아도 서버가 추가적인 리소스를 푸시할 수 있음
    2. 서비스 워커를 사용하여 캐시된 자원을 리턴 받아서 불필요한 네트워크 트래픽을 줄입니다.
12. 헤더 압축
  1. HPACK 압축 형식을 사용
    1. 전송되는 헤더 필드를 정적 huffman 코드로 인코딩
    2. 공유 압축 컨텍스트를 구성
      1. 정적/동적 테이블로 구성
        
        정적 테이블 : 사양에 정의되며, 모든 연결에 사용될 가능성이 있는 공용 HTTP 헤더 필드를 제공
        
        동적 테이블 : 처음에는 비어있으며, 특정 연결에서 교환되는 값에 따라 업데이트

HTTP/3

HTTP/3는 QUIC이라는 프로토콜 위에서 돌아가는 HTTP입니다.

QUIC란?

Quick UDP Internet Connection의 약자로 UDP를 사용하여 인터넷 연결을 하는 프로토콜

TCP 단점

TCP vs UDP위 그림처럼 TCP는 신뢰성이 높고 느리고, UDP는 신뢰성이 낮고 빠릅니다.
현재 TCP를 사용하고 있는 HTTP/2 보다 빠르게 사용하기 위해서는 TCP를 버리고 UDP를 사용하는 것을 목적으로 하였습니다.

TCP가 느린 이유는 다음과 같습니다.

3 Way Handshake 간략히 설명하면 #1~3의 통신을 통해서 정상적으로 연결이 되면 신뢰성이 생겨 이후에 데이터를 주고 받습니다.HTTP/1.1에서는 하나의 TCP 연결에 하나의 요청만 처리하게 되어 있어서 매 요청마다 3 Way handshake를 해줘야 하며, HTTP/2에서는 최소화를 하기 위해 단일 TCP 연결을 유지하면서 여러개의 요청을 처리할 수 있도록 변경되었습니다.
하지만, TCP를 버리기 전에는 적어도 1번 이상 3 Way handshake를 해줘야 하기 때문에 속도가 느립니다.
HOLB(Head of line Blocking)이럴 경우 병목이 발생하는데 이러한 현상을 HOLB라 부릅니다. 이 현상은 HTTP/1, HTTP/2까지 발생하는 문제입니다.
TCP를 사용한 통신에서는 패킷은 패킷 재조립을 위해서 무조건 정확한 순서대로 처리되어야 합니다. (위에서 시퀀스 번호가 그 예)
그래서 통신 중간에 패킷이 손실되면 완전한 데이터로 다시 조립할 수 없어서 다음 패킷을 처리할 수 없습니다.

따라서, UDP를 사용하여 위 2가지 문제를 해결하여 프로토콜을 개발한 것 입니다.

UDP 사용 이유

연결 설정 레이턴시 감소
TCP + TLS 같은 경우 신뢰성있는 연결과 암호화에 필요한 모든 정보를 교환하고 유효성 검사를 한 후에 데이터 교환
QUIC은 데이터를 바로 전달. 단, 클라이언트가 서버로 첫 요청을 보낼 때는 서버의 세션 키를 모르는 상태이기 때문에 서버의 Connection ID를 사용하여 생성한 특벽한 키를 사용하여 통신을 암호화 합니다.
TCP의 3 way handshake 때문에 연결 시에 레이턴시를 줄이기가 어렵습니다.

패킷 손실 감지에 걸리는 시간 단축

 1. Separate Packet Number Spaces
 2. Monotonically Increasing Packet Numbers
 3. Clearer Loss Epoch
 4. No Reneging
 5. More ACK Ranges
 6. Explicit Correction For Delayed Acknowledgements
 7. Probe Timeout Replaces RTO and TLP
 8. The Minimum Congestion Window is Two Packets

참고 : https://www.ietf.org/id/draft-ietf-quic-recovery-29.html#name-relevant-differences-betwee

아래는 QUIC에서 속도 향상을 위해서 작업한 방식들입니다.
멀티플렉싱 지원
위 그림처럼 HTTP/1.1은 하나의 TCP 연결에 하나의 스트림만 사용하기 때문에 HOLB 문제에서 벗어날 수 없습니다.
HTTP/2 같은 경우 하나의 TCP 연결 안에서 여러 개의 스트림을 처리하는 멀티플레싱 기법 도입으로 성능을 끌어올렸습니다.
HTTP/3 또한 HTTP/2와 동일하게 지원합니다.
멀티플렉싱은 HOLB를 방지하기 위한 기술입니다.
클라이언트의 IP가 바뀌어도 연결이 유지됨
TCP의 경우 소스의 IP 주소와 포트, 연결 대상의 IP 주소와 포트로 연결을 식별하기 때문에 IP가 바뀌면 연결이 끊깁니다.
QUIC은 Connection ID를 사용하여 서버와 연결을 생성합니다. 클라이언트의 IP와는 전혀 무관한 데이터이기 때문에 기존의 연결을 계속 유지할 수 있습니다.

테스트 및 구축 방법

아직 Nginx에서는 preview 상태이며, nginx 1.16.1 소스과 quiche를 받아서 patch 후 compile하여 사용해야합니다.

% curl -O https://nginx.org/download/nginx-1.16.1.tar.gz % tar xvzf nginx-1.16.1.tar.gz % git clone –recursive https://github.com/cloudflare/quiche % cd nginx-1.16.1 % patch -p01 < ../quiche/extras/nginx/nginx-1.16.patch
% ./configure
–prefix=$PWD
–with-http_ssl_module
–with-http_v2_module
–with-http_v3_module
–with-openssl=../quiche/deps/boringssl
–with-quiche=../quiche % make

events {
    worker_connections  1024;
}

http {
    server {
        # Enable QUIC and HTTP/3.
        listen 443 quic reuseport;

        # Enable HTTP/2 (optional).
        listen 443 ssl http2;

        ssl_certificate      cert.crt;
        ssl_certificate_key  cert.key;

        # Enable all TLS versions (TLSv1.3 is required for QUIC).
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;

        # Add Alt-Svc header to negotiate HTTP/3.
        add_header alt-svc 'h3-23=":443"; ma=86400';
    }
}

위와 같이 설정 후 설정한 사이트에 크롬으로 접속하면 protocol에 h3-q050이 보여야 합니다.
아래 이미지는 cloudflare에 접속하여 확인한 화면입니다.

[괌] 여행 준비

jmkim87 — Mon, 13 Mar 2023 09:24:52 +0900

1. 여행 준비물

여권
- 6개월 이상 남은 여권
신분증
- 운전면허증도 가능
볼펜
- 비행기 안에서 문서 작성해야 하는 경우가 있음
전자세관신고서 (도착하기 72시간 이내에 할 것)
- 괌 입국 서류 총정리 (여행 필수 준비물), .. : 네이버블로그 (naver.com)
  - 여기에 전자세관 신고서 쓰는 방법 있음
  - 먼저 읽어보고 작성
- 괌 필수 세관 신고서 (landing.cards)
  - 영문으로 작성해야함
2차 영문접종확인서 (아래 전부 필요)
- 예방접종도우미 (kdca.go.kr)
  - 낸다는 말도 있고 안 낸다는 말이 있어서 출력해서 가지고 있는 게 좋을 듯
- 제출은 항공사에서 표 받을 때 제출하면 됨.
- 전자예방접종증명서(COOV APP(쿠브앱) 설치)
  - 쿠브앱에서 증명서 클릭 후 우측 하단에 국제증명서 눌러서 인증 진행하면 보임
괌 비자 면제 서류 (괌 비자면제신청서 )
- 비행기 안에서 작성하는 서류이고 이스타 소지자이면 작성할 필요 없음
- 이스타는 몇 개월 이내에 또 괌에 방문할 사람들이 미리 돈 내고 빠르게 수속 밟기 위한 비자 (인당 21$)
  - 만약 하나투어에서 작성하라고 하면 비용 물어보고, 만약 작성 했다면 입국 심사받는 곳에 ESTA(이스타) 수속하는 줄이 따로 있으니 빠르게 입국이 가능
- 아래 링크 읽어보고 대비할 것 (한글로 질문지가 쓰여있으나 각자 영어로 다 작성해야 함.)
- 입국 심사 때 제출해야 함.
- 괌 입국 서류 총정리 (여행 필수 준비물), .. : 네이버블로그 (naver.com)
CDC 서약서
- 카운터 앞에 서류들이 쌓여 있어서 그거 각자 한 장씩 쓰면 됨
- 가끔 항공사 측에서 종이를 준다고 하지만 미리 쓰는 걸 추천
괌 입국심사
- 괌입국서류 준비만틈 떨렸던 입국심사. 괌 입국심사는 아주 간단했는데 마스크 잠깐 벗고 얼굴 확인 후에 손가락 오른손 엄지, 나머지 손가락, 왼손 엄지, 나머지 손가락 찍고 간단하게 질문 몇 가지 하고 도장 쾅쾅 찍고 끝! 질문의 수는 3~4가지 됐는데 간단한 영어라 걱정할 필요는 없음.
- 입국심사질문으로는 왜 왔는지, 얼마나 머무는지, 어느 호텔에 묵는지, 몇 번 와봤는지 정도였는데 허니문이라고 말하니깐 잘 지내라는 이야기까지 해줬다. 영어 못해도 눈치코치로 알아들을 수 있는 정도의 질문
- 괌여행후기 [준비물꿀팁편] 필수 준비물 총정리 : 네이버 카페 (naver.com)
  - 입국심사 질문이 약간 적혀 있다.
여행자 보험
- 공항에서 4박 5일 들면 됨.
환전
- 팁을 카드로 낼 수도 있지만 혹시 모를 일을 위해 달러가 필요함
- 공항보다는 은행이 좀 더 쌀 수 있음
신용카드
- 해외에서 카드를 사용하고 싶을 시 빠르게 발급받아서 가는 것도 추천
- 트래블월렛은 카드 신청하고 앱에서 해당 국가 돈을 환전하면서 충전식으로 사용 가능
여러 가지
- 옷 (거의 여름옷이라는데 아래 링크 참고)
- 선크림 (SPF50 이상)
  - 해가 강함
- 선글라스
- 모자
- 상비약
  - 감기약, 상처약(후시딘 같은)
- https://blog.naver.com/saladin324/223012758828
110V 어댑터
- 우리나라에서 11자 어댑터라고 하면 알아듣는 그 변환잭
- 가져갈 기기들이 대부분 프리폴트이겠지만 혹시나 하면 볼트 적혀 있는 곳 보면 100v-220v 이런 식으로 쓰여있으면 대부분 사용 가능
충전 케이블
핸드폰 로밍 또는 포켓와이파이
- 비행기 타고나서 샐룰러 끄고 비행기모드로 하면 됨.
- 포켓와이파이가 잘 안 되는 경우도 있다고 하니 그럴 경우는 숙소 와이파이로 사용하면서 구글맵 지도를 다 찍는 방법을 사용
- 해외 데이터 요금 폭탄을 막는 방법 4가지 - 스카이스캐너-항공권, 호텔, 렌터카 최저가 비교예약 (skyscanner.co.kr)
보조배터리
- 이건 기내에 들고 타야 함.
마스크
우산
- 소나기가 자주 있다고 하니
셀카봉
블루투스 이어폰 (숙소에서 쉴 때)
- 숙소에 넷플릭스가 있을 수 있으나 계정이 각자 필요 할 수 있어서 그냥 태블릿 가져가서 보는 것도 추천

주의사항

팁문화

https://blog.naver.com/mellow47/222830991259

식당
- 식당에서 밥 먹을 시 계산지에 Service Charge 나 Included Gratuity라고 10~15% 적혀 있으면 따로 팁은 안내도 됨.
- 만약 붙어 있지 않으면 음식 값의 10~20% 팁으로 생각할 것
- 만약 카드라면 계산지에 additional Tip에 팁 금액 쓰고 Total 금액에 다 더해서 사인하면 됨
- 밥 다 먹고 계산하기 전에 Check Please라고 하면 계산지 가져다줌
호텔
- 객실 정리 해주기 때문에 매일 인당 $1 주는 게 거의 관례
투어
- 특별한 별도로 투어가 있다면 인당 $1~2 달러 생각하면 됨.

대중교통

티롤리
- https://blog.naver.com/neti96/222984977345
- 호텔 프런트에서 시간표를 받을 수 있고 아래 사진 참고 (23년 1월 기준)
- 버스 앞 유리창에 종착점이 붙여 있으니 방향 잘 보고 확인
  - 잘 모르겠으면 호텔 프런트에 물어볼 것
- 요금은
  - 편도 : $4
  - 1일: $10
  - 2일 : $14
  - 3일 : $18
  - 5일 : $24

티롤리 노선도

티롤리 시간표

택시
- 한인택시가 여러 종류라서 아래 두 블로그 보고 각각의 카카오친구 등록해서 가격 물어보면 될 듯
  - https://guambada.tistory.com/117
  - https://blog.naver.com/minek23/221510753892
- 카카오택시를 괌에서 쓸 수 있다고 함.
  - https://blog.naver.com/iheendung/223001186909

[강화 학습] 1990년 이후 강화학습 관련 모델이나 기법

jmkim87 — Mon, 27 Feb 2023 21:07:15 +0900

Q-Learning (1992): 이후 강화학습 분야의 대표적인 알고리즘 중 하나인 Q-Learning이 Watkins와 Dayan에 의해 제안됨. [논문: "Q-Learning", 1992]

TD-Gammon (1995): 텐니스 게임에서의 자가 학습을 통해 세계 챔피언을 이긴 최초의 강화학습 모델인 TD-Gammon이 제안됨. [논문: "Temporal Difference Learning of Backgammon Strategy", 1995]

DQN (2013): DeepMind에서 개발된 Deep Q-Network(DQN)은 딥러닝을 강화학습에 적용한 첫번째 모델로, Atari 게임에서 인간 수준의 성능을 보임. [논문: "Playing Atari with Deep Reinforcement Learning", 2013]

Actor-Critic (2016): 대표적인 강화학습 알고리즘 중 하나인 Actor-Critic은 신경망 모델을 사용하여 정책(policy)과 가치함수(value function)를 동시에 학습하는 방식으로 구현됨. [논문: "Asynchronous Methods for Deep Reinforcement Learning", 2016]

AlphaGo (2016): 구글 딥마인드 팀에서 개발한 인공지능 기반의 바둑 프로그램으로, 강화학습, 신경망, 몬테카를로 트리 탐색 등의 기술을 사용하여 이세돌 9단과 대국을 했을 때 4승 1패의 기록을 달성하는 등 바둑 역사상 최초로 프로 수준의 기량을 보여주었다. AlphaGo의 성공은 인공지능의 발전에 큰 기여를 하였으며, 이후 알파고 제로와 알파제로 등 다양한 알파고 시리즈가 개발되어 대표적인 강화학습 모델로 자리 잡았다. [논문: "Mastering the Game of Go with Deep Neural Networks and Tree Search", 2016]

Dueling DQN (2016): 강화학습 분야에서 딥러닝 모델을 사용하여 Atari 게임에서 인간 수준의 성능을 보인 첫 모델 중 하나인 Dueling DQN이 소개됨. [논문: "Dueling Network Architectures for Deep Reinforcement Learning", 2016]

Rainbow (2017): 다양한 강화학습 모델의 장점을 합친 Rainbow가 발표되어 Atari 게임에서 최고 성능을 달성함. [논문: "Rainbow: Combining Improvements in Deep Reinforcement Learning", 2017]

Proximal Policy Optimization (PPO) (2017): OpenAI에서 제안한 Proximal Policy Optimization(PPO)은 안정적인 정책 최적화 알고리즘으로, Atari 게임과 로봇 제어 문제에서 우수한 성능을 보임. [논문: "Proximal Policy Optimization Algorithms", 2017]

Soft Actor-Critic (SAC) (2018): 연속적인 행동 공간(Continuous Action Space)에서 안정적인 학습을 위해 제안된 SAC는 안정적이면서도 높은 성능을 보이는 대표적인 알고리즘 중 하나임. [논문: "Soft Actor-Critic Algorithms and Applications", 2018]

AlphaZero (2018): 딥러닝을 이용한 강화학습 알고리즘의 한계를 극복한 AlphaZero는, 오로지 게임 규칙만을 입력으로 받아 최적의 전략을 스스로 학습하고, 세계 최고 수준의 바둑, 장기, 체스 선수들을 이길 정도의 실력을 보임. [논문: "Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm", 2018]

RL^2 (2018): 강화학습을 위한 메타-러닝 방법인 RL^2는, 새로운 태스크를 빠르게 학습할 수 있는 강화학습 모델을 학습하는 모델로, 최신 연구 주제 중 하나임. [논문: "Meta-Learning with Reinforcement Learning", 2018]

A3C (2018): Asynchronous Advantage Actor-Critic(A3C)은 비동기적으로 여러 환경에서 학습하는 방식으로, 실시간으로 대규모 데이터를 학습할 수 있음. [논문: "Asynchronous Methods for Deep Reinforcement Learning", 2018]

RAINBOW (2018): Google DeepMind에서 제안한 RAINBOW는 다양한 강화학습 알고리즘들을 융합하여 개발한 모델로, Atari 게임에서 DQN보다 더욱 높은 성능을 보임. [논문: "Rainbow: Combining Improvements in Deep Reinforcement Learning", 2018]

World Models (2019): 강화학습 모델에 베이지안 네트워크와 생성모델을 결합하여 게임에서 좋은 성능을 보이는 World Models가 소개됨. [논문: "World Models", 2019]

PlaNet (2019): Model-based 강화학습 알고리즘인 PlaNet은 모델 학습에 Variational Auto-Encoder(VAE)를 사용하여 높은 성능을 보이며, 예측 정확도가 높아서 몇몇 문제에서는 Model-Free 알고리즘과 견줄만한 성능을 보인다. 또한, 비교적 적은 수의 환경 탐색으로도 높은 성능을 얻을 수 있는 장점이 있다. [논문: "Stabilizing Off-Policy Q-Learning via Bootstrapping Error Reduction", 2019]

MuZero (2019): 일반 게임과 바둑, 체스 등의 게임에서 뛰어난 성능을 보이는 모델로, 강화학습, 자가 대국, 신경망 등의 기술을 활용하여 구현되었다. MuZero는 특히 게임에 대한 사전 지식 없이도 학습 가능하며, 게임 상태의 내부 모델을 학습하여 미래의 게임 상태를 예측하여 최적의 행동을 결정한다. [논문: "Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model", 2019]

D4RL (2020): 데이터셋 구축 및 평가를 위한 강화학습 벤치마크인 D4RL(Dataset for Deep Data-Driven Reinforcement Learning)이 소개됩니다. [논문: "D4RL: Datasets for Deep Data-Driven Reinforcement Learning", 2020]

DreamerV2 (2021): 자기 대국과 같은 높은 차원의 문제를 해결하기 위한 강화학습 알고리즘인 DreamerV2가 소개됩니다. [논문: "DreamerV2: Deep Reinforcement Learning for Vision-Based Robotic Manipulation with Latent Imagination", 2021]

MOReL (2021): 도메인 어댑티브 강화학습을 위한 모델 기반 강화학습 알고리즘인 MOReL(Model-Based Offline Reinforcement Learning)이 소개됩니다. [논문: "MOReL: Model-Based Offline Reinforcement Learning for Non-Stationary Environments", 2021]

Muzero General (2021): MuZero 모델을 보완한 Muzero General이 발표되었다. Muzero General은 MuZero와 같이 게임에서 높은 성능을 보이지만, 훨씬 더 광범위한 문제에 적용할 수 있다. [논문: "Muzero General: A Generalized Framework for Offline Planning", 2021]

R2D2 (2022): 대규모 분산 강화학습 시스템인 R2D2(Rollout2Distibuted Deep Reinforcement Learning)이 소개됩니다. [논문: "R2D2: Rollout2Distibuted Deep Reinforcement Learning for Large-Scale Multi-Agent Environments", 2022]

[이미지 처리] 1990년 이후 이미지 관련 모델이나 기법

jmkim87 — Sun, 26 Feb 2023 21:22:27 +0900

LeNet-5 (1998): 이미지 분류를 위한 최초의 합성곱 신경망 모델로, 손글씨 숫자 인식에 성공함. [논문: "Gradient-based learning applied to document recognition", 1998]

SIFT (1999): 이미지에서 특징점을 검출하고, 이를 기초로 이미지를 비교하는 방법으로, 이미지 인식 분야에서 큰 역할을 함. [논문: "Distinctive Image Features from Scale-Invariant Keypoints", 1999]

Bag-of-features (2004): 이미지의 전체적인 특징만을 고려하여 이미지를 분류하는 방법으로, 이미지 분류 분야에서 활용되었음. [논문: "An Introduction to the Bag-of-Features Framework for Image Classification and Retrieval", 2004]

HOG (2005): 이미지 내의 에지 방향을 히스토그램으로 표현한 후, 이를 분석하는 방법으로, 사물 검출 분야에서 활용됨. [논문: "Histograms of Oriented Gradients for Human Detection", 2005]

Deformable Part-based Model (DPM) (2008): 객체의 각 부분을 검출하고, 이들을 조합하여 객체를 검출하는 방법으로, 사물 검출 분야에서 활용되었음. [논문: "Beyond PASCAL: A benchmark for 3D object detection in the wild", 2008]

Deep Convolutional Neural Network (DCNN) (2012): 다층 합성곱 신경망 모델로, 이미지 인식 분야에서 혁신적인 성과를 냈고, 이후 많은 딥러닝 모델들의 기반 기술이 되었음. [논문: "Imagenet classification with deep convolutional neural networks", 2012]

Spatial Pyramid Pooling (SPP) (2014): 이미지 내의 특징들을 고정된 크기의 블록으로 분할하여 히스토그램으로 만들어, 크기가 다른 이미지에서도 동일한 크기의 특징 벡터를 추출할 수 있도록 한 방법으로, 이미지 인식 분야에서 활용되었음. [논문: "Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition", 2014]

ResNet (2015): 이미지 인식 분야에서 혁신적인 딥러닝 모델 중 하나인 ResNet은 네트워크의 깊이가 증가함에 따라 발생하는 gradient vanishing 문제를 해결하였습니다. ResNet은 residual connection이라는 새로운 구조를 도입하여, 이전 레이어의 출력을 다음 레이어의 입력으로 사용함으로써, 딥러닝 모델을 더욱 깊게 학습시킬 수 있게 되었습니다. [논문: "Deep Residual Learning for Image Recognition", 2015]

GQN (2018): 다양한 위치와 방향에서 입력된 2D 이미지들을 3D 공간에 배치하고 이를 연속적으로 조합하여 새로운 관찰 가능한 이미지를 생성하는 Generative Query Network (GQN)가 제안됨. [논문: "Neural Scene Representation and Rendering", 2018]

BigGAN (2018): 기존의 GAN 모델에서 발전시켜 고해상도, 다양한 카테고리의 이미지 생성에 뛰어난 성능을 보이는 BigGAN 모델이 발표됨. [논문: "Large Scale GAN Training for High Fidelity Natural Image Synthesis", 2018]

StyleGAN (2019): GAN 기반 모델 중 하나인 StyleGAN은 기존의 GAN 모델들과는 다르게 생성된 이미지의 품질 뿐 아니라 이미지의 특정 스타일을 조정할 수 있는 기능을 갖추고 있음. [논문: "A Style-Based Generator Architecture for Generative Adversarial Networks", 2019]

ViT (2020): 기존의 CNN 모델에 비해 더욱 간결한 구조를 갖추고 있으며, 전이학습에 용이한 Vision Transformer (ViT)가 발표됨. [논문: "An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale", 2020]

CLIP (2021): 이미지와 텍스트를 함께 이용하여 모델 학습을 진행하는 Contrastive Language-Image Pre-Training (CLIP) 모델이 발표됨. 이 모델은 이미지 검색, 이미지 분류 등 다양한 응용 분야에서 높은 성능을 보임. [논문: "Learning Transferable Visual Models From Natural Language Supervision", 2021]

Stable Diffusion (2021): 이미지 생성 분야에서 최신 기술 중 하나인 Stable Diffusion이 발표되었습니다. 이 모델은 CLIP, UNet, VAE(Variational Auto Encoder, 자기부호화기)이라는 세 가지 인공신경망으로 이루어져 있다. 유저가 텍스트를 입력하면 텍스트 인코더(CLIP)가 유저의 텍스트를 토큰(Token)이라는 UNet이 알아들을 수 있는 언어로 변환하고, UNet은 토큰을 기반으로 무작위로 생성된 노이즈를 디노이징하는 방식이다. 디노이징을 반복하다 보면 제대로 된 이미지가 생성되며, 이 이미지를 픽셀로 변환하는 것이 VAE의 역할이다. 해상도가 높아질수록 리소스를 기하급수적으로 사용하게 되는 종전의 확산 확률 이미지 생성 모델과 달리, 앞뒤에 오토인코더를 도입하여 이미지 전체가 아닌 훨씬 작은 차원의 잠재공간(latent space)에서 노이즈를 삽입/제거하므로, 비교적 큰 해상도의 이미지를 생성하는데도 리소스 사용량을 대폭 줄여 일반 가정의 그래픽카드 정도로도 이용이 가능해진 것이 특징입니다. [논문: "High-Resolution Image Synthesis with Latent Diffusion Models", 2021]

[자연어처리] 1990년 이후 자연어처리에 쓰인 모델이나 기법들

jmkim87 — Sat, 25 Feb 2023 21:17:10 +0900

LSTM (1997): 반복 신경망을 장기 기억을 유지할 수 있도록 확장한 LSTM(Long Short-Term Memory) 모델이 제안됨. [논문: "Long Short-Term Memory", 1997]

Conditional Random Field (2001): 레이블된 시퀀스 데이터를 모델링하는데 사용되는 조건부 랜덤 필드(Conditional Random Field) 모델이 제안됨. [논문: "Conditional Random Fields: Probabilistic Models for Segmenting and Labeling Sequence Data", 2001]

Word2Vec (2013): 단어를 밀집 벡터(dense vector)로 표현하는 기법인 Word2Vec이 제안됨. [논문: "Efficient Estimation of Word Representations in Vector Space", 2013]

Sequence to Sequence (Seq2Seq) (2014): 인코더-디코더(encoder-decoder) 구조를 사용하여 시퀀스를 다른 시퀀스로 변환하는 모델인 Seq2Seq가 제안됨. [논문: "Sequence to Sequence Learning with Neural Networks", 2014]

Attention Mechanism (2014): 입력 시퀀스의 각 단어가 출력 시퀀스의 각 단어에 직접 매핑되는 대신, 입력 시퀀스의 모든 단어가 출력의 각 단어에 영향을 주는 방식으로 작동하는 어텐션(attention) 메커니즘이 제안됨. [논문: "Neural Machine Translation by Jointly Learning to Align and Translate", 2014]

Pointer Network (2015): 일반적인 시퀀스-시퀀스(Seq2Seq) 모델의 한계를 극복하기 위해, 출력 시퀀스를 생성할 때 입력 시퀀스의 요소를 가리키는 방식으로 작동하는 포인터(Pointer) 네트워크가 제안됨. [논문: "Pointer Networks", 2015]

Character-level Convolutional Network (2016): 단어 대신 문자 단위의 컨볼루션(Convolution) 신경망을 사용하여 단어나 문장을 분류하는 모델이 제안됨. [논문: "Character-level Convolutional Networks for Text Classification", 2016]

Transformer (2017): 자연어 처리 분야에서 가장 유명한 모델 중 하나인 Transformer가 소개됨. self-attention 기반 신경망 구조인 Transformer는 번역, 요약, 질의응답 등 다양한 자연어 처리 문제에서 좋은 성능을 보이며, 이전 모델들과는 달리 순차적인 계산을 하지 않고 전체 문장을 동시에 처리하는 방식을 채택하여 학습 속도가 빠르고 효과적이다. [논문: "Attention Is All You Need", 2017]

ELMo (2018): 사전 훈련된 언어 모델을 활용해 단어의 다의어성(disambiguation)과 문맥 파악 등을 수행하는 모델로, 이후 BERT와 같은 모델의 발전에 영향을 끼쳤다. [논문: "Deep contextualized word representations", 2018]

BERT (2018): 사전 훈련된 언어 모델 중 가장 대표적인 모델 중 하나로, Transformer 구조를 활용해 사전 학습된 언어 모델을 기반으로 문장 분류, 질의 응답, 개체명 인식 등 다양한 자연어 처리 태스크에서 우수한 성능을 보여주었다. [논문: "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding", 2018]

GPT (2018): OpenAI에서 발표한 Transformer 기반 언어 생성 모델로, 문장을 생성하는 과정에서 이전 단어와 다음 단어의 관계를 고려해 다양한 문장을 생성할 수 있다. [논문: "Improving Language Understanding by Generative Pre-Training", 2018]

XLNet (2019): 자기회귀(autoregressive) 모델의 한계를 극복하기 위해 자기회귀 언어 모델과 오토인코더(autoencoder)를 결합한 모델로, 다양한 자연어 처리 태스크에서 우수한 성능을 보여주며, BERT와 같은 모델의 한계를 극복하고자하는 연구들에 큰 영향을 끼쳤다. [논문: "XLNet: Generalized Autoregressive Pretraining for Language Understanding", 2019]

RoBERTa (2019): BERT와 유사한 구조를 가지고 있으나, 더 많은 데이터를 이용하여 학습시켰습니다. [논문: "RoBERTa: A Robustly Optimized BERT Pretraining Approach", 2019]

ALBERT (2019): BERT와 유사한 구조를 가지고 있으나, 파라미터를 줄여 더 경량화시켰습니다. [논문: "ALBERT: A Lite BERT for Self-supervised Learning of Language Representations", 2019]

ELECTRA (2020): BERT와 유사한 구조를 가지고 있으나, 마스킹된 단어를 진짜 단어인 것처럼 학습시켜 더 효과적인 학습을 이루었습니다. [논문: "ELECTRA: Pre-training Text Encoders as Discriminators Rather Than Generators", 2020]

DistilBERT (2019): BERT와 유사한 구조를 가지고 있으나, 더 작은 모델 크기로 학습시켜 더 빠르게 추론할 수 있습니다. [논문: "DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter", 2019]

CamemBERT (2019): 프랑스어 자연어 처리를 위해 BERT를 수정하고 학습시켰습니다. [논문: "CamemBERT: a Tasty French Language Model", 2019]

XLM (2019): 다국어 자연어 처리를 위해 BERT를 수정하고 학습시켰습니다. [논문: "Cross-lingual Language Model Pretraining", 2019]

RoBERTa (2019): BERT 모델의 사전 훈련을 개선하고 성능을 향상시킨 RoBERTa가 소개됨. [논문: "RoBERTa: A Robustly Optimized BERT Pretraining Approach", 2019]

T5 (2020): Transformer를 기반으로 하는 다목적 언어 모델로, 텍스트 생성, 번역, 요약, 질의 응답 등 다양한 태스크를 하나의 모델로 수행할 수 있다. [논문: "Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer", 2020]

GPT-3 (2020): 대규모 transformer 모델을 사용한 언어 생성 모델로 GPT-3가 소개됨. [논문: "Language Models are Few-Shot Learners", 2020]

[React] React 18

jmkim87 — Fri, 24 Feb 2023 23:16:51 +0900

React 18은 React 프레임워크의 새로운 버전입니다. 이번 버전에서는 기존의 React와 비교하여 많은 기능 개선 및 업그레이드가 이루어졌습니다. 예를 들어, 성능을 개선하고 안정성을 확보하기 위해 다양한 업그레이드가 이루어졌습니다.

주요 기능

서버 사이드 렌더링 개선: 이번 버전에서는 기존에 있었던 서버 사이드 렌더링의 성능 이슈가 해결되었습니다. 이로 인해 더욱 빠르고 안정적인 서버 사이드 렌더링이 가능해졌습니다. 이 기능의 개선으로 인해, 사용자들은 더욱 빠른 웹 페이지 로딩 시간을 경험할 수 있게 되었습니다.
새로운 이벤트 모델: 기존의 이벤트 모델에서 발생하던 문제점들을 개선하였습니다. 예를 들어, 이제 이벤트 처리가 더욱 직관적이고 유연해졌습니다. 이로 인해, 사용자 경험과 개발자 경험 모두가 향상될 것입니다.
빠른 초기 로딩: 이번 버전에서는 초기 로딩 속도가 매우 빨라졌습니다. 이는 사용자 경험을 높이고 검색 엔진 최적화(SEO)에도 도움이 됩니다. 이 기능의 개선으로 인해, 사용자들은 더욱 빠른 페이지 로딩 속도를 경험할 수 있게 되었습니다.
자동 배치(Concurrent Mode): React 18에서는 자동 배치 기능이 추가되어 UI 업데이트가 더욱 빠르고 부드러워졌습니다. 이 기능의 개선으로 인해, 사용자들은 더욱 더 빠르고 부드러운 UI를 경험할 수 있게 되었습니다.
React Suspense: React 18에서는 새로운 기능으로 React Suspense가 추가되었습니다. 이를 통해 데이터 로딩이 완료될 때까지 UI를 로딩 상태로 유지하거나, 로딩 중인 데이터에 대한 fallback UI를 보여줄 수 있습니다. 이 기능의 개선으로 인해, 사용자들은 더욱 더 부드러운 UI 및 더욱 높은 유저 경험을 경험할 수 있게 되었습니다.

결론

React 18은 기존의 React에서 발생하던 성능 이슈와 문제점들을 개선하여 더욱 빠르고 안정적인 웹 개발을 가능케 합니다. 이를 통해 사용자 경험을 향상시키고 검색 엔진 최적화를 위한 노력도 더욱 더 효과적으로 이루어질 것입니다. 이번 버전에서의 업그레이드와 개선 사항은 React 프레임워크의 기능적인 발전만큼이나, 웹 개발자들에게 편리함과 향상된 개발 경험을 제공합니다. 또한, 이번 버전에서는 더욱 많은 개발자들이 React를 사용할 수 있게 되었습니다.

#3. Longest Substring Without Repeating Characters [Medium] [Javascript]

jmkim87 — Thu, 14 Apr 2022 21:39:35 +0900

문제

Given a string s, find the length of the longest substring without repeating characters.

Example 1:

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Example 2:

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3:

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

Constraints:

0 <= s.length <= 5 * 104
s consists of English letters, digits, symbols and spaces.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

var lengthOfLongestSubstring = function(s) {
    const map = {};
    var left = 0;

    return s.split('').reduce((max, v, i) => {
        left = map[v] >= left ? map[v] + 1 : left;
        map[v] = i;
        return Math.max(max, i - left + 1);
    }, 0);
};

#2. Add Two Numbers [Medium][Javascript]

jmkim87 — Sun, 3 Apr 2022 14:36:55 +0900

문제

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Example 2:

Input: l1 = [0], l2 = [0]
Output: [0]

Example 3:

Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,0,0,0,1]

Constraints:

The number of nodes in each linked list is in the range [1, 100].
0 <= Node.val <= 9
It is guaranteed that the list represents a number that does not have leading zeros.

풀이

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

var addTwoNumbers = function(l1, l2) {
    let upNumber = 0;
    const head = new ListNode(0, null);
    let pr = head;

    while(l1 !== null || l2 !== null) { 
        const sum = (l1 ? l1.val : 0) + (l2 ? l2.val: 0);
        const current = new ListNode((sum + upNumber) % 10, null);
        upNumber = Math.floor((sum + upNumber) / 10);
        l1 = l1 ? l1.next : null;
        l2 = l2 ? l2.next : null;
        pr.next = current;
        pr = pr.next;
    }

    if(upNumber > 0) {
        pr.next = new ListNode(upNumber, null)
    }


    return head.next;
};

#1. Two Sum [Easy] [javascript]

jmkim87 — Thu, 31 Mar 2022 19:35:22 +0900

문제

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

Constraints:

2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
Only one valid answer exists.

Follow-up:

Can you come up with an algorithm that is less than

O(n2)

time complexity?

풀이

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

var twoSum = function(nums, target) {
    const results = [];
    let index = 0;
    while(nums.length) {
        const first = nums.shift();
        index++;
        const result = nums.findIndex((num) => (target - (num + first) === 0));
        if(result > -1) {
            results.push(index - 1);
            results.push(result + index);
            break;
        }
    }
    return results;
};

기술 블로그 모음 입니다.

jmkim87 — Mon, 17 May 2021 18:12:32 +0900

이래저래 모아둔 기술 블로그 링크 모듬입니다. 보이거나 링크 변경될 때 수정할 예정입니다.

카카오 http://tech.kakao.com
네이버 http://d2.naver.com
VCNC http://engineering.vcnc.co.kr
우아한형제들 기술 블로그 https://woowabros.github.io
SK플래닛 http://feeds.feedburner.com
Amazon Web Services 한국 블로그 https://aws.amazon.com/ko/blogs/korea/
스타일쉐어 https://styleshare.github.io
Spoqa https://spoqa.github.io
이음소시어스 http://bigmatch.i-um.net
토스랩(잔디) https://tosslab.github.io
굿닥 엔지니어링 블로그 http://dev.goodoc.co.kr
티몬 http://tmondev.blog.me
엠비안 http://blog.embian.com
데일리호텔 https://dailyhotel.io
Mozilla 웹 기술 블로그 http://hacks.mozilla.or.kr/
Google Developers Korea 블로그 http://googledevkr.blogspot.in
달리웍스 http://techblog.daliworks.net
조이코퍼레이션 https://medium.com
후이서울 https://engineering.huiseoul.com
드라마앤컴퍼니 http://blog.dramancompany.com
꿈많은청년들 https://blog.dreamyoungs.com
Realm https://realm.io
하이퍼커넥트 https://hyperconnect.github.io/
네이버 클라우드 플랫폼 블로그 https://blog.naver.com/n_cloudplatform
당근마켓 팀블로그 https://medium.com/n42-corp
RemoteMonster https://blog.remotemonster.com
컬리 기술 블로그 https://helloworld.kurly.com/
핑퐁 기술 블로그 https://blog.pingpong.us
쿠팡 기술 블로그 https://medium.com/coupang-tech
Line https://engineering.linecorp.com/ko/blog/
Airbnb https://medium.com/airbnb-engineering
페이스북 개발자 블로그 https://developers.facebook.com/blog/
Netfilx https://netflixtechblog.com
twitter https://blog.twitter.com/engineering/en_us.html
microsoft https://techcommunity.microsoft.com/t5/custom/page/page-id/Blogs
dropbox https://dropbox.tech
instagram https://instagram-engineering.com
toast https://meetup.toast.com
레진코믹스 https://tech.lezhin.com
야놀자 https://yanolja.github.io
zigzag https://devblog.croquis.com/ko/
무신사 https://medium.com/musinsa-tech

1장 빅테이터 기술 기초 다지기

jmkim87 — Fri, 2 Oct 2020 23:35:30 +0900

1. 빅데이터 기술 기초 다지기

아파치 하둡(Apache Hadoop) : 높은 확장성과 신뢰성을 보유한 분산 스토리지와 분산 처리 기능을 제공하기 위해 다양한 소프트웨어를 밀접하게 통합한 에코시스템. 대표적으로 분산 파일 시스템 HDFS(Hadoop Distributed File System)과 분산 서버 클러스터 환경에서 프로세스를 실행하는 YARN(Yet Another Resource Negotiator)가 있다.

클러스터(Cluster)란?
- 저장이나 연산 등 하나 이상의 기능을 제공하기 위해 협력하는 서버의 조합.
- 마스터(Master)와 워커(Worker)가 존재
  - 마스터: 워커를 조율하는 역할을 담당하며, 워커 장비에서 실행되는 서비스나 데이터에 대한 메타 데이터를 관리하고 워커 장비의 일부에 장애가 발생하더라도 서비스가 멈추지 않고 계속 실행 될 수 있게 보장.
  - 워커 : 실제 작업을 수행하며, 데이터를 처리하고 연산을 수행하고 조회나 검색 등의 서비스를 제공하는 역할

1-1. 하둡 에코시스템 둘러보기

하둡 에코시스템은 하둡을 중심으로 만들어진 데이터 엔지니어링 프로젝트와 프레임워크 전부를 의미.

여기서는 프로젝트의 의존 관계를 데이터와 제어 두가지로 구분함.

핵심 컴포넌트

**HDFS**
- **하둡 분산 파일 시스템(Hadoop Distributed File System)**은 확장성과 장애 허용성을 가진 분산 파일 시스템
- 상당히 긴 순차 접근(Sequential access) 방식을 통해 디스크에 불변 데이터를 저장하는데 최적화돼 있음
- 데이터를 설정 가능한 크기의 block으로 나눠 저장.
- 기본은 128MB이며, 데이터 회복성 및 데이터 병렬 처리를 위해 여러대의 서버에 각 블록의 복제본을 저장
- 클러스터에 있는 워커 노드는 데이터 노드(Data node) 데몬을 실행 새 블록을 전달받아서 로컬디스크에 저장
  - 데이터의 저장 및 제공을 담당
  - 블록과 블록의 ID만 알고 있음
- 마스터 서버에서 실행되고 있는 **네임 노드(Name node)**는 파일 자체의 메타 데이터를 관리
  - 파일이 어느 복제본에 속하는지에 대한 정보
  - 파일과 블록 사이의 매핑 정보
  - 파일 이름, 권한, 속성, 복제 계수(Replication factor)등에 대한 정보
- 불변성을 위해 파일의 일부분 수정을 지원하지 않음.
YARN(Yet Another Resource Negotiator)
- 작업 스케줄링, 클러스터 리소스 관리를 위한 프레임 워크
- 워커 노드 안에 노드 매니저(Node Manager)가 리소스 매니저(Resource Manager)에 다양한 정보 전달
  - 가상 코어(vcore)의 단위로 얼마나 많은 연산 자원을 사용할 수 있는지
  - 해당 노드에 메모리가 얼마나 남아 있는지

ZooKeeper

분산 환경에서 서버들간의 상호 조정이 필요한 다양한 서비스 제공
하나의 서버에서 처리한 결과를 다른 서버들과 동기화(데이터 안정성 보장)
운영(active) 서버에서 문제가 발생하여 서비스 제공할 수 없는 경우 다른 대기중인 서버를 운영서버로 변경하여 중지없이 제공
하나의 서버에만 서비스가 집중되지 않도록 서비스를 분산하여 동시에 처리
중앙 집중식 서비스로 분산처리 및 분산 환경을 구성하는 서버 설정을 통합적으로 관리
지노드(znode) : 데이터를 가지고 있으며, 0개 이상의 자식 노드를 가질수 있음
앙상블(ensemble) : 회복성을 확보하기 위해 인스턴스를 각기 서로 다른 서버에 배포

쿼럼(quorum) : 다수결 원칙에 따라 합의(consensus)를 이끌어 내므로 홀수의 서버에 배포하고 이때 과반수의 서버로 이루어진 그룹

프로젝트	주키퍼 사용 목적
HDFS	고가용성 조율
HBase	메타데이터 관리 및 조율
솔라	메타데이터 관리 및 조율
카프카	메타데이터 관리 및 조율
얀	고가용성 조율
하이브	테이블 및 파티션 잠금 및 고가용성

아파치 하이브(Hive) 메타스토어
- 하둡 내에 존재하는 비정형 바이너리 데이터(unstructured binary data)가 아닌 정형 데이터셋(structured dataset)에 대한 정보를 데이터 셋, 테이블, 뷰 같은 논리적인 위계 구조로 구성해서 관리
- HDFS에서는 하이브 테이블이 디렉토리와 같다.
- 파티셔닝을 지원하며, 파티션된 테이블은 HDFS 상에서 하위 디렉토리를 가지게 된다.
- 하나의 테이블 안에서의 모든 파일은 동일한 포맷으로 저장돼야 한다.
- 관리형 테이블(managed table), 외부 테이블(external table)을 지원
  - 관리형 테이블 사용시 테이블 삭제되면 스토리지 엔진에 저장된 데이터를 모두 삭제
  - 외부 테이블 사용시 데이터베이스에 있는 테이블의 메타데이터만 관리

연산 프레임워크

하둡 맵리듀스(MapReduce)
- 대용량 데이터를 분산 처리하기 위한 프로그래밍 모델 프레임워크
- MapReduce Framework를 이용하면 대규모 분산 컴퓨팅 환경에서, 대량의 데이터를 병렬로 분석 가능
- 연산을 맵(Map), 셔플(Shuffle), 리듀스(Reduce) 3 단계로 나눠서 처리
아파치 스파크(Spark)
- 효율성과 사용성에 중점을 둔 분산 연산 프레임워크
- 다수의 저사양 장비로 이루어지는 워크 노드에 있는 메모리를 최대한 활용하는 것
- 배치 연산과 스트리밍 연산을 모두 지원
- 데이터셋에 직접 적용할 수 있는 풍부한 API를 제공
- 프로세싱 그래프가 표준 쿼리 옵티마이저를 거친 후에 실행
- 스파크 표준 쿼리 옵티마이저 : 관계형 데이터베이스 혹은 대규모 병렬 쿼리 엔진의 쿼리 옵티마이저와 비슷
  - 파이프라인 실행의 효율성을 극대화 하기 위해 프로세싱 그래프를 재배치(rearrange), 결합(combine), 가지치기(prune) 사용

분석용 SQL 엔진

아파치 하이브(Hive)
- 하둡에 사용되는 원조 데이터 웨어하우징 기술
- HDFS에 저장된 정형 데이터를 SQL과 비슷한 문법(하이브QL)으로 쿼리할 수있게 만든 기술
- ETL(추출(Extract), 변환(Transform), 적재(Load)), 보고서 데이터 생성, 벌크 데이터 처리 등 오프라인 배치 작업에 적합
아파치 임팔라(Impala)
- 대규모 병렬 처리(Massive Parallel Processing) 엔진
- MapReduce를 사용하지 않고 C++로 개발한 인메모리 엔진을 사용하여 빠른 성능을 보여줌
- 하둡이나 클라우드 스토리지에 저장된 대용량 데이터셋에 대한 고속, 대화형 SQL 쿼리를 목적으로 설계
- 테라바이트 단위의 데이터에 대해 다수의 동시 실행 애드혹 쿼리, 보고서 스타일의 쿼리를 수초내에 처리하는 것이 목표

스토리지 엔지

아파치 HBase
- HDFS의 컬럼(열) 기반 데이터베이스
- 분산 테이블에 cell이라고 불리는 키-값 쌍의 반정형 데이터 형식으로 HDFS에 저장
- 실시간 랜덤 조회 및 업데이트 가능
- 각각의 프로세스들은 개인의 데이터를 비동기적(동시성 X)으로 업데이트 할 수 있음. 단 MapReduce는 일괄처리 방식으로 수행!
- Hadoop 및 HDFS위에 Bigtable과 같은 기능을 제공
- Cell key를 위계 구조(hierarchy)를 가지도록 세분화
  - 로우 키 : Cell의 논리적인 그룹인 로우row를 정의함
  - 컬럼 패밀리 : 메모리와 디스크에 분리되어 저장되고, 컬럼 한정자로 세분화되는데 하나의 로우에 수백만 개의 컬럼 한정자가 있을 수 있음.
  - 버전 : 타임스탬프로 되어 있음.
  - 리전(region) : HBase에서 수평확장의 기본단위이며, 함께 저장되는 테이블의 부분집합
아파치 쿠두(Kudu)
- 미리 정의된 스키마를 따르는 테이블에 타입을 가진 컬럼으로 구성된 레코드를 저장하는 정형 데이터 스토어
- 컴럼의 일부는 테이블의 기본 키로 사용되며, 인덱스가 생성됨
- 파티셔닝 매커니즘
  - 범위 파티셔닝(Range Partitioning) : 각 태블릿은 상한과 하한으로 이뤄진 범위를 갖고 있으며, 범위 내에 들어가는 파티션 키를 가진 모든 레코드는 해당 태블릿에 저장
  - 해시 파티셔닝(Hash Partitioning) : 사용자는 테이블 파티셔닝의 기준이 되는 고정된 수의 해시 버킷을 지정할 수 있고 각 행에서 선택된 컬럼의 해시 값을 해시 커빗 수로 나눈 나머지를 기준으로 태블릿에 저장
아파치 솔라(Solr)
- 정보검색 라이브러리인 루씬의 엔터프라이즈 버전
- 텍스트 검색, 다면적 검색, 실시간 인덱싱, 클러스터링, 데이터베이스 통합, 다양한 문서처리 및 솔라 분산 인덱싱 등 기능을 지원
- 루씬에서 나온 개념인 역방향 인덱스(inverted index)를 사용
아파치 카프카(Kafka)
- 실시간으로 기록 스트림을 게시, 구독, 저장 및 처리할 수 있는 분산 데이터 스트리밍 플랫품
- 입수되는 메시지를 분산 저장되는 순차적인 로그로 저장하고, 클라이언트나 크라이언트의 그룹은 간단한 숫자 형태의 오프셋을 이용해 특정 지점으로부터의 데이터를 가져옴
- 다양한 업스트림 소스와 다운스트림 싱크를 통합하고 회복성있는 고가용성 입수 버퍼를 제공
- 토픽(topic) : 기초가 되는 데이터 구조
- 브로커(broker) : 여러대의 서버
- 프로듀서(producer) : 카프카 토픽의 파티션으로 메시지를 발행
- 컨슈머(consumer) : 토픽에 있는 데이터를 읽음
- 컨슈머 그룹(consumer group) : 확장성을 위해 여러 컨슈머로 묶을 수 있음

데이터 입수

아파치 플룸(Flume)
- 대량의 로그 데이터를 여러 소스에서 수집하여 저장하기 위한 목적
- 이벤트 : 플룸에서 전달하는 데이터 단위
아파치 스쿱(Sqoop)
- 관계형 데이터베이스와 하둡 사이에서 데이터 이관을 지원하는 툴
  
  데이터 임포트
  
  데이터 익스포트

컴포넌트 요약

프로젝트 이름	설명	용도	의존 관계
ZooKeeper	분산 설정 서비스	분산 프로세스와 분산 잠금 사이의 메타데이터 공유	없음
HDFS	분산 파일 스토리지	불변 데이터를 위한 확장성 있는 스토리지	ZooKeeper
Yarn	분산 리소스 스케줄링 및 실행 프레임워크	확장성 있는 분산 컴퓨팅 자원을 필요로 하는 프레임워크	ZooKeeper, HDFS
MapReduce	범용 분산 연산 프레임워크	배치 연산 작업	Yarn, HDFS
Spark	범용 분산 연산 프레임워크	배치, 분석 SQL, 스트리밍 작업	자원 스케줄러(Yarn, Mesos) 및 데이터 소스(HDFS, Kudu 등)
Hive	SQL 기반 분석 쿼리 프레임워크	분산 SQL 작업	Yarn, 데이터 소스(HDFS, Kudu)
Impala	SQL 기반 대규모 병렬 처리 분산 엔진	분석 및 대화형 SQL 작업	데이터 소스(HDFS, Kudu, HBase)
HBase	위계 구조를 가진 키-값 데이터 분산/정렬 스토어	정형 키를 가진 로우 기반 데이터에 대한 고속 랜덤 읽기/쓰기	HDFS, ZooKeeper
Kudu	정형 데이터용 분산 스토어	랜덤 읽기/쓰기 및 분석 작업	없음
Solr	엔터프라이즈 검색 프레임 워크	확장성 있는 도큐먼트 인덱싱 및 임의 필트 쿼리	HDFS, ZooKeeper
Kafka	분산 발행/구독 메시징 프레임워크	데이터 프로세싱 파이프라인의 주기적 또는 실시간 실행	ZooKeeper

러닝스칼라 10장 - 고급 타입 특징

jmkim87 — Mon, 28 Sep 2020 23:43:59 +0900

스칼라 데이터 타입 특징을 깊게 알아보자.
이 장을 이해함으로써 스칼라 API, 라이브러리 동작 방식을 이해할 수 있다.

튜플과 함숫값 클래스

튜플은 TupleX[Y] 케이스 클래스의 인스턴스로 구현

X: 1 <= X <= 22, 튜플의 입력 매개변수 개수

Y: 타입 매개변수

productArity: 튜플의 매개변수 개수를 반환하는 함수, 튜플이 상속받는 ProductX 트레이트에 정의됨

scala> val x = (10, 20)
x: (Int, Int) = (10,20)

scala> val x: (Int, Int) = Tuple2(10, 20)
x: (Int, Int) = (10,20)

scala> println("Does the arity = 2? " + (x.productArity == 2))
Does the arity = 2? true

함수값은 FunctionX[Y] 트레이트를 확장한 익명 클래스의 인스턴스로 구현된다.

X: 매개변수 개수

Y: 타입 매개변수, 첫 번째는 반환값 타입, 두 번째부터는 매개변수의 타입
스칼라 컴파일러가 함수 리터럴을 FunctionX를 확장하는 새로운 클래스의 apply() 메소드의 body로 전환한다.
이는 모든 함수가 클래스 메소드로 구현되도록 제한하는 JVM과 호환되도록 해준다.

scala> val hello1 = (n: String) => s"Hello, $n"
hello1: String => String = $$Lambda$839/0x000000080104a040@3820cfe

scala> val h1 = hello1("Function Literals")
h1: String = Hello, Function Literals

scala> val hello2 = new Function1[String, String] {
     |   def apply(n: String) = s"Hello, $n"
     | }
hello2: String => String = <function1>

scala> val h2 = hello2("Functional Instances")
h2: String = Hello, Functional Instances

scala> println(s"hello1 = $hello1, hello2 = $hello2")
hello1 = $line6.$read$$iw$$iw$$$Lambda$839/0x000000080104a040@3820cfe, hello2 = <function1>

Function1 트레이트는 FunctionX (X != 1)에는 없는 2개의 메소드를 가지고 있다.

andThen: 두 함수값으로부터 새로운 함수값을 생성, 왼쪽 인스턴스에서 오른쪽에 있는 인스턴스를 실행

compose: 반대 방향으로 동작

scala> val doubler = (i: Int) => i*2
doubler: Int => Int = $$Lambda$970/0x00000008010c3040@22b10124

scala> val plus3 = (i: Int) => i+3
plus3: Int => Int = $$Lambda$971/0x00000008010c3840@79ae3fb1

scala> val append = (doubler andThen plus3)(1)
append: Int = 5

scala> val prepend = (doubler compose plus3)(1)
prepend: Int = 8

묵시적 매개변수 (implicit parameter)

nonimplicit 매개변수와 별개로 implicit한 매개변수 그룹을 정의한다.
implicit 매개변수에 명시적으로 값을 넣어도 동작한다.

scala> object Doubly {
     |   def print(num: Double)(implicit fmt: String) = {
     |     println(fmt format num)
     |   }
     | }
defined object Doubly

scala> case class USD(amount: Double) {
     |   implicit val printFmt = "%.2f"
     |   def print = Doubly.print(amount)
     | }
defined class USD

scala> new USD(81.924).print
81.92

scala> Doubly.print(3.724)("%.1f")
3.7

묵시적 클래스 (implicit class)

묵시적 클래스는 특정 클래스의 자동 전환을 제공

// Int를 Fishes 클래스로 자동 전환
scala> object IntUtils {
     |   implicit class Fishies(val x: Int) {
     |     def fishes = "Fish" * x
     |   }
     | }
defined object IntUtils

scala> import IntUtils._
import IntUtils._

scala> println(3.fishes)
FishFishFish

묵시적 클래스 제약 사항

다른 객체, 클래스, 트레이트 안에 정의되어야 한다.
하나의 nonimplicit 클래스 인수를 받아야 한다.
현재 네임스페이스의 다른 객체, 클래스, 트레이트와 클래스명이 겹치면 안된다.

케이스 클래스는 자동으로 생성된 동반 객체와 이름이 겹치기 때문에 묵시적 클래스로 사용할 수 없다.

객체 내에 구현하는 것이 가장 좋다. 객체 내에 정의할 경우 쉽게 임포트할 수 있다.

여러가지 묵시적 클래스를 가진 scala.Predef 객체는 자동으로 네임스페이스에 추가된다.

예를 들어서 x -> y 연산자는 아래와 같이 정의되어 자동으로 적용된다.

// 간략하게 적음
// 1 -> "a" Tuple2(1,"a")
implicit class ArrowAssoc[A](x: A) {
  def ->[B](y: B) = Tuple2(x, y)
}

타입

클래스, 트레이트 타입은 사용가능하지만 객체는 타입으로 간주하지 않는다.

scala> class A
defined class A

scala> trait B
defined trait B

scala> val a:A = new A
a: A = A@4860627a

scala> val b:B = new B{}
b: B = $anon$1@79486f38

타입 별칭 (type alias)

기존 타입을 새롭게 명명하는 것

타입 별칭은 객체, 클래스, 트레이트 내부에서만 정의가능

객체는 타입 별칭을 생성하는 데 사용할 수 없음

type <식별자>[타입 매개변수] = <타입명>[타입 매개변수]

scala> object TypeFun {
     |   type Whole = Int
     |   val x: Whole = 5
     |
     |   type UserInfo = Tuple2[Int, String]
     |   val u: UserInfo = new UserInfo(123, "George")
     |
     |   type T3[A,B,C] = Tuple3[A,B,C]
     |   val things = new T3(1, 'a', true)
     | }
defined object TypeFun

scala> val x = TypeFun.x
x: TypeFun.Whole = 5

scala> val u = TypeFun.u
u: TypeFun.UserInfo = (123,George)

scala> val things = TypeFun.things
things: (Int, Char, Boolean) = (1,a,true)

추상 타입 (abstract type)

추상 클래스, 트레이트를 mixin한 서브클래스가 구현해야만 하는 타입을 선언하기 위해 사용
허용 가능한 타입의 범위를 지정하기 위해 타입 매개변수로 사용된다.
인스턴스를 생성하는데 사용할 수 없다.

scala> class User(val name: String)
defined class User

scala> trait Factory { type A; def create: A }
defined trait Factory

scala> trait UserFactory extends Factory {
     |   type A = User
     |   def create = new User("")
     | }
defined trait UserFactory
//위의 코드와 동일하기 동작하지만 더 간결함
scala> trait Factory[A] { def create: A }
defined trait Factory

scala> trait UserFactory extends Factory[User] { def create = new User("") }
defined trait UserFactory

경계가 있는 타입 (bounded type)

상한 경계

<식별자> <: <상한 경계 타입>

해당 타입 또는 서브타입으로 제한

scala> class BaseUser (val name: String)
defined class BaseUser

scala> class Admin(name: String, val level: String) extends BaseUser(name)
defined class Admin

scala> class Customer(name: String) extends BaseUser(name)
defined class Customer

scala> class PreferredCustomer(name: String) extends Customer(name)
defined class PreferredCustomer

check: [A <: BaseUser](u: A)Unit

scala> check(new Customer("Fred"))

scala> check(new Admin("", "strict"))
Fail!

하한 경계

<식별자> >: <하한 경계 타입>

해당 타입 또는 그 타입이 확장한 타입으로 제한

scala> def recruit[A >: Customer](u: Customer): A = u match {
     |   case p: PreferredCustomer => new PreferredCustomer(u.name)
     |   case u: Customer => new Customer(u.name)
     | }
recruit: [A >: Customer](u: Customer)A

scala> val customer = recruit(new Customer("Fred"))
customer: Customer = Customer@52d7889a

scala> val preferred = recruit(new PreferredCustomer("George"))
preferred: Customer = PreferredCustomer@32dd05af/

scala> abstract class Card {
     |   type UserType <: BaseUser
     |   def verify(u: UserType): Boolean
     | }
defined class Card

scala> class SecurityCard extends Card {
     |   type UserType = Admin
     |   def verify(u: Admin) = true
     | }
defined class SecurityCard

scala> val v1 = new SecurityCard().verify(new Admin("George", "high"))
v1: Boolean = true

타입 가변성 (type variance)

타입 가변성을 사용하면 타입 매개변수를 더 유연하게 사용할 수 있다.

scala> class Car { override def toString = "Car()" }
defined class Car

scala> class Volvo extends Car { override def toString = "Volvo()" }
defined class Volvo

// Volvo 인스턴스가 타입 Car의 값으로 할당될 수 있음
scala> val c: Car = new Volvo()
c: Car = Volvo()

// Item[Volvo] 인스턴스는 Item[Car]의 값으로 할당될 수 없다.
scala> val c: Item[Car] = new Item[Volvo](new Volvo)
                          ^
       error: type mismatch;
        found   : Item[Volvo]
        required: Item[Car]
       Note: Volvo <: Car, but class Item is invariant in type A.
       You may wish to define A as +A instead. (SLS 4.5)

타입 매개변수 앞에 +를 붙이면 공변(covariant)하게 만들 수 있다.

공변성은 타입 매개변수가 그 타입이 확장한 타입으로 변할 수 있는 성질

scala> case class Item[+A](a: A) { def get: A = a }
defined class Item

scala> val c: Item[Car] = new Item[Volvo](new Volvo)
c: Item[Car] = Item(Volvo())

scala> val auto = c.get
auto: Car = Volvo()

타입 매개변수 앞에 -를 붙이면 반공변(contravariant)하게 만들 수 있다.

반공변성은 타입 매개변수가 서브타입으로 변할 수 있는 성질

메소드 매개변수에 사용된 타입 매개변수는 반공변성을 가진다.

scala> class Check[+A] { def check(a: A) = {} }
                                   ^
       error: covariant type A occurs in contravariant position in type A of value a

scala> class Check[-A] { def check(a: A) = {} }
defined class Check

scala> class Car; class Volvo extends Car; class VolvoWagon extends Volvo
defined class Car
defined class Volvo
defined class VolvoWagon

scala> class Item[+A](a: A) { def get: A = a }
defined class Item

scala> class Check[-A] { def check(a: A) = {} }
defined class Check

scala> def item(v: Item[Volvo]) { val c: Car = v.get }
item: (v: Item[Volvo])Unit

scala> def check(v: Check[Volvo]) { v.check(new VolvoWagon()) }
check: (v: Check[Volvo])Unit

모든 타입 매개변수를 불변의 상태로 유지하는 것이 더 안전하다.

패키지 객체 (package object)

패키지 객체는 해당 패키지에 위치한 파일 package.scala에 정의되어 네임스페이스에 자동 임포드된다.

// 위치: com/oreilly/package.scala
package object oreilly {
  type Mappy[A, B] = collection.mutable.HashMap[A, B]
}

러닝스칼라 9장 - 객체, 케이스 클래스, 트레이트

jmkim87 — Mon, 28 Sep 2020 23:41:47 +0900

객체(object)

하나 이상의 인스턴스를 가질 수 없는 형태의 클래스, 싱글턴(Singletom)
클래스 이름으로 객체에 접근
JVM에서 최초로 접근될 때 인스턴스화
자바에서는 클래스의 특정 필드와 메소드를 정적(static)으로 지정.(인스턴스 기반 필드/메소드와 섞여있음) 스칼라는 전역 필드/메소드와 인스턴스 기반 필드/메소드를 분리
class 대신 object 키워드 사용, 클래스 매개변수를 취할 수 없음

object <identifier> [extends <identifier>] [{ fields, methods, and classes }]

scala> object Hello { println("in Hello"); def hi = "hi" }
defined object Hello

scala> println(Hello.hi)
in Hello
hi

scala> println(Hello.hi)
hi

순수 함수와 외부 입출력을 이용하는 함수에 어울림, 해당 함수들은 클래스의 필드와 거의 상관이 없기 때문에 클래스 메소드로 적합하지 않음

Apply 메소드와 동반 객체

동반 객체 : 클래스와 동일한 이름을 가지고, 동일 파일 내에 정의되는 객체. 서로의 private/protected 멤버에 접근 가능.
객체의 apply 메소드 : 객체의 이름으로 호출하는 메소드, 팩토리(factory)패턴을 위해 주로 사용. // List(1, 2, 3), Option(1)

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Multiplier(val x: Int) { def product(y: Int) = x * y }

object Multiplier { def apply(x: Int) = new Multiplier(x) }

// Exiting paste mode, now interpreting.

defined class Multiplier
defined object Multiplier

scala> val tripler = Multiplier(3)
tripler: Multiplier = Multiplier@5af28b27

scala> val result = tripler.product(13)
result: Int = 39

scala> :paste
// Entering paste mode (ctrl-D to finish)

object DBConnection {
  private val db_url = "jdbc://localhost"
  private val db_user = "franken"
  private val db_pass = "berry"

  def apply() = new DBConnection
}

class DBConnection {
  private val props = Map(
    "url" -> DBConnection.db_url,
    "user" -> DBConnection.db_user,
    "pass" -> DBConnection.db_pass
  )
  println(s"Created new connection for " + props("url"))
}

// Exiting paste mode, now interpreting.

defined object DBConnection
defined class DBConnection

scala> val conn = DBConnection()
Created new connection for jdbc://localhost
conn: DBConnection = DBConnection@4d27d9d

객체를 가지는 명령줄 어플리케이션

자바의 public static void main ~, 프로그램 진입점
파라미터로 문자열(Array[String]로 유일한 파라미터 받고 Unit을 반환하는)을 가진 main 메소드를 포함한 객체 필요. 컴파일 후 해당 객체 파일에 대하여 scala 명령어로 실행.

$ cat > Cat.scala
object Cat {
  def main(args: Array[String]) {
    for (arg <- args) {
      println( io.Source.fromFile(arg).mkString )
    }
  }
}

$ scalac Cat.scala

$ scala Cat Date.scala
object Date {
  def main(args: Array[String]) {
    println(new java.util.Date)
  }
}

App trait를 상속해서 만들 수 있음

object HelloWorld {
   def main(args: Array[String]) {
     println("Hello, world!")
   }
 }

object HelloWorld extends App {
  println("Hello, world!")
}

케이스 클래스(case class)

자동으로 생성되는 메소드를 포함하는 클래스, 또한 자동으로 동반객체가 생성되는데 해당 객체도 자동으로 생성된 메소드를 가짐
자동으로 생성되는 모든 메소드들은 케이스 클래스의 매개변수 목록을 기반으로 생성

Name	위치	설명
apply	객체	케이스 클래스를 인스턴스화하는 팩토리 메소드
unapply	객체	인스턴스를 그 인스턴스의 필드들의 튜플로 추출하여 패턴 매칭에 케이스 클래스 인스턴스를 사용하 수 있도록 함
copy	클래스	요청받은 변경사항이 반영된 인스턴스의 사본을 반환함. 매개변수느 현재 필드 값으로 설정된 기본값을 갖는 클래스의 필드임
equals	클래스	다른 인스턴스의 모든 필드가 이 인스턴스의 모든 필드와 일치하면 true 반환. 연산자 ==로도 호출 가능
hashCode	클래스	인스턴스의 필드들의 해시 코드를 반환함. 해시 기반의 컬렉션에 유용함
toString	클래스	클래스명과 필드들을 String으로 전환함

클래스 정의 앞에 case 키워드 추가
클래스 매개변수를 값 필드로 자동으로 전환하여 사용(val 직접 붙일 필요 없음)

**case class <identifier> ([var] <identifier>: <type>[, ... ])
                        [extends <identifier>(<input parameters>)]
                        [{ fields and methods }]**

scala> case class Character(name: String, isThief: Boolean)
defined class Character

scala> val h = Character("Hadrian", true)                    
h: Character = Character(Hadrian,true)                       

scala> val r = h.copy(name = "Royce")                        
r: Character = Character(Royce,true)

scala> h == r                                                
res0: Boolean = false

scala> h match {
     |   case Character(x, true) => s"$x is a thief"         
     |   case Character(x, false) => s"$x is not a thief"
     | }
res1: String = Hadrian is a thief

데이터 전송 객체를 표현할 때 사용. (필요한 메소드들 자동으로 생성해줘서 편의 제공)

트레이트(trait)

다중 상속을 가능케 하는 클래스 유형 중 하나, 여러 개의 trait를 확장(mixin)할 수 있음
인스턴스화 할 수 없고, 클래스 매개변수를 취할 수 없음 (타입 매개변수 사용은 가능)
trait 키워드를 사용해서 정의함, with 키워드를 사용하여 두 개 이상의 trait을 확장할 수 있음

trait <identifier> [extends <identifier>] [{ fields, methods, and classes }]

scala> trait HtmlUtils {
     |   def removeMarkup(input: String) = {
     |     input
     |       .replaceAll("""</?\w[^>]*>""","")
     |       .replaceAll("<.*>","")
     |   }
     | }
defined trait HtmlUtils

scala> trait SafeStringUtils {
     |
     |   // Returns a trimmed version of the string wrapped in an Option,
     |   // or None if the trimmed string is empty.
     |   def trimToNone(s: String): Option[String] = {
     |     Option(s) map(_.trim) filterNot(_.isEmpty)
     |   }
     | }
defined trait SafeStringUtils

scala> class Page(val s: String) extends SafeStringUtils with HtmlUtils {
     |   def asPlainText: String = {
     |     trimToNone(s) map removeMarkup getOrElse "n/a"
     |   }
     | }
defined class Page

scala> new Page("<html><body><h1>Introduction</h1></body></html>").asPlainText
res3: String = Introduction

scala> new Page("  ").asPlainText
res4: String = n/a

scala> new Page(null).asPlainText
res5: String = n/a

여러 개의 trait을 확장한 경우, 상속될 클래스와 트레이트의 수평적인 리스트를 받아서 한 클래스가 다른 클래스를 확장하는 수직적 체인으로 재구성(선형화)
오른쪽에서 왼쪽 순으로 가장 가까운 부모부터 높은 부모로 배치된다. (class D extends A with B with C => class D extends C extends B extends A)

scala> trait Base { override def toString = "Base" }
defined trait Base

scala> class A extends Base { override def toString = "A->" + super.toString }
defined class A

scala> trait B extends Base { override def toString = "B->" + super.toString }
defined trait B

scala> trait C extends Base { override def toString = "C->" + super.toString }
defined trait C

scala> class D extends A with B with C { override def toString = "D->" +
  super.toString }
defined class D

scala> new D()
res50: D = D->C->B->A->Base

부모 클래스의 행위를 재정의, 부가적 기능을 추가 (부모 클래스와 기능을 추가한 trait)

scala> class RGBColor(val color: Int) { def hex = f"$color%06X" }
defined class RGBColor

scala> val green = new RGBColor(255 << 8).hex
green: String = 00FF00

scala> trait Opaque extends RGBColor { override def hex = s"${super.hex}FF" }
defined trait Opaque

scala> trait Sheer extends RGBColor { override def hex = s"${super.hex}33" }
defined trait Sheer

scala> class Paint(color: Int) extends RGBColor(color) with Opaque
defined class Paint

scala> class Overlay(color: Int) extends RGBColor(color) with Sheer
defined class Overlay

scala> val red = new Paint(128 << 16).hex
red: String = 800000FF

scala> val blue = new Overlay(192).hex
blue: String = 0000C033

셀프 타입

트레이트가 클래스에 추가될 때 특정 타입 또는 그 서브타입과 함께 사용되어야 함을 강제
트레이트 정의의 중괄호를 연 다음 식별자, 요청받은 타입, =>를 포함한다

scala> class A { def hi = "hi" }
defined class A

scala> trait B { self: A =>                                             
     |   override def toString = "B: " + hi
     | }
defined trait B

scala> class C extends B
<console>:9: error: illegal inheritance;                                
 self-type C does not conform to B's selftype B with A
       class C extends B
                       ^

scala> class C extends A with B                                         
defined class C

scala> new C()
res1: C = B: hi

입력 매개변수가 필요한 클래스에 트레이트로 기능을 추가하는데 사용, 트레이트는 입력 매개변수를 지정하지 않고도 클래스를 확장할 수 있음

scala> class TestSuite(suiteName: String) { def start() {} }      
defined class TestSuite

scala> trait RandomSeeded { self: TestSuite =>                        
     |   def randomStart() {
     |     util.Random.setSeed(System.currentTimeMillis)
     |     self.start()
     |   }
     | }
defined trait RandomSeeded

scala> class IdSpec extends TestSuite("ID Tests") with RandomSeeded {     
     |   def testId() { println(util.Random.nextInt != 1) }
     |   override def start() { testId() }
     |
     |   println("Starting...")
     |   randomStart()
     | }
defined class IdSpec

트레이트를 이용하여 인스턴스화

클래스가 인스턴스화될 때 클래스에 트레이트를 추가, 클래스가 의존하는 기능이 클래스 정의 시점에 추가되지 않다가 클래스가 인스턴스화 될 때 주입됨(종속성 주입)
트레이트가 클래스를 확장하는 식, 왼쪽부터 오른쪽으로의 선형화
하나 이상의 트레이트를 with 키워드를 사용해서 클래스에 추가(extends는 사용 불가, 트레이트를 확장하는 것이 아닌 트레이트의 의한 확장)

scala> class User(val name: String) {
     |   def suffix = ""
     |   override def toString = s"$name$suffix"
     | }
defined class User

scala> trait Attorney { self: User => override def suffix = ", esq." }
defined trait Attorney

scala> trait Wizard { self: User => override def suffix = ", Wizard" }
defined trait Wizard

scala> trait Reverser { override def toString = super.toString.reverse }
defined trait Reverser

scala> val h = new User("Harry P") with Wizard
h: User with Wizard = Harry P, Wizard

scala> val g = new User("Ginny W") with Attorney
g: User with Attorney = Ginny W, esq.

scala> val l = new User("Luna L") with Wizard with Reverser
l: User with Wizard with Reverser = draziW ,L anuL

trait 사용처(Programming in Scala)

간결한 인터페이스를 확장해 풍부한 인터페이스 만들기

trait에 간결한 인터페이스 역할을 하는 추상 메소드를 정의하고 풍부한 인터페이스 역할을 할 여러 메소드를 추상메소드를 이용하는 방식으로 구현(메소드 구현 넣을 수 있음)

해당 trait을 mix in한 클래스에서 추상 메소드로 지정한 간결한 인터페이스만 구현해주면 풍부한 인터페이스까지 포함한 클래스 완성

trait Rectangular {
 def topLeft :Point
 def bottomRight :Point  // 2개의 추상 메소드만 mix in한 클래스에서 구현해주면 아래 모든 메소드 이용 가능

 def left = topLeft.x
 def right = bottomRight.x
 def width = right - left
 // 여러 기하 관련 메소드..
}
// Rectangle, Component 클래스 등에서 Rectangular trait를 mix in해 직사각형 객체를 편리하게 쓸 수 있게 만들 수 있다(기하학적 속성을 조회하는 모든 메소드를 갖출 수 있음)

// Orderd trait : 하나의 비교 연산자만 작성하면 모든 비교 연산자 구현을 대신할 수 있음
class Rational(n :Int, d :Int) extends Ordered[Rational] {  // 타입 파라미터 명시해야
 // ...

 // 두 객체가 동일하면 0, 자신이 인자보다 작으면 음수, 크면 양수 반환
 // 아래 메소드 구현만 채워주면, 해당 클래스는 <, >, <=, >= 연산 모두 제공할 수 있게 된다
 def compare(that: Rational) = (this.number * that.denom) - (that.number * this.denom)

 // equals는 정의하지 않음. Ordered를 상속하더라도 직접 정의해야 함.
}

쌓을 수 있는 변경 정의

super 호출을 동적으로 바인딩한다. (클래스에서는 super 호출을 정적으로 바인딩한다) trait을 이용해 원하는 기능을 스택처럼 쌓아 올릴 수 있다.

abstract class IntQueue {
 def get() :Int
 def put(x: Int)
}

// (슈퍼클래스를 지정 함으로써) IntQueue를 상속한 클래스에만 mix in할 수 있음
trait Doubling extends IntQueue {
 abstract override def put(x : Int) = super.put(2 * x)  // 큐에 있는 모든 정수를 두 배 만들기
}
// 컴파일러에게 의도적으로 super의 메소드를 호출했다는 사실을 알리기 위해 abstract override로 표시해야 함
// 즉 어떤 trait에 abstract override메소드가 있다면, 그 trait는 반드시 해당 메소드에 대한 구체적 구현을 제공하는 클래스에 mix in 해야함

trait Incrementing extends IntQueue {
 abstract override def put(x : Int) = super.put(x + 1) // 큐에 모든 정수에 1을 더한다
}

trait Filtering extends IntQueue {
 abstract override def put(x : Int) = if (x >= 0) super.put(x) // 큐에 있는 음수를 걸러낸다
}

import scala.collection.mutable.ArrayBuffer
class BasicIntQueue extends IntQueue {
 private val buf = new ArrayBuffer[Int]
 def get() = buf.remove(0)
 def put(x:Int) = buf += x
 override def toString() = buf.toString
}

val queue = new BasicIntQueue with Incrementing with Filtering
queue.put(-1); queue.put(0); queue.put(1)  // -> 1, 2

val queue2 = new BasicIntQueue with Filtering with Incrementing
queue2.put(-1); queue2.put(0); queue2.put(1)  // -> 0, 1, 2

러닝스칼라 8장 - 클래스

jmkim87 — Mon, 28 Sep 2020 23:38:50 +0900

클래스란?

데이터 구조와 함수의 조합으로, 객체지향 언어의 핵심 구성 요소

특징

상속(inheritance) : 다른 클래스로 확장할 수 있어서 서브 클래스와 슈퍼 클래스의 계층 구조 생성 가능
다형성(polymorphism) : 서브 클래스가 부모 클래스를 대신하여 작업하는 것이 가능
캡슐화(encapsulation) : 클래스의 외관을 관리하는 프라이버시 제어를 제공

class User
val u = new User
val u1 = new User
val isAnyRef = u.isInstanceOf[AnyRef]

/*
    defined class User
    u: User = User@4c478184
    u1: User = User@2e6ef924
    isAnyRef: Boolean = true
*/

AnyRef는 classes의 부모 타입입니다.

클래스 기본

**// 1번 예제**
class User {
  val name: String = "jmkim"
  def greet: String = s"Hello from $name"
  override def toString = s"User($name)"
}

val u = new User
println(u.greet)
/*
    defined class User
    u: User = User(jmkim)
    Hello from jmkim
*/

toString을 override 함으로써 기존에 User@4c478184 처럼 보여지는 것을
u: User = User(jmkim)처럼 변경 됩니다.

**// 2번 예제**
class User(val name: String) {
  def greet: String = s"Hello from $name"
  override def toString = s"User($name)"
}

val u = new User("jmkim")
println(u.greet)
/*
    defined class User
    u: User = User(jmkim)
    Hello from jmkim
*/

1번 예제와 다르게 name을 매개 변수로 받으면서 바로 클래스 필드로 사용하는 방법입니다.

다음은 리스트를 사용하여 다양한 것을 해봅니다.

val users = List(new User("jam"), new User("karl"), new User("jason"), new User("sophie"), new User("kai"), new User("lucas"), new User("jeff"))
val usersSize = users.size
val userNameSize = users map (_.name.length)
val sorted = users sortBy (_.name)
val jason = users find (_.name contains "jason")
val greet = jason map (_.greet) getOrElse "Hi"

val test = users find (_.name contains "test")
val greet1 = test map (_.greet) getOrElse "Hi"

/*
    users: List[User] = List(User(jam), User(karl), User(jason), User(sophie), User(kai), User(lucas), User(jeff))
    usersSize: Int = 7
    userNameSize: List[Int] = List(3, 4, 5, 6, 3, 5, 4)
    sorted: List[User] = List(User(jam), User(jason), User(jeff), User(kai), User(karl), User(lucas), User(sophie))
    jason: Option[User] = Some(User(jason))
    greet: String = Hello from jason
    test: Option[User] = None
    greet1: String = Hi
*/

클래스 상속, 다형성

상속 : 서브 클래스가 부모 클래스로부터 필드와 메소드를 extends 키워드로 확장된 것이며, override로
상속받은 메소드를 재정의 할 수 있습니다.

class A {
  def hi = "Hello from A"
  override def toString = getClass.getName
}

class B extends A
class C extends B {
  override def hi = "hi C -> " + super.hi
}

val hiA = new A().hi
val hiB = new B().hi
val hiC = new C().hi
/*
    defined class A
    defined class B
    defined class C
    hiA: String = Hello from A
    hiB: String = Hello from A
    hiC: String = hi C -> Hello from A
*/

다형성 : 서브 클래스는 자신의 부모 클래스를 확장하므로 부모의 필드와 메소드를 100% 지원하지만 그 역은 성립하지 않을 수 도 있습니다.

class A {
  def hi = "Hello from A"
  override def toString = getClass.getName
}

class B extends A
class C extends B {
  override def hi = "hi C -> " + super.hi
}

val a: A = new A
val a: A = new B
val b: B = new B
val b: B = new A

/*
    defined class A
    defined class B
    defined class C
    a: A = A
    a: A = B
    b: B = B
    Error:(14, 12) type mismatch;
        found   : A
        required: B
        val b: B = new A
*/

클래스 정의하기

입력 매개변수로 클래스 정의하기

class Car(val make: String, var reserved: Boolean) {
  def reserve(r: Boolean):Unit = {reserved = r}
}

val t = new Car("Tesla", false)
t.reserve(true)
println(s"My ${t.make} is now reserved? ${t.reserved}")
/*
    defined class Car
    t: Car = Car@2c4c333a
    My Tesla is now reserved? true
*/

val t2 = new Car(reserved = false, make = "Toyota")
println(t2)
/*
    t2: Car = Car@20a0dd40
    My Toyota is now reserved? false
*/

class Lotus(val color: String, reserved: Boolean) extends Car("Lotus", reserved)
val l = new Lotus("sliver", false)
println(s"Requested a ${l.color} ${l.make}")
/*
    defined class Lotus
    l: Lotus = Lotus@6067b0f0
    Requested a sliver Lotus
*/

입력 매개변수와 기본값으로 클래스 정의하기

class Car(val make: String, var reserved : Boolean = true, val year: Int = 2005) {
  override def toString = s"$year $make, reserved = $reserved"
}

val a = new Car("Acura")
val l = new Car("Lexus", year = 2010)
val p = new Car(reserved = false, make = "Porsche")
/*
    a: Car = 2005 Acura, reserved = true
    l: Car = 2010 Lexus, reserved = true
    p: Car = 2005 Porsche, reserved = false
*/

그 외의 클래스 유형

추상 클래스

추상 클래스는 다른 클래스들에 의해 확장되도록 설계되었으나 인스턴스를 생성하지 않는 클래스
서브클래스들이 필요로 하는 핵심적인 필드와 메소드를 실제 구현물을 제공하지 않으면서 정의하는 데에 사용

abstract class Car {
  val year: Int
  val automatic: Boolean = true
  def color: String
}

class Mini(val year: Int, val color: String) extends Car

val redMini: Car = new Mini(2005, "Red")
println(s"Got a ${redMini.color} Mini")
/*
    defined class Car
    defined class Mini
    redMini: Car = Mini@19fce221
    Got a Red Mini
*/

익명 클래스

익명클래스는 서브 클래스가 한번만 필요한 상황일 때 코드를 단순화 해주는 데에 도움을 줍니다.
추상 클래스를 따로 extends로 상속 받는 class를 만들지 않고 notification.register에 있는 것처럼
new Listener로 정의하여 익명 클래스를 만들어 넣습니다.

abstract class Listener {def trigger}
class Listening {
  var listener: Listener = null
  def register(l: Listener) {listener = l}
  def sendNotification() {listener.trigger}
}

val notification = new Listening()

notification.register(new Listener {
  def trigger {println(s"Trigger at ${new java.util.Date}")}
})

notification.sendNotification()
/*
    defined class Listener
    defined class Listening
    notification: Listening = Listening@1db58f45
    Trigger at Sat Jun 20 14:17:07 KST 2020
*/

그외의 필드와 메소드 유형

중복 정의된 메소드

동일한 이름과 반환값을 갖지만, 다른 입력 매개변수를 갖는 둘 또는 그 이상의 메소드를 가질 수 있습니다.

class Printer(msg: String) {
  def print(s:String):Unit = println(s"$msg: $s")
  def print(l:Seq[String]):Unit = print(l.mkString(", "))
}

new Printer("Today's Report").print("Foggy"::"Rainy":: "Hot" :: Nil)
/*
    defined class Printer
    Today's Report: Foggy, Rainy, Hot
*/

apply 메소드

apply 메소드는 기본 메소드 또는 인젝터 메소드로 불리며 메소드 이름 없이 호출 될 수 있습니다.

class Multiplier(factor: Int) {
  def apply(input: Int) = input * factor
}

val tripleMe = new Multiplier(3)
val tripled = tripleMe.apply(10)
val tripled2 = tripleMe(10)
/*
    defined class Multiplier
    tripleMe: Multiplier = Multiplier@43e42b0b
    tripled: Int = 30
    tripled2: Int = 30
*/

지연값

지연값은 자신이 처음 인스턴스화될 때에만 생성되며 val 키워드 앞에 lazy를 씁니다.
클래스 수명 내에 실행 시간과 성능에 민감한 연산이 한 번만 실행 될 수 있음을 보장하며,
보통 파일 기반의 속성, 데이터 베이스 커넥션 열기, 그 외 정말 필요한 경우 단 한번만 초기화 되어야 하는
불변의 데이터와 같은 정보를 저장하는데 사용합니다.

class RandomPoint {
  val x = {println("creating x"); util.Random.nextInt}
  lazy val y = {println("now y"); util.Random.nextInt}
}

val p = new RandomPoint()
println(s"Location is ${p.x}, ${p.y}")
println(s"Location is ${p.x}, ${p.y}")
/*
    defined class RandomPoint
    creating x
    p: RandomPoint = RandomPoint@6ecd22fd
    now y
    Location is 389314740, -1884004327
    Location is 389314740, -1884004327
*/

패키징

패키지는 스칼라 코드를 점으로 구분된 경로를 사용하여 디렉토리별로 정리할 수 있게 해줍니다.

mkdir -p src/com/oreilly
cat > src/com/oreilly/Config.scala
# class Config(val baseUrl:String = "http://localhost")
scalac src/com/oreilly/Config.scala
ls com/oreilly/Config.class
# com/oreilly/Config.class

패키징된 클래스에 접근하기

import java.util.Date
val d = new Date

import scala.collection.mutable._
// import scala.collection.mutable.{ArrayBuffer => ArrBuf, Queue}

val b = new ArrayBuffer[String]

b += "Hello"

val q = new Queue[Int]

q.enqueue(3,4,5)

val pop = q.dequeue
println(q)

/*
    import scala.collection.mutable._
    b: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer()
    res0: b.type = ArrayBuffer(Hello)
    q: scala.collection.mutable.Queue[Int] = Queue()
    res1: q.type = Queue(3, 4, 5)
    pop: Int = 3
    Queue(4, 5)
*/

패키징 구문

아래와 같이 package를 사용하여 만들 수 있습니다.

package com {
  package oreilly {
    class Config(val baseUrl: String = "http://localhost")
  }
}

val url = new com.oreilly.Config().baseUrl

프라이버시 제어

기본은 pubilc이며 상황에 따라서 protected, private를 사용하여 제어를 할 수 있습니다.

protected : 정의한 클래스와 서브 클래스의 코드에서만 접근이 가능합니다.
private : 정의한 클래스에서만 접근이 가능합니다.

class User(private var password: String) {
  def update(p: String): Unit = {
    println("Modifying the password!")
    password = p
  }
  def validate(p: String) = p == password
} 

val u = new User("1234")
val isValid = u.validate("4567")

u.update("4567")
val isValid = u.validate("4567")
/*
    defined class User

    u: User = User@2030ce87
    isValid: Boolean = false

    Modifying the password!
    isValid: Boolean = true
*/

프라이버시 접근 변경자

package com.oreilly {
  // []로 접근 블록을 지정해 줄 수 있습니다. 
  private[oreilly] class Config {
    val url = "http://localhsot"
  }

  class Authentication {
    private[this] val password = "jason"
    def validate = password.nonEmpty
  }

  class Test {
    println(s"url = ${new Config().url}")
  }
}

object Example extends App {
  val valid = new com.oreilly.Authentication().validate
  println(valid)

  new com.oreilly.Test
/*
    true
    url = http://localhsot
*/
}

종단 클래스와 봉인 클래스

종단 클래스(final class)는 더이상 상속을 받지 못하게 만들며, 변수에 final을 쓸 경우 override가 방지 됩니다.

봉인 클래스(sealed class)는 클래스의 서브클래스가 부모 클래스와 동일한 파일에 위치하도록 제한 합니다.
또한, 클래스의 계층 구조에 대해 안전하게 가정하는 코드를 작성 할 수 있습니다.

// 같은 파일 안에 class를 상속 할 경우
sealed class Fruit(color: String) {
  def printColor = println(color)
}

class Apple extends Fruit("Red") {
  def print = "Apple"
}

// 다른 파일에서 상속 할 경우
class Banana extends Fruit("Yellow") {

}
// illegal inheritance from sealed class Fruit

러닝스칼라 7장 - 그 외의 컬렉션

jmkim87 — Mon, 28 Sep 2020 23:35:33 +0900

불변의 컬렉션

List, Set, Map 은 불변의 컬렉션
코드의 안정성을 높이고 버그를 방지하기 위해 데이터와 데이터 구조는 변경되거나 자신의 상태를 바꿀 수 없다.

가변 컬렉션 생성하기

collection.mutable은 자동으로 추가되지 않아서 반드시 포함해야한다.

//불변
collection.immutable.Buffer
collection.immutable.Set
collection.immutable.Map

//가변
collection.mutable.Buffer
collection.mutable.Set
collection.mutable.Map

가변 컬렉션을 이용하면 추가나 변경을 할 수 있다.
toList , toSet, toMap 메소드를 이용해서 가변 컬렉션을 불변의 컬랙션으로 만들 수 있다.
toBuffer 메소드를 이용해서 불변의 컬렉션을 가변적인 컬렉션으로 변경할 수 있다.
버퍼의 단점이 너무 광범위하다는 것인데 이것을 빌더(builder)로 해

컬렉션 빌더 사용하기

Builder는 Buffer를 단순화한 형태로, 할당된 컬렉션 타입을 생성하고 추가연산만 지원

scala> val b = Set.newBuilder[Char]
b = scala.collection.mutable.SetBuilder@3789ad3d

scala> b += 'h'
scala.collection.mutable.SetBuilder@3789ad3d

scala> b ++= List('e', 'l', 'l', 'o')
scala.collection.mutable.SetBuilder@3789ad3d

scala> val helloSet = b.result
helloSet: scala.collection.immutable.Set[Char] = Set(h, e, l, o)

불변의 컬렉션을 전환하기 위해 단지 가변적인 컬렉션을 반복적으로 생성한다면 Builder
빌더는 자신의 타입에 대응하는 불변의 타입이 무엇인지 알고 있음
빌더의 장점?

배열

Array는 고정된 크기를 가지며, 내용을 변경할 수 있으며, 인덱스를 가지고 있다.
자바 배열은 toString() 메소드를 재정의 하지 않기 때문에 타입 매개변수와 참조를 출력, 스칼라는 재정의

scala> val colors = Array("red" ,"green", "blue")

scala> colors(0) = "purple"
Array[String] = Array(purple, green, blue)

scala> println("vert purple : " + colors)
vert purple : [Ljava.lang.String;@6f76b33e

val files = new java.io.File(".").listFiles
Array(./.jupyter, ./Untitled.ipynb, ./.ipynb_checkpoints, ./Untitled1.ipynb, ./Untitled2.ipynb)

val scala = files map (_.getName) filter(_ endsWith "ipynb")
Array(Untitled.ipynb, Untitled1.ipynb, Untitled2.ipynb)

JVM 코드를 위해 필요한 경우가 아니라면 이 타입을 사용하는 것은 권하지 않는다 왜?

Seq와 시퀀스

Seq는 오든 시퀀스의 루트 타입으로 List , Vector도 포함
Seq는 인스턴스화 할 수 없지만 List를 생성하는 방법으로 Seq를 호출 할 수 있다.

scala> val inks = Seq('C','M','Y','K')
inks = List(C, M, Y, K)

Vector : 색인된 접근을 위해 Array에 의해 지원받는 리스트
List : n번쨰 항목에 접근하려면 헤드부터 탐색
String : Char 구성 요소를 가지는 시쿼스

스트림

Stream 타입은 하나 또는 그 이상의 시작 요소들과 재귀함수로 생성되는 지연(lazy) 컬랙션
스트림의 구성 요소들은 나중에 추출될 떄를 대비하여 캐시에 저장되어 각 요소가 한번만 생성됨을 보장
Stream.Empty로 종료될 수 있고 무한히 커질수 있다.
List 와 마찬가지로 헤드와 테일로 구성된 재귀적인 데이터 구조

scala> def inc(i: Int) : Stream[Int] = Stream.cons(i,inc(i+1))
scala> def inc(head: Int): Stream[Int] = head #:: inc(head+1)
inc: (i : Int)Stream[Int]

scala> val s = inc(1)
s: Stream[Int] = Stream(1,?)

scala> val l = s.take(5).toList
List(1,2,3,4,5)

scala> s
Stream(1,2,3,4,5,?)

scala> def to(head:Char, end:Char):Stream[Char] = (head > end) match {
    case true => Stream.empty
    case false => head #:: to((head+1).toChar , end)
}
to: (head: Char, end: Char)Stream[Char]

scala> val hexChars = to('A','F').take(20).toList
hexChars = List(A, B, C, D, E, F)

모나딕

Iterable 연산 같은 변형 연산을 지원하지만 하나 이상의 요소는 포함할 수 없다.
잠재적 값을 나타내며 추가 연산을 연결하거나 값을 추출하는 안전한 연산 제

Option 컬렉션

크기가 1이 넘지 않는 컬렉션으로 단일값의존재 또는 부재를 나타냄
널(null) 값의 안전한 대체제, NullPointException을 일으킬 가능성이 즐어듬
타입-매개변수화된 컬랙션인 Some 과 빈 컬렉션인 None
함수 결과를 처리하는데 type-safe 방식을 제공

scala> def divid(amt: Double, divisor:Double): Option[Double] = {
           if(divisor == 0) None
           else Option(amt/divisor)
}
divid: (amt: Double, divisor: Double)Option[Double]

scala> val legit = divid(5,2)
legit = Some(2.5)

scala> val illegit = divid(3,0)
illegit = None

headOption 과 find 연산

scala> val odds = List(1,3,5)

scala> val events = odds filter (_ % 2 ==0)
events = List()

scala> val firstEven = events.headOption
firstEven = None

scala> val words = List("risible", "scavenger", "gist")

scala> val uppercase = words find (w => w == w.toUpperCase)
Option[String] = None

scala> val lowercase = words find ( w => w == w.toLowerCase)
Option[String] = Some(risible)

Option으로부터 값 추출하기

get() 메소드도 있지만 안전하지 않다, None에 get 을 한다면 no such element 에러가 발생하기 때문이다.
누란된 갑슬 처리하는 대체값이 있는 fold나 getorElse를 사용하자

Name	Example	설명
fold	nextOption.fold(-1)(x => x)	Some인 경우 주어진 함수로부터 추출한 값을 None인 경우 시작값을 반환함, 그외 다른 fold나 reduce도 마찬가지
getOrElse	nextOption getOrElse 5	Some의 값을 반환하거나 아니면 이름 매개변수의 결과를 반환
orElse	nextOption orElse nextOption	실제로 값을 추출하지는 않지만 None 인 경우 값을 채우려함
매치 표현식	nextOption match { case Some(x) => x ; case None => -1	값이 있는 경우 매치표현식으로 그 값을 처리함

null 을 쓰는 것보다 더 안전한 방법, 그 이유는 모든 널 포인트 에러를 방지 못하기 때문

Try 컬렉션

util.Try 컬렉션은 에러 처리를 컬랙션 관리로 바꿔 놓는다.
스칼라에서는 예외(Exception)을 발생시켜 에러를 일으킬 수 있다.
예외를 발생시키기 위해서는 Exception 키워드와 함께 throw를 사용

scala> def loopAndFail (end:Int , failAt: Int ) : Int = {
        for ( i <- 1 to end ) {
           println(s"$i) " )
           if (i == failAt ) throw new Exception("Too many iterations")
        }
        end
      }

catch 보단 util.Try 만 사용하는 것을 추천, 그 이유는 에러를 처리하기에 더 안전하고 완전한 모나딕 접근법
util.Try 는 Success 와 Failure 을 가지고 있다.

scala> val t1 = util.Try( loadAndFail(2,3))
1)
2)
Success(2)

scala> val t2 = util.Try ( loadAndFail(4,2))
1)
2)
Failure(java.lang.Exception: Too many iterations)

Try 에러 처리 메소드

Name	Example	설명
flatMap	nextError flatMap { _ => nextError }	Success인 경우 util.Try를 반환하는 함수를 호출함으로써 현재의 반환값을 새로운 내장된 반환값(또는 예외에 매핀함, 우리의 ‘nextError’ 데모함수는 입력값을 취하지 않기 때문에 우리는 현재 Success로 부터 사용하지 않는 입력값을 나타내는 언더스코어를 사용
foreach	nextError foreach(x => println(“success!” + x))	Success인 경우 주어진 함수를 한 번 실행하고, Failure 일 때는 실행하지 않
getOrElse	nextError getOrElse 0	Success에 내장된 값을 반환하거나,Failure인 경우 이름에 의한 매개변수의 결과를 반환함
orElse	nextError orElse nextError	flatMap의 반대되는 메소드, Failure인 경우 그 역시Try를 반환하는 함수를 호출함.orElse로 어쩌면 Failure를 Success로 전환 할 수 있음
toOption	nextError.toOption	Try를 Option으로 전환하여 Success는 Some으로 Failure는 None이 됨. 내장된 Exception을 잃게 된다는 단점이 있음
map	nextError map (_ * 2)	Success인 경우 새로운 값에 내장된 값을 매핑하는 함수를 호출함
매치표현식	nextError match { case util.Success(x) => x; case util.Failure(error) => -1 }	Success를 (’x’에 저장된) 반환값으로 또는 Failure를 (’error’에 저장된) 예외로 처리하기 위해 매치 표현식을 사용함.
아무일도 하지않음	nextError	가장 쉬운 에러 처리 방식으로, 내가 개인적으로 선호하는 방식임. 이 방식으로 단순히 예외가 잡히거나,현재의 애플리케이션을 종료시킬 때까지 호출 스택을 타고 전파되도록 그대로 둠. 이 방식은 민감한 경우에 사용하면 문제가 크겠짐나, 발새한 예왼느 결코 무시되지 않음

scala> val input = " 123 "
input = " 123 "

scala> val result = util.Try(input.toInt) orElse util.Try(input.trim.toInt)
result = Success(123)

scala> result foreach { r => println(s"Parsed '$input' to $r!" )}
Parsed ' 123 ' to 123!

scala> val x = result match {
           case util.Success(x) => Some(x)
           case  util.Failure(ex) => {
               println(s"$input")
               None
           }
       }

x = Some(123)

퓨처 컬렉션

백그라운드 작업을 개시하는 concurrent.Future
Option과 Try 와는 달리 즉시 사용하지 못할수 있다.
퓨처를 함수로 호출하면 현행 스레드와는 별개의 스레드에서 그 함수를 실행시킨다.

scala> import concurrent.ExecutionConscala 3.Implicits.global
scala> val f = concurrent.Future{println("hi")}
Message: <console>:25: error: Cannot find an implicit ExecutionConscala 3.

scala>  val f = concurrent.Future{Thread.sleep(5000);println("hi")}
scala> println("waiting")
waiting
hi

퓨처의 작업이 완료될때 실행할 콜백 함수를 설정 가능
백그라운드 작업이 끝날때까지 main 스레드를 차단하고 기다리는 기능

비동기식 퓨처 연산

Name	Example	설명
failbackTo	nextFtr(1) failbackTo nextFtr(2)	두번째 퓨쳐를 첫번째 연결하고 새로운 종합적인 퓨처를 반환함. 첫 번째 퓨처가 성공적이지 않다면 두 번째 퓨처가 호출
flatMap	nextFtr(1).flatMap(int => nextFtr())	두번째 퓨처를 첫 번째에 연결하고 새로운 종합적인 퓨처를 반환함. 첫 번째가 성공적이라면 그 반환 값이 두 번째를 호출하는데 사용됨
map	nextFtr(1) map (_ * 2)	주어진 함수를 퓨처에 연결하고 새로운 종합적인 퓨처를 반환함. 퓨처가 성공적이라면 그 반환 값이 해당 함수를 호출할 때 사용됨
onComplete	nextFtr() onComplete { _ getOrElse 0 }	퓨처의 작업이 완료된 후 주어진 함수가 값 또는 예외를 포함한 Try를 이용하여 호출됨
onFailure	nextFtr() onFailure { case _ => “Error!” }	퓨처의 작업이 예외를 발생시키면 주어진 함수는 그 예외를 가지고 호출됨
onSuccess	nextFtr() onSuccess { case _ => s“Got $x” }	퓨처의 작업이 성공적으로 완료되었으면 주어진 함수는 그 반환값을 가지고 호출
Future.sequence	concurrent.Future sequence List(nextFtre(1),nextFtr(5))	주어진 시퀀스에서 퓨처를 벙행으로 실행하여 새로운 퓨처를 반환함. 시퀀스 내의 모든 퓨처가 성공하면 이들의 반환값의 리스트가 반환됨. 그렇지 않으면 그 시퀀스내에서 처음으로 발생한 예외가 반환됨

import concurrent.ExecutionConscala 3.Implicits.global
import concurrent.Future
import scala.io.Source
def cityTemp(name:String): Double = {
    val url = "http://api.openweathermap.org/data/2.5/weather"
    val cityUrl = s"$url?&APPID=72bf27b20bf867de6236aca3a257e0d1&q=$name"
    val json = io.Source.fromURL(cityUrl).mkString.trim
    val pattern = """.*"temp":([\d.]+).*""".r
    val pattern(temp) = json
    temp.toDouble
}

val cityTemps = Future sequence Seq(
    Future(cityTemp("Seoul")), Future(cityTemp("Jeju"))
)

cityTemps onSuccess {
  case Seq(x,y) if (x>y) => println(s"Seoul is warmer: $x K")
  case Seq(x,y) if (y>x) => println(s"Jeju is warmer: $x K")
}

동기식 퓨처 처리

백그라운드 스레드가 완료되기를 기다리는 동안 메인 스레드를 차단
concurrent.Await.result() 사용
주어진 시간보다 빠르게 처리되면 결과가 반환되지만 아니라면 java.util.concurrent.TimeoutException 발생

scala> def nextFtr( i: Int = 0 ) = Future {
    def rand(x:Int) = util.Random.nextInt(x)
    Thread.sleep(rand(5000))
    if(rand(3)>0) (i +1) else throw new Exception
}
nextFtr: (i: Int)scala.concurrent.Future[Int]

scala> import concurrent.duration._

scala> val amount = concurrent.Await.result(nextFtr(5), maxtime)
amount: Int = 6

scala> val amount = concurrent.Await.result(nextFtr(5), maxtime)
java.lang.Exception

러닝스칼라 6장 - 보편적인 컬렉션

jmkim87 — Mon, 28 Sep 2020 23:31:57 +0900

컬렉션(collection) 프레임워크는 배열, 리스트, 맵, 집합, 트리와 같이 주어진 타입을 가지는 하나 또는 그 이상의 값을 수집하는 데이터 구조를 제공한다. 1. 성능이 좋고, 객체지향적, 타입-매개변수화 - 자바 컬렉션 라이브러리 1. jvm이기 때문에 자바 컬렉션을 스칼라에서 활용 가능

스칼라는 여러 이유로 컬렉션을 재정의함 1. 고차함수 이용 (map, filter, reduce) 1. mutable/immutable 타입의 계층 구조

리스트, 집합, 그리고 맵

`List 타입`: immutable 단반향 연결 리스트

scala> val numbers = List(32, 95, 24, 21, 17)
numbers: List[Int] = List(32, 95, 24, 21, 17)

scala> val colors = List("red", "green", "blue")
numbers: List[String] = List(red, green, blue)

scala> println(s"I have ${colors.size} colors: $colors")
I have 3 colors: List(red, greem, blue)

모든 컬렉션은 size 메소드롤 통해서 포함된 데이터의 개수를 반환 가능하다.

컬렉션은 초기화때 사용했던 데이터의 타입을 기억하여 타입-매개변수화 될 수 있다.

scala> val colors = List("red", "green", "blue")
numbers: List[String] = List(red, green, blue)

scala> colors.head
res0: String = red

scala> colors.tail
res1: List[String] = List(green, blue)

scala> colors(1)
res2: String = green

scala> colors(2)
res2: String = blue

head와 tail메소드를 이용하여 리스트의 첫번쨰 요소와 나머지 요소를 반환할 수 있다.<collect>(index)를 통하여 0번째부터 컬렉션의 인덱스의 요소를 반환할 수 있다.

for 루프를 이용하여 컬렉션안의 요소를 순회 할 수 있다.

scala> val numbers = List(32, 95, 24, 21, 17)
numbers: List[Int] = List(32, 95, 24, 21, 17)

scala> val total=0; for(i <- numbers) {total += i}
total: Int = 189

고차함수 이용

스칼라의 컬렉션은 반복하고(iterate), 매핑하고(map,) 축소하기(reduce, fold)위하여 고차함수를 이용

scala> val colors = List("red", "green", "blue")
numbers: List[String] = List(red, green, blue)

scala> colors.foreach( (c: String) => println(c) )
red
green
blue

scala> val sizes = colors.map( (c: String) => c.size )
List[Int] = List(3, 5, 4)

scala> val numbers = List(32, 95, 24, 21, 17)
numbers: List[Int] = List(32, 95, 24, 21, 17)

scala> val total = numbers.reduce( (a: Int, b:Int) => a + b )
total: Int = 189

foreach는 프로시져를 취하고, 해당 프로시져에 리스트의 요소를 주압
map은 리스트의 요소를 다른 값이나 타입으로 전환하는 함수를 취함
reduce는 리스트의 ㅇㅛ소를 단일 항목으로 결합하는 함수를 취함

`Set 타입`: immutable, 순서 없음, List와 동일연산 지원

scala> val unique = Set(10, 20, 30, 20, 20, 10)
unique: scala.collection.immutable.Set[Int] = Set(10, 20, 30)

scala> val sum = unique.reduce( (a: String, b: Int) => a + b )
sum: Int = 60

`Map 타입`: immutable, key-value, 해시맵, 딕셔너리, 연관배열등으로 알려짐

key는 유일키로 value와 연결된다.
Map을 생성 할때 kv쌍을 튜플로 기술하면 된다.
키와 값의 관계는 -> 연산자로 정의된다.

scala> val colorMap = Map("red" -> 0xFF0000, "green" -> OxFF00, "blue" -> 0xFF)
    colorMap: scala.collection.immutable.Map[String, Int] = Map(red -> 16711680, green -> 65280, blue -> 255)
}

scala> val redRGB = colorMap("red")
redRGB: Int = 16711680

scala> val hasWhite = colorMap.contains("white")
hasWhite: Boolean = false

scala> for (pairs <- colorMap) { println(pairs) }
(red, 16711680)
(green, 65280)
(blue, 255)

리스트의 종류

일반적인 리스트 - List(1,2,3)
중첩된 리스트 - List(List(1,2), List(3), List(4,5))
tuple 리스트 - List(('A',1), ('B', 2))
등 등 일관성 있는 매개변수 추론이 되는 요소의 리스트르 생성가능

isEmpty 메서드를 이용하여 리스트의 값 소유여부를 측정 가능하다.

scala> val primes = List(2, 3, 5, 7, 11, 13)
primes: List[Int] = List(2, 3, 5, 7, 11, 13)

scala> var i = primes
i: List[Int] = List(2, 3, 5, 7, 11, 13)

scala> while(! i.isEmpty) { print(i.head + ", "); i = i.tail}
2, 3, 7, 11, 13

리스트의 마지막을 검출하기 위해 isEmpty를 사용할 수 있지만 다른 방법으로 Nil인스턴스를 활용할 수 있다.
모든 리스트는 그 종점으로 Nil으로 종료된다.

scala> val primes = List(2, 3, 5, 7, 11, 13)
primes: List[Int] = List(2, 3, 5, 7, 11, 13)

scala> var i = primes
i: List[Int] = List(2, 3, 5, 7, 11, 13)

scala> while(i != Nil) { print(i.head + ", "); i = i.tail}
2, 3, 7

Nil은 List[Nothing]의 싱글턴 인스턴스, Nothing은 모든 스칼라 리스트에 호환되기 때문에 종점으로 안전히 사용가능하다.
새로운 빈 리스트를 생성하면 새로 생긴 인스턴스 대신 Nil을 반ㄹ환한다.
Nil은 immutable 데이터 구조기때문에 근본적으로 빈 리스트 인스턴스와 차이가 없다.

scala> val l = List[Int] = List()
l: List[Int] = List()

scala> l == Nil
res0: Boolean = true

생성 연산자

Nil의 속성을 이용하여 생성 연산자를 이용한 리스트를 생성 할 수 있다.
오른쪽-결합형(right-associative)인 :: 연산자를 이용하여 리스트를 생성 가능하다.

오른쪽-결합형(right-associative) 표기법 - 스칼라에서 연산자가 :로 끝나면 오른쪽 결합형으로 그 연산자의 오른쪽의 객체에서 호출 된다.

scala> val first = Nil.::(1)
first: List[Int] = List(1)

scala> first.tail == Nil
res3: Boolean = true

리스트 산술 연산

산술은 추가하고, 제거하고, 나누고, 결합하고, 구성 요소를 변경하는 등의 작업을 의미한다.
immutable형이기 때문에 실제로는 변경 사항을 반영한 새로운 리스트를 반환한다.

Name	Example	설명
::	1 :: 2:: Nil	리스트에 개별 요소를 덧붙임
:::	List(1 2) ::: List(2, 3)	이 리스트 앞에 다른 리스트를 추가함
++	List(1, 2) ++ Set(3, 4, 3)	이 리스트에 다른 컬렉션을 덧붙임
==	List(1, 2) == List(1, 2)	두 컬렉션의 요소를 비교
distinct	List(3, 5, 4, 3, 4).distinct	중복 요소가 없는 리스트를 반환
drop	List(1 ,2 , 3 ,4) drop 2	주어진 n개의 요소를 앞에서 부터 제거
filter	List(23, 8, 14, 21) filter (_ > 18)	참/거짓 함수를 참으로 만족한 요소를 반환
flatten	List(List(1,2), List(3,4)).flatten	중첩된 리스트의 요소를 단일 리스트로 전환함
partition	List(1, 2, 3, 4, 5) partition (_ < 3)	참/거짓 기준으로 리스트를 2개로 나눔
reverse	List(1,2,3).reverse	요소의 순서가 거꾸로인 리스트 반환
slice	List(2,3,5,7) slice (1, 3)	첫번째, 두번째-1 사이의 요소의 리스트를 반환
sortBy	List(“apple”, “to”) sortBy (_.size)	주어진 함수의 값을 이용하여 요소를 정렬함
sorted	List(“apple”, “to”).sorted	자연값 기준 정렬
splitAt	List(2, 3, 5, 7) splitAt 2	주어진 인덱스 기준으로 리스트를 2개로 나눔
take	List(2, 3, 5, 7, 11, 13) take 3	리스트에서 첫번쨰 n개의 요소를 추출
zip	List(1, 2) zip List(“a”, “b”)	두 리스트의 요소들을 튜플 결합한 리스트를 반한

연산자 vs 점 표기법 - 매개변수가 없어 . 표기법이 요구되는 경우를 제외하면 개인의 선택문제이다.

::도 연산자이기 떄문에 순서가 역순이 되나 다음과 같은 수행도 가능하다.

scala> val numbers = 1 :: 2 :: 3 :: Nil
numbers: List[Int] = List(1, 2, 3)

리스트는 단일 연결리스트로 앞에서 연산하는 것이 이익이다.
::, drop, take는 앞에서 부터 연산되지만 간혹 전체 순회가 필요한 동반연산(corollary operation)이 필요할 수 있다.
:+(왼쪽 결합형 연산자, 책오타), dropRight, takeRight

scala> val appended = List(1, 2, 3, 4) :+ 5
appended: List[Int] = List(1, 2, 3, 4, 5)

scala> val suffix = appended takeRight 3
suffix: List[Int] = List(3, 4, 5)

scala> val middle = suffix dropRight 2
middle: List[Int] = List(3)

리스트 매핑

Map 메서드는 함수를 취하여 요소에 적용하고, 그 결과를 새로운 리스트에 수집한다.

Name	Example	설명
collect	List(0, 1, 0) collect { case => “ok” }	각 요소에 case 적용 뒤 적용된 요소를 반환
flatMap	List(“milk,tea”) flatMap (_.split(“,”))	주어진 함수를 이용하여 요소에 적용한 뒤 flatten함
map	List(“milk,tea”) map (_.toUooerCase)	주어진 함수를 이용하여 각 요소를 변환함

리스트 축소

리스트를 단일 값으로 축소한다. 스칼라 컬렉션은 수학적 축소 연산과 부울 축소 연산을 지원한다.
또한 스칼라는 fold로 알려진 일반적인 고차 연산을 지원하는데, 이를 사용하여 임의의 다른 형태의 리스트 축소 알고리즘을 생성할 수 있다.

수학적 축소 연산

Name	Example	설명
max	List(41, 59, 26).max	리스트의 최댓값 추출
min	List(10.9, 32.5, 4.23, 5.67).min	리스트의 최솟값 추출
product	List(5, 6, 7).product	원소들의 곱을 반환
sum	List(11.3, 23.5, 7.2).sum	원소들의 합을 반환

부울 축소 연산

Name	Example	설명
contains	List(34, 29, 18) contains 29	리스트가 해당 요소를 포함하는지 검사
endsWith	List(0, 4, 3) endsWith List(4, 3)	리스트가 주어진 리스트로 끝나는지 검사
exists	List(24, 17, 32 exists (_ < 18)	최소 하나의 요소가 주어진 조건 함수를 만족하는지 검사
forall	List(24, 17, 32 forall (_ < 18)	모든 요소가 주어진 조건 함수를 만족하는지 검사
startsWith	List(0, 4, 3) startsWith List(0)	리스트가 주어진 리스트로 시작하는지 검사

커링 활용

contains를 직접 구현한다고 가정해보자.

scala> def contains(x: Int, l: List[Int]): Boolean = {
  | var a: Boolean = false
  | for (i <- l) { if (!a) a = (i == x) }
  | a
}
contains: (x:Int, l: List[Int])Boolean

scala> val included = contains(19, List(46, 19, 92))
included: Boolean = true

요소 순회와 조건 함수를 다음과 같이 분리하여 개선 할 수 있다.

scala> def boolReduce(l: List[Int], start: Boolean)(f: (Boolean, Int) => Boolean): Boolean = {
  | var a = start
  | for (i <- l) a = f(a, i)
  | a
}
boolReduce: (l: List[Int], start: Boolean)(f: (Boolean, Int) => Boolean)Boolean

scala> val included = boolReduce(List(46, 19, 92), false) { (a, i) => if (a) a else (i == 19)}
included: Boolean = true

같은 방식으로 boolean 함수 뿐만이 아닌 reduce 연산에 일반화 시킬 수 있다.

scala> def reduceOp[A,B](l: List[A], start: B)(f: (B, A) => B): B = {
  | var a = start
  | for (i <- l) a = f(a, i)
  | a
}
reduceOp: [A, B](l: List[A], start: B)(f: (B, A) => B)B

scala> val included = reduceOp(List(46, 19, 92), false) { (a, i) => if (a) a else (i == 19)}
included: Boolean = true

scala> val answer = reduceOp(List(11.3, 23.5, 7.2), 0.0)(_ + _)
answer: Double = 42.0

list-folding (fold 함수)

스칼라 컬렉션은 이미 다음과 같은 내장 연산을 제공하고 있다. 내장 연산들은 왼쪽에서 오른쪽, 오른쪽에서 왼쪽, 순서와 무관한 버전을 모두 제공할 만큼 유연하다.

Name	Example	설명
fold	List(4, 5, 6).fold(0)(_ + _)	초기값을 기준으로 리스트 축소
foldLeft	List(4, 5, 6).foldLeft(0)(_ + _)	초기값을 기준으로 왼쪽에서 오른쪽으로 리스트 축소
foldRight	List(4, 5, 6).foldRight(0)(_ + _)	초기값을 기준으로 오른쪽에서 왼쪽으로 리스트 축소
reduce	List(4, 5, 6).reduce(_ + _)	페어요소 별 리스트 축소
reduceLeft	List(4, 5, 6).reduceLeft(_ + _)	첫번째 요소 기준으로 왼쪽에서 오른쪽으로 리스트 축소
reduceRight	List(4, 5, 6).reduceRight(_ + _)	마지막 요소 기준으로 오른쪽에서 왼쪽으로 리스트 축소
scan	List(4, 5, 6).scan(0)(_ + _)	초기값 기준으로 축소 함수를 취하여 각각의 누적 리스트를 반환
scanLeft	List(4, 5, 6).scanLeft(0)(_ + _)	초기값 기준으로 축소 함수를 취하여 왼쪽 부터 오른쪽으로 수행 후 각각의 누적 리스트를 반환
scanRight	List(4, 5, 6).scanRight(0)(_ + _)	초기값 기준으로 축소 함수를 취하여 오른쪽 부터 왼쪽으로 수행 후 각각의 누적 리스트를 반환

컬렉션 전환

컬렉션들은 서로 다른 타입의 컬렉션으로 전환 될 수 있다.

Name	Example	설명
mkString	List(24, 99, 104).mkString(“,”)	주어진 구분자로 컬렉션을 String으로 전환
toBuffer	List(‘f’, ‘t’).toBuffer	immutable을 mutable로 전환
toList	Map(“a” -> 1, “b” -> 2).toList	컬렉션을 List로 전환
toMap	Set(1 -> true, 3 -> true).toMap	두 요소 튜블로 구성된 컬렉션을 Map으로 전환
toSet	List(2, 5, 3, 2).toSet	컬렉션을 Set으로 전환
toString	List(2, 5, 5, 3, 2).toString	컬렉션 타입을 포함하여 콜렉션을 문자열로 전환

자바와 스칼라 컬렉션 호환성

스칼라는 jvm으로 컴파일되고 그 위에서 동작한다.
즉 jdk와 상호작용뿐 아니라 어떤 자바 라이브러리도 추가 할 수 있어야한다는 것이 보편적인 요구사항이다.
그러나 자바 컬렉션과 스칼라 컬렉션의 타입은 기본적으로 호환 되지 않는다.

자바와 스칼라 컬렉션 사이의 전환을 하려면 다음 명령어를 추가해야한다.

import collection.JavaConverters._

collection.JavaConverters의 메서드가 추가 되면 자바와 스칼라 컬렉션에 다음 연산을 사용할 수 있다.

Name	Example	설명
asJava	List(12, 29).asJava	스칼라 컬렉션을 대응되는 자바 컬렉션으로 전환
asScala	new java.util.ArrayList(5).asScala	자바 컬렉션을 대응되는 스칼라 컬렉션으로 전환

컬렉션으로 패턴 매칭하기

이전에 배웠던 단일값 패턴 매칭은 다음과 같다.

scala> val statuses = List(500, 404)
statuses: List[Int] = List(500, 404)

scala> msg = statuses.head match {
  | case x if x < 500 => "okay"
  | case _ => "whoah, an error"
}
msg: String = whoah, an error

하지만 컬렉션의 값 중 하나의 값밖에 검사할 수 없다. 다음은 개선 버전이다.

scala> msg = statuses match {
  | case x if x contains(500) => "has error"
  | case _ => "okay"
}
msg: String = has error

이와 다르게 값 바인딩을 통하여 패턴 가드에서 컬렉션의 일부 또는 모든 요소에 값 바인딩이 가능하다.

scala> msg = statuses match {
  | case List(500, x) => s"Error followed by $x"
  | case List(e, x) => s"$e was followed by $x"
}
msg: String = Error followed by 404

리스트는 head와 tail로 분해 가능하기 떄문에 다음과 같은 매칭도 가능하다.

scala> val head = List('r', 'g', 'b') match {
  | case x :: xs => x
  | case Nil => ' '
}
head: Char = r

튜플도 값 바인딩을 이용한 패턴 매칭을 지원한다. 패턴 매칭은 스칼라 표준 컬렉션 라이브러리의 평범한 연산이 아니라 함수형 언어의 핵심적 특징이다.

러닝스칼라 5장 - 일급 함수

jmkim87 — Mon, 28 Sep 2020 23:14:41 +0900

스칼라는 일급 함수, 선언형 프로그래밍을 지원한다.

**일급 함수(first-class function)** : 함수형 프로그래밍에서 함수는 일급(first-class) 객체

다른 데이터 타입처럼 리터럴 형태로 생성될 수 있다.
val, var로 저장될 수 있다.
다른 함수의 매개변수나 반환값으로 사용될 수 있다.

**선언형 프로그래밍(declarative programming)** : 고차함수(또는 다른 함수를 사용하는 로직)는 단순히 이루어져야 할 작업을 선언하고 그 작업을 직접 수행하지 않음

함수 타입과 값

함수 타입은 입력 타입과 반환값 타입의 그룹으로 표현된다.

([<타입>, ...]) => <타입>

def double(x: Int): Int = x * 2
val myDouble: Int => Int = double
myDouble(5)

와일드 카드 연산자로 함수를 할당하면 함수 타입을 쓰지 않아도 된다.

val <식별자> = <함수명> _

val myDouble = double _

고차함수(higher-order function)

입력 매개변수나 반환값으로 함수 타입의 값을 가지는 함수

// safeStringOp: (s: String, f: String => String): String
def safeStringOp(s: String, f: String => String) = {
  if (s != null) f(s) else s
}

def reverser(s: String) = s.reverse

safeStringOp(null, reverser) // null
safeStringOp("Ready", reverser) // "ydaeR"

함수 리터럴(function literal)

함수명이 없는 함수
익명 함수(Anonymous function), 람다 표현식(Lambda expression), 람다(Lambda), (function0, function1, function2…) 으로도 불린다.

([식별자: <타입>, ...]) => <표현식>

val doubler = (x: Int) => x * 2
// val doubler = x => x * 2 안됨
val doubled = doubler(22) // 44

함수 리터럴은 고차 함수 호출 내부에서 정의 가능

def safeStringOp(s: String, f: String => String) = {
  if (s != null) f(s) else s
}
safeStringOp("Ready", (s: String) => s.reverse)
// safeStringOp("Ready", s => s.reverse) 가능

자리표시자 구문(placeholder syntax)

매개변수를 와일드카드 연산자( _ )로 대체

1) 함수의 명시적 타입이 정의되어 있고, 2) 매개변수가 한 번 사용되거나 사용되지 않을 때 사용가능
placeholder의 개수는 입력 인수 개수와 동일

val doubler: Int => Int = _ * 2

def safeStringOp(s: String, f: String => String) = {
  if (s != null) f(s) else s
}
safeStringOp("Ready", _.reverse)

def combination(x: Int, y: Int, f: (Int, Int) => Int) = f(x,y)
combination(23, 12, _ * _) // 23*12

타입 매개변수 사용하기

def tripleOp1[A, B](a: A, b: A, c: A, f: (A, A, A) => B) = f(a,b,c)
tripleOp1[Int, Double](23, 92, 14, _ * _ + _)
// tripleOp1(23, 92, 14, _ * _ + _) 불가능

def tripleOp2[A, B](a: A, b: A, c: A)(f: (A, A, A) => B) = f(a,b,c)
tripleOp2(23, 92, 14)( _ * _ + _)

부분 적용 함수(Partially Applied Function)와 커링(currying)

부분 적용 함수: 와일드 카드 연산자를 이용해서 어떤 함수를 부분적으로 적용한 함수

def factorOf(x: Int, y: Int) = y % x == 0
val multipleOf3 = factorOf(3, _: Int)
val y = multipleOf3(78)

커링: 한 매개변수 그룹은 적용하고 다른 그룹은 적용하지 않는 기법

def factorOf(x: Int)(y: Int) = y % x == 0
val isEven = factorOf(2) _
val z = isEven(32) // true

다중 매개변수 그룹을 가지는 함수를 함수 체인(chain) 형태로 간주한다.
예를 들어 def factorOf(x: Int, y: Int)의 함수 타입은 (Int, Int) => Boolean이다.
하지만 def factorOf(x: Int)(y: Int)의 함수 타입은 Int => Int => Boolean (체인 형식)이다.
이 함수를 커링하면 Int => Boolean이 된다.

이름에 의한(by-name) 호출 매개변수

값 또는 값을 반환하는 함수 모두를 취할 수 있는 매개변수, 함수 유연성을 높일 수 있다.

<식별자>: => <타입>

만약 함수를 매개변수로 받는 경우, 함수를 사용할 때 마다 함수를 호출한다.
함수에 반복하여 접근할 때 발생할 수 있는 문제들에 대해 생각하고 사용해야된다.
예를 들어, 데이터베이스에 고정값을 검색하고 그 값을 반환하는 표현식을 by-name 호출 매개변수로 사용한다면 함수 내에서 사용될 때마다 데이터베이스에 접근하게 된다.

def doubles(x: => Int) = {
  println("Now doubling " + x)
  x * 2
}

doubles(5)
// Now doubling 5
// res18: Int = 10

def f(i: Int) = { println(s"Hello from f($i)"); i }

doubles( f(18) )
// Hello from f(8)
// Now doubling 8
// Hello from f(8)
// res19: Int = 16

부분 함수(partial function)

입력타입을 만족하는 값을 모두 처리하지 못하는 함수
컬렉션과 패턴 매칭으로 작업할 때 유용하다.

val statusHandler: Int => String = {
  case 200 => "Okay"
  case 400 => "Your Error"
  case 500 => "Our Error"
}

statusHandler(401) // scala.MatchError 발생

함수 리터럴 블록으로 고차 함수 호출하기

def safeStringOp(s: String)(f: String => String) = {
  if ( s != null ) f(s) else s
}

val uuid = java.util.UUID.randomUUID.toString
val timedUUID = safeStringOp(uuid) { s =>
  val now = System.currentTimeMillis
  val timed = s.take(24) + now
  timed.toUpperCase
}

데이터베이스 트랜젝션 관리에서 고차 함수는 세션을 열고, 함수 매개변수를 호출하고, 커밋또는 롤백을 하여 트랜젝션 종료
오류를 내지 않을 때까지 함수 매개변수를 여러번 재시도
지역, 전역, 외부값(환경변수)에 기반하여 조건부로 함수 매개변수 호출

함수 내용에 관계 없이 일반화해서 처리할 수 있는 부분를 고차 함수로 정의

러닝스칼라 4장 - 함수

jmkim87 — Mon, 28 Sep 2020 23:13:16 +0900

순수 함수

입력 매개변수만을 가지고 계산을 수행한 후 값을 반환한다.
함수 외부의 어떤 데이터도 사용하거나 영향을 주지 않는다.
동일 입력에 대해 항상 같은 값을 반환한다.

주어진 입력으로 계산하는 것 이외에 프로그램의 실행에 영향을 미치지 않아야 한다, 즉 부수 효과(side effect) 가 없다

함수 정의

def multiplier(x:Int, y:Int):Int = {x * y}

def로 시작하며 이름이 따라온다 - 그 뒤 괄호 안에는 매개변수 목록이 온다 (매개변수 타입은 추론하지 않으므로 지정해야 한다) - 그 뒤 : 뒤에 결과 타입을 지정한다 (결과 타입은 추론이 가능하므로 생략할 수 있다, 재귀 함수면 생략 불가능) - 함수 본문은 표현식 또는 표현식 블록으로 구성되어 있으며, 마지막 줄이 함수의 반환값이 된다

프로시저

반환값을 가지지 않는 함수. 문장(println()호출 등)으로 끝나는 함수. Unit 타입으로 추론된다.

부수 효과(메소드 밖에 있는 상태(var 변수) 변경, I/O 수행 등)를 위해 실행

def log(d: Double) = println(f"Got value $d%.2f")

매개변수가 없는 함수

def hi() = "hi"
hi()
// hi

함수 호출 시 빈괄호를 붙이거나 안 붙일 수 있다.

관례 상 메소드에 부수 효과가 있다면 괄호를 넣고, 없다면 괄호를 사용하지 않는다.

def hi = "hi"
hi() // compile error
hi // hi

함수를 매개변수 괄호 없이 정의할 수 있다. 해당 경우에는 빈괄호를 붙여서 호출할 수 없다.

표현식 블록 매개변수

def formatEuro(amt: Double) = f"$amt%.2f euro"
formatEuro {
  val rate = 1.32
  0.235 + 0.7123 + rate * 5.32
}

단일 매개변수일 때 괄호를 중괄호로 바꾸고 표현식 블록을 매개변수로 사용할 수 있다. 함수 호출 시 표현식을 평가한 후, 반환값을 함수 매개변수로 사용한다.

계산된 값을 함수로 전달해야 할 때 지역 변수에 저장할 필요 없이 넘길 수 있다.

재귀 함수

꼬리 재귀

재귀적 호출이 새로운 스택 공간을 생성하지 않는 대신 현행 함수의 스택 공간을 사용하도록 최적화됨. 마지막 문장이 재귀적 호출이여야 한다

@tailrec annotation : 표시된 함수가 꼬리 재귀로 최적화 될 수 없다면 컴파일 에러 발생시킨다.

def boom(x:Int) : Int = 
    if (x == 0) 1
    else bool(x - 1)

@annotation.tailrec
def boom(x:Int) : Int = 
    if (x == 0) 1
    else bool(x - 1) + 1 
// 마지막 문장이 재귀적 호출만 있지 않다. + 1을 추가로 하고 있어 compile error

@annotation.tailrec
val funValue = nestedFum _
def nestedFum(x :Int) : Unit = 
    if (x != 0) {println(x); funValue(x - 1)}  
// 함수 값을 통하는 중간 경로가 있어 재귀적 호출이라고 볼 수 없다. compile error

중첩 함수

함수(외부) 내에 다른 함수(내부) 정의. 내부 함수는 외부 함수 scope에서만 사용할 수 있다.

메소드로 생각하면 scope을 class 내 -> 해당 method 내로 옮기는 효과가 있다.

def max(a: Int, b: Int, c: Int) = {
  def max(x: Int, y: Int) = if (x > y) x else y
  max(a, max(b, c))
}

이름 붙인 매개변수

매개변수 목록에 정해진 순서와 다른 순서로 함수에 인자 전달 가능

def speed(distance:Float, time:Float) = distance / time
speed(time = 10, distance = 100)

default 매개변수 값

default 값을 지정해 놓으면 함수 호출 시 해당 인자 생략 가능, 이름 붙인 인자와 같이 쓰면 유용함

기본값을 갖는 매개변수가 필수 매개변수 다음에 오도록 함수 매개변수를 구조화해야

def printTime(out: java.io.PrintStream = Console.out, divisor:Int = 1) = out.println("time = " + System.CurrentTimeMillis() / divisor)
printTime(out = Console.err)
printTime(divisor = 1000)

def greet(name: String, prefix: String = "") = s"$prefix$name"
greet("Ola")

가변 매개변수

정해지지 않은 개수의 입력 인수들로 함수를 정의

함수의 마지막 파라미터만 지정 가능, 함수 내에서 해당 타입의 배열로 취급됨

def echo(args: String *) = for(arg <- args) println(arg)
echo("AA")
echo("AA", "BB")

커링

타입 매개변수

매개 변수 또는 반환 값 등에 사용될 타입을 지시한다 (타입을 매개변수화)

def identity[A](a: A) : A = a
val s: String = identity[String]("Hello")
val s: String = identity("Hello") // 함수에 전달하는 리터럴 값이나 함수의 반환 값을 할당한 값의 타입을 통해 타입 추론 가능, 타입 매개변수 생략 가능

메소드

클래스에서 정의된 함수로 그 객체의 데이터에 동작. <인스턴스>.<메소드>로 호출

스칼라에서는 모든 것이 객체(int, double 등도)이므로 산술 연산자도 해당 객체 내의 메소드로 정의되어 있다.

객체와 메소드, 그리고 매개변수를 공백으로 구분하는 연산자 호출법으로 메소드 호출이 가능하므로 연산자 메소드들을 연산자처럼 보이게 할 수 있다.

2 + 3  // compiler가 아래 모양으로 변경
2.+(3)

d compare 18.0 // 모든 메소드에 사용 가능
"abcde" substring (1, 2) // 매개 변수가 여러 개면 괄호 이용

연산자 우선순위는 method 첫 글자를 보고 우선순위 결정. a +++ b * c(+++, * 는 메소드 이름)일 경우 a +++ (b *** c)로 취급(*가 +보다 우선순위 높음)

한가지 예외, =로 끝나는 메소드는 =(할당 연산자)와 동급으로 취급해 우선순위 제일 낮게 취급. x = y + 1일 경우 x = (y + 1)로 취급(가 +보다 우선순위 높지만. =는 할당연산자로 분류)

가독성 있는 함수 작성하기

짧고 이해하기 쉬운 이름 정하기. 하고자 하는 일을 합리적으로 요약할 수 있는 이름.
복잡한 함수를 작고 단순한 함수로 나누기
함수 내에 세부사항과 맥락에 대한 설명, 잠재적인 문제점, TODO등을 주석으로 표현하기.
ScalaDoc 헤더 추가

러닝스칼라 3장 - 표현식과 조건문

jmkim87 — Mon, 28 Sep 2020 23:11:23 +0900

표현식

표현식(expression) 은 값을 반환하는 코드의 단위입니다.

// String 리터럴
"hello"
"hel"+'l'+'o'

표현식으로 값과 변수 정의하기

아래와 같이 표현식의 반환값을 값 또는 변수에 할당하는 식으로 나타낼 수 있습니다.

val <식별자>[: <타입>] = <표현식>

표현식 블록

표현식 블록 은 중괄호({,})를 사용하여 하나로 묶어서 사용합니다.

두 표현식

val x = 5 * 20; val amount = x + 10

표현식 블록

val amount = { val x = 5 * 20; x + 10}

여러 줄로 표현

val amount = {
  val x = 5 * 20
  x + 10
}

삼중 구조 후반부에 제어 구조를 다룰 때 다룹니다.

{ val a = 1; { val b = a * 2; { val c = b + 4; c}}}

문장(statement)

문장(statement) : 값을 반환하지 않는 표현식

문장 블록(Statement block) : 표현식 블록과 다르게 값을 반환하지 않습니다. * 결과 값이 없기 때문에 보편적으로 기존 데이터를 수정하거나 애플리케이션 범위 밖을 변경하는데 사용 합니다.

If .. Else 표현식 블록

If 표현식

if (<부울식>) <표현식>

if ( 47 % 3 > 0 )  println("Not a multiple of 3")

If-Else 표현식

if (<부울식>) <표현식> else <표현식>

val x = 10 
val y = 20 
val max = if (x > y) x else y // 20

다른 언어에서 지원하는 삼항 표현식을 사용하지 않는 이유는 간결하게 표현할 수 있기 때문

매치 표현식

switch문과 유사합니다.

<표현식> match { case <패턴 매치> => <표현식> [case ...] }

If .. else와 같은 방식의 match

val x = 10 
val y = 20 
val max = x > y match { 
    case true => x 
    case false => y 
} //max = 20s

Request Status Code

val status = 500
val message = status match { 
    case 200 => “ok” 
    case 400 => { 
        println("ERROR - we called the service incorrectly.") 
        "error"
    } 
    case 500 => { 
        println("ERROR - the service encountered an error.") 
        "error" 
    } 
} 
// ERROR - the service encountered an error 
// message : error

여러 패턴을 동일한 case 블록 사용하기

val day = "MON" 
val kind = day match { 
    case "MON" | "TUE" | "WED" | "THU" | "FRI" => { 
        "weekday" 
    } 
    case "SAT" | "SUN" => { 
        "weekend" 
    } 
} 
//kind = "weekday"

Error

"match me" match {
    case "nope" => "sorry"
} 
// scala.MatchError

위처럼 에러를 방지하기 위해 와일드 카드로 매칭하여 예외처리 합니다.

와일드카드로 매칭하기

값 바인딩(value binding)

case 블록이 유지되는 동안만 정의됩니다.

val message = "FAIL"
val status = message match {
case "OK" => 200
case other => {
  println(other) // "FAIL"
  -1
}
}

와일드 카드(_, underscore)
- _를 사용하며 값 바인딩과 다르게 해당 값에 대해서 접근할 수 없습니다.
```
val status = message match {
case "OK" => 200
case _ => {
  -1
}
}
```

패턴 가드를 이용한 매칭

기존의 if문과 다르게 둘러싸고 있는 ()가 필요 없습니다.

case <패턴> if <부울식> => <하나 이상의 표현식>

val response: String = null
response match {
  case s if s != null => println(s"Received '$s'")
  case s => println("Error!")
}
// "Error!"

패턴 변수를 이용한 타입 매칭

패턴 변수는 다른 타입의 값으로 전환할 수 있습니다. 패턴 변수에서의 제한은 반드시 소문자로 시작해야합니다.

case <identifier>: <type> => <one or more expressions>

패턴 변수 사용법

val y:Any = 12345

y match {
  case x: String => s"'$x'"
  case x: Double => f"$x%.2f"
  case x: Float => f"$x%.2f"
  case x: Long => s"${x}l"
  case x: Int => s"${x}i"
}
//12345i

루프

숫자 범위 정의하기
<시작 정수값> [to|until] <끝 정수값> [by increment]

기본 for 루프로 반복하기
for (<식별자> <- <반복자>)[yield] [<표현식>]

for (x <- 1 to 7) {println(s"Day $x:")}
/*
    Day 1:
    Day 2:
    Day 3:
    Day 4:
    Day 5:
    Day 6:
    Day 7:
*/

만약 for loop시에 하나의 컬렉션에 넣어서 반환하려면 yield를 사용합니다.

for (x <- 1 to 7) yield { s"Day $x:"}
// res0: IndexedSeq[String] = Vector(Day 1:, Day 2:, Day 3:, Day 4:, Day 5:, Day 6:, Day 7:)

반복자 가드

for (<identifier> <- <iterator> if <Boolean expression>) ...

아래는 3의 배수로 이루어진 컬렉션을 만드는 예제입니다.

val threes = for (i <- 1 to 20 if i % 3 == 0) yield i 

val threes_multi_line = for {
  i <- 1 to 20
  if i % 3 == 0
} yield i
// threes_multi_line: IndexedSeq[Int] = Vector(3, 6, 9, 12, 15, 18)

중첩된 반복자

for 루프에 추가된 부가적인 반복자로, 전체 반복 횟수를 자신의 반복 횟수만큼 반복합니다.

val two_dimension = for {
  x <- 1 to 2
  y <- 1 to 3  
} {print(s"($x, $y)")}
// (1, 1)(1, 2)(1, 3)(2, 1)(2, 2)(2, 3)two_dimension: Unit = ()

값 바인딩

for 루프 정의에서 값 바인딩을 사용하여 좀 더 깔끔한 코드를 만들 수 있습니다.

for (<식별자> <- <반복자> ; <식별자> = <표현식>) ...

예시로 아래에 0에서 8까지 2의 거듭 제곱 값을 계산하는 for 루프 입니다. 값 바인딩을 사용하지 않았을 경우 코드가 좀 길어집니다.

val powersOf2 = for (i <- 0 to 8) yield {
  val pow = 1 << i
  pow
}
// powersOf2: IndexedSeq[Int] = Vector(1, 2, 4, 8, 16, 32, 64, 128, 256)

값 바인딩을 사용하면 아래와 같이 깔끔하게 정의할 수 있습니다.

val powerOf2 = for (i <- 0 to 8; pow = 1 << i) yield pow
// powersOf2: IndexedSeq[Int] = Vector(1, 2, 4, 8, 16, 32, 64, 128, 256)

위에서 사용한 <<(shift 연산자)는 비트를 옮기는 역할을 합니다.

대략적인 ...
1 : 0b000000001
2 : 0b000000010
4 : 0b000000100
8 : 0b000001000
...
256 : 0b100000000

While과 Do/While 루프

while (<부울식>) 표현식

var x = 10
while (x > 0) x -= 1

var x = 10
do x -= 1 while ( x > 0 )

FAQ

yield 사용 시 동작 방법
1. for loop에서는 map function처럼 동작 합니다.
  1. https://docs.scala-lang.org/tutorials/FAQ/yield.html
2. yield 앞에 사용법에 따라서 동작 방식이 달라질 듯 합니다.

러닝스칼라 2장 - 데이터로 작업하기: 리터럴, 값, 변수, 타입

jmkim87 — Mon, 28 Sep 2020 23:06:30 +0900

스칼라에서 값과 변수에 저장된 데이터를 더 이상 사용하지 않으면 자바 가상 머신의 가비지 컬렉션이 자동으로 할당을 취소한다. 직접 할당 취소할 필요도 능력도 없다.

리터럴(literal)

숫자 5, 문자 A, 텍스트 ’Hello, World’처럼 소스 코드에 바로 등장하는 데이터

값 (value)

불변의 타입을 갖는 스토리지 단위이며, 데이터를 저장 - 명시적인 타입이 있어야 하는 것은 아니다, 스칼라 컴파일러가 할당된 데이터를 기반으로 추론한다. => 타입 추론 (type inference) - 코드를 작성하는데 타입 추론은 편하지만 가독성을 떨어뜨리지 않는 범위에서 사용

val <식별자>[: 타입] = <데이터>

변수 (variable)

값을 저장하고 그 값을 가져올 수 있도록 할당되거나 예약된 메모리 공간에 대응하는 유일한 식별자 - 메모리 공간에 예약되어 있는 동안에는 새로운 값을 계속 할당할 수 있다. - 메로리 간의 내용은 동적이며 가변적이다. - 스칼라에서는 관례상 변수보다 값을 선호하는 이유는 값을 사용하면 소스 코드가 안정적이며 예측할 수 있기 때문 - 디버깅이 쉽고 멀티 스레드 코드에서 가변 데이터보다 더 안정적이며 에러 발생 확률이 적어진다.

var <식별자>[: 타입] = <데이터>

타입 추론은 가능하지만 지정된 타입은 바꿀수 없다. (예외로 Double 변수에 Int를 할당하면 Double로 바꿔준다)

명명

이름은 숫자로 시작할수 없다
val a.b = 4 는 불가능 하지만 val ‘a.b’ = 4 는 가능하다.
관례상 camel case 를 쓴다.

타입

숫자형 타입

이름	크기	리터럴
Byte	1byte
Short	2byte
Int	4byte	5, 0x0f
Long	8byte	5l
Float	4byte	5f
Double	8byte	5d, 5.0

스칼라는 타입 순위에 기반하여 한 타입의 순자를 자동으로 다른 타입으로 전환해준다 => 상향전환
표는 자동 전환 순위대로 정렬한것이다. Byte 타입이 최하위여서 모든 타입으로 전환 가능
높은 순위의 데이터 타입이 더 낮은 순위의 타입으로 자동 전환을 허용하지 않는다.
to 으로 수동 전환은 가능

문자열

텍스트의 문자열, 스칼라늬 String은 자바의 String을 기반으로 하며, 여러줄 리터럴(multiline literal) 과 문자열 보간(interpolation)을 추가 - 숫자타입과 마찬가지로 수학 연산자 사용 지원 - 여러줄 String은 입력할때 """ """ 를 사용한다 (이때는 인지 못함) - 문자열 보간

val approx = 355/113f
println(s"PI, using 255/113 is about $approx.")
PI, using 255/113 is about 3.141593

val pepper = "pepper "
println(s"${pepper *3} salt")
pepper pepper pepper  salt

// printf
val item = "apple"
f"I wrote a new $item%.3s today"
I wrote a new app today

정규 표현식

검색 패턴을 나타내는 문자와 구두점으로 이루어진 문자열이다. - java.util.regex.Pattern에 기반 - matches, replaceAll, replaceFrist

정규 표현식으로 값 캡처하기

정규 표현식의 고급 처리 기법을 위해서 r 연산자를 호출하여 문자열을 정규표현식 타입으로 전환하면 된다.

scala> val input = "Enjoying this apple 3.14159 times today"
input: String = Enjoying this apple 3.14159 times today

scala> val pattern= """.* apple ([\d.]+) times .*""".r
pattern: scala.util.matching.Regex = .* apple ([\d.]+) times .*

scala> val pattern(amountText) = input
amountText: String = 3.14159

scala> val amount = amountText.toDouble
amount: Double = 3.14159

참고: https://programmingnote.tistory.com/36

스칼라 타입의 개요

Any는 절대 루트로 다은 모든 타입들은 이 루트의 두 자식 노으인 AnyVal, AnyRef의 자식이다.
Anyval는 값 타입 (value type)이라 하며 숫자형 타입과 Char, Boolean, Unit 포함
- 객체로 힙메모리에 할당되거나 JVM 기본값으로 스택에 지역적으로 할당된다
- AnyVal 이외에는 AnyRef 이며 오직 객체로 힙 메모리에만 할당
최하위 Nothing, Null 타입
- Nothing은 프로그램 흐름에 영향을 줄 수 있는 연산에서 호환성 있는 반환값을 제공
- return 키워드는 Nothing 이며 타입으로만 사용하며 인스터스화 할 수 없다.
- Null은 AnyRef의 서브타입으로 키워드 Null 타입을 제공
- String변수는 언제라도 null 타입이 될수있고 그 변수는 메모리의 어떤 문자열 인스턴스도 가리키지 않는다.
char는 String 타입의 기본이 되는 타입으로 단일 문자
- 다르 숫자와 양방향 전환이 가능하다.
Boolean 타입은 true와 false
- 스칼라는 다른 타입을 부울 타입으로 자동 전환해주지 않는다.
- null이 아닌 문자열을 true 라고 하지 않고, 숫자 0은 false 와 다르다.
Unit은 데티어 타입을 나타내는 대신 데이터가 없음을 나타낸다.
- void 와 유사하고 () 로 표현

타입 연산

Name	Example	설명
asInstanceOf[타입>]	5.asInstanceOf[Long]	해당값을 원하는 타입의 값으로 전환, 그 값이 새로운 타입과 호환되지 않으면 에러
getClass	(7.0/5).getClass	해당값의 타입 반환
isInstanceOf	(5.0).isInstanceOf[Float]	해당 값이 주어진 타입을 가지면 true 반환
hashCode	"A".hashCode	해당 값의 해시값 반환
to<타입>	20.toByte	하나의 값을 호환되는 값으로 반환
toString	(3.0/ 4.0).toString	해당 값을 String으로 전환

asInstanceOf는 요청받은 타입으로 전환될 수 없으면 에러가 발생한다.
- 런타입 에러가 발생하는 것을 피하기 위해서는 가능하다면 타입 지정된 전환 연산인 to을 사용하는 것이 좋다.

튜플

둘 이상의 값을 가지는 순서가 있는 컨테이너, 각각의 값은 서로 다른 타입을 가질 수 있다. - 항목은 1부터 시작하는 인덱스를 이용하여 접근가능 , 화살표 연산자로 사용하는 방법

appendix. 그외 이슈

tuple은 왜 loop 순회 할 수 없는가?

튜플은 Tuple case클래스와 product trait으로 구성
tuple/product는 item개수에 따라 직접 구현됨
product는 내부에 item에 매핑되는 member를 가지고 있음 product구성
각 member는 productElement(n: Int)로 조회될 수 있음
product는 productElement를 loop 호출하는 productIterator를 가지고 있음
이것을 사용하여 loop 순회 가능

python의 속도

스칼라와 파이썬

러닝스칼라 1장 - 스칼라 시작하기

jmkim87 — Mon, 28 Sep 2020 22:51:02 +0900

해당 챕터는 책과 좀 다르게 intellij로 환경 설정 하는 방법으로 적겠습니다.

1.1. 설치하기

Intellij를 처음 설치 후 첫 실행 시 아래와 같은 화면에서 설치 할 수 있습니다.
새 프로젝트를 만들 시 다음과 같이 선택 할 수 있습니다. Use library에 버전이 없을 경우 Create를 누릅니다.
1. 이미 Scala를 따로 깔으셨다면 자동으로 잡힐꺼라 생각됩니다.
Use library에 버전이 없을 때 Create 버튼을 누르면 아래와 같이 나옵니다.
다운 받을 버전 선택
설치가 완료 되면 Use library에 버전이 들어가서 보여집니다.

참조 : https://wingnim.tistory.com/71

1.1.1. 번외

Intellij 첫 실행 시에 scala를 깔지 않았다면 2가지 방법이 있습니다.
1. Scala를 별도로 설치하여 사용하기
  - 이 방식은 별도로 해보지 않았지만 될 듯 합니다.
2. Intellij plugin에서 scala를 검색하여 설치하기
  1. 프로젝트 생성 전 화면에서 아래 화면처럼 plugin을 선택합니다.
  2. plugin -> Marketplace에서 scala 검색 후 설치하고 Intellij를 재시작 합니다.

1.2. 실행 해 보기

기본 적인 실행은 아래와 같이 object를 만들고 extends app을 사용하여 실행합니다.
1. sbt를 사용하기 원하시면 젤 하단에 sbt shell에서 test나 run을 실행 시키실 수 있습니다.

깔끔한 파이썬 탄탄한 백엔드 -8-

jmkim87 — Thu, 3 Sep 2020 22:48:47 +0900

8. Unit Test

기능을 개발하고 나서 제대로 돌아가는지 매번 수동으로 API를 쏠수 없으니 Unit Test를 하여 각 기능들이 제대로 돌아가는지 테스트를 해야합니다.

UI test / End-to-End Test

웹브라우저를 통해서 웹사이트를 실제로 접속하고 UI에 직접 입력하고 클릭하는 등을 통해서 기능을 정상적으로 작동하고 화면이 정상적으로 작동하는지 테스트 해보는 방식

아래는 웹 UI test하는 툴입니다.

Selenium
Katalon
Protractor
CasperJS
PhantomJS

Integration test(통합 테스트)

각 기능(모듈)을 통합하는 과정에서 모듈간 호환성의 문제를 찾아내기 위해 수행되는 테스트

빅뱅 통합 : 전체 모듈을 모두 통합한 이후 통합 테스트를 수행하는 방식. (서비스 전체를 한번에 유저 시나리오로 테스트 하는 방식)
점진적 통합 : 한번에 모듈을 통합하지 않고 하향식/상향식 기법으로 점진적으로 통합하면서 테스트 하는 방식 (시나리오 하나씩 붙이면서 테스트를 하는 방식)

Unit Test

각각 기능 하나에 대해서 코드 테스트를 합니다.

python3에서 uniittest라는 모듈이 탑재되어 있지만 좀더 쓰기 편한 pytest를 사용합니다.

테스트를 할 파일명은 test_ 를 붙여야 합니다.

# test_minitter.py
import pytest
import bcrypt
import json
import config
import sys
from sqlalchemy import create_engine, text
sys.path.append('../')
from app import create_app

database = create_engine(config.test_config['DB_URL'], encoding='utf-8', max_overflow=0)

@pytest.fixture
def api():
    app = create_app(config.test_config)
    app.config['TESTING'] = True
    api = app.test_client()

    return api

def setup_function():
    hashed_password = bcrypt.hashpw(b"test password", bcrypt.gensalt())
    new_users = [
        {
            "id": 1,
            "name": "test1",
            "email": "test1@test.com",
            "profile": "test1 profile",
            "hashed_password": hashed_password
        },
        {
            "id": 2,
            "name": "test2",
            "email": "test2@test.com",
            "profile": "test2 profile",
            "hashed_password": hashed_password
        }
    ]

    database.execute(text("""
        INSERT INTO users (
            id,
            name,
            email,
            profile,
            hashed_password
        ) VALUES (
            :id,
            :name,
            :email,
            :profile,
            :hashed_password
        )
    """), new_users)

    database.execute(text("""
        INSERT INTO tweets (
            user_id,
            tweet
        ) VALUES (
            2,
            "Hello World!"
        )
    """))

def teardown_function():
    database.execute(text("SET FOREIGN_KEY_CHECKS=0"))
    database.execute(text("TRUNCATE users"))
    database.execute(text("TRUNCATE tweets"))
    database.execute(text("TRUNCATE users_follow_list"))
    database.execute(text("SET FOREIGN_KEY_CHECKS=1"))

def test_ping(api):
    resp = api.get('/ping')
    assert b'pong' in resp.data

def test_login(api):
    resp = api.post(
        '/login',
        data = json.dumps({'email': 'test1@test.com', 'password': 'test password'}),
        content_type = 'application/json'
    )
    assert b"access_token" in resp.data

def test_unauthorized(api):
    resp = api.post(
        '/tweet',
        data = json.dumps({'tweet': 'Hello World!'}),
        content_type = 'application/json'
    )
    assert resp.status_code == 401

    resp = api.post(
        '/follow',
        data = json.dumps({'follow': 2}),
        content_type = 'application/json'
    )
    assert resp.status_code == 401

    resp = api.post(
        '/unfollow',
        data = json.dumps({'unfollow': 2}),
        content_type = 'application/json'
    )
    assert resp.status_code == 401

def test_tweet(api):
    resp = api.post(
            '/login',
            data = json.dumps({'email': 'test1@test.com', 'password': 'test password'}),
            content_type = 'application/json'
            )
    resp_json = json.loads(resp.data.decode('utf-8'))
    access_token = resp_json['access_token']

    resp = api.post(
        '/tweet',
        data = json.dumps({'tweet': "Hello World!"}),
        content_type = 'application/json',
        headers = {'Authorization': access_token}
    )
    assert resp.status_code == 200

    resp = api.get(f'/timeline/1')
    tweets = json.loads(resp.data.decode('utf-8'))

    assert resp.status_code == 200
    assert tweets == {
        "user_id": 1,
        "timeline": [
            {
                "user_id": 1,
                "tweet": "Hello World!"
            }
        ]
    }

def test_follow(api):
    resp = api.post(
        '/login',
        data = json.dumps({'email': 'test1@test.com', 'password': 'test password'}),
        content_type = 'application/json'
    )
    resp_json = json.loads(resp.data.decode('utf-8'))
    access_token = resp_json['access_token']

    resp = api.get(f'/timeline/1')
    tweets = json.loads(resp.data.decode('utf-8'))

    assert resp.status_code ==200
    assert tweets == {
        'user_id': 1,
        'timeline': []
    }

    resp = api.post(
        '/follow',
        data = json.dumps({'id': 1, 'follow': 2}),
        content_type = 'application/json',
        headers = {'Authorization': access_token}
    )

    assert resp.status_code == 200

    resp = api.get(f'/timeline/1')
    tweets = json.loads(resp.data.decode('utf-8'))

    assert resp.status_code == 200
    assert tweets == {
        'user_id': 1,
        'timeline' : [
            {
                'user_id': 2,
                'tweet': 'Hello World!'
            }
        ]
    }

def test_unfollow(api):
    resp = api.post(
        '/login',
        data = json.dumps({'email': 'test1@test.com', 'password': 'test password'}),
        content_type = 'application/json'
    )
    resp_json = json.loads(resp.data.decode('utf-8'))
    access_token = resp_json['access_token']

    resp = api.post(
        '/follow',
        data = json.dumps({'id': 1, 'follow': 2}),
        content_type = 'application/json',
        headers = {'Authorization': access_token}
    )
    assert resp.status_code == 200

    resp = api.get(f'/timeline/1')
    tweets = json.loads(resp.data.decode('utf-8'))

    assert resp.status_code == 200
    assert tweets == {
        "user_id" : 1,
        "timeline": [
            {
                "user_id": 2,
                "tweet": "Hello World!"
            }
        ]
    }

    resp = api.post(
        '/unfollow',
        data = json.dumps({'id': 1, 'unfollow': 2}),
        content_type = 'application/json',
        headers = {'Authorization': access_token}
    )

    assert resp.status_code == 200

    resp = api.get(f'/timeline/1')
    tweets = json.loads(resp.data.decode('utf-8'))

    assert resp.status_code == 200
    assert tweets == {
        "user_id": 1,
        "timeline": []
    }

위와 같이 작성합니다.
assert로 값 비교하여 true이면 pass 입니다.

$> pytest -p no:warnings -vv -s
================================================= test session starts ==================================================
platform linux -- Python 3.6.5, pytest-5.4.1, py-1.8.1, pluggy-0.13.1 -- /project/huggingfaceAPI/venv/bin/python
cachedir: .pytest_cache
rootdir: /project/huggingfaceAPI/test
collected 6 items

test_minitter.py::test_ping PASSED
test_minitter.py::test_login PASSED
test_minitter.py::test_unauthorized PASSED
test_minitter.py::test_tweet PASSED
test_minitter.py::test_follow PASSED
test_minitter.py::test_unfollow PASSED

================================================== 6 passed in 11.87s ==================================================

위와 같이 깔끔하게 나오면 됩니다.
teardown_function 함수로 test시작 전/후에 실행시킵니다. 내용은 DB 초기화 입니다.

깔끔한 파이썬 탄탄한 백엔드 -7-

jmkim87 — Thu, 3 Sep 2020 22:47:39 +0900

7. 인증

인증은 private api와 같은 사용자를 제한해야하는 api에서 필요하며, public api와 같은 경우 사용 횟수 제한이나 남용 방지등을 위해 쓰입니다.

인증 흐름

인증을 생성 및 사용 방법은 대략적으로 아래와 같습니다.

회원 가입을 진행할때 api에 id/pw를 api에 보냅니다.
회원 가입 api에서 id/pw를 체크하고 별 문제 없으면 DB에 저장합니다. 이때 id는 그대로 저장하며 pw는 암호화해서 저장합니다.
회원 가입이 완료 되면 로그인 합니다. 이때 들어온 id와 pw를 DB에 저장된 값과 비교합니다. (pw는 암호화한 후 암호화로 저장된 DB와 비교합니다.)
로그인이 OK가 되면 이때 access token을 만들어서 front-end에 전송합니다.
Front-end에서는 이제 API를 사용할 때 access-token을 같이 보내어 사용 가능한 사용자라는 것을 확인 시켜줍니다. access-token이 만료되지만 않으면 재로그인을 하지 않고 계속 token으로 통신이 가능합니다.

비밀번호 암호화

암호화에는 두가지 방식이 있습니다.

일반적으로 비밀번호를 암호화 할때는 단방향 암호화 방식을 사용합니다. 다만 md5나 sha1 같은 경우 rainbow table과 같은 hash table로 깨지기 쉽기 때문에 깨기 어렵게 하는 hash 알고리즘을 사용합니다.

여기서 사용할 것은 bcrypt 알고리즘입니다.

salting : 비밀번호에 랜덤 값을 더해서 해시화 (다만 salt에 쓰는 키값은 서버나 conf 파일 같은 곳에 저장되는 경우가 많기 때문에 서버 자체의 보안에 조심해야합니다.)
키 스트레칭(Key stretching) : 단방향 해시 값을 계산후 그 해시값을 또 해시하는 방법으로 여러번 반복 합니다.

참고 : https://namu.wiki/w/암호 알고리즘

JWT

access token을 만드는 방법은 다양하지만 여기서는 많이 쓰이는 JWT를 사용합니다.

구조
- header : 토큰 타입과 사용되는 해시 알고리즘을 지정합니다.
- payload : 실제로 서버 간에 전송하고자 하는 데이터 부분. 다만 base64로 암호화하는거라 민감한 데이터는 넣지 말아야 합니다.
- signature : BASE64URL 코드화된 header와 payload 그리고 JWT secret를 헤더에 지정된 암호 알고리즘으로 암호화하여 전송
  
  참고 : https://medium.com/sjk5766/jwt-json-web-token-소개-49e211c65b45

decorator 함수

우리는 http header에 access token이 있는지 특정 api에서 검사를 할 decorator를 만들어야 합니다. 다른 파일들처럼 decorator를 따로 작성합니다.

# decorator.py
import jwt
from api import *
from functools import wraps
from flask import request, Response, current_app, g

def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        access_token = request.headers.get('Authorization')
        if access_token is not None:
            try:
                payload = jwt.decode(access_token, current_app.config['JWT_SECRET_KEY'], 'HS256')
            except jwt.InvalidTokenError:
                payload = None

            if payload is None: return Response(status = 401)

            user_id = payload['user_id']
            g.user_id = user_id
            g.user = get_user(user_id) if user_id else None
        else:
            return Response(status=401)
        return f(*args, **kwargs)
    return decorated_function

Http header에 Authorization에 access token이 있는지 확인합니다.
없으면 401을 반환 합니다.
있으면 JWT로 decode하여 user_id값을 global로 설정합니다.

Authorization이 필요한 API에 decorator를 설정 합니다.

# app.py
@app.route('/tweet', methods=['POST'])
@login_required
def tweet():
    user_tweet = request.json
    user_tweet['id'] = g.user_id
    tweet = user_tweet['tweet']

    if len(tweet) > 300:
        return '300자를 초과했습니다.', 400

    insert_tweet(user_tweet)

    return '', 200

@app.route('/follow', methods=['POST'])
@login_required
def follow():
    payload = request.json
    payload['id'] = g.user_id

    insert_follow(payload)

    return '', 200

@app.route('/unfollow', methods=['POST'])
@login_required
def unfollow():
    payload = request.json
    payload['id'] = g.user_id

    insert_unfollow(payload)

    return '', 200

tweet, follow, unfollow에는 auth가 필요하기에 decorator를 설정합니다.

jam 블로그

LLM 추론 엔진 최적화: 효율성과 성능 향상을 위한 심층 분석

초보 개발자를 위한 MCP(Model Context Protocol) 가이드: Claude 플랫폼 활용 예제

MCP(Model Context Protocol)란 무엇인가?

MCP가 필요한 이유

MCP의 기본 작동 방식

MCP 실습 예제: Claude 플랫폼 활용하기

Claude 플랫폼에서의 MCP 활용법

마치며

[내돈내산] 똑똑한 사람은 어떻게 생각하고 질문하는가 – 사고력 실종의 시대, 앞서가는 사람의 생존 전략

책을 선택한 이유

추천 대상

책 소개

주요 문구

감상 및 느낀 점

총평 – 질문은 최고의 사고 훈련이자 AI 시대의 필수 역량!

구매한 곳

[내돈내산] 초역 부처의 말

책을 선택한 이유

추천 대상

책 소개

주요 문구

감상 및 느낀 점

총평 – 마음을 다스리는 데 도움을 주는 책!

구매한 곳

[내돈내산] 주식 투자 책: 비기너 편

부제 : 더 이상 미룰 수 없어서 시작했지만 뭐부터 해야 할지 몰라 고른 첫 번째 머니북

책을 선택한 이유

추천 대상

책 소개

주요 문구

감상 및 느낀 점

총평 – 주식 초보라면 꼭 읽어야 할 첫 번째 책!

[내돈내산] 트럼프 2.0 시대 – 트럼프의 재선과 세계 질서의 변화

책을 선택한 이유

추천 대상

책 소개

왜 미국인들은 다시 트럼프를 선택했을까?

트럼프 2기의 핵심 키워드

주요 소제목

감상 및 느낀 점

총평 – 트럼프 시대의 변화를 알고 싶다면 꼭 읽어야 할 책!

구매한 곳

[내돈내산] 디자인 구구단 – 디자인이 필요한 순간, ‘툭’ 튀어나오는 디자인 공식

책을 선택한 이유

추천 대상

책 소개​

주요 문구

감상 및 느낀 점

총평 – 누구에게나 추천하고 싶은 디자인 입문서!

구매한 곳

HTTP/3 (HTTP Protocol 발전 과정)

HTTP/3

HTTP Protocol 발전 과정

요약

HTTP/0.9

HTTP/1.0

HTTP/1.1

HTTP/2

HTTP/3

QUIC란?

TCP 단점

UDP 사용 이유

테스트 및 구축 방법

[괌] 여행 준비

1. 여행 준비물

주의사항

팁문화

대중교통

[강화 학습] 1990년 이후 강화학습 관련 모델이나 기법

[이미지 처리] 1990년 이후 이미지 관련 모델이나 기법

[자연어처리] 1990년 이후 자연어처리에 쓰인 모델이나 기법들

[React] React 18

주요 기능

결론

#3. Longest Substring Without Repeating Characters [Medium] [Javascript]

문제

#2. Add Two Numbers [Medium][Javascript]

문제

풀이

책 소개

`List 타입`: immutable 단반향 연결 리스트