


요즘, 𝕏 Blue 사용자들이 앱 아이콘을 변경할 수 있는 기능이 공지되었습니다. 이 기능은 Reddit 앱도 비슷한 기능을 제공하고 있습니다.

![이미지](/assets/img/2024-07-23-ChangingtheAndroidAppIconProgrammatically_0.png)

온라인에서 해결책을 찾는 것은 비교적 쉽습니다. 그러나 나에게 흥미로운 점은 이를 구현하는 방법을 묻는 사람들이 StackOverflow에 올리면서 받는 반응이었습니다. 대부분의 응답자들은 이게 불가능하다고 주장하지만, 우회 방법이 실제로 존재한다는 사실을 무시합니다.

# 우회 방법이 있다면, 그것은 불가능한 일이 아닙니다.

<div class="content-ad"></div>

![이미지](/assets/img/2024-07-23-ChangingtheAndroidAppIconProgrammatically_1.png)

이 해결책은 여러 해 동안 돌고 있습니다. 일부 사용자들은 특정 폰에서 문제가 발생했다고 보고했지만, 이 방법은 제게는 작동합니다. 그러므로 구현이 어렵지 않다는 점 때문에 여기에 공유하고 싶습니다.

## 작동 원리

AndroidManifest.xml에서 activity-alias 요소를 선언하여 여러 런처 아이콘을 생성할 수 있습니다. 앱 아이콘을 변경하는 효과는 현재 아이콘을 비활성화하고 새로운 아이콘을 활성화하여 달성됩니다.

<div class="content-ad"></div>

# AndroidManifest.xml에 앱 아이콘 정의하기

앱 아이콘을 프로그래밍적으로 변경하려고 노력하지만, 여전히 미리 정의된 일련의 아이콘을 하드코딩해야 합니다. 이를 통해 우리는 프로그래밍적으로 그들 사이를 전환할 수 있게 됩니다. 예를 들어, 다음 코드는 기본 아이콘 외에 세 개의 추가 런처 아이콘을 생성합니다.

주의할 점:

- 별칭(alias)으로 생성하는 activity-alias를 위해 구체적인 클래스를 구현할 필요는 없습니다. 기존 targetActivity를 가리키는 한 됩니다.
- 원래 MainActivity가 더 이상 android.intent.action.MAIN에 응답하지 않기 때문에, 기본 activity-alias를 활성화해야만 합니다.
- 아이콘 외에 라벨도 변경할 수 있습니다.
- 필요한 intent-filter를 반드시 포함해야 합니다. 그렇지 않으면 특정 activity-alias가 활성화될 때 앱을 실행할 수 없게 됩니다.

<div class="content-ad"></div>

# 아이콘 선택을 위한 UI 생성

구현 방식은 완전히 우리에게 달려 있습니다. ViewModel 및 Repository를 사용하여 사용 가능한 아이콘 목록 및 현재 선택 항목을 관리하는 복잡한 접근 방식을 선택할 수도 있습니다. 활동 별칭(activity-alias로 정의한 구성 요소 이름과 아이콘을 올바르게 연결할 수 있다면 작동할 것입니다.

![아이콘 선택을 위한 UI](/assets/img/2024-07-23-ChangingtheAndroidAppIconProgrammatically_2.png)

# 앱 아이콘 활성화/비활성화하기

<div class="content-ad"></div>

기술적으로는 구성 요소(활동 또는 활동 별칭)를 프로그래밍 방식으로 활성화 또는 비활성화하고 있습니다. 각 구성 요소에는 다른 아이콘이나 이름이 함께 제공됩니다.

## 구성 요소 활성화

AndroidManifest.xml에는 클래스 이름만 제공할 수 있지만, 구성 요소 이름을 지정할 때는 패키지 이름을 포함한 완전히 정규화된 클래스 이름을 제공해야 합니다. setComponentEnabledSetting()을 COMPONENT_ENABLED_STATE_ENABLED 상태로 실행한 후에는 런처가 새로운 앱 아이콘을 표시해야 합니다.

## 구성 요소 비활성화

<div class="content-ad"></div>

위의 과정과 동일하지만 이번에는 상태를 COMPONENT_ENABLED_STATE_DISABLED로 변경합니다. 일반적으로는 하나의 구성요소만 활성화하려고 하지만, 나머지 모두를 비활성화해야 할 수도 있습니다.

주의할 점:

- 현재 활성 상태인 구성요소를 비활성화하려고 하면, DONT_KILL_APP 플래그를 지정해도 앱이 종료됩니다.
- 위에서 언급한대로 MainActivity가 더 이상 인텐트 필터에 응답하지 않기 때문에 “Run App” 기능을 사용하여 앱을 실행할 수 없을 수 있습니다. 대신 gradle 명령줄을 사용하여 앱을 설치해야 합니다.
- 구성요소를 개별적으로 반복하지 않고 아이콘 목록이 있는 경우, packageManager.setComponentEnabledSettings()를 사용하여 설정 목록을 전달할 수 있습니다(API 레벨 33 이상 필요).

# 모두 함께 적용하기

<div class="content-ad"></div>

- AndroidManifest.xml 파일에서 가능한 앱 아이콘 옵션을 정의합니다.
- 사용자가 아이콘을 선택할 수 있는 화면을 제공합니다.
- 사용자의 현재 설정을 사용자 환경 설정에 저장하여 선택 화면에서 표시할 수 있습니다. 그러나 각 구성 요소의 상태를 확인하는 가장 정확한 방법은 packageManager.getComponentEnabledSetting()을 사용하는 것입니다.
- 사용자가 아이콘을 선택한 후, 선택한 구성 요소를 활성화하고 나머지는 비활성화하여 여러 개의 아이콘이 생성되지 않도록 합니다.
- 이후 앱은 자동으로 종료될 가능성이 있습니다. Reddit은 이러한 상황이 발생하기 전에 빠르게 확인 대화상자를 표시합니다.

![이미지](/assets/img/2024-07-23-ChangingtheAndroidAppIconProgrammatically_3.png)

# 샘플 앱

![이미지](/assets/img/2024-07-23-ChangingtheAndroidAppIconProgrammatically_4.png)

<div class="content-ad"></div>

만약 직접 코딩하기 귀찮다면, 깃허브에 예제 앱이 있어서 빠르게 테스트해 볼 수 있어요.

PS: 그렉의 팬이에요. 😛

# 마지막으로

어떤 사람은 이 방법이 딥링크와 같은 일부 기능을 망가뜨린다고 말하지만, 저는 이것이 레딧 앱에서 발견된 구현임을 말할 수밖에 없어요.

<div class="content-ad"></div>

네, 아이콘 또는 앱 이름이 변경되는 것 이상의 기능을 활용하여 컴포넌트의 활성화/비활성화 기술을 사용할 수 있습니다. 무엇이든 상상해보고 구현할 수 있는 다른 기능이 무엇인지 확인해보세요!

안드로이드 앱 아이콘 변경하는 방법





![Caching101RubyonRails](/assets/img/2024-07-23-Caching101RubyonRails_0.png)

루비 온 레일즈, 종종 간단히 레일즈로 불리는 것은 MIT 라이선스 하에 루비로 작성된 서버 측 웹 애플리케이션 프레임워크입니다. MVC(Model-View-Controller) 프레임워크로서 데이터베이스, 웹 서비스 및 웹 페이지에 대한 기본 구조를 제공합니다. 루비 온 레일즈에서 효율적이고 빠른 웹 애플리케이션을 개발하는 중요한 측면 중 하나는 효과적인 캐싱입니다. 캐싱은 작업의 결과를 임시 저장 영역에 저장하는 프로세스로, 해당 데이터에 대한 미래 요청을 빠르게 처리할 수 있게 합니다. 이 글에서는 루비 온 레일즈에서 사용할 수 있는 다양한 캐싱 전략, 이점 및 언제 사용해야 하는지에 대해 다룹니다.

# 루비 온 레일즈에서의 캐싱 유형

## 페이지 캐싱


<div class="content-ad"></div>

페이지 캐싱은 전체 HTML 페이지를 캐싱하는 것을 의미합니다. 레일즈 앱을 완전히 우회하기 때문에 가장 빠른 캐싱 방법입니다. 웹 서버가 직접 저장된 HTML 파일을 제공하여 레일즈 응용프로그램 스택을 거치지 않습니다. 그러나 페이지 캐싱은 동적 웹 애플리케이션이 더 일반적인 사용자별 컨텐츠가 증가함에 따라 인기가 줄어들었습니다.

## 액션 캐싱

액션 캐싱은 페이지 캐싱과 비슷하지만 더 세밀한 제어가 가능합니다. 컨트롤러 액션의 출력을 캐싱하지만 여전히 레일즈 스택을 통과하여 캐시 제공 전에 인증 및 필터링을 실행할 수 있습니다. 인증이 필요한 페이지나 페이지 캐싱으로 처리할 수 없는 동적 요소가 포함된 페이지에 적합합니다.

## 조각 캐싱

<div class="content-ad"></div>

프래그먼트 캐싱은 전체 페이지가 아닌 뷰의 일부를 캐시하는 데 사용됩니다. 이 전략은 페이지 일부가 정적으로 유지되는 애플리케이션에서 특히 유용합니다. 다른 부분은 자주 변경됩니다. 프래그먼트 캐싱을 사용하면 개발자가 메뉴, 헤더 또는 푸터와 같이 캐시할 뷰의 특정 부분을 지정할 수 있습니다. 이렇게 하면 성능이 크게 향상되고 여전히 필요한 곳에 동적 콘텐츠를 제공할 수 있습니다.

# 캐싱 전략 구현하기

## 페이지 캐싱

페이지 캐싱을 구현하려면 컨트롤러에서 caches_page 메서드를 사용할 수 있습니다. 캐시하려는 작업을 지정하고 Rails는 자동으로 생성된 HTML을 저장합니다.

<div class="content-ad"></div>


<img src="/assets/img/2024-07-23-Caching101RubyonRails_1.png" />

## Action Caching

액션 캐싱을 위해 caches_action 메소드를 사용하세요. 페이지 캐싱과 비교하여 더 유연하며, before 필터를 포함할 수 있습니다.

<img src="/assets/img/2024-07-23-Caching101RubyonRails_2.png" /> 


<div class="content-ad"></div>

## 프래그먼트 캐싱

프래그먼트 캐싱은 뷰에서 cache 메서드를 사용하여 직접 구현할 수 있습니다. Rails는 프래그먼트의 캐싱과 검색을 자동으로 처리할 것입니다.

![이미지](/assets/img/2024-07-23-Caching101RubyonRails_3.png)

# 고급 캐싱 기술

<div class="content-ad"></div>

## 저레벨 캐싱

저레벨 캐싱은 임의의 객체를 캐싱할 수 있게 해주어 개발자가 무엇을 캐싱할지에 대해 미세한 제어권을 제공합니다. 특히, 검색하거나 계산하기 비용이 비실 경우 데이터의 일부를 캐싱하는 데 매우 유용합니다.

![캐싱 이미지](/assets/img/2024-07-23-Caching101RubyonRails_4.png)

## 러시안 돌 캐싱

<div class="content-ad"></div>

러시안 돌 캐싱은 중첩된 조각들을 개별적으로 캐시하면서도 더 큰 조각의 일부로도 캐싱하는 기술입니다. 이 방법은 나머지 캐시에 영향을 미치지 않고 단일 캐시 조각을 무효화하는 데 효과적입니다.

## 조건부 GET 지원

Rails는 fresh_when 및 stale? 메서드를 사용하여 조건부 GET를 지원합니다. 이러한 메서드는 내용이 변경되었는지 여부를 판별하고 서버가 새로운 응답을 보내야 하는지 브라우저의 캐시를 신뢰할 수 있는지를 결정하는 데 도움이 됩니다.

# 결론

<div class="content-ad"></div>

캐싱은 루비 온 레일 애플리케이션의 성능을 향상시키는 강력한 기술입니다. 다양한 캐싱 전략을 이해하고 구현함으로써, 개발자는 애플리케이션의 반응성을 크게 향상시키고 서버 부하를 줄이며 더 나은 사용자 경험을 제공할 수 있습니다. 정적 콘텐츠에 대한 페이지 캐싱부터 동적 요소에 대한 프래그먼트 캐싱까지, Rails는 캐싱을 통해 응용 프로그램 성능을 최적화하는 강력한 도구 세트를 제공합니다.

Ruby on Rails에서 캐싱하는 가장 기본적인 방법





![image](/assets/img/2024-07-23-RelearningJavaWhatstheDifferenceBetweenExceptionandError_0.png)

어떤 프로그램은 결코 실패하지 않을까요?

어쩌면 이러한 프로그램은 프로그래머의 꿈 속에서만 존재하는 것이겠죠. 프로그래밍 언어와 소프트웨어가 발전함에 따라, 예외가 항상 우리와 함께해 왔습니다. 예상치 못한 상황을 적절하게 처리하는 것은 프로그램 신뢰성을 보장하는 데 중요합니다.

자바 언어의 탄생부터 비교적 포괄적한 예외 처리 메커니즘을 제공해 왔습니다. 이것이 자바가 그만큼 흔해지게 된 이유 중 하나인데요 – 신뢰할 수 있는 프로그램을 작성하고 유지하는 데 큰 장벽을 낮춰 주기 때문입니다. 오늘날, 예외 처리 메커니즘은 현대 프로그래밍 언어에서 표준적으로 적용되고 있습니다.


<div class="content-ad"></div>

# 오늘의 질문

예외(Exception)와 에러(Error)를 비교하고, 런타임 예외와 체크 예외의 차이를 설명해주세요.

# 전형적인 답변

Exception과 Error는 모두 Throwable의 하위 클래스입니다. Java에서는 Throwable의 인스턴스만이 던져지거나 잡힐 수 있어 예외 처리 메커니즘에서 기본적인 타입입니다.


<div class="content-ad"></div>

예외(Exception)와 에러(Error)는 Java 플랫폼 디자이너가 다른 종류의 문제들을 분류한 것을 반영합니다. 예외는 일반 프로그램 실행 중에 예상되고, 잠재적으로 관리 가능한 문제를 나타냅니다. 이러한 문제들은 적절히 잡고 처리해야 합니다.

에러는 반면에, 일반적인 조건에서 일어나기 어려운 상황을 가리킵니다. 대부분의 에러 인스턴스는 프로그램(예를 들어 JVM 자체)을 비정상적이고 회복 불가능한 상태로 이끌 수 있습니다. 이러한 비정상 상황이기 때문에 일반적으로 잡고 처리하지 않습니다. 일반적인 예시로는 OutOfMemoryError 및 에러의 서브클래스들이 있습니다.

예외는 확인된 예외(checked exceptions)와 확인되지 않은 예외(unchecked exceptions)로 나뉩니다. 확인된 예외는 소스 코드에서 명시적으로 처리하거나 선언해야 하며, 이것은 컴파일 시간 확인의 일부입니다. 확인되지 않은 예외 또는 런타임 예외는 NullPointerException 및 ArrayIndexOutOfBoundsException과 같은 로직 오류로, 코딩 방법을 통해 피할 수 있는 오류로 컴파일 시간에 강제되지 않습니다.

# 시험 포인트들

<div class="content-ad"></div>

Exception과 Error의 차이점을 분석하면 Java의 핸들링 메커니즘에 대한 개념적 이해를 확인할 수 있어요. 전반적으로, 이는 개념을 명확히 이해하는 데 관한 것이에요.

일상적인 프로그래밍에서 예외를 효과적으로 처리하는 것은 기술의 표시에요. 두 가지 측면을 잘 이해하는 것이 중요해요:

- Throwable, Exception 및 Error의 디자인과 분류를 이해하는 것. 이는 널리 사용되는 서브클래스를 알고 사용자 정의 예외를 만드는 방법도 포함돼요.
- Error, Exception 및 RuntimeException의 특정 예제에 친숙해지는 것. 전형적인 예제를 나열한 간단한 클래스 다이어그램은 참고용으로 유용하며 기본적인 이해를 확인하는 데 도움이 될 수 있어요.

많은 면접관들은 더 깊이 들어가서, 어떤 Error 또는 Exception에 익숙한지 묻을 수도 있어요. 이러한 개념에 대한 기본 개념을 갖고 있다면 도움이 될 거예요.

<div class="content-ad"></div>


![image](/assets/img/2024-07-23-RelearningJavaWhatstheDifferenceBetweenExceptionandError_1.png)

일부 하위 유형 중 NoClassDefFoundError와 ClassNotFoundException의 차이와 같은 것에 집중하는 것이 유용합니다. 이는 고전적인 입문 주제입니다.

둘째, Java에서 Throwable을 처리하는 요소와 실천 방법을 이해하는 것이 중요합니다. 기본 구문 및 try-catch-finally 블록, throw 및 throws 키워드와 같은 것을 숙달하는 것이 필수입니다. 또한 일반적인 시나리오를 처리하는 방법을 알아야 합니다.

예외 처리 코드는 상당히 장황할 수 있으며 종종 반복적인 catch 블록이나 finally 블록에서 리소스 정리가 필요합니다. Java 언어의 진화로 인해 try-with-resources와 여러 catch 블록과 같은 더 편리한 기능이 도입되었습니다. 예를 들어 컴파일 중에 Java 컴파일러는 기본 처리 논리를 자동으로 생성하여 규약에 따라 AutoCloseable이나 Closeable을 구현하는 개체를 자동으로 닫습니다.


<div class="content-ad"></div>

```java
try (BufferedReader br = new BufferedReader(…);
     BufferedWriter writer = new BufferedWriter(…)) {// Try-with-resources
// do something
catch ( IOException | XEception e) {// Multiple catch
   // Handle it
} 
```

# 지식 확장

이전 토론은 대부분 개념적 측면을 다뤘습니다. 이제 실용적 선택 사항에 대해 이야기하고 일부 코드 예제와 함께 분석해 보겠습니다.

첫 번째로 시작해 봅시다. 다음 코드에 반영된 예외 처리 문제는 무엇일까요?

<div class="content-ad"></div>

```java
try {
  // 비즈니스 코드
  // …
  Thread.sleep(1000L);
} catch (Exception e) {
  // 무시하기
}
```

이 코드는 간결하지만 예외 처리의 두 가지 기본 원칙을 위반합니다.

첫째로, Exception과 같은 일반적인 예외를 catch 하는 대신 Thread.sleep()에 의해 발생하는 InterruptedException과 같은 특정 예외를 catch 하는 것이 좋습니다.

일상적인 개발 및 협업에서는 코드를 쓰는 것보다 읽는 일이 더 많습니다. 소프트웨어 공학은 협업의 예술이므로 우리의 코드를 가능한 한 정보적으로 만드는 의무가 있습니다. Exception과 같은 일반적인 예외는 우리의 의도를 혼동시킵니다. 또한, 우리는 프로그램이 우리가 원치 않는 예외를 catch하지 않도록 해야 합니다. 예를 들어 RuntimeException이 catch되는 대신 전파되는 것이 좋을 수도 있습니다.


<div class="content-ad"></div>

또한 주의 깊게 고려하지 않는 한 Throwable 또는 Error을 잡지 마십시오. OutOfMemoryError를 올바르게 처리하기가 어려울 수 있습니다.

두 번째로, 예외를 삼키지 마십시오. 이는 매우 진단하기 어려운 문제로 이어질 수 있기 때문에 예외 처리에서 매우 중요합니다.

예외를 삼키는 것은 종종 코드가 실패하지 않을 것이라는 가정이나 예외를 무시해도 문제가 되지 않을 것이라는 가정에 기반을 둔 것입니다. 그러나 제품 코드에서는 이러한 가정을 절대 하지 마십시오!

만약 우리가 예외를 throw하거나 Logger를 사용하여 로깅하지 않는다면, 프로그램이 예측할 수 없이 나중에 갑자기 종료될 수 있습니다. 그때 예외가 발생한 위치를 판별하고 원인을 파악하기 어려워집니다.

<div class="content-ad"></div>

이제 두 번째 코드 조각을 살펴보겠습니다.

```js
try {
   // 비즈니스 코드
   // …
} catch (IOException e) {
    e.printStackTrace();
}
```

실험용 코드로서, 이 코드 조각은 본질적으로 문제가 있는 것은 아니지만 실제 운영 코드에서는 일반적으로 이러한 처리 방식이 허용되지 않습니다. 그 이유에 대해 생각해 보겠습니다.

먼저, printStackTrace() 메서드의 문서를 살펴보겠습니다. "이 throwable 및 해당 백트레이스를 표준 오류 스트림에 출력합니다."라고 시작합니다. 여기서 문제는 약간 더 복잡한 운영 시스템에서는 표준 오류(STERR)가 이상적인 출력 옵션이 아니라는 것입니다. 출력이 어디에 정확히 도착하는지 판단하기 어렵기 때문입니다.

<div class="content-ad"></div>

분산 시스템에서 특히 예외가 발생하더라도 스택 추적이 없으면 진단에 장벽이 생깁니다. 따라서 로그에 자세한 정보를 출력하기 위해 생성 로깅 시스템을 사용하는 것이 좋습니다.

이제 "일찍 던지고, 나중에 잡기" 원칙을 이해하기 위해 다음 코드 조각을 살펴보겠습니다.

```js
public void readPreferences(String fileName){
  //...작업 수행... 
  InputStream in = new FileInputStream(fileName);
  //...환경 설정 파일 읽기...
}
```

만약 fileName이 null이라면 프로그램은 NullPointerException을 throw합니다. 그러나 문제가 즉시 드러나지 않기 때문에 스택 추적이 상당히 혼란스러울 수 있으며 상대적으로 복잡한 디버깅이 필요할 수 있습니다. 이 NPE는 예시일 뿐이며, 실제 제품 코드에서 환경 설정 실패 등 여러 시나리오가 발생할 수 있습니다. 감지 지점에서 예외를 일찍 던지면 문제가 더 명확하고 직접적으로 해결됩니다.

<div class="content-ad"></div>

코드를 수정하여 "조기 throw"로 변경할 수 있어요. 이렇게 하면 예외 정보가 훨씬 명확해져요.

```js
public void readPreferences(String filename) {
    Objects.requireNonNull(filename);
    // 다른 작업 수행...
    InputStream in = new FileInputStream(filename);
    // 환경 설정 파일 읽기...
}
```

"나중에 catch"에 대해 말하자면, 예외를 처리한 후에 무엇을 해야 할지 고민하는 상황이 흔해요. 이전에 언급한 것처럼, 가장 나쁜 접근 방법은 예외를 "삼켜 버리는" 것인데, 그렇게 되면 문제가 숨겨져 버릴 수 있어요. 예외를 어떻게 처리해야 할지 모르겠다면, 원래 예외의 원인 정보를 유지한 채로 다시 던지거나 새로운 예외를 던질 수 있어요. 명확한 (비즈니스) 로직이 있는 높은 수준에서는 적절한 처리 방법이 보통 보다 분명해져요.

가끔은 커스텀 예외를 정의해야 할 때가 있어요. 그럴 때는 충분한 정보를 제공하는 것 외에도 다음을 고려해 보세요:

<div class="content-ad"></div>

- Checked Exception으로 정의해야 하는지 여부는 이 유형이 예외적인 상황에서 회복하도록 설계되었기 때문입니다. 예외 설계자로서 종종 이러한 상황을 분류할 정보가 충분합니다.
- 진단 정보가 충분하게 포함되어 있는지 확인하되, 민감한 정보는 포함하지 않도록 주의해야 합니다. 예를 들어 Java 표준 라이브러리에서 java.net.ConnectException은 "Connection refused (Connection refused)"와 같은 에러 메시지를 제공하지만 기계 이름, IP 주소 또는 포트와 같은 구체적인 세부 정보를 제공하지 않아 정보 보안에 중요한 고려 사항입니다. 마찬가지로, 민감한 사용자 데이터는 일반적으로 로그에 출력되어서는 안 됩니다.

산업 내에서 Java의 Checked Exception이 설계 결함일 수도 있다는 논란이 있습니다. 비판자들은 다음을 주장합니다:

- Checked Exception 뒤에 있는 가정은 우리가 예외를 잡아서 회복한다는 것입니다. 그러나 대부분의 경우 회복이 불가능합니다. Checked Exception의 사용은 원래의 설계 의도에서 크게 벗어났습니다.
- Checked Exception은 함수형 프로그래밍과 호환되지 않습니다. Lambda/Stream 코드를 사용해본 경우에는 이를 잘 이해하게 될 것입니다.
- Spring이나 Hibernate와 같은 많은 오픈 소스 프로젝트가 Checked Exception을 피하는 방법을 채택했습니다. 이 경향은 Scala와 같은 새로운 프로그래밍 언어의 설계에도 반영되고 있습니다.

관심이 있다면 아래를 참고하세요:

<div class="content-ad"></div>

물론, 일부 사람들은 지나치게 수정할 필요가 없다고 믿습니다. 실제로 IO 및 네트워크 관련 예외와 같이 회복이 가능한 예외가 몇 가지 있습니다. 자바는 포괄적인 산업 실무를 통해 고품질 소프트웨어를 구축하는 능력을 입증했습니다. 이 주제를 더 깊게 들어가지는 않겠습니다.

성능 관점에서, 자바의 예외 처리 메커니즘에는 두 가지 비용이 많이 드는 측면이 있습니다:

- try-catch 블록의 성능 오버헤드: try-catch 블록을 사용하면 성능 오버헤드가 추가됩니다. 보다 구체적으로 말하면, JVM의 코드 최적화 능력에 영향을 줄 수 있습니다. 필요한 코드 세그먼트에서만 예외를 처리하고 하나의 try 문으로 큰 코드 블록을 묶지 않는 것이 좋습니다. 게다가 예외를 사용하여 코드의 흐름을 제어하는 것은 일반적으로 조건문(예: if/else 또는 switch)을 사용하는 것보다 비효율적입니다.
- 예외 생성 시 스택 스냅샷: 자바에서 예외를 인스턴스화할 때마다 스택의 스냅샷이 촬영되는데, 이는 비교적 무거운 작업입니다. 예외가 매우 빈번히 발생하면 이러한 비용이 상당해질 수 있습니다.

극도의 성능이 필요한 저수준 라이브러리의 경우, 스택 트레이스를 포착하지 않는 예외를 생성하는 방법이 있습니다. 이 방법은 스택 트레이스가 미래에 필요할지를 예측할 수 있다는 가정 때문에 논란이 될 수 있습니다. 이는 소규모 시나리오에서는 가능할 수 있지만, 대규모 프로젝트에서는 현명한 선택이 아닐 수 있습니다. 스택 트레이스 정보가 필요하지만 수집되지 않으면, 특히 마이크로서비스와 같은 분산 시스템에서 복잡한 시스템에서 문제를 진단하는 것이 훨씬 어려워집니다.

<div class="content-ad"></div>

서비스가 성능 저하나 처리량 감소를 겪을 때 가장 빈번하게 발생하는 예외를 분석하면 소중한 통찰을 얻을 수도 있습니다.

# 결론

오늘은 Java의 예외 처리 메커니즘에 대한 간단한 요약을 제공했습니다. 일반적인 개념적 문제에서 시작하여 널리 받아들여지는 모범 사례들과 최신 산업의 예외 처리에 대한 합의를 분석했고, 코드 예제와 함께 설명했습니다. 마지막으로, 예외와 관련된 성능 부담에 대해 논의하면서 이 정보가 도움이 되기를 바랍니다.

![이미지](/assets/img/2024-07-23-RelearningJavaWhatstheDifferenceBetweenExceptionandError_2.png)

자바  Exception과 Error의 차이점 정리



![image](/assets/img/2024-07-23-JavaAdvancedConcurrencyInterviewQuestions01_0.png)

면접에서는 종종 주제에 대한 깊이를 평가하려고 할 것입니다. 예를 들어, Java 동시성과 비동기 작업 실행의 일부 고급 구조를 사용할 수 있더라도 멀티 스레딩 및 동시성이 시간이 지남에 따라 어떻게 발전했는지를 이해하려고 할 것입니다. 예를 들어 Java에서 스레드를 관리하고 생성하는 여러 가지 방법을 알고 있는지 알아볼 것입니다. Java에서 스레드 생성 및 관리에 대한 훌륭한 참고 자료가 있습니다.

그러나 동시성 개념을 이해하고 구현하기 위해서는 어떻게 스레딩이 작동하는지, 간단한 문제를 해결하는 동안 이러한 개념을 어떻게 구현할 수 있는지 이해해야 할 수도 있습니다.

Java에서 스레드 간 통신 및 스레드의 상태를 이해하는 데 좋은 리딩 자료가 있습니다. 프로그래밍에 활용할 수 있습니다.

<div class="content-ad"></div>

지금 이 글에서는 한 가지 문제에 대해 살펴보고, 해당 문제를 간단한 스레드 생성 또는 Completable Future의 일부 추상화를 사용하여 해결하고자 합니다.

여기서 유의해야 할 중요한 점은 여러 스레드가 객체의 상태를 공유하도록 허용하려면 동기화 구조체에는 대체물이 없다는 것입니다. 동시성을 처리하고 여러 비동기 작업을 만드는 것은 전혀 다른 개념이며 서로 다른 사용 사례를 구현합니다.

# 문제:

![이미지](/assets/img/2024-07-23-JavaAdvancedConcurrencyInterviewQuestions01_1.png)

<div class="content-ad"></div>

<img src="/assets/img/2024-07-23-JavaAdvancedConcurrencyInterviewQuestions01_2.png" />

```java
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EvenOddPrinter {
    public static void main(String[] args) {
        final int maxNumber = 20; // 출력할 최대 숫자 정의
        ExecutorService executor = Executors.newFixedThreadPool(2); // 두 개의 스레드를 가진 스레드 풀 생성

        Runnable printEven = () -> {
            for (int i = 2; i <= maxNumber; i += 2) { // 짝수는 2부터 시작
                System.out.println("짝수: " + i);
                try {
                    Thread.sleep(100); // 몇 가지 연산을 시뮬레이션하고 출력을 더 가독성 있게 만들기 위해 슬립
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 중단된 상태를 복원
                    System.out.println("스레드가 중단되었습니다: " + e.getMessage());
                }
            }
        };

        Runnable printOdd = () -> {
            for (int i = 1; i <= maxNumber; i += 2) { // 홀수는 1부터 시작
                System.out.println("홀수: " + i);
                try {
                    Thread.sleep(100); // 몇 가지 연산을 시뮬레이션하고 출력을 더 가독성 있게 만들기 위해 슬립
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 중단된 상태를 복원
                    System.out.println("스레드가 중단되었습니다: " + e.getMessage());
                }
            }
        };

        CompletableFuture<Void> evenFuture = CompletableFuture.runAsync(printEven, executor);
        CompletableFuture<Void> oddFuture = CompletableFuture.runAsync(printOdd, executor);

        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(evenFuture, oddFuture);
        combinedFuture.join(); // 두 작업이 완료될 때까지 기다림

        executor.shutdown(); // Executor 서비스 종료
    }
}
```

# 출력:

<img src="/assets/img/2024-07-23-JavaAdvancedConcurrencyInterviewQuestions01_3.png" />

<div class="content-ad"></div>

# 이제 인터뷰에서는 고급 구조를 사용하지 않고 쓰레드를 본질적으로 사용할 수 있는지 확인하려고 합니다.

![이미지](/assets/img/2024-07-23-JavaAdvancedConcurrencyInterviewQuestions01_4.png)

# Completable Future를 사용하지 않고 더 효율적인 방법.

짝수와 홀수 번호 출력 프로그램을 더 효율적이고 동기화된 상태로 만들기 위해 두 쓰레드 간의 조정을 위해 공유 객체를 활용할 수 있습니다. 짝수와 홀수 출력 작업이 번갈아 가며 실행되도록 보장하기 위해 sleep() 대신에 wait()와 notify()를 사용하여 쓰레드 실행을 효율적으로 관리할 수 있습니다. 이 접근 방식은 불필요한 대기를 줄이고 프로그램을 더 반응적으로 만듭니다.

<div class="content-ad"></div>

<img src="/assets/img/2024-07-23-JavaAdvancedConcurrencyInterviewQuestions01_5.png" />

```java
public class EvenOddPrinterUsingThreads {
    private static final Object lock = new Object();
    private static final int MAX_NUMBER = 20;
    private static int current = 1;

    public static void main(String[] args) {
        Thread evenThread = new Thread(() -> printEvenNumbers());
        Thread oddThread = new Thread(() -> printOddNumbers());

        evenThread.start();
        oddThread.start();
    }

    private static void printEvenNumbers() {
        while (current <= MAX_NUMBER) {
            synchronized (lock) {
                if (current % 2 == 1) { // If current is odd, wait
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                } else {
                    System.out.println("Even: " + current);
                    current++;
                    lock.notifyAll(); // Notify the other thread
                }
            }
        }
    }

    private static void printOddNumbers() {
        while (current <= MAX_NUMBER) {
            synchronized (lock) {
                if (current % 2 == 0) { // If current is even, wait
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                } else {
                    System.out.println("Odd: " + current);
                    current++;
                    lock.notifyAll(); // Notify the other thread
                }
            }
        }
    }
}
```

Output:

<div class="content-ad"></div>

# 주요 향상 사항:

- 동기화된 블록은 한 번에 하나의 스레드만 블록을 실행할 수 있도록 보장합니다. 이로 인해 두 스레드가 동시에 숫자를 인쇄하려고 하는 것을 방지합니다.
- 효율적인 대기 및 통지: sleep() 대신 wait() 및 notifyAll()을 사용하여 스레드가 실행을 일시 중지하고 자신의 차례가 될 때까지 기다릴 수 있어서 유휴 시간을 줄입니다.
- 공유 카운터: 두 스레드가 현재 카운터를 공유하고 이를 사용하여 인쇄할 숫자를 결정합니다. 이를 통해 별도로 범위를 계산하거나 확인할 필요 없이 올바른 순서를 보장합니다.

# 작동 방식:

- 두 스레드가 시작되고 숫자를 인쇄하기를 시도합니다.
- 현재 값에 따라 한 스레드가 숫자를 인쇄하고 현재 값을 증가시키고, 다른 스레드는 기다립니다.
- 인쇄를 마친 후, 스레드는 notifyAll()을 호출하여 다른 스레드를 깨우고, 그 다음 반복에서 다시 현재 값을 확인합니다. 만일 자신의 차례가 아니라면 다시 대기합니다.
- 이 과정은 현재 값이 MAX_NUMBER를 초과할 때까지 반복되며, 그때 두 스레드가 실행을 완료하고 자연스럽게 종료됩니다.

<div class="content-ad"></div>

# 이제 인터뷰어가 더 이에 대해 질문할 수 있을 것 같습니다.

![이미지](/assets/img/2024-07-23-JavaAdvancedConcurrencyInterviewQuestions01_7.png)

Predicate 인터페이스를 사용하면 두 가지 조건을 설계하고 이러한 조건을 CompletableFuture에 전달하여 더 쉽게 구현할 수 있습니다. 유일한 차이점은 이제 홀수와 짝수를 확인하는 로직이 Predicate 자체에 의해 제어된다는 것입니다.

```java
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Predicate;

public class EvenOddPrinterWithPredicate {

    private static final int MAX_NUMBER = 20;
    private static AtomicInteger current = new AtomicInteger(1);
    private static final Object lock = new Object();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Predicate<Integer> isEven = num -> num % 2 == 0;
        Predicate<Integer> isOdd = isEven.negate();

        CompletableFuture<Void> evenTask = CompletableFuture.runAsync(() -> printNumbers(isEven), executor);
        CompletableFuture<Void> oddTask = CompletableFuture.runAsync(() -> printNumbers(isOdd), executor);

        CompletableFuture.allOf(evenTask, oddTask).join(); // 두 작업이 모두 완료될 때까지 기다림

        executor.shutdown();
    }

    private static void printNumbers(Predicate<Integer> condition) {
        while (current.get() <= MAX_NUMBER) {
            synchronized (lock) {
                if (condition.test(current.get())) {
                    System.out.println((condition == isEven ? "짝수: " : "홀수: ") + current.getAndIncrement());
                    lock.notify();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }
        }
    }
}
```

<div class="content-ad"></div>

# 주요 변경 사항 및 기능:

- 우리는 두 개의 Predicate`Integer` 인스턴스인 isEven과 isOdd를 정의하여 각각 짝수와 홀수 숫자에 대한 조건을 캡슐화했습니다. 이렇게 함으로써 printNumbers 메서드 내의 조건 확인이 더 표현력 있고 유연해집니다.
- printNumbers 메서드는 숫자를 인쇄할 조건을 나타내는 Predicate`Integer`를 조건 매개변수로 사용합니다. 이 메서드는 짝수와 홀수 작업에서 모두 사용되어 코드 중복을 줄입니다.
- 함수형 프로그래밍 스타일: Predicate를 조건 확인에 사용하여 함수형 프로그래밍 스타일을 보여줌으로써 코드를 더 모듈화하고 이해하기 쉽게 만듭니다.
- 비동기 실행을 위한 CompletableFuture: CompletableFuture.runAsync()와 executor를 사용하여 작업을 비동기적으로 실행하여 병렬로 실행되지만 동기화를 통해 조정됩니다.

우리가 본 모든 예제에서는 성능을 벤치마크해보지 않았지만, 주제의 심도를 나타내기 위해 동일한 문제를 여러 가지 방법으로 해결하려고 노력했습니다.

# 주요 포인트:

<div class="content-ad"></div>

- 비동기 이벤트 처리는 동기화 필요성을 제거하지 않습니다.
- 스레드 간 동기화는 서로 작업하고 통신할 때 항상 필요합니다.
- 모든 솔루션은 동일한 목표를 달성하지만 약간 다른 프로그래밍 및 구조 스타일을 가지고 있습니다.
- 이 글은 다른 것보다 더 나은 목록을 증명하려는 것이 아닙니다.

클랩을 공유해주시고 고급 Java 개발자에게는 매우 사소한 문제일 수 있겠지만, 이 글은 다양한 멀티스레딩 스타일에 대한 지식을 넓히는 데 초점을 맞추고 있습니다. 클랩 공유해주시고 다시 방문해주시기 바랍니다.


2024 최신 Java 개발자 인터뷰 질문 모음




요청 폭포, "폭포 차트"로 시각화된 것은 웹 개발과 성능 분석에서 필수적인 도구입니다. 웹 페이지 내 자원 로딩의 순서와 시간을 보여주어 개발자들이 성능 문제를 진단하고 로딩 시간을 최적화하는 데 도움이 됩니다. 요청 폭포의 구성 요소와 효과적인 활용 방법에 대해 알아봅시다.

### 요청 폭포의 주요 구성 요소

- 자원 요청:

폭포 차트의 각 행은 웹 페이지에서 요청된 자원을 나타냅니다 (예: HTML, CSS, JavaScript, 이미지, 폰트).
- 타임라인:

수평 축은 시간을 나타내며, 일반적으로 밀리초 단위로 표시됩니다. 타임라인은 초기 페이지 로드를 기준으로 각 요청이 시작하고 끝나는 시점을 보여줍니다.
- 요청 단계:
DNS Lookup: 도메인 이름을 IP 주소로 해결하는 데 걸리는 시간.
TCP 연결: 클라이언트와 서버 간에 TCP 연결을 설정하는 데 걸리는 시간.
TLS 핸드셰이크: 요청이 HTTPS를 통해 이루어진 경우, TLS 핸드셰이크를 완료하는 데 걸리는 시간.
요청 전송: HTTP 요청을 서버로 보내는 데 걸리는 시간.
대기 (TTFB - 첫 번째 바이트까지의 시간): 요청을 보낸 후 서버의 응답을 기다리는 시간.
콘텐츠 다운로드: 첫 번째 바이트를 받은 후 자원을 다운로드하는 데 걸리는 시간.
- 자원 유형과 크기:

자원의 유형 (스크립트, 스타일시트, 이미지 등) 및 바이트 단위의 크기에 관한 정보.

### 요청 폭포를 읽고 활용하는 방법

<div class="content-ad"></div>

- 병목 현상 식별:

로딩이 느린 리소스를 나타내는 긴 막대를 찾아보세요. 이것들은 성능 병목 현상을 드러낼 수 있습니다. CSS 및 JavaScript 파일과 같은 페이지 렌더링을 차단하는 리소스는 특히 최적화할 필요가 있습니다.
- 병렬 vs. 순차적 로딩:

병렬로 로딩되는 리소스는 전체적으로 로드 시간을 개선할 수 있습니다. 그러나 어떤 리소스는 종속성으로 인해 순차적으로 로드될 수도 있습니다 (예: 다른 스크립트에 의존하는 JavaScript 파일).
- 핵심 경로:

핵심 경로는 페이지 렌더링 전에 로드 및 처리해야 하는 리소스로 구성됩니다. 이러한 리소스를 최적화하면 페이지 로드 시간을 크게 단축할 수 있습니다.

### 요청 워터폴이 나타내는 일반적인 문제

- DNS 지연:

긴 DNS 조회 시간은 초기 요청 속도를 느리게 할 수 있습니다. 더 빠른 DNS 공급업체 사용이나 DNS 쿼리 캐싱과 같은 해결책이 있습니다.
- 서버 응답 지연:

긴 TTFB는 서버 성능 문제를 나타낼 수 있습니다. 서버 구성 최적화, 백엔드 성능 향상 및 콘텐츠 전송 네트워크(CDN) 사용이 도움이 될 수 있습니다.
- 큰 리소스:

대형 이미지, 스크립트 또는 다른 리소스는 페이지 렌더링을 지연시킬 수 있습니다. 리소스 크기 최적화 및 지연 로딩과 같은 기술 사용으로 성능을 개선할 수 있습니다.
- 블로킹 스크립트:

렌더링을 차단하는 JavaScript 파일은 지연을 일으킬 수 있습니다. 스크립트의 지연 또는 비동기적 로딩을 통해 이 문제를 완화할 수 있습니다.

### 요청 워터폴 차트 생성 도구

<div class="content-ad"></div>

- WebPageTest: 자세한 워터폴 차트와 다른 성능 측정 항목을 제공하는 무료 온라인 도구입니다.
- Chrome DevTools: Google Chrome 브라우저에 내장되어 있으며 요청 워터폴을 시각화하는 "Network" 탭이 포함되어 있습니다.
- Firefox 개발자 도구: Chrome DevTools와 비슷한 기능을 제공하며 요청 워터폴을 분석하는 "Network" 패널이 포함되어 있습니다.
- GTmetrix: 워터폴 차트를 포함한 포괄적인 성능 보고서를 제공하는 또 다른 온라인 도구입니다.

요청 워터폴을 이해하고 분석하는 것은 웹 개발자와 성능 분석가가 웹 페이지의 로딩 속도와 사용자 경험을 최적화하기 위해 중요합니다. 병목 현상을 식별하고 해결함으로써 개발자는 웹 성능을 크게 향상시키고 사용자에게 더 부드럽고 빠른 경험을 제공할 수 있습니다.

웹 성능 최적화를 위한 요청 워터폴 방식 적용




자바스크립트의 세계로 뛰어들어보세요! LabEx에서 선별한 프로그래밍 랩 컬렉션으로 여러분의 기술을 갈고 닦으려는 초보자든, 새로운 도전을 찾는 숙련된 개발자든 상관없이 다양한 주제를 탐험하고 정복할 수 있습니다. 🚀

![마스터링 자바스크립트: 매력적인 프로그래밍 랩 모음](/assets/img/2024-07-23-MasteringJavaScriptACollectionofEngagingProgrammingLabs_0.png)

## Iterable의 슈퍼셋: Set 연산 탐구

이 랩에서는 Set 생성자와 Array.prototype.every() 메서드를 사용하여 한 Iterable이 다른 것의 슈퍼셋인지 여부를 판단하는 방법을 배웁니다. 첫 번째 Iterable이 두 번째 Iterable의 모든 요소를 포함하는지(중복 제외) 확인하는 함수를 만드는 방법을 알아봅니다. 이 랩은 자바스크립트에서 셋(set)을 다루는 방법에 대한 이해를 깊이 있게 향상시켜 줄 것입니다. 👨‍💻 Iterable의 슈퍼셋 랩

<div class="content-ad"></div>


![Caesar Cipher](/assets/img/2024-07-23-MasteringJavaScriptACollectionofEngagingProgrammingLabs_1.png)

## 자바스크립트에서 시저 암호 구현하기

암호학 세계로 빠져들어 시저 암호를 구현하는 방법을 배워보세요. 시저 암호는 주어진 문자열의 각 글자를 알파벳의 특정 위치로 이동하여 간단한 암호화 알고리즘입니다. 이 전통적인 기술을 사용하여 메시지를 암호화하고 해독하는 방법을 배우며 문자열 조작과 배열 메소드를 탐색해보세요. 🔒 시저 암호 구현하기 랩

## 자바스크립트에서 가중치가 적용된 랜덤 샘플링


<div class="content-ad"></div>

JavaScript에서 가중치 샘플 기능을 실용적으로 구현하는 방법을 발견하세요. 이 실습을 통해 reduce() 및 findIndex()와 같은 배열 메소드를 사용하여 Math.random()과 함께 배열에서 무작위 요소를 생성하는 방법을 배우고, 각 요소에 할당된 확률을 제공된 가중치를 기반으로 설정하는 방법을 배울 수 있습니다. 🎲 가중 랜덤 추출 실습

## HTML, CSS, JavaScript로 구현된 과일 매칭 게임

HTML, CSS 및 JavaScript를 사용하여 간단한 `Fruit for Fun` 게임을 만들어 보면서 프론트엔드 기술을 테스트해보세요. 이 프로젝트에서는 게임 보드를 구축하고 이미지를 클릭하여 과일 쌍을 맞추는 논리를 구현하는 방법을 학습할 수 있습니다. 🍎 과일 매칭 게임 실습

## 배열이 동일한 내용을 가졌는지 확인하기

<div class="content-ad"></div>

JavaScript에서 두 배열이 동일한 내용을 가지고 있는지 확인하는 방법을 알아보세요. 두 배열을 가져와서 순서와는 관계없이 동일한 요소를 포함하고 있는 경우 true를 반환하고 그렇지 않은 경우 false를 반환하는 함수를 작성할 겁니다. 이 기능을 구현하기 위해 Set, for...of 루프, 그리고 Array.prototype.filter()의 조합을 활용하세요. 🔍 배열이 동일한 내용을 가지고 있는지 확인하는 랩

![image](/assets/img/2024-07-23-MasteringJavaScriptACollectionofEngagingProgrammingLabs_2.png)

## 조건이 충족될 때까지 생성하기

JavaScript의 제너레이터 세계로 빠져들어보세요. 이 랩에서는 특정 조건이 충족될 때까지 새로운 값을 생성하는 제너레이터 함수를 만드는 방법을 배우게 됩니다. 손을 더럽히는 코딩 연습을 통해, 제너레이터가 어떻게 작동하며 코드를 간소화하고 성능을 향상시키는 데 어떻게 사용될 수 있는지 더 잘 이해하게 될 겁니다. 🔄 조건이 충족될 때까지 생성하기 랩

<div class="content-ad"></div>

<img src="/assets/img/2024-07-23-MasteringJavaScriptACollectionofEngagingProgrammingLabs_3.png" />

## 객체의 속성을 반복하기

자바스크립트에서 객체의 속성을 반복하는 기술을 탐색해보세요. 이 랩은 Object.keys()와 Array.prototype.forEach() 메서드를 사용하여 객체의 속성을 순회하고 각각에 대해 콜백 함수를 실행하는 방법을 가르쳐줍니다. 자바스크립트에서 객체를 다루고 속성을 조작하는 방법에 대한 이해력을 향상시키세요. 🔑 객체의 속성 반복하기 랩

<img src="/assets/img/2024-07-23-MasteringJavaScriptACollectionofEngagingProgrammingLabs_4.png" />

<div class="content-ad"></div>

이 매혹적인 프로그래밍 랩에 뛰어들어 JavaScript 개발자로 최대한의 잠재력을 발휘하세요! 💪 즐거운 코딩하세요!

## 더 배우고 싶으신가요?

- 🌳 최신 JavaScript 기술트리 배우기
- 📖 더 많은 JavaScript 자습서 읽기
- 💬 저희 Discord에 가입하거나 @WeAreLabEx로 트윗하기

초보 개발자라면 알아둬야할 자바스크립트 프로그래밍 실습 프로젝트




당신은 개발자입니까? 새로운 놀라운 프레임워크를 설명하는 방법을 모르시나요?

개발자들이 자신의 프레임워크와 코드를 설명할 때 사용하는 상위 10가지 형용사:

- ⚡️ 번개처럼 빠른
- 🚀 초 효율적인
- 📈 매우 확장 가능한
- 🔧 높은 모듈화
- 🔄 완벽하게 통합된
- 🔥 불타는 속도
- 🛡 방탄 조끼
- 🧼 예외적으로 깨끗한
- 💪 강력한
- 🌟 최신세대

개발자들이 코드와 프레임워크를 설명할 때 많이 하는 말들




# 난수 생성 이해하기

난수는 시뮬레이션, 암호화, 통계 샘플링 등 다양한 분야에서 중요한 역할을 합니다. 이 글은 무작위 숫자가 어떻게 생성되는지에 대해 다루며, JavaScript와 Python이라는 인기 있는 프로그래밍 언어를 중점적으로 살펴봅니다.

## 의사난수 생성기 (PRNGs)

대부분의 프로그래밍 언어는 의사난수 생성기(PRNGs)를 사용하여 무작위 숫자를 생성합니다. PRNGs는 수학적 알고리즘을 사용하여 무작위로 보이는 숫자 시퀀스를 생성합니다. 이 숫자들은 초기값인 시드에 의해 결정되기 때문에 실제로 무작위가 아닙니다. 하지만 많은 응용 프로그램에는 충분합니다.

<div class="content-ad"></div>

### PRNGs의 특성

- 결정론적: 동일한 시드가 주어지면 PRNG는 항상 동일한 숫자 시퀀스를 생성합니다.
- 주기성: PRNG는 일정 기간이 지난 후 숫자 시퀀스를 반복합니다.
- 속도: PRNG는 일반적으로 빠르고 효율적입니다.

## JavaScript: Math.random()

JavaScript의 Math.random() 함수는 임의의 숫자를 생성하는 데 자주 사용됩니다. Math.random()에서 사용하는 정확한 알고리즘은 다른 JavaScript 엔진 간에 다를 수 있지만, 널리 사용되는 알고리즘은 Mersenne Twister입니다.

<div class="content-ad"></div>

### Math.random()이 어떻게 작동하는지

Mersenne Twister는 긴 주기와 고품질의 난수로 유명합니다. 다음은 JavaScript에서 Mersenne Twister 알고리즘을 구현하는 간소화된 예제입니다:

```js
class MersenneTwister {
  constructor(seed) {
    if (seed === undefined) {
      seed = new Date().getTime();
    }
    this.mt = new Array(624);
    this.index = 0;
    this.mt[0] = seed;
    for (let i = 1; i < 624; i++) {
      this.mt[i] = (0x6c078965 * (this.mt[i - 1] ^ (this.mt[i - 1] >> 30)) + i) >>> 0;
    }
  }

  generate() {
    if (this.index === 0) {
      this.twist();
    }
    let y = this.mt[this.index];
    y = y ^ (y >> 11);
    y = y ^ ((y << 7) & 0x9d2c5680);
    y = y ^ ((y << 15) & 0xefc60000);
    y = y ^ (y >> 18);
    this.index = (this.index + 1) % 624;
    return y / 0xffffffff;
  }

  twist() {
    for (let i = 0; i < 624; i++) {
      const y = (this.mt[i] & 0x80000000) + (this.mt[(i + 1) % 624] & 0x7fffffff);
      this.mt[i] = this.mt[(i + 397) % 624] ^ (y >> 1);
      if (y % 2 !== 0) {
        this.mt[i] = this.mt[i] ^ 0x9908b0df;
      }
    }
  }
}

// 사용 예제:
const mt = new MersenneTwister(12345); // 시드 값
const randomNumber = mt.generate(); // 랜덤 숫자 가져오기
console.log(randomNumber);
```

이 코드는 난수를 생성하는 데 사용되는 Mersenne Twister 알고리즘의 간소화된 버전을 보여줍니다.

<div class="content-ad"></div>

### Math.random()을 사용하여

JavaScript에서는 Math.random()을 사용하여 0(포함)과 1(미포함) 사이의 임의의 숫자를 생성할 수 있어요:

```js
const randomNumber = Math.random();
console.log(randomNumber);
```

## Python: random 모듈

<div class="content-ad"></div>

파이썬은 무작위 숫자를 생성하는 다양한 함수를 포함하는 random 모듈을 제공합니다. 파이썬의 random 모듈이 사용하는 기본 PRNG 알고리즘은 Mersenne Twister입니다.

### Python의 random 모듈 사용 방법

다음은 Python에서 무작위 숫자를 생성하는 예시입니다:

```python
import random

# 0.0부터 1.0까지의 무작위 부동 소수점 숫자 생성
random_float = random.random()
print(random_float)

# 1부터 100까지의 무작위 정수 생성
random_int = random.randint(1, 100)
print(random_int)

# 평균이 0이고 표준편차가 1인 정규분포에서 무작위 숫자 생성
random_normal = random.gauss(0, 1)
print(random_normal)
```

<div class="content-ad"></div>

### 랜덤 숫자 생성기 시드하는 방법

재현성을 보장하기 위해 Python에서 랜덤 숫자 생성기를 시드할 수 있습니다:

```python
import random

# 랜덤 숫자 생성기 시드
random.seed(12345)

# 랜덤 숫자 생성
print(random.random())
print(random.randint(1, 100))
```

동일한 시드 값을 사용하면 프로그램을 실행할 때마다 동일한 순서의 랜덤 숫자가 생성됩니다.

<div class="content-ad"></div>

## 결론

랜덤 숫자 생성은 다양한 응용 분야에서 중요한 개념입니다. JavaScript의 Math.random() 및 Python의 random 모듈에서 생성된 숫자는 완전히 무작위가 아니지만, 대부분의 실제 용도에는 충분히 무작위성을 제공합니다. 이러한 생성기가 어떻게 작동하는지 이해하고 효과적으로 사용하는 방법을 파악하는 것은 개발자와 연구자에게 모두 중요합니다.

본 문서는 JavaScript와 Python에서 랜덤 숫자가 생성되는 기본 개요와 Math.random() 및 Python의 random 모듈을 활용하는 실용적인 예제를 제공합니다.

랜덤 함수 생성 방법에 대해서 깊게 알아보자




## 렌더 엔진

ExpressoTS는 Express.js의 웹 서버 기능을 향상시켜 보기를 렌더링하는 과정을 간소화하여 제공합니다. ExpressoTS는 EJS, PUG 및 Handlebars (HBS)를 포함한 다양한 렌더 엔진을 기본으로 지원하여 개발자들이 추가 구성이 필요하지 않고 각 엔진별로 기본 설정이 제공되므로 쉽게 뷰를 렌더링할 수 있습니다.

## 지원하는 렌더 엔진

ExpressoTS는 다음과 같은 렌더 엔진을 지원합니다.

<div class="content-ad"></div>

- EJS
- PUG
- HBS (핸들바)

### 핸들바 구성 옵션

```js
export type HandlebarsOptions = {
    viewEngine?: string; // 사용할 뷰 엔진
    viewsDir?: string; // 뷰 폴더의 경로
    partialsDir?: string; // 파셜 폴더의 경로
};
```

#### 기본 핸들바 구성 옵션

<div class="content-ad"></div>

```js
{
    viewEngine: "hbs",
    viewsDir: <root>/views,
    partialsDir: <root>/views/partials,
}
```

### Default Folder structure

Default folder structure for Handlebars:

```js
src
views
|--partials
|   |--partial.hbs
|--index.hbs
```

<div class="content-ad"></div>

다른 엔진들은 모두 동일한 구조를 따릅니다. Handlebars에만 특정한 부분 폴더(partials folder)가 있는 점을 제외하고는요.

### Handlebars 파일 예시

```js
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>HBS 예시</title>
    </head>
    <body>
        <h1>Handlebars에서 안녕하세요</h1>
        <p>파셜 렌더링: {> partial}</p>
    </body>
</html>
```

## 다른 엔진 구성 옵션

<div class="content-ad"></div>

### Pug 구성 옵션

```js
export type PugOptions = {
    viewEngine?: string;
    viewsDir?: string;
};
```

#### 기본 Pug 구성 옵션

```js
{
    viewEngine: "pug",
    viewsDir: <root>/views,
}
```

<div class="content-ad"></div>

### EJS 구성 옵션

```js
export type EjsOptions = {
    viewsDir?: string;
    viewEngine?: string;
    serverOptions?: EjsOptionsServer;
};
```

#### 기본 EJS 구성 옵션

```js
{
    viewEngine: "ejs",
    viewsDir: <root>/views,
    serverOptions: {
        cache: true,
        compileDebug: false,
        debug: false,
        delimiter: "%",
        strict: false,
    },
}
```

<div class="content-ad"></div>

## 사용 방법

ExpressoTS를 설정하여 응용 프로그램에서 HBS(핸들바)와 같은 렌더 엔진을 사용하는 방법에 대해 알려드리겠습니다:

app.provider 구성 공급자에서 렌더 엔진을 설정할 수 있습니다:

```js
export class App extends AppExpress {
    private middleware: IMiddleware;
    private provider: ProviderManager;

    constructor() {
        super();
        this.middleware = container.get<IMiddleware>(Middleware);
        this.provider = container.get(ProviderManager);
    }

    protected configureServices(): void {
        // 렌더 엔진을 HBS로 설정합니다.
        this.setEngine(Engine.HBS);

        this.middleware.setErrorHandler();
    }

    protected async postServerInitialization(): Promise<void> {
        if (this.isDevelopment()) {
            this.provider.get(Env).checkAll();
        }
    }

    protected serverShutdown(): void {}
}
```

<div class="content-ad"></div>

만약 렌더 엔진에 사용자 정의 옵션을 전달하려면, 원하는 옵션을 포함한 객체를 setEngine 메서드에 전달하면 됩니다. 예를 들어, 보기 디렉토리를 사용자 정의 경로로 설정하려면 다음과 같이 할 수 있습니다:

```js
this.setEngine<HBS>(Engine.HBS, { viewsDir: <<custom-path>> });
```

### ExpressoTS에서 보기 렌더링하는 방법

ExpressoTS에서 보기를 렌더링하려면 Response 객체에서 제공하는 render 메서드를 사용할 수 있습니다. 아래는 ExpressoTS에서 보기를 렌더링하는 예시입니다:

<div class="content-ad"></div>

```js
@Get("/")
root(@response() res: Response) {
    res.render("index", { date: new Date(), name: "Random information" });
}
```

위 예제에서는 Response 객체의 render 메서드가 호출되어 렌더링할 뷰의 이름과 뷰로 전달할 데이터가 포함된 객체가 전달됩니다. 뷰 엔진은 제공된 데이터로 뷰를 렌더링하고 렌더링된 HTML을 클라이언트에게 반환합니다.

### Render 데코레이터

@Render 데코레이터는 컨트롤러 메서드에 사용하여 지정된 뷰 엔진을 사용해 뷰를 렌더링하는 데에 사용할 수 있습니다. 다음은 ExpressoTS에서 @Render 데코레이터를 사용하여 뷰를 렌더링하는 방법의 예시입니다:

<div class="content-ad"></div>

#### 데코레이터에서 뷰 및 기본 데이터 전달 렌더링

```js
@Get("/")
@Render("index", { date: new Date(), name: "랜덤 정보" })
root() {}
```

#### 데코레이터에서 뷰만 전달 렌더링

```js
@Get("/")
@Render("index")
root() {
    return { date: new Date(), name: "랜덤 정보" };
}
```

<div class="content-ad"></div>

행복한 코딩하세요! 🐎

ExpressoTS Render 엔진 개념 및 내용 정리





![Image](/assets/img/2024-07-23-WhatstheProblemwithInheritanceinProgramming_0.png)

일부 사람들에게는 C++ 또는 Java와 같은 언어를 통해 객체 지향 프로그래밍을 배운 사람들에게는 상속이 OOP의 선행 조건이 아니라는 것이 놀라울 수 있습니다.

일부 프로그래밍 언어는 상속을 지원하지 않지만 상속이 있는 언어보다 여전히 더 객체 지향적으로 간주됩니다.

Erlang 프로그래밍 언어의 창시자인 Joe Armstrong은 Erlang이 유일한 진정한 객체 지향 언어일 수도 있다고 말한 적이 있습니다.


<div class="content-ad"></div>

알란 케이, 오래된 순수 OOP 언어 중 하나인 Smalltalk의 발명가도 동의했습니다.

Erlang은 주요 OOP 언어인 Java나 C++과는 근본적으로 다른 함수형, 액터 기반 언어입니다. 클래스와 상속을 갖고 있지 않지만 메시지 전달과 캡슐화를 지원합니다.

클래스 자체가 OOP에 꼭 필요한 것은 아니기 때문에 상속이 필수적이지 않다고 받아들이기 쉽습니다.

Self가 이 분야의 초기 개척자인 프로토타입 기반 언어로 알려진 클래스 없이 객체 지향 언어 패밀리도 있습니다.

<div class="content-ad"></div>

나의 경험에 따르면, 상속은 객체 지향 언어에서 가장 남용되는 기능 중 하나입니다.

이 글에서는 상속과 관련된 문제점을 강조하는 몇 가지 예시를 소개하겠습니다.

탱크 전투 게임을 작성한다고 가정해봅시다. 많은 사람들은 다음과 같이 상속을 사용하여 도메인을 모델링할 것입니다:

탱크는 AmoredVehicle을 확장하고, AmoredVehicle은 Vehicle을 확장합니다.

<div class="content-ad"></div>

이것은 순수하게 분류학적인 관점에서만 의미가 있지만, 우리의 목표는 분류체계를 만드는 것이 아닙니다.

더 중요한 것은 게임 엔진의 관점에서 의미가 있는지 여부이며, 우리 자신의 관점이 아닙니다.

게임 엔진은 탱크를 캔버스에 그리고, 탱크와 다른 장애물 간의 충돌을 확인하며, 탱크를 애니메이션화해야합니다.

탱크는 보이는 객체이고, 애니메이션이 적용되며, 물리적입니다.

<div class="content-ad"></div>

이러한 속성을 인터페이스로 표현할 수 있습니다. 여기서는 단일 상속 언어(예: Java) 관점에서 여러 인터페이스의 구현이 허용되지만 다중 상속은 허용되지 않습니다.

다중 상속에는 자체적인 문제가 있습니다. 이에 대해 자세히 설명하지는 않겠지만, 인터페이스를 사용하면 이러한 문제를 피할 수 있습니다.

```java
interface Visible { 
  void draw(Canvas c);
}

interface Animated {
  void tick();
}

interface Physical { 
  Shape hitBox();
  Shape hurtBox();
}

class Tank implements Visible, Animated, Physical { .. }

class Screen {
  [..]
  void draw() {
    for (Visible each : obj)
      each.draw(canvas);
  }
}

[..]

// 게임 루프
animations.tick();
screen.draw();
collisionDetector.check();
```

실제로 탱크가 실제로 차량과 같다고 해서 프로그램에서 반드시 차량 클래스를 가져야 하는 것은 아닙니다.

<div class="content-ad"></div>

게임에서는 "차량"을 고려하지 않을 수 있으며, 대신 렌더링, 애니메이션 및 서로 충돌할 수 있는 객체를 고려합니다.

이제 다음을 고려해 봅시다: 우리는 서로 다른 종류의 포탑, 엔진 및 라디오를 가진 탱크를 표현해야 합니다.

또한 게임 중에 이러한 요소를 동적으로 변경해야 할 수도 있습니다.

상속은 정적이며, 많은 언어에서는 단일 상속만 지원합니다.

<div class="content-ad"></div>

```js
class 탱크 { ... }

class 120mm포탑탱크 extends 탱크 { ... }
class V12트윈터보엔진탱크 extends 탱크 { ... }
class 둘다있는탱크 extends ??? { ... }
```

그래서 위의 방식은 작동하지 않을 것입니다.

서브클래스로 모든 조합을 표현하는 대신, 다양한 구성 요소를 사용하여 탱크를 함께 구성할 수 있습니다.

```js
탱크 tank = new 탱크(
  new 105mm포탑(),
  new V12트윈터보엔진(),
  new 단거리라디오()
);

tank.무기업그레이드(new 150mm포탑());
```

<div class="content-ad"></div>

이렇게 하면 서로 다른 탱크와 장비를 섞어서 사용할 수 있고, 동적으로 변경할 수도 있습니다.

상속의 또 다른 문제는 하위 클래스가 기본 클래스의 구현 세부 정보와 결합될 수 있다는 것입니다.

다음과 같은 기본 클래스가 있다고 상상해보세요. 여기서 addAll 메서드는 내부적으로 add 메서드를 사용하는 방식으로 구현되어 있습니다. 이것은 구현 세부 정보입니다.

```js
class MyList<T> {

  void add(T item) { .. }

  void addAll(T... items) {
    for (T each : items)
      add(each);
  }
}
```

<div class="content-ad"></div>

우리는 요소를 추가한 횟수에 대한 통계를 유지하는 서브클래스를 만들고 싶어해요.

```js
class MyListWithStatistics<T> extends MyList<T> {
  int timesAdded = 0;
  
  @Override
  void add(T item) {
    timesAdded++;
    super.add(item);
  }

  @Override
  void addAll(T... items) {
    timesAdded += items.length;
    super.addAll(items);
  }  
}
```

우리는 단순한 카운터를 증가시키고 슈퍼클래스의 메소드를 호출하는 방식으로 작업합니다.

그러나 리스트에 5개의 항목을 추가한 후에는 카운터가 8로 증가합니다. 왜냐하면 add 및 addAll 두 곳에서 카운터를 증가시켰고 후자는 전자를 사용했기 때문이에요.

<div class="content-ad"></div>

```js
var list = new MyListWithStatistics<Integer>();
list.add(1);
list.add(2);
list.addAll(3, 4, 5);
System.out.println(list.timesAdded);
```

이 문제는 addAll을 오버라이드하지 않고 수정할 수 있습니다. 그러나 핵심은 하위 클래스가 여전히 상위 클래스의 이 구현 세부 정보에 결합되어 있다는 것입니다.

누군가 상위 클래스의 구현을 변경할 때마다 하위 클래스도 영향을 받을 수 있습니다.

만약 데코레이터와 같은 합성을 사용했다면 이 문제를 피할 수 있었을 것입니다.

<div class="content-ad"></div>

사항이 완벽하지 않아도, 별도로 논의해야 할 아이덴티티와 평등에 관련된 문제가 발생할 수 있습니다.

구성을 사용할 때 객체의 외부 인터페이스에만 의존하므로 결합이 약해집니다.

![그림](/assets/img/2024-07-23-WhatstheProblemwithInheritanceinProgramming_1.png)

원래 질문으로 돌아가면, Dog가 Animal을 상속해야 할까요?

<div class="content-ad"></div>

그건 경우에 따라 다를 거예요. 프로그램 관점에서 유용한가요? 개가 실생활에서 동물이라고 해서 반드시 프로그램 안에서도 같은 방식으로 표현해야 한다는 뜻은 아니에요.

우리 프로그램 안에 개와 고양이와 같은 다른 종류의 객체가 혼합된 컬렉션이 있는가요?

만약 그것이 예라면, 다른 종류의 동물들 간에 공통점을 포착할 수 있는 추상화가 필요할 가능성이 높아요. 이를 인터페이스나 슈퍼클래스를 사용하여 구현할 수 있어요.

그렇다고 해서 추상화를 반드시 Animal이어야 하는 것은 아니에요. 예를 들어, 개와 고양이가 플레이어에 대항하는 적인 게임에서는 적을 나타내는 추상화를 사용하는 것이 더 나을 수도 있어요.

<div class="content-ad"></div>

프로그램이 이러한 객체들을 사용하는 방식에서 결정되어야지 생물학 수업에서만 알 수 있는 거 아니지 않을까요?

당신이 생각하기에 가장 과도하게 사용되는 프로그래밍 언어 기능은 무엇인가요?

Posts