Ver3.0 ๐ Kotlin์ ์คํ์ ๊ธฐ๋ฅ: ๋ฏธ๋์ ์ธ์ด ๋ฐ์ ๋ฐฉํฅ๊ณผ ๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ๋ชจ๋ ๊ฒ

๐ Kotlin์ ์คํ์ ๊ธฐ๋ฅ: ๋ฏธ๋์ ์ธ์ด ๋ฐ์ ๋ฐฉํฅ๊ณผ ๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ๋ชจ๋ ๊ฒ
์ฝํ๋ฆฐ์ด ์ค๋นํ๋ ํ์ ์ ์ธ ๊ธฐ๋ฅ๋ค์ ํํค์ณ๋ณด์!
์๋ , ์น๊ตฌ! ๐ ์ค๋์ ์ ๋ง ํฅ๋ฏธ์ง์งํ ์ฃผ์ ๋ฅผ ๊ฐ์ง๊ณ ์์ด. ๋ฐ๋ก Kotlin์ ์คํ์ ๊ธฐ๋ฅ๋ค์ด์ผ. ์ฝํ๋ฆฐ์ ์ฌ์ฉํ๊ณ ์๋ค๋ฉด, ํน์ ๊ด์ฌ์ด ์๋ค๋ฉด ์ด ๊ธ์ ์ ๋ง ๋์น๋ฉด ์ ๋ผ!
์ฝํ๋ฆฐ์ 2011๋ JetBrains๊ฐ ๊ณต๊ฐํ ์ดํ๋ก ์์ฒญ๋ ์ฑ์ฅ์ ๊ฑฐ๋ญํด์์ด. ํนํ 2017๋ ๊ตฌ๊ธ์ด ์๋๋ก์ด๋ ๊ณต์ ์ธ์ด๋ก ์ฑํํ๋ฉด์ ํญ๋ฐ์ ์ธ ์ธ๊ธฐ๋ฅผ ์ป์์ง. ํ์ง๋ง ์ฝํ๋ฆฐ ํ์ ์ฌ๊ธฐ์ ๋ฉ์ถ์ง ์์์ด. ๊ณ์ํด์ ์๋ก์ด ๊ธฐ๋ฅ๋ค์ ์คํํ๊ณ , ์ธ์ด๋ฅผ ์งํ์ํค๊ณ ์๊ฑฐ๋ . ๐ฑ
์ด ๊ธ์์๋ ์ฝํ๋ฆฐ์ ์คํ์ ๊ธฐ๋ฅ๋ค์ด ๋ฌด์์ธ์ง, ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง, ๊ทธ๋ฆฌ๊ณ ๋ฏธ๋์ ์ด๋ค ๋ฐฉํฅ์ผ๋ก ๋ฐ์ ํ ์ง ํจ๊ป ์ดํด๋ณผ ๊ฑฐ์ผ. ํ๋ก๊ทธ๋จ ๊ฐ๋ฐ์ ๊ด์ฌ ์๋ ์ฌ๋์ด๋ผ๋ฉด ๋๊ตฌ๋ ์ฝ๊ฒ ์ดํดํ ์ ์๋๋ก ์น๊ทผํ๊ฒ ์ค๋ช ํด์ค๊ฒ!
๐ฌ ์คํ์ ๊ธฐ๋ฅ์ด๋ ๋ฌด์์ผ๊น?
๋จผ์ ๊ธฐ๋ณธ๋ถํฐ ์ง๊ณ ๋์ด๊ฐ์. ์คํ์ ๊ธฐ๋ฅ(Experimental Features)์ด๋ ์ฝํ๋ฆฐ ์ธ์ด์ ์ ์์ผ๋ก ํฌํจ๋๊ธฐ ์ ์ ๊ฐ๋ฐ์๋ค์ด ๋ฏธ๋ฆฌ ์ฌ์ฉํด๋ณผ ์ ์๋๋ก ์ ๊ณต๋๋ ๊ธฐ๋ฅ๋ค์ด์ผ. ๐งช
์๊ฐํด๋ด. ์๋ก์ด ๊ธฐ๋ฅ์ ์ธ์ด์ ์ถ๊ฐํ๋ค๋ ๊ฑด ์์ฒญ๋ ์ฑ ์์ด ๋ฐ๋ฅด๋ ์ผ์ด์ผ. ํ๋ฒ ์ถ๊ฐ๋๋ฉด ์๋ง์ ๊ฐ๋ฐ์๋ค์ด ์ฌ์ฉํ๊ฒ ๋๊ณ , ๋์ค์ ๋ณ๊ฒฝํ๊ฑฐ๋ ์ ๊ฑฐํ๊ธฐ๊ฐ ๋งค์ฐ ์ด๋ ค์์ง๊ฑฐ๋ . ๊ทธ๋์ ์ฝํ๋ฆฐ ํ์ ์ ์คํ ์ ๊ทผ ๋ฐฉ์์ ํํ์ด.
๐ก ์คํ์ ๊ธฐ๋ฅ์ ํน์ง
โข ๋ถ์์ ์ฑ: API๊ฐ ๋ณ๊ฒฝ๋ ์ ์์ด
โข ํผ๋๋ฐฑ ์์ง: ์ค์ ์ฌ์ฉ ์ฌ๋ก๋ฅผ ํตํด ๊ฐ์ ์ ํ์
โข ๋ช
์์ ๋์: ์ฌ์ฉํ๋ ค๋ฉด ๋ช
์์ ์ผ๋ก opt-in ํด์ผ ํจ
โข ์งํ ๊ฐ๋ฅ์ฑ: ์ ์ ๊ธฐ๋ฅ์ผ๋ก ์น๊ฒฉ๋๊ฑฐ๋ ํ๊ธฐ๋ ์ ์์
์คํ์ ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ ค๋ฉด @OptIn ์ด๋
ธํ
์ด์
์ด๋ ์ปดํ์ผ๋ฌ ์ต์
์ ํตํด ๋ช
์์ ์ผ๋ก ๋์ํด์ผ ํด. ์ด๊ฑด "๋๋ ์ด ๊ธฐ๋ฅ์ด ๋ณ๊ฒฝ๋ ์ ์๋ค๋ ๊ฑธ ์๊ณ ์์ด!"๋ผ๊ณ ์ ์ธํ๋ ๊ฑฐ์ง. ๐
@OptIn(ExperimentalStdlibApi::class)
fun useExperimentalFeature() {
// ์คํ์ ๊ธฐ๋ฅ ์ฌ์ฉ
val result = someExperimentalFunction()
}
๐ฏ ์ฃผ์ ์คํ์ ๊ธฐ๋ฅ๋ค ์ดํด๋ณด๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ฝํ๋ฆฐ์ ์คํ์ ๊ธฐ๋ฅ๋ค์ ํ๋์ฉ ์ดํด๋ณด์! ๊ฐ ๊ธฐ๋ฅ์ด ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๊ณ ํ๋์ง, ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง ์์๋ณผ ๊ฑฐ์ผ. ๐
์ปจํ ์คํธ ๋ฆฌ์๋ฒ๋ ์ฝํ๋ฆฐ 1.6.20์์ ๋์ ๋ ์คํ์ ๊ธฐ๋ฅ์ด์ผ. ์ด๊ฑด ์ ๋ง ํ์ ์ ์ธ ๊ธฐ๋ฅ์ธ๋ฐ, ํจ์๋ ํ๋กํผํฐ๊ฐ ํน์ ์ปจํ ์คํธ์์๋ง ์ฌ์ฉ ๊ฐ๋ฅํ๋๋ก ๋ง๋ค ์ ์์ด.
๊ธฐ์กด์๋ ํ์ฅ ํจ์(Extension Function)๋ฅผ ์ฌ์ฉํด์ ํน์ ํ์ ์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ ์ ์์์ด. ํ์ง๋ง ์ฌ๋ฌ ์ปจํ ์คํธ๊ฐ ํ์ํ ๊ฒฝ์ฐ์๋ ์ ํ์ด ์์์ง. ์ปจํ ์คํธ ๋ฆฌ์๋ฒ๋ ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด!
// ๊ธฐ์กด ๋ฐฉ์์ ํ๊ณ
class LoggingContext {
fun log(message: String) { println("[LOG] $message") }
}
class DatabaseContext {
fun query(sql: String): List = listOf("data")
}
// Context Receivers ์ฌ์ฉ
context(LoggingContext, DatabaseContext)
fun performDatabaseOperation() {
log("Starting database operation")
val results = query("SELECT * FROM users")
log("Operation completed with ${results.size} results")
}
๋ณด๋ค์ํผ, context ํค์๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ฌ๋ฌ ์ปจํ ์คํธ๋ฅผ ๋์์ ์๊ตฌํ ์ ์์ด. ์ด๊ฑด ์์กด์ฑ ์ฃผ์ (Dependency Injection) ํจํด์ ๋ ๊น๋ํ๊ฒ ๊ตฌํํ ์ ์๊ฒ ํด์ฃผ์ง! ๐จ
๐ ์ค์ฉ์ ์ธ ํ์ฉ ์ฌ๋ก
์ปจํ ์คํธ ๋ฆฌ์๋ฒ๋ ํนํ DSL(Domain Specific Language) ๊ตฌ์ถ, ๋ก๊น ์์คํ , ํธ๋์ญ์ ๊ด๋ฆฌ ๋ฑ์์ ๋น์ ๋ฐํด. ์ฝ๋์ ๊ฐ๋ ์ฑ์ ๋์ด๋ฉด์๋ ํ์ ์์ ์ฑ์ ์ ์งํ ์ ์๊ฑฐ๋ !
์ธ๋ผ์ธ ํด๋์ค๋ ์ฝํ๋ฆฐ 1.3์์ ์คํ์ ์ผ๋ก ๋์ ๋์๊ณ , ์ดํ Value Classes๋ก ์งํํ์ด. ์ด ๊ธฐ๋ฅ์ ์ฑ๋ฅ ์ต์ ํ์ ํ์ ์์ ์ฑ์ ๋์์ ๋ฌ์ฑํ๋ ค๋ ๋ชฉ์ ์ผ๋ก ๋ง๋ค์ด์ก์ง. ๐ช
๊ธฐ๋ณธ ์์ด๋์ด๋ ๊ฐ๋จํด. ์๋ก์ด ํ์ ์ ๋ง๋ค๋, ๋ฐํ์์๋ ์ถ๊ฐ์ ์ธ ๊ฐ์ฒด ์์ฑ ์ค๋ฒ๏ฟฝ๋ ์์ด ์์ ๊ฐ์ฒ๋ผ ๋์ํ๊ฒ ํ๋ ๊ฑฐ์ผ.
@JvmInline
value class UserId(val value: Long)
@JvmInline
value class Email(val value: String) {
init {
require(value.contains("@")) { "Invalid email format" }
}
}
fun sendEmail(userId: UserId, email: Email) {
// ํ์
์์ ์ฑ ํ๋ณด!
// UserId์ Email์ ํผ๋ํ ์ ์์
}
// ์ฌ์ฉ ์์
val user = UserId(12345L)
val email = Email("user@example.com")
sendEmail(user, email)
// sendEmail(email, user) // ์ปดํ์ผ ์๋ฌ!
์ด ๊ธฐ๋ฅ์ ์ฅ์ ์ ๋ช ํํด. ๊ธฐ๋ณธ ํ์ (Long, String ๋ฑ)์ ๋ํํ๋ฉด์๋ ๋ฐํ์ ์ฑ๋ฅ ์์ค์ด ๊ฑฐ์ ์์ด. ๋์์ ํ์ ์์คํ ์ ํตํด ์ค์๋ฅผ ๋ฐฉ์งํ ์ ์์ง! ๐ก๏ธ
Contracts๋ ์ฝํ๋ฆฐ 1.3์์ ๋์ ๋ ์คํ์ ๊ธฐ๋ฅ์ผ๋ก, ํจ์์ ๋์์ ์ปดํ์ผ๋ฌ์๊ฒ ๋ ๋ช ํํ๊ฒ ์๋ ค์ฃผ๋ ๋ฉ์ปค๋์ฆ์ด์ผ. ์ด๋ฅผ ํตํด ์ปดํ์ผ๋ฌ๊ฐ ๋ ๋๋ํ ํ์ ์ถ๋ก ๊ณผ ์ค๋งํธ ์บ์คํ ์ ํ ์ ์๊ฒ ๋ผ. ๐ง
import kotlin.contracts.*
fun String?.isNotNullOrEmpty(): Boolean {
contract {
returns(true) implies (this@isNotNullOrEmpty != null)
}
return this != null && this.isNotEmpty()
}
fun processString(input: String?) {
if (input.isNotNullOrEmpty()) {
// ์ฌ๊ธฐ์ input์ ์๋์ผ๋ก non-null๋ก ์ค๋งํธ ์บ์คํ
๋จ
println(input.length) // null ์ฒดํฌ ์์ด ์ฌ์ฉ ๊ฐ๋ฅ!
}
}
Contracts๋ฅผ ์ฌ์ฉํ๋ฉด ์ปค์คํ ๊ฒ์ฆ ํจ์๋ฅผ ๋ง๋ค ๋ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํจ์๋ค์ฒ๋ผ ์ค๋งํธ ์บ์คํ ์ด ์๋ํ๊ฒ ๋ง๋ค ์ ์์ด. ์ฝ๋๊ฐ ํจ์ฌ ๊น๋ํด์ง์ง! โจ
๐ Contract์ ์ฃผ์ ์ ํ
โข returns(value) implies (condition): ํน์ ๊ฐ์ ๋ฐํํ ๋์ ์กฐ๊ฑด
โข returnsNotNull() implies (condition): null์ด ์๋ ๊ฐ์ ๋ฐํํ ๋์ ์กฐ๊ฑด
โข callsInPlace: ๋๋ค๊ฐ ํธ์ถ๋๋ ํ์์ ์์ ๋ช
์
Kotlin Multiplatform Mobile์ iOS์ Android ์ฑ์์ ๋น์ฆ๋์ค ๋ก์ง์ ๊ณต์ ํ ์ ์๊ฒ ํด์ฃผ๋ ๊ธฐ์ ์ด์ผ. 2020๋ ์ํ ๋ฒ์ ์ผ๋ก ์์ํด์ ํ์ฌ๋ ๋ฒ ํ ๋จ๊ณ์ ์์ด. ๐ฑ
์ด ๊ธฐ๋ฅ์ "Write Once, Run Anywhere"์ ํ๋์ ํด์์ด๋ผ๊ณ ๋ณผ ์ ์์ด. ํ์ง๋ง React Native๋ Flutter์ฒ๋ผ UI๊น์ง ๊ณต์ ํ๋ ๊ฒ ์๋๋ผ, ๋น์ฆ๋์ค ๋ก์ง๋ง ๊ณต์ ํ๊ณ UI๋ ๊ฐ ํ๋ซํผ์ ๋ค์ดํฐ๋ธ ๊ธฐ์ ์ ์ฌ์ฉํ๋ ๊ฑฐ์ง.
// ๊ณตํต ์ฝ๋ (commonMain)
expect class Platform() {
val name: String
}
fun getPlatformName(): String {
return "Hello, ${Platform().name}!"
}
// Android ๊ตฌํ (androidMain)
actual class Platform {
actual val name: String = "Android ${android.os.Build.VERSION.SDK_INT}"
}
// iOS ๊ตฌํ (iosMain)
actual class Platform {
actual val name: String = UIDevice.currentDevice.systemName() + " " +
UIDevice.currentDevice.systemVersion
}
expect/actual ๋ฉ์ปค๋์ฆ์ ํตํด ํ๋ซํผ๋ณ ๊ตฌํ์ ์ ๊ณตํ๋ฉด์๋ ๊ณตํต ์ธํฐํ์ด์ค๋ฅผ ์ ์งํ ์ ์์ด. ์ ๋ง ๋๋ํ์ง? ๐ค
kotlinx.serialization์ ์ฝํ๋ฆฐ ๊ฐ์ฒด๋ฅผ JSON, ProtoBuf, CBOR ๋ฑ ๋ค์ํ ํ์์ผ๋ก ๋ณํํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ. ์ปดํ์ผ๋ฌ ํ๋ฌ๊ทธ์ธ์ ํ์ฉํด์ ๋ฆฌํ๋ ์ ์์ด ๋น ๋ฅธ ์ฑ๋ฅ์ ์ ๊ณตํด. โก
import kotlinx.serialization.*
import kotlinx.serialization.json.*
@Serializable
data class User(
val id: Long,
val name: String,
val email: String,
@SerialName("is_active")
val isActive: Boolean = true
)
fun main() {
val user = User(1, "๊น์ฝํ๋ฆฐ", "kotlin@example.com")
// ๊ฐ์ฒด โ JSON
val jsonString = Json.encodeToString(user)
println(jsonString)
// {"id":1,"name":"๊น์ฝํ๋ฆฐ","email":"kotlin@example.com","is_active":true}
// JSON โ ๊ฐ์ฒด
val deserializedUser = Json.decodeFromString(jsonString)
println(deserializedUser)
}
์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ฅ์ ์ ํ์ ์์ ์ฑ๊ณผ ์ฑ๋ฅ์ด์ผ. ์ปดํ์ผ ํ์์ ์ง๋ ฌํ ์ฝ๋๊ฐ ์์ฑ๋๊ธฐ ๋๋ฌธ์ ๋ฐํ์ ์ค๋ฒํค๋๊ฐ ๊ฑฐ์ ์๊ณ , ์๋ชป๋ ํ์ ๋ณํ์ ์ปดํ์ผ ์์ ์ ์ก์๋ผ ์ ์์ด! ๐ฏ
๐ฎ ๋ฏธ๋์ ๋ฐ์ ๋ฐฉํฅ
์, ์ด์ ์ ๋ง ํฅ๋ฏธ๋ก์ด ๋ถ๋ถ์ด์ผ. ์ฝํ๋ฆฐ์ด ์์ผ๋ก ์ด๋ค ๋ฐฉํฅ์ผ๋ก ๋ฐ์ ํ ์ง ์ดํด๋ณด์! ์ด๊ฑด ๋จ์ํ ์ถ์ธก์ด ์๋๋ผ KEEP(Kotlin Evolution and Enhancement Process) ๋ฌธ์์ ๊ณต์ ๋ก๋๋งต์ ๊ธฐ๋ฐ์ผ๋ก ํ ๋ด์ฉ์ด์ผ. ๐บ๏ธ
์ฝํ๋ฆฐ ํ์ ํ์ ์์คํ ์ ๋์ฑ ๊ฐ๋ ฅํ๊ฒ ๋ง๋ค๊ธฐ ์ํด ๋ ธ๋ ฅํ๊ณ ์์ด. ํนํ Union Types์ Intersection Types ๊ฐ์ ๊ณ ๊ธ ํ์ ๊ธฐ๋ฅ๋ค์ด ๋ ผ์๋๊ณ ์์ง.
// ๋ฏธ๋์ ๊ฐ๋ฅํ ์ ์๋ Union Types ์์
fun processValue(value: String | Int) {
when (value) {
is String -> println("๋ฌธ์์ด: $value")
is Int -> println("์ ์: $value")
}
}
// Intersection Types ์์
interface Drawable {
fun draw()
}
interface Clickable {
fun click()
}
fun handleElement(element: Drawable & Clickable) {
element.draw()
element.click()
}
์ด๋ฐ ๊ธฐ๋ฅ๋ค์ด ์ถ๊ฐ๋๋ฉด ํ์ ์์ ์ฑ์ด ๋์ฑ ํฅ์๋๊ณ , ๋ ํํ๋ ฅ ์๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๊ฒ ๋ ๊ฑฐ์ผ! ๐จ
์ฝํ๋ฆฐ์ ๊ณ์ํด์ ์ฑ๋ฅ ์ต์ ํ์ ์ง์คํ๊ณ ์์ด. ํนํ ๋ค์ ์์ญ๋ค์ด ์ฃผ๋ชฉ๋ฐ๊ณ ์์ง:
| ์์ญ | ๋ชฉํ | ์์ ํจ๊ณผ |
|---|---|---|
| ์ปดํ์ผ ์๋ | ์ฆ๋ถ ์ปดํ์ผ ๊ฐ์ | ๊ฐ๋ฐ ์์ฐ์ฑ ํฅ์ |
| ๋ฐํ์ ์ฑ๋ฅ | ์ธ๋ผ์ธ ์ต์ ํ ๊ฐํ | ์คํ ์๋ ๊ฐ์ |
| ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ | ๊ฐ์ฒด ํ ๋น ์ต์ํ | GC ์๋ ฅ ๊ฐ์ |
| ์ฝ๋ฃจํด | ์ค์ผ์ค๋ง ์๊ณ ๋ฆฌ์ฆ ๊ฐ์ | ๋์์ฑ ์ฒ๋ฆฌ ํจ์จ ์ฆ๋ |
Kotlin Multiplatform์ ๋จ์ํ ๋ชจ๋ฐ์ผ์ ๋์ด์ ๋ ๋ง์ ํ๋ซํผ์ผ๋ก ํ์ฅ๋๊ณ ์์ด. ์น์ด์ ๋ธ๋ฆฌ(WebAssembly), ์๋ฒ์ฌ์ด๋, ๋ฐ์คํฌํฑ ์ ํ๋ฆฌ์ผ์ด์ ๊น์ง ์ฝํ๋ฆฐ์ผ๋ก ๊ฐ๋ฐํ ์ ์๊ฒ ๋๋ ๊ฑฐ์ง! ๐
๐ฏ ๋ฉํฐํ๋ซํผ ๋ก๋๋งต
โข Kotlin/Wasm: WebAssembly ํ๊ฒ ์ง์ ๊ฐํ
โข Kotlin/Native: ๋ค์ดํฐ๋ธ ํ๋ซํผ ์ฑ๋ฅ ๊ฐ์
โข Compose Multiplatform: UI ํ๋ ์์ํฌ ํ์ฅ
โข ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํ๊ณ: ๋ฉํฐํ๋ซํผ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฆ๊ฐ
์ต๊ทผ AI์ ๋จธ์ ๋ฌ๋์ด ๋์ธ์์? ์ฝํ๋ฆฐ๋ ์ด ํ๋ฆ์ ๋ฐ๋ง์ถฐ ๋๊ฐ๊ณ ์์ด. KotlinDL(Kotlin Deep Learning) ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ๋ฐ์ ํ๊ณ ์๊ณ , TensorFlow์์ ํตํฉ๋ ๊ฐ์ ๋๊ณ ์์ง. ๐ง
// KotlinDL ์ฌ์ฉ ์์
val model = Sequential.of(
Input(784),
Dense(300, activation = Activations.Relu),
Dense(100, activation = Activations.Relu),
Dense(10, activation = Activations.Linear)
)
model.use {
it.compile(
optimizer = Adam(),
loss = Losses.SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS,
metric = Metrics.ACCURACY
)
it.fit(
dataset = trainDataset,
epochs = 10,
batchSize = 100
)
}
๐ผ ์ค๋ฌด์์ ์คํ์ ๊ธฐ๋ฅ ํ์ฉํ๊ธฐ
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค๋ฌด์์ ์ด๋ป๊ฒ ํ์ฉํ ์ ์๋์ง ์์๋ณด์! ์คํ์ ๊ธฐ๋ฅ์ ํ๋ก์ ํธ์ ๋์ ํ ๋๋ ์ ์คํด์ผ ํด. ๋ช ๊ฐ์ง ์ค์ฉ์ ์ธ ๊ฐ์ด๋๋ผ์ธ์ ๊ณต์ ํ ๊ฒ. ๐
โ ๏ธ ์ฃผ์์ฌํญ
1. ํ๋ก์ ํธ ๊ท๋ชจ ๊ณ ๋ ค
์์ ํ๋ก์ ํธ๋ ํ๋กํ ํ์
์์๋ ์คํ์ ๊ธฐ๋ฅ์ ์์ ๋กญ๊ฒ ์ฌ์ฉํด๋ ๊ด์ฐฎ์. ํ์ง๋ง ๋๊ท๋ชจ ํ๋ก๋์
์ฝ๋๋ฒ ์ด์ค์์๋ ์ ์คํด์ผ ํด.
2. ํ ํฉ์
ํ์ ๋ชจ๋๊ฐ ์คํ์ ๊ธฐ๋ฅ์ ํน์ฑ์ ์ดํดํ๊ณ ๋์ํด์ผ ํด. ๋์ค์ API๊ฐ ๋ณ๊ฒฝ๋๋ฉด ํจ๊ป ๋์ํด์ผ ํ๊ฑฐ๋ .
3. ๋ง์ด๊ทธ๋ ์ด์
๊ณํ
์คํ์ ๊ธฐ๋ฅ์ด ๋ณ๊ฒฝ๋๊ฑฐ๋ ์ ๊ฑฐ๋ ๊ฒฝ์ฐ๋ฅผ ๋๋นํ ๋ง์ด๊ทธ๋ ์ด์
๊ณํ์ ์ธ์๋ฌ.
์๋๋ฆฌ์ค 1: ๋ด๋ถ ๋๊ตฌ ๊ฐ๋ฐ
ํ์ฌ ๋ด๋ถ์์ ์ฌ์ฉํ๋ ๋๊ตฌ๋ ์คํฌ๋ฆฝํธ๋ฅผ ๊ฐ๋ฐํ ๋๋ ์คํ์ ๊ธฐ๋ฅ์ ์ ๊ทน ํ์ฉํด๋ ์ข์. ์ฌ์ฉ์๊ฐ ์ ํ์ ์ด๊ณ , ํ์ํ๋ฉด ๋น ๋ฅด๊ฒ ์์ ํ ์ ์๊ฑฐ๋ . ๐ ๏ธ
์๋๋ฆฌ์ค 2: ์๋ก์ด ํ๋ก์ ํธ ์์
์์ ํ ์๋ก์ด ํ๋ก์ ํธ๋ฅผ ์์ํ๋ค๋ฉด, ์คํ์ ๊ธฐ๋ฅ์ ์๋ํด๋ณผ ์ข์ ๊ธฐํ์ผ. ๋ ๊ฑฐ์ ์ฝ๋์ ๋ํ ๋ถ๋ด์ด ์์ผ๋๊น!
์๋๋ฆฌ์ค 3: ๊ฒฉ๋ฆฌ๋ ๋ชจ๋
์ ์ฒด ํ๋ก์ ํธ๊ฐ ์๋๋ผ ํน์ ๋ชจ๋์๋ง ์คํ์ ๊ธฐ๋ฅ์ ์ ์ฉํ๋ ๊ฒ๋ ์ข์ ์ ๋ต์ด์ผ. ๋ฌธ์ ๊ฐ ์๊ฒจ๋ ์ํฅ ๋ฒ์๋ฅผ ์ ํํ ์ ์์ง.
// build.gradle.kts
kotlin {
sourceSets {
val experimentalModule by creating {
dependencies {
// ์คํ์ ๊ธฐ๋ฅ ์ฌ์ฉ
}
}
val stableModule by creating {
dependencies {
// ์์ ์ ์ธ API๋ง ์ฌ์ฉ
}
}
}
}
๐ ํ์ต ๋ฆฌ์์ค์ ์ปค๋ฎค๋ํฐ
์ฝํ๋ฆฐ์ ์คํ์ ๊ธฐ๋ฅ์ ์ ๋๋ก ํ์ฉํ๋ ค๋ฉด ๊ณ์ ํ์ตํ๊ณ ์ปค๋ฎค๋ํฐ์ ์ํตํด์ผ ํด. ์ฌ๊ธฐ ์ ์ฉํ ๋ฆฌ์์ค๋ค์ ์ ๋ฆฌํด๋ดค์ด! ๐
๐ ๊ณต์ ๋ฆฌ์์ค
โข Kotlin ๊ณต์ ๋ฌธ์: kotlinlang.org์์ ์ต์ ์ ๋ณด ํ์ธ
โข KEEP ์ ์ฅ์: GitHub์์ ์ ์์ ์ฝ๊ธฐ
โข Kotlin Blog: ๊ณต์ ๋ธ๋ก๊ทธ์์ ์
๋ฐ์ดํธ ์์ ๋ฐ๊ธฐ
โข YouTrack: ์ด์ ํธ๋์ปค์์ ๋ฒ๊ทธ ๋ฆฌํฌํธ ๋ฐ ๊ธฐ๋ฅ ์์ฒญ
๐ก ์ปค๋ฎค๋ํฐ ์ฐธ์ฌ ํ
์ฝํ๋ฆฐ ์ปค๋ฎค๋ํฐ๋ ์ ๋ง ํ๋ฐํด! Kotlin Slack, Reddit์ r/Kotlin, Stack Overflow ๋ฑ์์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ์ํตํ ์ ์์ด. ์คํ์ ๊ธฐ๋ฅ์ ๋ํ ๊ฒฝํ์ ๊ณต์ ํ๊ณ , ๋ฌธ์ ๋ฅผ ํจ๊ป ํด๊ฒฐํ๋ ๊ฒ ํฐ ๋์์ด ๋ผ.
๊ทธ๋ฆฌ๊ณ ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ฝํ๋ฆฐ ์ ๋ฌธ๊ฐ๋ค๊ณผ ์ฐ๊ฒฐ๋ ์๋ ์์ด. ์ค๋ฌด ๊ฒฝํ์ด ํ๋ถํ ๊ฐ๋ฐ์์๊ฒ ๋ฉํ ๋ง์ ๋ฐ๊ฑฐ๋, ํ๋ก์ ํธ์ ๋ํ ์กฐ์ธ์ ๊ตฌํ ์ ์์ง. ํผ์ ๊ณ ๋ฏผํ์ง ๋ง๊ณ ์ปค๋ฎค๋ํฐ์ ํ์ ํ์ฉํด๋ด! ๐ค
๐ง ์ค์ ์์ : ์คํ์ ๊ธฐ๋ฅ์ผ๋ก ๋ฌธ์ ํด๊ฒฐํ๊ธฐ
์ด๋ก ๋ง ๋ฐฐ์ฐ๋ฉด ์ฌ๋ฏธ์์์? ์ค์ ๋ก ์คํ์ ๊ธฐ๋ฅ์ ์ฌ์ฉํด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์์ ๋ฅผ ์ดํด๋ณด์! ๐ช
๋ง์ ํ๋ก์ ํธ์์ ๋ก๊น ์ ํ์์ ์ด์ง๋ง, ๋ก๊ฑฐ๋ฅผ ๋งค๋ฒ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌํ๊ฑฐ๋ ์ ์ญ ๋ณ์๋ก ์ฌ์ฉํ๋ ๊ฑด ์ข์ง ์์. Context Receivers๋ฅผ ์ฌ์ฉํ๋ฉด ์ด ๋ฌธ์ ๋ฅผ ์ฐ์ํ๊ฒ ํด๊ฒฐํ ์ ์์ด!
// ๋ก๊น
์ปจํ
์คํธ ์ ์
interface Logger {
fun info(message: String)
fun error(message: String, throwable: Throwable? = null)
fun debug(message: String)
}
class ConsoleLogger : Logger {
override fun info(message: String) = println("[INFO] $message")
override fun error(message: String, throwable: Throwable?) =
println("[ERROR] $message ${throwable?.message ?: ""}")
override fun debug(message: String) = println("[DEBUG] $message")
}
// Context Receivers ํ์ฉ
context(Logger)
fun processUserData(userId: String) {
info("์ฌ์ฉ์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ ์์: $userId")
try {
// ๋ฐ์ดํฐ ์ฒ๋ฆฌ ๋ก์ง
val userData = fetchUserData(userId)
debug("๋ฐ์ดํฐ ์กฐํ ์๋ฃ: ${userData.size} ํญ๋ชฉ")
validateData(userData)
info("๋ฐ์ดํฐ ๊ฒ์ฆ ์๋ฃ")
} catch (e: Exception) {
error("๋ฐ์ดํฐ ์ฒ๋ฆฌ ์คํจ", e)
throw e
}
}
context(Logger)
fun fetchUserData(userId: String): List {
debug("๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฟผ๋ฆฌ ์คํ")
return listOf("data1", "data2", "data3")
}
context(Logger)
fun validateData(data: List) {
debug("๋ฐ์ดํฐ ๊ฒ์ฆ ์์")
require(data.isNotEmpty()) { "๋ฐ์ดํฐ๊ฐ ๋น์ด์์ต๋๋ค" }
}
// ์ฌ์ฉ ์์
fun main() {
with(ConsoleLogger()) {
processUserData("user123")
}
}
๋ณด๋ค์ํผ, ๋ก๊ฑฐ๋ฅผ ๋ช ์์ ์ผ๋ก ์ ๋ฌํ์ง ์์๋ ๋ชจ๋ ํจ์์์ ์์ฐ์ค๋ฝ๊ฒ ์ฌ์ฉํ ์ ์์ด. ์ฝ๋๊ฐ ํจ์ฌ ๊น๋ํด์ง์ง? โจ
๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๋ค๋ฃฐ ๋ ID๋ฅผ ํผ๋ํ๋ ์ค์๋ ์ ๋ง ํํด. Value Classes๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฐ ์ค์๋ฅผ ์ปดํ์ผ ํ์์ ์ก์ ์ ์์ด!
@JvmInline
value class UserId(val value: Long) {
init {
require(value > 0) { "User ID๋ ์์์ฌ์ผ ํฉ๋๋ค" }
}
}
@JvmInline
value class OrderId(val value: Long) {
init {
require(value > 0) { "Order ID๋ ์์์ฌ์ผ ํฉ๋๋ค" }
}
}
@JvmInline
value class ProductId(val value: Long) {
init {
require(value > 0) { "Product ID๋ ์์์ฌ์ผ ํฉ๋๋ค" }
}
}
// ๋ฐ์ดํฐ ํด๋์ค๋ค
data class User(val id: UserId, val name: String)
data class Order(val id: OrderId, val userId: UserId, val productId: ProductId)
data class Product(val id: ProductId, val name: String, val price: Double)
// ์๋น์ค ๋ ์ด์ด
class OrderService {
fun createOrder(userId: UserId, productId: ProductId): Order {
// ํ์
์์ ์ฑ ๋ณด์ฅ!
val orderId = OrderId(generateOrderId())
return Order(orderId, userId, productId)
}
fun getOrdersByUser(userId: UserId): List {
// userId๋ฅผ ๋ค๋ฅธ ID ํ์
๊ณผ ํผ๋ํ ์ ์์
return database.findOrders(userId)
}
private fun generateOrderId(): Long = System.currentTimeMillis()
}
// ์ปดํ์ผ ์๋ฌ ์์
fun wrongUsage() {
val userId = UserId(123)
val productId = ProductId(456)
// โ ์ปดํ์ผ ์๋ฌ! ํ์
์ด ๋ง์ง ์์
// val order = Order(userId, productId, userId)
// โ
์ฌ๋ฐ๋ฅธ ์ฌ์ฉ
val orderId = OrderId(789)
val order = Order(orderId, userId, productId)
}
์ด๋ ๊ฒ ํ๋ฉด Long ํ์ ์ ID๋ค์ ํผ๋ํ๋ ์ค์๋ฅผ ์์ ํ ๋ฐฉ์งํ ์ ์์ด. ๊ฒ๋ค๊ฐ ๋ฐํ์ ์ค๋ฒํค๋๋ ์์ง! ๐ฏ
์ปค์คํ ๊ฒ์ฆ ๋ก์ง์ ๋ง๋ค ๋ Contracts๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋๊ฐ ํจ์ฌ ์์ฐ์ค๋ฌ์์ ธ.
import kotlin.contracts.*
// ๋ฌธ์์ด ๊ฒ์ฆ
fun String?.isValidEmail(): Boolean {
contract {
returns(true) implies (this@isValidEmail != null)
}
return this != null && this.contains("@") && this.contains(".")
}
fun String?.isValidPhoneNumber(): Boolean {
contract {
returns(true) implies (this@isValidPhoneNumber != null)
}
return this != null && this.matches(Regex("^\\d{3}-\\d{4}-\\d{4}$"))
}
// ์ปฌ๋ ์
๊ฒ์ฆ
fun List?.isNotNullOrEmpty(): Boolean {
contract {
returns(true) implies (this@isNotNullOrEmpty != null)
}
return this != null && this.isNotEmpty()
}
// ์ฌ์ฉ ์์
data class UserRegistration(
val email: String?,
val phone: String?,
val interests: List?
)
fun validateAndProcess(registration: UserRegistration) {
// ์ค๋งํธ ์บ์คํ
๋๋ถ์ null ์ฒดํฌ ๋ถํ์!
if (registration.email.isValidEmail()) {
println("์ด๋ฉ์ผ ๊ธธ์ด: ${registration.email.length}")
// registration.email์ ์๋์ผ๋ก non-null String์ผ๋ก ์ฒ๋ฆฌ๋จ
}
if (registration.phone.isValidPhoneNumber()) {
println("์ ํ๋ฒํธ: ${registration.phone.replace("-", "")}")
// registration.phone๋ non-null String
}
if (registration.interests.isNotNullOrEmpty()) {
println("๊ด์ฌ์ฌ ๊ฐ์: ${registration.interests.size}")
registration.interests.forEach { println("- $it") }
// registration.interests๋ non-null List
}
}
Contracts ๋๋ถ์ ๊ฒ์ฆ ํจ์๋ฅผ ํต๊ณผํ๋ฉด ์๋์ผ๋ก ์ค๋งํธ ์บ์คํ ์ด ๋์ด์ ์ฝ๋๊ฐ ํจ์ฌ ๊ฐ๊ฒฐํด์ ธ! ๐
โก ์ฑ๋ฅ ๊ณ ๋ ค์ฌํญ
์คํ์ ๊ธฐ๋ฅ์ ์ฌ์ฉํ ๋ ์ฑ๋ฅ๋ ์ค์ํ ๊ณ ๋ ค์ฌํญ์ด์ผ. ๊ฐ ๊ธฐ๋ฅ์ด ์ฑ๋ฅ์ ๋ฏธ์น๋ ์ํฅ์ ์์๋ณด์! ๐
| ๊ธฐ๋ฅ | ์ฑ๋ฅ ์ํฅ | ์ต์ ํ ํ |
|---|---|---|
| Context Receivers | ๊ฑฐ์ ์์ | ์ปดํ์ผ ํ์์ ์ฒ๋ฆฌ๋๋ฏ๋ก ๋ฐํ์ ์ค๋ฒํค๋ ์ต์ |
| Value Classes | ์์ | ์ธ๋ผ์ธ๋์ด ์์ ํ์ ์ฒ๋ผ ๋์, ๋ฐ์ฑ ์์ |
| Contracts | ์์ | ์ปดํ์ผ๋ฌ ์ต์ ํ์๋ง ์ฌ์ฉ, ๋ฐํ์ ์ฝ๋ ์์ฑ ์ ํจ |
| Serialization | ๋งค์ฐ ๋น ๋ฆ | ๋ฆฌํ๋ ์ ๋์ ์ฝ๋ ์์ฑ ์ฌ์ฉ |
| Multiplatform | ํ๋ซํผ ์์กด์ | ๊ฐ ํ๋ซํผ์ ์ต์ ํ๋ ์ฝ๋ ์์ฑ |
๐ก ์ฑ๋ฅ ์ธก์ ํ
์คํ์ ๊ธฐ๋ฅ์ ๋์ ํ ๋๋ ๋ฐ๋์ ๋ฒค์น๋งํฌ๋ฅผ ํด๋ด. Kotlin์ kotlinx.benchmark ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉด ์ ํํ ์ฑ๋ฅ ์ธก์ ์ด ๊ฐ๋ฅํด. ์ถ์ธกํ์ง ๋ง๊ณ ์ธก์ ํ์! ๐
// kotlinx.benchmark ์ฌ์ฉ ์์
@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
class ValueClassBenchmark {
@Benchmark
fun withValueClass(): UserId {
return UserId(12345L)
}
@Benchmark
fun withRegularClass(): RegularUserId {
return RegularUserId(12345L)
}
@Benchmark
fun withPrimitive(): Long {
return 12345L
}
}
// ๊ฒฐ๊ณผ: Value Class๋ primitive์ ๊ฑฐ์ ๋์ผํ ์ฑ๋ฅ!
๐จ ์คํ์ ๊ธฐ๋ฅ๊ณผ ๋์์ธ ํจํด
์คํ์ ๊ธฐ๋ฅ๋ค์ ๊ธฐ์กด์ ๋์์ธ ํจํด์ ๋ ์ฐ์ํ๊ฒ ๊ตฌํํ ์ ์๊ฒ ํด์ค. ๋ช ๊ฐ์ง ์์๋ฅผ ์ดํด๋ณด์! ๐๏ธ
Context Receivers๋ฅผ ์ฌ์ฉํ๋ฉด Builder ํจํด์ ๋ ํ์ ์์ ํ๊ฒ ๋ง๋ค ์ ์์ด.
// ์ ํต์ ์ธ Builder ํจํด
class Pizza private constructor(
val size: String,
val cheese: Boolean,
val pepperoni: Boolean,
val mushrooms: Boolean
) {
class Builder {
private var size: String = "Medium"
private var cheese: Boolean = false
private var pepperoni: Boolean = false
private var mushrooms: Boolean = false
fun size(size: String) = apply { this.size = size }
fun cheese() = apply { this.cheese = true }
fun pepperoni() = apply { this.pepperoni = true }
fun mushrooms() = apply { this.mushrooms = true }
fun build() = Pizza(size, cheese, pepperoni, mushrooms)
}
}
// Context Receivers๋ฅผ ํ์ฉํ ๊ฐ์ ๋ ๋ฒ์
interface PizzaBuilder {
var size: String
var cheese: Boolean
var pepperoni: Boolean
var mushrooms: Boolean
}
class PizzaBuilderImpl : PizzaBuilder {
override var size: String = "Medium"
override var cheese: Boolean = false
override var pepperoni: Boolean = false
override var mushrooms: Boolean = false
}
context(PizzaBuilder)
fun large() { size = "Large" }
context(PizzaBuilder)
fun addCheese() { cheese = true }
context(PizzaBuilder)
fun addPepperoni() { pepperoni = true }
context(PizzaBuilder)
fun addMushrooms() { mushrooms = true }
fun buildPizza(block: context(PizzaBuilder) () -> Unit): Pizza {
val builder = PizzaBuilderImpl()
with(builder) {
block()
return Pizza(size, cheese, pepperoni, mushrooms)
}
}
// ์ฌ์ฉ ์์
val myPizza = buildPizza {
large()
addCheese()
addPepperoni()
}
Value Classes๋ฅผ ์ฌ์ฉํ๋ฉด Strategy ํจํด์ ๋ ํจ์จ์ ์ผ๋ก ๊ตฌํํ ์ ์์ด.
// ๊ฒฐ์ ์ ๋ต์ Value Class๋ก ํํ
@JvmInline
value class PaymentStrategy(val process: (Double) -> Boolean) {
companion object {
val CreditCard = PaymentStrategy { amount ->
println("์ ์ฉ์นด๋๋ก $amount ์ ๊ฒฐ์ ")
true
}
val BankTransfer = PaymentStrategy { amount ->
println("๊ณ์ข์ด์ฒด๋ก $amount ์ ๊ฒฐ์ ")
true
}
val Cryptocurrency = PaymentStrategy { amount ->
println("์ํธํํ๋ก $amount ์ ๊ฒฐ์ ")
true
}
}
}
class PaymentProcessor {
fun processPayment(amount: Double, strategy: PaymentStrategy): Boolean {
return strategy.process(amount)
}
}
// ์ฌ์ฉ ์์
fun main() {
val processor = PaymentProcessor()
processor.processPayment(10000.0, PaymentStrategy.CreditCard)
processor.processPayment(20000.0, PaymentStrategy.BankTransfer)
// ์ปค์คํ
์ ๋ต๋ ์ฝ๊ฒ ์ถ๊ฐ
val customStrategy = PaymentStrategy { amount ->
println("์ปค์คํ
๊ฒฐ์ ๋ฐฉ์: $amount ์")
true
}
processor.processPayment(30000.0, customStrategy)
}
๐ ์ค์ ํ๋ก์ ํธ ์ฌ๋ก
์ด๋ก ๊ณผ ์์ ๋ ์ข์ง๋ง, ์ค์ ๋ก ์ด๋ค ํ๋ก์ ํธ๋ค์ด ์คํ์ ๊ธฐ๋ฅ์ ์ฌ์ฉํ๊ณ ์๋์ง ์์๋ณด๋ฉด ๋ ๋์์ด ๋ ๊ฑฐ์ผ! ๐ข
๐ ์ฃผ๋ชฉํ ๋งํ ํ๋ก์ ํธ๋ค
1. Ktor (์น ํ๋ ์์ํฌ)
Ktor๋ ์ฝํ๋ฆฐ์ผ๋ก ๋ง๋ ๋น๋๊ธฐ ์น ํ๋ ์์ํฌ์ผ. Context Receivers์ ์ฝ๋ฃจํด์ ์ ๊ทน ํ์ฉํด์ ๊น๋ํ API๋ฅผ ์ ๊ณตํ๊ณ ์์ด.
2. Exposed (๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ)
JetBrains์ SQL ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธ Exposed๋ DSL ๊ตฌ์ถ์ ์คํ์ ๊ธฐ๋ฅ๋ค์ ํ์ฉํ๊ณ ์์ด. ํ์
์์ ํ ์ฟผ๋ฆฌ ์์ฑ์ด ๊ฐ๋ฅํ์ง.
3. Arrow (ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ)
Arrow๋ ์ฝํ๋ฆฐ์ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ๊ฐ๋
์ ๋์
ํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ. Context Receivers๋ฅผ ์ฌ์ฉํด์ ๋ ์ฐ์ํ ํจ์ํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๊ฒ ํด์ค.
4. kotlinx.serialization
์์ ์ธ๊ธํ ์ง๋ ฌํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ปดํ์ผ๋ฌ ํ๋ฌ๊ทธ์ธ๊ณผ ์คํ์ ๊ธฐ๋ฅ๋ค์ ํ์ฉํด์ ๋์ ์ฑ๋ฅ์ ๋ฌ์ฑํ์ด.
๋ง์ ๊ธฐ์ ๋ค์ด ์ฝํ๋ฆฐ์ ์คํ์ ๊ธฐ๋ฅ์ ํ๋ก๋์ ์ ๋์ ํ๊ณ ์์ด. ๋ฌผ๋ก ์ ์คํ๊ฒ ์ ๊ทผํ์ง๋ง, ๊ทธ๋งํผ ๊ฐ์น๊ฐ ์๋ค๋ ๋ป์ด์ง! ๐ผ
Netflix๋ ์๋๋ก์ด๋ ์ฑ์์ ์ฝํ๋ฆฐ์ ์ ๊ทน ์ฌ์ฉํ๊ณ ์๊ณ , ์ผ๋ถ ์คํ์ ๊ธฐ๋ฅ๋ ํ ์คํธ ์ค์ด์ผ. ํนํ ๋ฉํฐํ๋ซํผ ๊ธฐ๋ฅ์ ๊ด์ฌ์ด ๋ง์.
Slack๋ ์๋๋ก์ด๋ ์ฑ์ ์ฝํ๋ฆฐ์ผ๋ก ์ฌ์์ฑํ๋ฉด์ ์ต์ ๊ธฐ๋ฅ๋ค์ ํ์ฉํ๊ณ ์์ด. ์ฝ๋ฃจํด๊ณผ Flow๋ฅผ ์ค์ฌ์ผ๋ก ์ํคํ ์ฒ๋ฅผ ๊ตฌ์ฑํ์ง.
Square๋ ์คํ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค(OkHttp, Retrofit ๋ฑ)์ ์ฝํ๋ฆฐ์ผ๋ก ๋ง์ด๊ทธ๋ ์ด์ ํ๋ฉด์ ์คํ์ ๊ธฐ๋ฅ๋ค์ ๊ฒํ ํ๊ณ ์์ด.
๐ฎ 2024๋ ์ดํ์ ์ ๋ง
์, ์ด์ ์ ๋ง ํฅ๋ฏธ์ง์งํ ๋ฏธ๋ ์ด์ผ๊ธฐ๋ฅผ ํด๋ณด์! ์ฝํ๋ฆฐ ํ์ด ์ค๋นํ๊ณ ์๋ ๊ฒ๋ค๊ณผ ์ปค๋ฎค๋ํฐ์ ๊ธฐ๋๋ฅผ ์ดํด๋ณผ๊ฒ. ๐
K2 ์ปดํ์ผ๋ฌ๋ ์ฝํ๋ฆฐ์ ์ฐจ์ธ๋ ์ปดํ์ผ๋ฌ์ผ. ์์ ํ ์๋ก ์์ฑ๋์๊ณ , ๋ค์๊ณผ ๊ฐ์ ๊ฐ์ ์ฌํญ๋ค์ ์ ๊ณตํด:
โก K2 ์ปดํ์ผ๋ฌ์ ์ฃผ์ ๊ฐ์ ์ฌํญ
โข ์ปดํ์ผ ์๋: ๊ธฐ์กด ๋๋น 2๋ฐฐ ์ด์ ๋น ๋ฅธ ์ปดํ์ผ
โข IDE ์ฑ๋ฅ: IntelliJ IDEA์์ ๋ ๋น ๋ฅธ ์ฝ๋ ๋ถ์
โข ํ์ฅ์ฑ: ์๋ก์ด ๊ธฐ๋ฅ ์ถ๊ฐ๊ฐ ๋ ์ฌ์์ง
โข ์ ํ์ฑ: ๋ ์ ํํ ํ์
์ถ๋ก ๊ณผ ์๋ฌ ๋ฉ์์ง
K2 ์ปดํ์ผ๋ฌ๊ฐ ์์ ํ๋๋ฉด ๋ ๋ง์ ์คํ์ ๊ธฐ๋ฅ๋ค์ด ๋น ๋ฅด๊ฒ ์ถ๊ฐ๋ ์ ์์ ๊ฑฐ์ผ. ์ธ์ด ๋ฐ์ ์๋๊ฐ ๊ฐ์ํ๋๋ ๊ฑฐ์ง! ๐
Kotlin/Wasm์ ์ ๋ง ์ฃผ๋ชฉํ ๋งํ ๊ธฐ์ ์ด์ผ. ์น ๋ธ๋ผ์ฐ์ ์์ ๋ค์ดํฐ๋ธ์ ๊ฐ๊น์ด ์ฑ๋ฅ์ผ๋ก ์ฝํ๋ฆฐ ์ฝ๋๋ฅผ ์คํํ ์ ์๊ฒ ํด์ฃผ๊ฑฐ๋ .
// Kotlin/Wasm ์์ (๋ฏธ๋ ์ฝ๋)
@WasmExport
fun fibonacci(n: Int): Int {
return if (n <= 1) n
else fibonacci(n - 1) + fibonacci(n - 2)
}
// JavaScript์์ ํธ์ถ ๊ฐ๋ฅ
// const result = await kotlinModule.fibonacci(10);
์ด๊ฒ ์์ ํ๋๋ฉด ํ๋ก ํธ์๋ ๊ฐ๋ฐ์์๋ ์ฝํ๋ฆฐ์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๊ฒ ๋ ๊ฑฐ์ผ. React, Vue ๊ฐ์ ํ๋ ์์ํฌ์์ ํตํฉ๋ ๊ธฐ๋๋๊ณ ์์ด! ๐
AI ์๋์ ๋ง์ถฐ ์ฝํ๋ฆฐ๋ ์งํํ๊ณ ์์ด. JetBrains๋ AI ์ด์์คํดํธ๋ฅผ IDE์ ํตํฉํ๊ณ ์๊ณ , ์ฝํ๋ฆฐ ์ฝ๋ ์์ฑ์ ํนํ๋ ๋ชจ๋ธ๋ค๋ ๊ฐ๋ฐ ์ค์ด์ผ.
๐ค AI์ ์ฝํ๋ฆฐ์ ์๋์ง
์ฝํ๋ฆฐ์ ๋ช ํํ ๋ฌธ๋ฒ๊ณผ ํ์ ์์คํ ์ AI๊ฐ ์ฝ๋๋ฅผ ์ดํดํ๊ณ ์์ฑํ๊ธฐ์ ์ ๋ฆฌํด. ์์ผ๋ก๋ ์์ฐ์ด๋ก ์๊ตฌ์ฌํญ์ ์ค๋ช ํ๋ฉด ์ฝํ๋ฆฐ ์ฝ๋๊ฐ ์๋์ผ๋ก ์์ฑ๋๋ ์๋๊ฐ ์ฌ ๊ฑฐ์ผ!
์ฝํ๋ฆฐ ํ์ ํ์ ์์คํ ์ ๊ณ์ ๊ฐ์ ํ๊ณ ์์ด. ๋ค์๊ณผ ๊ฐ์ ๊ธฐ๋ฅ๋ค์ด ๋ ผ์๋๊ณ ์์ง:
// ๋ฏธ๋์ ๊ฐ๋ฅํ ์ ์๋ ๊ธฐ๋ฅ๋ค
// 1. Union Types
fun process(value: String | Int | Boolean) {
when (value) {
is String -> println("๋ฌธ์์ด")
is Int -> println("์ ์")
is Boolean -> println("๋ถ๋ฆฐ")
}
}
// 2. Sealed Interfaces์ ํ์ฅ
sealed interface Result {
data class Success(val value: T) : Result
data class Error(val message: String) : Result
object Loading : Result
}
// 3. ๋ ๊ฐ๋ ฅํ ์ ๋ค๋ฆญ
fun List.sumOf(selector: (T) -> R): R {
// ์ ๋ค๋ฆญ ์ ์ฝ์ด ๋ ์ ์ฐํด์ง
}
// 4. Effect System (๋ถ์์ฉ ์ถ์ )
suspend fun fetchData(): String throws IOException {
// ํจ์๊ฐ ๋์ง ์ ์๋ ์์ธ๋ฅผ ํ์
์์คํ
์์ ์ถ์
}
๐ฏ ์ค๋ฌด ์ ์ฉ ๊ฐ์ด๋
์ด์ ๋ฐฐ์ด ๋ด์ฉ์ ์ค์ ํ๋ก์ ํธ์ ์ ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด๋ณด์! ๋จ๊ณ๋ณ๋ก ์ ๊ทผํ๋ฉด ์์ ํ๊ฒ ๋์ ํ ์ ์์ด. ๐
๋จผ์ ํ๋ก์ ํธ์ ์คํ์ ๊ธฐ๋ฅ์ด ์ ๋ง ํ์ํ์ง ํ๊ฐํด์ผ ํด.
โ ํ๊ฐ ์ฒดํฌ๋ฆฌ์คํธ
โก ํ์ฌ ์ฝ๋๋ฒ ์ด์ค์ ๋ฌธ์ ์ ์ด ๋ช
ํํ๊ฐ?
โก ์คํ์ ๊ธฐ๋ฅ์ด ๊ทธ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋๊ฐ?
โก ํ์๋ค์ด ์๋ก์ด ๊ธฐ๋ฅ์ ํ์ตํ ์๊ฐ์ด ์๋๊ฐ?
โก API ๋ณ๊ฒฝ์ ๋์ํ ์ ์๋ ์ฌ์ ๊ฐ ์๋๊ฐ?
โก ํ๋ก์ ํธ์ ์ค์๋์ ์ํ๋๋ ์ด๋ ์ ๋์ธ๊ฐ?
๋ณธ๊ฒฉ์ ์ผ๋ก ๋์ ํ๊ธฐ ์ ์ ์์ ๊ท๋ชจ๋ก ํ ์คํธํด๋ด.
// ํ์ผ๋ฟ ํ๋ก์ ํธ ๊ตฌ์กฐ ์์
project/
โโโ src/
โ โโโ main/
โ โ โโโ stable/ // ์์ ์ ์ธ ์ฝ๋
โ โ โโโ experimental/ // ์คํ์ ๊ธฐ๋ฅ ์ฌ์ฉ
โ โโโ test/
โ โโโ stable/
โ โโโ experimental/
โโโ build.gradle.kts
// build.gradle.kts์์ ์คํ์ ๊ธฐ๋ฅ ํ์ฑํ
kotlin {
sourceSets {
val experimental by creating {
kotlin.srcDir("src/main/experimental")
dependencies {
implementation(kotlin("stdlib"))
}
}
}
compilerOptions {
freeCompilerArgs.add("-opt-in=kotlin.ExperimentalStdlibApi")
freeCompilerArgs.add("-Xcontext-receivers")
}
}
ํ์ผ๋ฟ์ด ์ฑ๊ณต์ ์ด๋ฉด ์ ์ง์ ์ผ๋ก ํ๋ํด๋๊ฐ.
โ ๏ธ ์ฃผ์ํ ์
โข ํ ๋ฒ์ ํ๋์ ์คํ์ ๊ธฐ๋ฅ๋ง ๋์
ํ๊ธฐ
โข ์ถฉ๋ถํ ํ
์คํธ ์ปค๋ฒ๋ฆฌ์ง ํ๋ณดํ๊ธฐ
โข ๋ฌธ์ํ๋ฅผ ์ฒ ์ ํ ํ๊ธฐ
โข ํ ๋ด ์ง์ ๊ณต์ ์ธ์
์งํํ๊ธฐ
๋์ ํ์๋ ์ง์์ ์ผ๋ก ๋ชจ๋ํฐ๋งํ๊ณ ํผ๋๋ฐฑ์ ์์งํด์ผ ํด.
// ๋ฉํธ๋ฆญ ์์ง ์์
class ExperimentalFeatureMetrics {
private val usageCount = AtomicInteger(0)
private val errorCount = AtomicInteger(0)
fun recordUsage() {
usageCount.incrementAndGet()
}
fun recordError(error: Throwable) {
errorCount.incrementAndGet()
logger.error("์คํ์ ๊ธฐ๋ฅ ์๋ฌ", error)
}
fun getMetrics(): Map {
return mapOf(
"usage" to usageCount.get(),
"errors" to errorCount.get()
)
}
}
๐ ํ์ต ์๋ฃ์ ๋ค์ ๋จ๊ณ
์ฌ๊ธฐ๊น์ง ์ฝ์๋ค๋ฉด ์ ๋ง ๋๋จํด! ๐ ์ด์ ๋ ๊น์ด ํ์ตํ๊ณ ์ถ์ ํ ๋ฐ, ์ถ์ฒ ์๋ฃ๋ค์ ์ ๋ฆฌํด๋ดค์ด.
๐ ์ถ์ฒ ํ์ต ์๋ฃ
๊ณต์ ๋ฌธ์
โข Kotlin Language Documentation (kotlinlang.org)
โข KEEP Repository (github.com/Kotlin/KEEP)
โข Kotlin Blog (blog.jetbrains.com/kotlin)
์จ๋ผ์ธ ๊ฐ์
โข Kotlin for Java Developers (Coursera)
โข Advanced Kotlin Programming (Udemy)
โข Kotlin Multiplatform Mobile (JetBrains Academy)
์ฑ
โข "Kotlin in Action" - Dmitry Jemerov, Svetlana Isakova
โข "Effective Kotlin" - Marcin Moskaลa
โข "Kotlin Coroutines" - Marcin Moskaลa
๊ทธ๋ฆฌ๊ณ ํผ์ ๊ณต๋ถํ๊ธฐ ์ด๋ ต๋ค๋ฉด ์ฌ๋ฅ๋ท์์ ์ฝํ๋ฆฐ ์ ๋ฌธ๊ฐ๋ฅผ ์ฐพ์๋ณด๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ. ์ค๋ฌด ๊ฒฝํ์ด ํ๋ถํ ๊ฐ๋ฐ์์๊ฒ 1:1 ๋ฉํ ๋ง์ ๋ฐ์ผ๋ฉด ํจ์ฌ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ ์ ์๊ฑฐ๋ ! ๐ช
์ฝํ๋ฆฐ ์ปค๋ฎค๋ํฐ๋ ์ ๋ง ํ๋ฐํ๊ณ ์น์ ํด. ๋ค์ ์ฑ๋๋ค์ ์ถ์ฒํด:
๐ ์ปค๋ฎค๋ํฐ ์ฑ๋
โข Kotlin Slack: surveys.jetbrains.com/s3/kotlin-slack-sign-up
โข Reddit r/Kotlin: ์์ด๊ถ ๊ฐ๋ฐ์๋ค๊ณผ ์ํต
โข ํ๊ตญ ์ฝํ๋ฆฐ ์ฌ์ฉ์ ๊ทธ๋ฃน: ํ์ด์ค๋ถ ๊ทธ๋ฃน
โข Stack Overflow: kotlin ํ๊ทธ๋ก ์ง๋ฌธํ๊ธฐ
โข GitHub Discussions: Kotlin ์ ์ฅ์์์ ๋
ผ์ ์ฐธ์ฌ
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ ๋ง ๊ธด ์ฌ์ ์ด์์ง? ๐ ์ฝํ๋ฆฐ์ ์คํ์ ๊ธฐ๋ฅ๋ค์ ๋ํด ์ ๋ง ๋ง์ ๊ฑธ ๋ค๋ค์ด. ํ ๋ฒ ์ ๋ฆฌํด๋ณด์!
์ฐ๋ฆฌ๋ ๋ค์ ๋ด์ฉ๋ค์ ์ดํด๋ดค์ด:
โจ ์คํ์ ๊ธฐ๋ฅ์ ๊ฐ๋
: ์ ํ์ํ๊ณ , ์ด๋ป๊ฒ ์๋ํ๋์ง
๐ฌ ์ฃผ์ ๊ธฐ๋ฅ๋ค: Context Receivers, Value Classes, Contracts, Multiplatform, Serialization
๐ ๋ฏธ๋ ๋ฐฉํฅ: K2 ์ปดํ์ผ๋ฌ, WebAssembly, AI ํตํฉ, ํ์
์์คํ
๊ฐ์
๐ผ ์ค๋ฌด ์ ์ฉ: ํ๊ฐ, ํ์ผ๋ฟ, ํ๋, ๋ชจ๋ํฐ๋ง ์ ๋ต
๐ ํ์ต ์๋ฃ: ๊ณต์ ๋ฌธ์, ๊ฐ์, ์ฑ
, ์ปค๋ฎค๋ํฐ
์ฝํ๋ฆฐ์ ๊ณ์ ์งํํ๊ณ ์์ด. ์คํ์ ๊ธฐ๋ฅ๋ค์ ๊ทธ ์งํ์ ์ต์ ์ ์ด์ง. ๋ชจ๋ ๊ธฐ๋ฅ์ ๋น์ฅ ์ฌ์ฉํ ํ์๋ ์์ด. ํ์ง๋ง ์ด๋ค ๊ธฐ๋ฅ๋ค์ด ์๊ณ , ์ด๋ค ๋ฐฉํฅ์ผ๋ก ๋ฐ์ ํ๋์ง ์๋ ๊ฒ๋ง์ผ๋ก๋ ํฐ ๋์์ด ๋ผ. ๐ฑ
๐ก ํต์ฌ ๋ฉ์์ง
์คํ์ ๊ธฐ๋ฅ์ "์ํํ ๊ฒ"์ด ์๋๋ผ "๋ฏธ๋๋ฅผ ์ค๋นํ๋ ๊ฒ"์ด์ผ. ์ ์คํ๊ฒ ์ ๊ทผํ๋, ๋๋ ค์ํ์ง๋ ๋ง์. ์ฝํ๋ฆฐ ํ๊ณผ ์ปค๋ฎค๋ํฐ๊ฐ ํจ๊ป ๋ ๋์ ์ธ์ด๋ฅผ ๋ง๋ค์ด๊ฐ๊ณ ์์ผ๋๊น! ๐ค
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ ๋๊ตฌ์ผ ๋ฟ์ด์ผ. ์ค์ํ ๊ฑด ๊ทธ ๋๊ตฌ๋ก ๋ฌด์์ ๋ง๋๋๋์ง. ์ฝํ๋ฆฐ์ ์คํ์ ๊ธฐ๋ฅ๋ค์ ์ฐ๋ฆฌ๊ฐ ๋ ๋์ ์ํํธ์จ์ด๋ฅผ ๋ง๋ค ์ ์๋๋ก ๋์์ฃผ๋ ๊ฐ๋ ฅํ ๋๊ตฌ๋ค์ด์ผ. ๐ฑ๐ป๐
์ด ๊ธ์ด ๋์์ด ๋์๊ธฐ๋ฅผ ๋ฐ๋ผ! ๊ถ๊ธํ ์ ์ด ์๊ฑฐ๋ ๋ ๊น์ด ์๊ณ ์ถ์ ๋ด์ฉ์ด ์๋ค๋ฉด, ์ฝํ๋ฆฐ ์ปค๋ฎค๋ํฐ์ ์ฐธ์ฌํด์ ์ง๋ฌธํด๋ด. ๋ชจ๋๊ฐ ๊ธฐ๊บผ์ด ๋์์ค ๊ฑฐ์ผ. ๐
๊ทธ๋ผ, ์ฆ๊ฑฐ์ด ์ฝํ๋ฆฐ ์ฝ๋ฉ ๋๊ธธ! Happy Kotlin Coding! ๐๐
๐ ์ด ๊ธ์ด ๋์์ด ๋์๋์?
์ฝํ๋ฆฐ์ ์คํ์ ๊ธฐ๋ฅ์ผ๋ก ๋ ๋์ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์ธ์!
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.