


자바 프로그래밍에서 개발자들이 종종 직면하는 문제 중 하나는 초기화되지 않은 정적 변수에 의해 발생하는 오류입니다. 이러한 오류는 예상치 못한 동작, 충돌 또는 코드의 비효율성으로 이어질 수 있습니다.

이 문제는 정적 블록을 올바르게 사용하는 방법을 모르기 때문에 주로 발생합니다.

자바의 정적 블록은 정적 변수를 초기화하고 클래스의 인스턴스 수와 관계없이 한 번만 실행되어야 하는 코드를 실행하는 수단을 제공합니다.

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

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

이 글에서는 자바에서 static 블록의 개념을 설명하고, static 블록이 어떻게 작동하는지 그리고 사용하는 방법에 대한 최상의 실천 방법을 살펴볼 것입니다.

이 글을 마치면 자바에서의 static 블록에 대한 이해를 가지고 코드의 품질과 성능을 향상시키는 데 static 블록을 어떻게 사용해야 하는지에 대한 좋은 이해를 얻을 것입니다.

# static 블록이란

자바에서 static 블록은 ''로 둘러싸인 코드 블록으로, static 키워드 앞에 위치합니다. 해당 클래스가 자바 가상 머신(JVM)에 로드될 때 실행되는 블록으로, 일반적으로 클래스의 인스턴스가 생성되기 전에 실행됩니다. static 블록의 기본 구문은 다음과 같습니다:

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

```java
public class MyClass {
  static {
      // Static block code here
  }
}
```

# 정적 블록을 사용하는 시기

정적 블록은 여러 중요한 이유로 사용됩니다:

정적 변수의 초기화 - 정적 블록은 주로 정적 변수를 초기화하는 데 사용됩니다. 인스턴스 변수와는 달리 정적 변수는 클래스의 모든 인스턴스에서 공유되며 클래스의 객체를 만들지 않고도 액세스할 수 있습니다.

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

```java
public class AppConfig {

    static Properties config;

    static {
        // 예시: 파일에서 구성 설정 로드
        try (InputStream input = new FileInputStream("config.properties")) {
            config = new Properties();
            config.load(input);
        } catch (IOException e) {
            // 파일 로딩 예외 처리
            e.printStackTrace();
        }
    }

    public static String getProperty(String key) {
        return config.getProperty(key);
    }
}
```

이 예제에서 정적 블록은 config.properties 파일로부터 구성 설정을 Properties 객체(config라는 이름으로)에 로드합니다. 이 설정을 통해 AppConfig 클래스가 처음 액세스될 때 한 번만 구성 데이터가 로드됩니다.

복잡한 초기화 작업 — 정적 블록은 데이터베이스에 연결 설정, 정적 컬렉션 초기화 또는 클래스 작동에 필요한 리소스 로딩과 같이 복잡한 설정이 필요한 정적 필드 초기화에 적합합니다.

```java
public class DatabaseConnection {

    static Connection conn;

    static {
        // 예시: 데이터베이스 연결 설정
        try {
            conn = DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            // 데이터베이스 연결 예외 처리
            e.printStackTrace();
        }
    }
}
```

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

여기서 static 블록은 JDBC를 사용하여 정적 Connection 객체 conn을 초기화하며, DatabaseConnection 인스턴스가 사용되기 전에 데이터베이스 연결이 설정되었음을 보장합니다.

예외 처리 - static 블록은 초기화 중에 발생할 수 있는 예외를 처리할 수 있습니다. 이를 통해 설정 중 발생한 모든 오류가 올바르게 로깅되거나 처리되어 클래스가 초기화에 실패할 경우 로드되지 않도록 보장합니다.

```java
public class MyClass {
    static {
        try {
            // 예외가 발생할 수 있는 코드
        } catch (Exception e) {
            // 예외 처리
            e.printStackTrace();
        }
    }
}
```

정적 초기화 중에 예외가 발생하면 JVM은 ExceptionInInitializerError를 throw하여 클래스의 초기화가 실패했음을 나타낼 수 있습니다.

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

# 실행 및 순서

- 실행 순서 정적 블록은 클래스 로딩 프로세스 중에 나타나는 순서대로 실행됩니다.
- 실행 시점 정적 블록은 JVM에 의해 클래스가 처음 메모리에 로드될 때 한 번만 실행됩니다.
- 초기화 보증 정적 블록을 사용하면 리소스가 액세스되기 전에 초기화되어 응용 프로그램 무결성과 신뢰성을 유지할 수 있습니다.

# 일부 단점

Java의 정적 블록에는 정적 변수가 올바르게 설정되고 코드가 한 번만 실행되는 것과 같은 많은 장점이 있지만, 단점도 있습니다.

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

일부 주요 정적 블록의 주요 단점은 다음과 같습니다:

- 유연성 부족: 정적 블록은 JVM에 의해 클래스가 로드될 때 실행되며, 프로그래머가 명시적으로 제어하거나 호출할 수 없습니다. 코드를 변경할 수 없는 경우, 원하는 때나 일어날 때 변경하는 것이 어려울 수 있습니다.
- 정적 블록에서 예외 처리가 제한됩니다. 정적 블록에서 예외가 발생할 경우 예상치 못한 동작을 일으키고 프로그램을 중단시킬 수 있습니다. 정적 블록의 오류를 수정하는 것이 어려울 수 있으며 추가적인 주의가 필요할 수 있습니다.
- 클래스에서 너무 많은 정적 부분을 사용하면 코드를 읽고 이해하기 어려워질 수 있습니다. 정적 블록은 다른 개발자들이 코드를 이해하고 변경하거나 유지하는 데 어렵게 만들 수 있습니다.
- 테스트가 어려울 수 있습니다. 정적 블록은 클래스가 로드될 때 자동으로 실행되며 프로그램의 다른 부분에 영향을 줄 수 있습니다. 이로 인해 특정 기능을 테스트하기 어려워질 수 있으며 코드 품질과 신뢰성 문제로 이어질 수 있습니다.
- 정적 블록은 클래스의 JVM 로딩에 바인딩되어 있으므로 여러 클래스가 동시에 로드될 때 예측할 수 없는 순서로 실행될 수 있습니다. 이 연결로 인해 복잡한 프로그램의 시작과 종료를 제어하는 것이 어려울 수 있습니다.

개발자가 정적 블록의 잠재적인 단점을 알고 이를 올바르게 사용하여 복잡성을 피하고 코드 품질을 유지하는 것이 중요합니다.

원문: https://www.1kevinson.com

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

이 글을 즐겁게 읽으셨기를 바랍니다. 이 튜토리얼이 도움이 되었는지 궁금합니다. 아래 댓글로 의견을 남겨주세요.

새로운 블로그 글을 놓치지 않으려면 뉴스레터를 구독하지 않도록 주의하세요.

또한 LinkedIn • Twitter • GitHub 또는 내 블로그에서 저를 찾아보실 수 있습니다.

Java 코드 최적화를 위한 static 블록 활용하는 방법 정리




![Spring Boot: Handling a REST Endpoint That Queries More Data Than Available Memory](/assets/img/2024-07-23-SpringBootJDBCQueryMoreDataThanAvailableMemory_0.png)

이 글 "Spring Boot: 사용 가능한 메모리보다 많은 데이터를 쿼리 처리하는 REST 엔드포인트 다루기"에서는 Spring Boot에서 사용 가능한 메모리보다 많은 데이터를 반환하는 REST 엔드포인트를 어떻게 만들 수 있는지 보여줍니다. 이 글에서는 JPA 대신 Spring Boot JDBC를 사용하여 이를 어떻게 달성할 수 있는지 살펴봅시다.

# 시나리오

같은 데이터베이스를 재사용하여, 백만 개의 주문과 500만 개 이상의 주문 항목을 갖습니다:

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

<img src="/assets/img/2024-07-23-SpringBootJDBCQueryMoreDataThanAvailableMemory_1.png" />
지금은 데이터를 저장하는 방법을 간소화하기 위해 평평한 DTO를 사용해봅시다.

```js
@Data
public class ReportDto {
  private final Long orderId;
  private final LocalDate date;
  private final String customerName;
  private final BigDecimal totalAmount;
  private final String currency;
  private final String status;
  private final String paymentMethod;
  private final Long productId;
  private final String productName;
  private final Integer quantity;
  private final BigDecimal price;
  private final BigDecimal itemTotalAmount;
}
```

다음 SQL 쿼리를 사용하여 데이터를 가져올 것이며, JdbcTemplate 클래스를 사용하여 쿼리를 실행할 것입니다:

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

```js
SELECT o.id, o.date, c.first_name, o.total_amount, o.currency, o.status, 
       o.payment_method, oi.product_id, p.name, oi.quantity, oi.price, 
       oi.total_amount
  FROM orders o
  JOIN customers c ON c.id = o.customer_id
  JOIN order_items oi ON oi.order_id = o.id
  JOIN products p ON p.id = oi.product_id
```

# 시도 1: queryForList 메서드 사용

queryForList 메서드를 사용하여 쿼리에서 반환된 각 필드-값 쌍을 포함하는 맵의 리스트를 반환하는 방법은 작동하지 않았습니다.

```js
@Controller
@RestController
@RequiredArgsConstructor
public class ReportController {

  private final ReportService reportService;

  @GetMapping("/v4/report")
  public ResponseEntity<List<ReportDto>> report4() {
    final var body = reportService.getResult();
    return ResponseEntity.ok(body);
  }
}

@Service
@RequiredArgsConstructor
public class ReportService {
  private final JdbcTemplate jdbcTemplate;

  public List<ReportDto> getResult() {
    List<Map<String, Object>> queryResult = jdbcTemplate.queryForList(QUERY);

    return toReportDto(queryResult);
  }
}
```

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

우리가 기대한 대로, 각 항목이 맵인 리스트에 전체 결과를 저장하면 다음 오류가 발생합니다:

```js
서블릿 [dispatcherServlet]의 서비스()이 경로가 있는 컨텍스트에서 
  예외를 던짐 [핸들러 디스패치 실패: java.lang.OutOfMemoryError: 
    Java heap space]

java.lang.OutOfMemoryError: Java heap space
```

# 시도 2: RowMapper를 사용한 query 메서드 사용

일반 결과를 반환하고 이를 DTO로 매핑하는 대신, 쿼리 처리 중에 RowMapper를 사용하여 매핑합시다.

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

```java
@Controller
@RestController
@RequiredArgsConstructor
public class ReportController {

  private final ReportService reportService;

  @GetMapping("/v5/report")
  public ResponseEntity<List<ReportDto>> report5() {
    final var body = reportService.getResult();
    return ResponseEntity.ok(body);
  }
}

@Service
@RequiredArgsConstructor
public class ReportService {
  private final JdbcTemplate jdbcTemplate;

  public List<ReportDto> getResult() {
    return jdbcTemplate.query(QUERY, (rs, rowNum) -> mapToReportDto(rs));
  }
}
```

이 접근 방식은 작동하는 것 같지만, 쿼리는 DTO로 매핑하기 전에 모든 데이터를 읽기 때문에 메모리 부족 오류가 발생할 수 있습니다.

# 시도 3: queryForStream 메서드 사용

다음 시도는 데이터베이스에서 스트림을 반환할 수 있는 queryForStream 메서드를 사용하는 것입니다. 그러나 이 전 시도와 유사한 구현이므로 성공하지 못했습니다.


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


@Controller
@RestController
@RequiredArgsConstructor
public class ReportController {

  private final ReportService reportService;

  @GetMapping("/v6/report")
  public ResponseEntity<List<ReportDto>> report6() {
    final var body = reportService.getResult();
    return ResponseEntity.ok(body);
  }
}

@Service
@RequiredArgsConstructor
public class ReportService {
  private final JdbcTemplate jdbcTemplate;

  public List<ReportDto> getResult() {
    return jdbcTemplate.queryForStream(QUERY, 
                                       (rs, rowNum) -> mapToReportDto(rs));
  }
}

# Try 4: Using the query Method with RowCallbackHandler

In JdbcTemplate, we can use a query method that accepts a RowCallbackHandler to process rows one-by-one and map them to the DTO, preventing the memory waste of holding both the query result and the DTOs simultaneously. Additionally, let’s set the fetch size to 1000, which makes JdbcTemplate fetch data in chunks of 1000 results instead of all at once.

```java
@Controller
@RestController
@RequiredArgsConstructor
public class ReportController {

  private final ReportService reportService;

  @GetMapping("/v7/report")
  public ResponseEntity<List<ReportDto>> report7() {
    final var body = reportService.getResult();
    return ResponseEntity.ok(body);
  }
}

@Service
@RequiredArgsConstructor
public class ReportService {
  private final JdbcTemplate jdbcTemplate;

  public List<ReportDto> getResult() {
    jdbcTemplate.setFetchSize(1000);

    final var result = new ArrayList<ReportDto>();

    jdbcTemplate.query(
        QUERY,
        rs -> {
          while (rs.next()) {
            result.add(mapToReportDto2(rs));
          }
        });

    return result;
  }
}
```

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

하지만, 이 방법만으로는 충분하지 않습니다.

# 마지막으로: RowCallbackHandler와 query 메서드를 사용하여 결과 스트리밍하기

문제를 해결하기 위해 데이터베이스에서 데이터를 쿼리하는 방법을 변경하는 것 이상이 필요합니다. 데이터를 스트리밍해야 합니다. 변경 사항은 다음과 같습니다:

- 행별로 쿼리 결과를 처리할 수 있는 JdbcTemplate 쿼리 메서드 사용.
- 클라이언트에 데이터를 청크로 전송할 수 있도록 REST 엔드포인트에서 StreamingResponseBody 클래스 사용.

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

```java
@Controller
@RestController
@RequiredArgsConstructor
public class ReportController {

  private final ReportService reportService;

  @GetMapping("/v7/report")
  public ResponseEntity<StreamingResponseBody> report7() {
    final var body = reportService.getResult();
    return ResponseEntity.ok(body);
  }
}

@Service
@RequiredArgsConstructor
public class ReportService {
  private final JdbcTemplate jdbcTemplate;
  private final ObjectMapper objectMapper = new ObjectMapper();

 public StreamingResponseBody getResult() {
    jdbcTemplate.setFetchSize(1000);

    return outputStream -> {
      jdbcTemplate.query(
          QUERY,
          rs -> {
            while (rs.next()) {
              try {
                var json = objectMapper.writeValueAsString(mapToReportDto(rs));
                outputStream.write(json.getBytes(StandardCharsets.UTF_8));

              } catch (final IOException e) {
                throw new RuntimeException(e);
              }
            }
          });
    };
  }
}
```

여기에는 다음이 있습니다:

- 컨트롤러는 결과 데이터를 스트리밍합니다.
- 서비스는 가져올 행 수를 1000으로 설정하여 쿼리가 한 번에 데이터베이스에서 1000개의 행을 반환하도록합니다. 그렇지 않으면 JdbcTemplate 클래스가 한꺼번에 모든 데이터를 가져오려고 하여 메모리 부족 오류가 발생합니다.
- 각 결과 세트에 대해 DTO로 매핑하고 JSON으로 변환한 후 출력 스트림에 작성합니다.

우리의 목표를 달성했습니다. 이 엔드포인트는 30초 안에 500 만 레코드를 반환할 수 있었습니다!


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

# 결론

JPA 대신 JdbcTemplate을 사용하면 DTO 매핑과 같은 몇 가지 작업을 수동으로 수행해야하지만, 데이터를 가져오기 위한 복잡한 SQL 쿼리를 간단하게 만들어 줍니다.

저는 항상 JPA를 사용하는 것을 추천합니다. 왜냐하면 더 쉽게 구현할 수 있으며 일부 오타를 피할 수 있기 때문입니다. 그러나 JdbcTemplate을 사용하면 극도로 복잡한 쿼리를 쉽게 작성하고 빠르게 실행할 수 있습니다.

데이터를 가져오기 위해 사용하는 프레임워크에 관계없이 어떠한 종류의 메모리 문제도 해결할 수 있는 도구를 갖고 있습니다.

Spring Boot JDBC를 활용해 메모리 초과 데이터를 조회하는 방법  




이 상세 가이드에서는 Java 8의 새로운 유용한 기능인 Java Predicates에 대해 알아보게 됩니다. 이 기사에서는 Java Predicates가 무엇이고 다양한 방법으로 그들을 어떻게 사용하는지에 대해 설명합니다.

![Java Predicates](/assets/img/2024-07-23-ThebestwaytouseJava8Predicates_0.png)

데이터 필터링, Predicates 연결, 일반적인 실수 피하기에 대해 알아가실 수 있습니다. Java Predicates를 사용하면 Java 프로그래밍 기술을 향상시키고 응용 프로그램을 더 나은 수준으로 끌어올릴 수 있습니다.

# Java Predicates란 무엇인가요?

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

자바 8에서는 predicate이 java.util.function 패키지에 소개된 함수형 인터페이스입니다. 이는 인수를 받아 참 또는 거짓을 반환하는 부울 값 함수를 나타냅니다. Predicate 인터페이스에는 평가하는 부울 조건에 사용되는 test()라는 하나의 추상 메서드가 있습니다.

```java
@FunctionalInterface
public interface Predicate<T> {
  boolean test(T t);
}
```

일반적으로 predicate은 컬렉션 내 요소를 필터링하거나 평가하는 데 유용한 도구입니다.

# 시작하기

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

자바 Predicate는 람다식을 사용하여 정의할 수 있는 함수형 인터페이스입니다. 문자열이 짝수 길이인지 확인하는 Predicate의 간단한 예시를 살펴보겠습니다:

```java
Predicate<String> startWithLetterN = s -> s.startsWith("N");
```

위 코드에서 startWithLetterN은 문자열 s가 문자 N으로 시작하는지 확인하는 Predicate입니다. 이 로직을 정의하기 위해 람다 표현식 `s -> s.startsWith("N")`을 사용합니다.

Predicate를 정의했다면 test() 메서드를 사용하여 데이터를 평가할 수 있습니다.

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

```java
// Boolean result = startWithLetterN.test("Mateo");

@Test
void verify() {
    // assertThat(result).isFalse();
}
```

# 연쇄적인 Predicates

Predicates에 대해 연쇄적인 작업을 적용하는 것은 매우 간단하며, 첫 번째 Predicate에 대해 method 및 두 번째 Predicate를 매개변수로 전달하여 이를 달성할 수 있습니다.

```java
Predicate<String> startWithLetterP = s -> s.startsWith("P");
Predicate<String> lengthGreaterThan5 = s -> s.length() > 5;
Predicate<String> startWithPAndGreaterThan5 = startWithLetterP.and(lengthGreaterThan5);

@Test
void check() {
    assertThat(startWithPAndGreaterThan5.test("Penelope")).isTrue();
}
```

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

# Predictates로 데이터 필터링하기

Predictates는 데이터를 필터링하는 데 자주 사용됩니다. 예를 들어, 특정 조건과 일치하는 항목의 컬렉션을 필터링하는 데 사용할 수 있습니다. 다음은 Predictates를 사용하여 숫자 목록을 필터링하는 예제입니다:

```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

Predicate<Integer> isGreaterThan4 = n -> n > 4;
Predicate<Integer> isEven = n -> n % 2 == 0;
List<Integer> matchingNumbers = numbers.stream()
        .filter(isEven.and(isGreaterThan4))
        .collect(Collectors.toList());

@Test
void check() {
    assertThat(matchingNumbers).hasSize(3).containsExactly(6, 8, 10);
}
```

다양한 Predictates 메서드를 사용하여 모든 필요한 경우에 일치시킬 수 있습니다.

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

자바 Predicates은 몇 가지 이점을 제공합니다. 인수로 전달되거나 결과로 반환될 수 있기 때문에 더 유연합니다. 또한 다른 문맥에서 조합하고 재사용할 수도 있습니다.

예를 들어, startWithLetterN과 같은 Predicate가 있다면 코드 전반에 걸쳐 여러 군데에서 사용할 수 있습니다. 이것은 루프 내에 정의된 조건이나 Stream의 filter() 메서드 내에서는 불가능합니다.

요약하자면, 자바에서 데이터를 필터링하는 데는 루프와 Stream을 사용할 수 있지만, 복잡한 조건과 큰 애플리케이션에서는 Predicates가 더 유연하고 재사용 가능한 접근법을 제공합니다.

# 피해야 할 함정들

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

자바 프레디케이트를 사용할 때 잠재적인 함정이 있습니다. 가장 흔한 함정 중 하나는 메소드 참조와 함께 발생하는 NullPointerExceptions입니다. 이는 일반적으로 null 값을 포함하는 컬렉션을 다룰 때 발생합니다.

```java
List<String> categories = Arrays.asList("Culture", "Entertainment", null);
Predicate<String> isShortWord = s -> s != null && s.length() < 4;

@Test
void check() {
    categories.stream()
        .filter(isShortWord)
        .forEach(System.out::println);
}
// 이 부분은 java.lang.NullPointerException을 발생시킬 것입니다. 🪲
```

이 예제에서는 짧은 단어를 가진 문자열 목록을 필터링하여 가져오려고 합니다. 그러나 목록에는 null 값이 포함되어 있어서 null 값을 호출하려고 할 때 NullPointerException이 발생합니다.

이 문제를 피하려면 Predicate에 null 값을 무시하는 추가적인 확인을 추가할 수 있습니다:

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

```java
List<String> categories = Arrays.asList("Culture", "Entertainment", null);
Predicate<String> isShortWord = s -> Objects.nonNull(s) && s.length() < 4;

@Test
void check() {
    categories.stream()
        .filter(isShortWord)
        .forEach(System.out::println);
}
// This will return an empty array []
```

또 다른 피해야 할 함정은 Predicate를 사용하여 연결된 작업의 순서입니다. and(), or(), negate()를 사용하여 Predicate를 연결할 때는 연산의 순서가 결과에 영향을 미칠 수 있다는 점을 기억해야 합니다.

예를 들어, null 값 처리에 대해 and() 연산은 교환 법칙을 따르지 않습니다:

```java
Predicate<Integer> isNotNull = Objects::nonNull;
Predicate<Integer> isGreaterThan3 = s -> s > 3;

Predicate<Integer> correctOrder = isNotNull.and(isGreaterThan3);
Predicate<Integer> incorrectOrder = isGreaterThan3.and(isNotNull);

@Test
void check() {
    System.out.println(correctOrder.test(null));  // false
    System.out.println(incorrectOrder.test(null));  // NullPointerException
}
```

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

# 끝

본 글은 Java Predicates를 마스터하는 포괄적인 가이드로 제공됩니다. Predicates가 어떻게 작동하는지, Java 프로그래밍에서 얼마나 중요한지, 그리고 코드에서 잘 활용하는 방법에 대해 배웠습니다.

이 가이드를 읽으면서 Java Predicates에 대해 배우고, 몇 가지 고급 기술을 습득하여 프로젝트에서 자신감 있고 능숙하게 사용할 수 있게 되었습니다.

이 글이 마음에 들었기를 바라며, 이 튜토리얼이 도움이 되었는지 궁금합니다. 아래 댓글로 의견을 알려주세요.

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

다가오는 블로그 포스트를 놓치지 않으려면 아래쪽에서 뉴스레터를 구독하는 걸 잊지마세요! 👇🏾

Java 8 Predicates 사용 방법 




이번 면접에서 면접관은 Java, Spring, Microservice, SQL, Kafka, 그리고 Hibernate에서 내 자신을 평가하라고 했어요. 아래에는 이번 면접에서 받은 모든 질문들을 적어봤어요.

- 마이크로서비스끼리 어떻게 효과적으로 통신할 수 있나요?

답변: 마이크로서비스는 서로 HTTP/REST나 gRPC와 같은 동기 방식, 실시간 요청을 위한 방법과 RabbitMQ, Kafka와 같은 메시지 브로커와 같은 비동기 방식을 사용하여 디커플링하고 확장 가능한 상호 작용을 할 수 있어요. 서비스 검색 도구와 API 게이트웨이를 활용하여 이러한 통신을 효율적으로 관리하고 최적화할 수 있어요.

2. SQL에서 언제 프로시저와 함수를 사용하나요?
답변: SQL에서 프로시저는 값을 반환하지 않는 작업을 수행하기 위해 자주 일련의 SQL 문을 실행하는 데 사용돼요. 그에 반해, 함수는 계산을 수행하고 단일 값을 반환하기 위해 사용돼요. 복잡한 비즈니스 로직에는 프로시저를 사용하고 SQL 쿼리 내에서 재사용 가능한 계산이나 변환을 위해 함수를 사용해요.

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

3. 어떤 캐싱 메커니즘을 사용해보셨나요?
답변: 저는 여러 가지 캐싱 메커니즘을 사용해봤어요, 그중에는 다음과 같은 것들이 있습니다:

- In-Memory Caching: 자주 액세스되는 데이터를 빠르게 검색하기 위해 Java 애플리케이션에서 Ehcache나 Guava와 같은 라이브러리를 사용하여 메모리에 저장합니다.
- Distributed Caching: Redis나 Memcached와 같은 도구를 사용하여 캐시된 데이터를 여러 서버 간에 공유하여 확장성과 신뢰성을 향상시킵니다.
- HTTP Caching: Varnish와 같은 캐싱 헤더 및 프록시를 구현하여 HTTP 응답을 캐시하고 백엔드 서버의 부하를 줄입니다.

4. 응집도와 결합도란 무엇이며, 어떤 종류의 결합도가 있나요?
답변: 응집도는 단일 모듈이나 구성 요소의 책임이 얼마나 관련되고 집중되어 있는지를 나타내며, 유지보수성을 위해 높은 응집도가 바람직합니다.

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

결합이란 모듈 간 상호 의존성의 정도를 나타내며, 낮은 결합은 유연성을 위해 바람직합니다. 결합의 종류에는 내용, 공통, 제어, 스탬프, 데이터 및 메시지 결합이 있으며, 의존성이 가장 높은 것부터 가장 낮은 것까지 다양합니다.

5. eh-cache에 대해 설명해 줄 수 있나요? 캐시에 모든 데이터를 로드하거나 특정 레코드를 로드하나요?
답변: Eh-cache는 효율적인 데이터 캐싱을 제공하는 Java 기반 인-메모리 캐싱 라이브러리입니다. 구성 설정에 따라 요청 시 특정 레코드를 로드하거나 캐시로 데이터를 미리로드(preload)할 수 있습니다.

6. get()과 load()의 차이는 무엇인가요?
답변: 

- get(): 즉시 데이터베이스에서 객체를 검색하거나 객체를 찾을 수 없는 경우 null을 반환하며, 검색 시점에 객체가 완전히 초기화되도록 보장합니다.
- load(): 데이터베이스에 즉시 접근하지 않고 프록시 객체를 반환하며, 최초 접근 시 객체를 찾을 수 없으면 예외를 throw합니다.

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

7. Hibernate에서 뷰와 조인을 어떻게 다루나요?
답변: Hibernate에서 뷰와 조인은 아래와 같이 다룹니다:

뷰 처리:

- Entity에 매핑:

- 뷰를 테이블처럼 취급하여 엔티티 클래스에 매핑합니다.

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

```java
@Entity
@Table(name = "view_name")
public class ViewEntity {
    // fields and mappings
}
```

2. 읽기 전용 구성:

- 보통 뷰는 읽기 전용이므로, 해당 엔티티를 읽기 전용으로 구성할 수 있습니다.

```java
@Entity
@Table(name = "view_name")
public class ViewEntity {
    // fields and mappings
}
```

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

# 조인 처리:

- JPQL/HQL:

- 엔티티 간 조인을 수행하려면 JPQL(Java Persistence Query Language) 또는 HQL(Hibernate Query Language)을 사용하세요.

```java
String hql = "SELECT e FROM Employee e JOIN e.department d WHERE d.name = :deptName";
List<Employee> results = session.createQuery(hql)
                                 .setParameter("deptName", "Sales")
                                 .list();
```

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

2. Criteria API:

Criteria API를 사용하여 조인에 대해 더 프로그래밍적인 접근 방식을 사용하세요.

```java
CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
Root<Employee> employee = cq.from(Employee.class);
Join<Employee, Department> department = employee.join("department");
cq.select(employee).where(cb.equal(department.get("name"), "Sales"));
List<Employee> results = session.createQuery(cq).getResultList();
```

3. Named Queries:

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

- 엔티티 클래스 내에서 명명된 쿼리에서 조인을 정의합니다.

```js
@NamedQuery(
    name = "Employee.findByDepartment",
    query = "SELECT e FROM Employee e JOIN e.department d WHERE d.name = :deptName"
)
```

위의 방법을 사용하여 하이버네이트에서 뷰와 조인을 처리하여 필요한대로 데이터를 검색하고 조작할 수 있습니다.

Kafka 용어와 작동 방식에 대해 설명하시오.

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

답변: Apache Kafka는 프로듀서가 레코드를 토픽에 보내고, 컨슈머가 이러한 레코드를 토픽에서 읽는 분산 이벤트 스트리밍 플랫폼입니다. 브로커는 레코드의 저장 및 검색을 관리하며, 토픽 내 파티션은 병렬 처리와 확장성을 가능하게 합니다. Kafka는 실시간 데이터 처리의 고 처리량, 내고장성 및 내구성을 보장합니다.

9. 언제 SQL 및 NoSQL을 사용하나요?

답변: SQL (구조화된 쿼리 언어) 및 NoSQL(Not Only SQL) 데이터베이스는 데이터의 성격 및 응용 프로그램의 특정 요구 사항에 따라 다른 시나리오에서 사용됩니다:

SQL을 사용하는 경우:

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

- 구조화된 데이터: 데이터가 매우 구조화되어 있고 스키마를 따를 때는 SQL 데이터베이스가 데이터 무결성과 일관성을 보장하기에 적합합니다.
- ACID 트랜잭션: 트랜잭션이 원자성, 일관성, 고립성, 지속성 보장이 필요할 때 SQL 데이터베이스는 견고한 지원을 제공합니다.
- 복잡한 쿼리: 복잡한 조인, 집계 및 주어진 쿼리를 필요로 하는 응용프로그램에서는 SQL 데이터베이스가 강력한 쿼링 기능을 제공하는 데 뛰어납니다.
- 수직 확장성: 수직 확장성(단일 서버에 더 많은 자원을 추가하여 확장)으로 응용프로그램의 성능 요구를 충족할 때.

NoSQL을 사용하는 경우:

- 비구조화 또는 반구조화된 데이터: 데이터가 스키마 없거나 관계형 모델에 잘 적합하지 않을 때는 NoSQL 데이터베이스가 유연성을 제공합니다.
- 확장성 및 가용성: NoSQL 데이터베이스는 수평 확장성(여러 서버에 걸쳐 확장)을 위해 설계되어 있어 대량의 데이터 및 고 처리량을 다루기에 적합합니다.
- 최종 일관성: 최종 일관성(데이터 일관성이 시간이 지남에 따라 달성)이 허용되고 가용성 및 분할 허용에 대한 일관성 요구가 완화된 경우.
- 문서, 키-값, 그래프 또는 칼럼 데이터 모델: 특정 NoSQL 데이터베이스 유형(예: 문서용 MongoDB, 키-값 쌍용 Redis, 그래프용 Neo4j)에 따라 데이터 모델이 응용프로그램 요구 사항과 일치하는 경우.

SQL과 NoSQL 중 어느 것을 선택할지는 데이터 구조, 확장성 요구 사항, 일관성 요구 사항 및 응용프로그램의 특정 사용 사례와 같은 요인에 따라 결정됩니다. 종종 각 유형의 장점을 활용하기 위해 하이브리드 접근법이나 다중 데이터 저장소(동일 시스템 내에서 SQL 및 NoSQL 데이터베이스 모두 사용)이 채택됩니다.

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

10. 성능 테스트에는, 웹 애플리케이션의 부하 테스트에 Apache JMeter를 주로 사용하고, 실시간 모니터링 및 상세 보고에는 Gatling을 사용하며 때로는 간단한 HTTP 서버 벤치마킹을 위해 Apache Bench (ab)를 사용합니다. 각 도구는 다양한 조건 하에서 응용 프로그램 성능을 측정하는 데 특정 강점을 제공합니다.

11. 서비스 및 데이터베이스 계층을 어떻게 테스트합니까?
답변: 서비스 계층을 테스트하기 위해, Mockito와 같은 mocking 프레임워크를 사용하여 의존성을 격리하고 비즈니스 로직을 검증하는 단위 테스트를 사용합니다. 데이터베이스 계층 테스트에는 올바른 데이터 상호작용 및 쿼리 실행을 보장하기 위해 내부 메모리 데이터베이스나 테스트 컨테이너와 같은 통합 테스트를 활용합니다. 단, 프로덕션 데이터에 영향을 미치지 않습니다.

12. Java에서 데이터 동시성을 처리하는 방법은 무엇인가요?
답변: 저는 이 주제에 대해 상세한 기사를 작성했습니다.

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

이 링크를 방문해주세요: Java에서 데이터 동시성을 다루는 방법

감사합니다. 여러분들이 면접 준비에 도움이 될 수 있기를 바랍니다.

- 👏 이 글에 박수를 보내주세요. 글을 널리 퍼지게 도와주세요 👏
- 🔔 팔로우하기: Medium | LinkedIn
- ✉️ 뉴스레터 구독하기

시니어 자바 개발자 면접 준비 및 질문 정리




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

러스트는 종종 시스템 프로그래밍 언어로만 인식되지만 실제로 다재다능한 범용 언어입니다. 데스크톱 앱을 위한 Tauri, 프론트엔드 개발을 위한 Leptos, 백엔드 개발을 위한 Axum과 같은 프로젝트들은 러스트가 시스템 프로그래밍에 그치지 않고 더 다양하게 활용될 수 있다는 것을 보여줍니다.

저는 러스트를 배우기 시작할 때 웹 애플리케이션을 만들어 연습했어요. 주로 백엔드 엔지니어로 활동하고 있기 때문에 이 분야에 가장 익숙했습니다. 러스트는 웹 개발에 최적인 것을 빨리 깨달았죠. 그 기능들 덕분에 신뢰성 있는 애플리케이션을 만들 수 있습니다. 러스트가 웹 프로그래밍에 완벽한 이유에 대해 설명하겠습니다.

## 에러 처리

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

얼마 전에, 머신 러닝 열풍에 휩싸여 LLM 열풍 이전에 파이썬으로 시작했습니다. 머신 러닝 모델을 이용할 필요가 있어 Django REST API를 작성하기로 결정했습니다. Django에서 요청 본문을 얻으려면 다음과 같은 코드를 작성해야 합니다.

```js
class User(APIView):
    def post(self, request):
        body = request.data
```

이 코드는 대부분의 경우 잘 작동합니다. 그러나 요청 본문을 잘못 보낸 경우 작동을 멈췄습니다. 데이터에 액세스하려고 시도하면 예외가 발생하여 500 상태 코드 응답이 발생했습니다. 접근이 예외를 유발할 수 있다는 점에 대해 전혀 인식하지 못했고 명확한 표시가 없었습니다.

Rust는 이를 다르게 처리하여 예외를 던지지 않고 오류를 결과 양식의 값으로 반환합니다. 결과에는 값과 오류가 모두 포함되어 있으며 값을 액세스하기 전에 오류를 처리해야 합니다.

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

```js
let body: RequestBody = serde_json::from_slice(&requestData)?;
```

물음표(?)는 호출하는 함수에서 오류를 처리하고 오류를 한 수준 더 상위로 전파하려는 것을 나타냅니다.

나는 오류를 값으로 처리하는 모든 언어가 정확하게 하는 것이라고 믿습니다. 이 방식은 예상치 못한 놀라움이 없도록 코드를 작성할 수 있게 합니다. 파이썬 예시에서 한 것과 같이요.

## 기본 변경 불가능성

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

요즘, 제 동료 중 한 분이 오픈 소스 프로젝트 중 하나에서 작업을 했어요. 그분은 클라이언트 라이브러리를 다른 것으로 교체해야 했어요. 그 분이 사용한 코드는 이렇습니다:

```js
newClient(
 WithHTTPClient(httpClient), // &http.Client{}
 WithEndpoint(config.ApiBasePath),
)
```

갑자기 연동 테스트에서 레이스 컨디션 오류가 발생했고, 그 분은 왜 그런지 이해할 수 없었어요. 도움을 요청해와서 문제를 추적해보니 이 코드 줄로 돌아왔어요. HTTP 클라이언트를 여러 클라이언트 사이에서 공유하고 있어서 오류가 발생했었어요. 여러 고루틴이 클라이언트를 읽고 WithHttpClient 함수가 클라이언트를 변형했기 때문에 일어난 문제였어요. 동일 자원에 독자와 작성자 스레드 모두가 있는 것은 Go에서 정의되지 않은 동작이나 패닉으로 이어질 수 있어요.

이는 또 다른 불쾌한 놀람이었어요. 그러나 Rust에서는 모든 변수가 기본적으로 변경할 수 없어요. 변수를 변경하려면 mut 키워드를 사용하여 명시적으로 지정해야 해요. API 클라이언트가 발생하는 일을 이해하고 예상치 못한 변형을 피하기 위해 이 도움이 돼요.

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

```rust
fn with_httpclient(client: &mut reqwest::Client) {}
```

## 매크로

자바나 파이썬과 같은 언어에서는 어노테이션이 있지만 러스트에서는 매크로를 사용합니다. 어노테이션은 Spring과 같은 환경에서 많은 일들이 반사(reflection)를 통해 자동으로 처리되는 우아한 코드를 만들 수 있습니다. 러스트 매크로는 덜 "마법(magic)" 같지만 더 깔끔한 코드를 만들어줍니다. 다음은 러스트 매크로의 예시입니다:

```rust
sqlx::query_as!(Student, "DELETE FROM student WHERE id = ? RETURNING *", id)
```

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

러스트에서의 매크로는 코드를 생성하고, 컴파일러가 빌드 과정에서 정확성을 확인하도록 하는 백그라운드에서 작동합니다. 매크로를 사용하면 컴파일 시간에 코드를 생성하여 실제 데이터베이스에 쿼리를 실행하는 코드를 생성하여 SQL 쿼리를 유효성 검사할 수 있습니다.

컴파일 시간에 코드의 정확성을 확인할 수 있는 능력은 특히 웹 개발에서 새로운 가능성을 열어줍니다. 웹 개발에서는 종종 원시 데이터베이스 문장이나 HTML 및 CSS 코드를 작성하는데, 이를 통해 버그가 적은 코드를 작성할 수 있습니다.

여기서 언급된 매크로는 선언적 매크로로, 러스트에는 다른 언어의 어노테이션과 유사한 절차적 매크로도 있습니다.

```rust
#[instrument(name = "UserRepository::begin")]
pub async fn begin(&self) {}
```

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

핵심 아이디어는 여전히 동일합니다: 코드를 백그라운드에서 생성하고 방법 전후에 일부 로직을 실행하여 더 견고하고 유지보수 가능한 코드를 보장합니다.

## 연결

다음은 Rust에서 우아한 코드를 확인해보세요:

```js
let key_value = request.into_inner()
                 .key_value
                 .ok_or_else(|| ServerError::InvalidArgument("key_value must be set".to_string()))?;
```

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

이 더 간결한 방식과 비교해 볼 때:

```js
Optional<KeyValue> keyValueOpt = request.getInner().getKeyValue();
if (!keyValueOpt.isPresent()) {
    throw new IllegalArgumentException("key_value must be set");
}
KeyValue keyValue = keyValueOpt.get();
```

Rust에서는 연산을 연결하여 간결하고 가독성이 좋은 코드를 작성할 수 있습니다. 그러나 이러한 멋진 구문을 구현하려면 From과 같은 트레이트를 자주 구현해야 합니다.

기능적 기술자들은 이 방식을 인식하고 이를 극찬할 수 있습니다. 모든 functional 및 procedural 프로그래밍의 혼합을 허용하는 어떤 언어라도 옳은 길을 걷고 있다고 생각합니다. 이것은 개발자들에게 특정 사용 사례에 가장 적합한 방법을 선택할 수 있는 유연성을 제공합니다.

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

## 스레드 안전성

이미 누군가가 경쟁 조건으로 인해 프로덕션에서 패닉을 유발한 적이 있나요? 부끄럽지만, 저인 제가 그러했습니다. 네, 그것은 기술 문제였습니다. 동시에 메모리 주소를 변경하고 읽는 것을 놓치기 쉽습니다. 그러나 이 예시를 고려해 봅시다:

```js
type repo struct {
 m map[int]int
}

func (r *repo) Create(i int) {
 r.m[i] = i
}

type Server struct {
 repo *repo
}

func (s *Server) handleRequest(w http.ResponseWriter, r *http.Request) {
 s.repo.Create(1)
}
```

여기서는 명시적으로 스레드를 시작하지 않고, 처음 보면 모든 것이 괜찮아 보입니다. 그러나 실제로는 HTTP 서버가 추상화에 의해 숨겨진 다중 스레드로 작동합니다. 웹 개발에서 이러한 추상화는 다중 스레딩과 관련된 잠재적인 문제를 숨길 수 있습니다. 이제 러스트로 동일한 기능을 구현해 봅시다:

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


```rust
struct repo {
    m: std::collections::HashMap<i8, i8>
}

#[post("/maps")]
async fn crate_entry(r: web::Data<repo>) -> HttpResponse {
    r.m.insert(1, 2);
    HttpResponse::Ok().json(MessageResponse {
        message: "good".to_string(),
    })
}
```

이 프로그램을 컴파일하려고 하면 Rust 컴파일러가 오류를 발생시킵니다:

![Rust Error](/assets/img/2024-07-22-WhyRustisthePerfectFitforWebDevelopment_1.png)

```rust
error[E0596]: cannot 
borrow data in an 
`Arc` as mutable                                                                                                                                             
   --> src\main.rs:117:5
    |
117 |     r.m.insert(1, 2);
    |     ^^^ cannot borrow as mutable
    |
    = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Arc<repo>
``` 


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

많은 사람들이 Rust의 오류 메시지가 보통 유용하다고 말하며, 그것은 종종 사실입니다. 그러나 이 경우에는 메시지가 혼란스럽고 즉시 명확하지 않을 수 있습니다. 다행히, 문제를 고치는 것은 간단하며 무엇을 해야 하는지 알고 있다면 됩니다: 작은 뮤텍스를 추가하기만 하면 됩니다:

```js
struct repo {
    m: HashMap<i8, i8>
}

#[post("/maps")]
async fn create_entry(r: web::Data<Mutex<repo>>) -> HttpResponse {
    let mut map = r.lock().await();
    map.m.insert(1, 2);
    HttpResponse::Ok().json(MessageResponse {
        message: "good".to_string(),
    })
}
```

컴파일러가 이러한 문제를 피할 수 있도록 도와주어 코드를 안전하고 신뢰할 수 있게 유지해 주는 것이 정말 아름다운 일입니다.

## Null Pointer Dereferencing

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

대부분의 사람들은 이 문제가 C에만 해당된다고 생각하지만, Java 또는 Go와 같은 언어에서도 마주칠 수 있습니다. 전형적인 문제의 예시를 살펴보겠습니다:

```js
type valueObject struct {
 value *int
}

func getValue(vo *valueObject) int {
 return *vo.value
}
```

"값을 사용하기 전에 값이 nil인지 확인하십시오." 라고 말할 수 있을 것입니다. 이는 Go에서 가장 큰 함정 중 하나입니다 - 포인터 메커니즘입니다. 때로는 메모리 할당을 최적화하고 때로는 선택적 값에 포인터를 사용합니다.

인터페이스를 다룰 때 특히 null 포인터 참조의 위험이 명확해집니다.

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

```js
type Repository interface {
 Get() int
}

func getValue(r Repository) int {
 return r.Get()
}

func main() {
 getValue(nil)
}
```

많은 언어에서 인터페이스에 대한 유효한 옵션으로 null 값을 전달하는 것이 가능합니다. 일반적으로 코드 리뷰에서 이를 잡지만, null 인터페이스가 개발 단계에 들어간 경우도 본 적이 있습니다. Rust에서는 이러한 문제가 간단히 불가능하기 때문에 우리의 실수로부터 추가적으로 보호할 수 있습니다:

```js
trait Repository {
    fn get(&self) -> i32;
}

fn get_value(r: impl Repository) -> i32 {
    r.get()
}

fn main() {
    get_value(std::ptr::null());
}
```

컴파일되지 않는다는 것을 언급하지 않을 수 없습니다.

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

## 영제화의 중요성

저는 포트와 어댑터에 대한 큰 팬입니다. 여기에는 몇 가지 추상화가 포함되어 있습니다. 복잡성에 따라 이러한 추상화는 응용 프로그램 내에서 명확한 경계를 생성하여 단위 테스트 가능성과 장기적인 유지 보수성을 향상시키는 데 필요할 수 있습니다. 비평가들의 한 주장은 성능이 감소한다는 것인데, 특정 인터페이스 구현이 컴파일 시간에 결정되지 않아 동적 디스패치가 종종 필요하기 때문입니다. Java 예시를 살펴보겠습니다:

```js
@Service
public class StudentServiceImpl implements StudentService {

    private final StudentRepository studentRepository;

    @Autowired
    public StudentServiceImpl(StudentRepository studentRepository) {
        this.studentRepository = studentRepository;
    }
}
```

Spring은 많은 작업을 자동으로 처리해 줍니다. 여기에는 @Autowired 주석을 사용한 의존성 주입 기능도 포함됩니다. 앱이 시작되면 Spring은 클래스 경로 스캐닝과 리플렉션을 수행합니다. 그러나 이 편의성은 성능 비용이 발생한다는 것을 의미합니다.

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

Rust는 제로 비용 추상화로 알려진 것 덕분에 성능 패널티 없이 이러한 깔끔한 추상화를 만들 수 있습니다:

```rust
struct ServiceImpl<T: Repository> {
    repo: T,
}

trait Service {}

fn new_service<T: Repository>(repo: T) -> impl Service {
    ServiceImpl { repo: repo }
}
```

이러한 추상화는 컴파일 타임에 처리되어 런타임 성능 비용이 없음을 보장합니다. 이를 통해 우리는 성능을 희생하지 않고도 깨끗하고 효율적인 코드를 유지할 수 있습니다.

## 데이터 변환

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

기업 애플리케이션에서는 복잡한 비즈니스 요구 사항을 처리하기 위해 종종 포트 및 어댑터 패턴을 사용합니다. 이 패턴은 데이터를 다른 레이어에 필요한 표현으로 변환하는 것을 포함합니다. 우리는 사용자 데이터를 비동기 통신의 이벤트로 받거나 동기 통신의 요청으로 받을 수 있습니다. 이 데이터는 도메인 모델로 변환되고 서비스 및 어댑터 레이어를 통해 전달됩니다.

그럼 이제 이 질문이 생깁니다: 변환 로직은 어디에 위치해야 할까요? 도메인 패키지에 있어야 할까요? 아니면 데이터가 매핑되는 패키지에 위치해야 할까요? 데이터를 변환하는 메서드는 어떻게 호출해야 할까요? 이러한 질문들은 종종 코드베이스 전체에 일관성이 떨어지게 만듭니다.

Rust는 From 트레이트를 사용하여 데이터 변환을 처리하는 명확한 방법을 제공하는 데 뛰어납니다. 어댑터에서 도메인으로 데이터를 변환해야 할 경우, 간단히 어댑터에서 From 트레이트를 구현하면 됩니다:

```rust
impl From<UserRequest> for domain::DomainUser {
    fn from(user: UserRequest) -> Self {
        domain::DomainUser {}
    }
}

impl From<domain::DomainUser> for UserResponse {
    fn from(user: domain::DomainUser) -> Self {
        UserResponse {}
    }
}

fn create_user(user: UserRequest) -> Result<()> {
    let domain_user = domain::upsert_user(user.into());
    send_response(domain_user.into())?;
    Ok(())
}
```

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

테이블 태그를 마크다운 형식으로 변경해보세요.

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


![Rust Web Development](/assets/img/2024-07-22-WhyRustisthePerfectFitforWebDevelopment_2.png)

![Rust Web Development](/assets/img/2024-07-22-WhyRustisthePerfectFitforWebDevelopment_3.png)

AWS 계정의 모든 버킷을 나열하고 각 버킷의 지역을 결정하는 람다 함수를 상상해보세요. 어떤 REST API 호출을 하고 for 루프를 사용하더라도 성능적으로 큰 차이가 없을 것이라고 생각할 수 있습니다. 어떤 언어라도 이 작업을 합리적으로 처리할 수 있을 거라고 생각하시죠?

그러나 테스트 결과, Rust가 Python보다 이 작업을 빠르게 수행하고 실행 시간 당 훨씬 적은 메모리를 사용한다는 것을 보여줍니다. 실제로, 그들은 100만 호출 당 6달러를 절약했습니다.


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

웹 및 Kubernetes 배경에서 사용자 부하에 따라 스케일 업 및 다운하는 경험으로 효율적인 자원 사용이 비용을 절약하고 시스템 신뢰성을 향상시킨다는 것을 확인할 수 있어요. 각 복제본 당 더 적은 자원 사용은 한 노드에 더 많은 컨테이너를 수용할 수 있다는 것을 의미해요. 각 복제본이 더 많은 요청을 처리할 수 있다면 전체적으로 더 적은 복제본이 필요하게 됩니다. 높은 성능과 효율적인 자원 활용은 비용 효율적이고 신뢰할 수 있는 시스템을 구축하는 데 중요해요.

# 마치며

웹 개발 분야에서 Rust로 3년간 작업하면서 정말 만족스러웠어요. 비동기 코드 또는 매크로를 작성하는 것과 같은 도전적인 측면은 사용하는 라이브러리에서 잘 처리돼요. 예를 들어, Tokio 라이브러리를 살펴봤다면, 상당히 복잡하다는 것을 아실 거예요. 그러나 비즈니스 로직에 집중하고 데이터베이스 또는 메시지 큐와 같은 외부 시스템과 상호 작용하는 웹 개발에서는 Rust의 우수한 안전 기능을 활용하면서 더 간단한 부분을 즐길 수 있어요.

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


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

루스트를 한 번 시도해 보세요. 즐기면서 더 나은 프로그래머가 될 수도 있을 거예요!

프론트엔드 개발에 Rust를 사용해야하는 이유 5가지

파이썬으로 페어 트레이딩 개발하는 방법 정리





![Switzerland Goes Open Source](/assets/img/2024-07-22-SwitzerlandGoesOpenSource_0.png)

# 맛있는 치즈와 초콜릿의 수도가 공공 서비스 코드, 데이터 및 API를 오픈 소스로 만들었습니다

7년 전 불가리아가 공공 서비스 소스 코드를 오픈 소스로 만들기로 결정했습니다. 올해 다른 유럽 국가가 이와 같은 길을 따르고 있습니다.

스위스는 유럽의 작은 나라로, 맛있는 치즈와 초콜릿으로 유명합니다. 또한 그 중에서 가장 부유한 국가 중 하나입니다.


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

이것은 민주적이라고 설명될 수 있는 나라이기도 합니다. 왜냐하면 중요한 변화에 대한 굽혀진 투표를 많이 실시하기 때문이죠. 이것은 준 민주주의 국가들에서는 존재하지 않는 것입니다.

올해 통과된 법안에서 스위스는 자유와 투명성을 표현하는 새로운 방법을 찾았습니다.

EMBAG(EN)라 불리는 새로운 법은 공공기관이 개발한 모든 소스 코드를 오픈소스로 공개해야 한다는 점을 요구합니다.

미디어에 크게 간과된 이 사건은 상당히 중요합니다. 이것은 불가리아의 행동을 따르고 몇 가지 예외만을 도입합니다.

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

제안된 작업은 제 3자의 권리를 침해하거나 보안 위험을 초래해서는 안 됩니다.

해당 코드는 무료로 사용, 개발 및 배포할 수 있는 라이센스에 공개되어야 합니다. 이것은 상당히 관대하며 공공기관과 민간 부문 간의 협력에 새로운 길을 열어줄 수 있습니다.

이 법안은 또한 공공기관이 개인정보와 보안과 같은 합리적인 예외 사항을 고려해 공개 데이터를 공유하고, 제 3자가 공공서비스와 상호 작용할 수 있는 API를 구축해야 한다고 규정합니다.

이 새로운 법률은 공공 서비스가 더 투명하고 접근 가능하도록 만드는 노력을 효율적으로 정리할 것입니다. 이는 이전 스위스, 불가리아 등 다른 국가들의 이니셔티브에서 가치 있는 것으로 입증되었습니다.

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

문제는 구현일 것입니다. 불가리아 예시에서 우리는 법률이 건축 및 코드 공유 방식에 대한 변화 접근의 시작에 불과하다는 것을 알 수 있었습니다.

세계 각지의 공공 서비스에서 오픈 소스에 대한 관심이 커지고 있으며, 더 많은 성공 사례들이 나타나면서 의사 결정자들은 오픈 소스에 잠재력을 보고 있습니다.

# 더 많은 오픈 소스와 코딩 기사를 읽으려면 팔로우하세요.

스위스 오픈소스 2024년 최신 동향

Java와 로컬에서 Apache Kafka 실행하는 방법




더러운 코드를 작성하는 것은 고통스럽지만, 특히 다른 사람들이 읽을 때는 더욱 힘들죠. 프로그래밍의 가장 어려운 부분은 작동하는 코드를 작성하는 것이 아니라 이해하기 쉽고 의미가 있는 코드를 작성하는 것입니다.

다행히도, 그런 부분에 코드 리뷰가 도움이 됩니다.

이번 주 초에는 함께 작업 중인 프로젝트에 대해 페로우 개발자 (Fabien HIEGEL)로부터 코드 리뷰를 받았고 SLAP 개념을 소개받았습니다.

소프트웨어 설계의 이 원칙은 제 코드를 개선하는 데 도움이 되었고, 오늘은 이를 공유하기 위해 이 개념에 관한 기사를 쓰기로 결정했습니다.

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

이 게시물에서 SLAP이 무엇인지, 그 이점은 무엇이며 코드에서의 사용 사례를 자세히 살펴보게 될 거에요.

# SLAP이란 무엇인가요?

SLAP은 Single Level of Abstraction Principle을 의미합니다. 이는 각 메소드나 함수가 단일 추상화 수준에서 작동해야 한다는 것을 의미합니다. 즉, 한 메소드가 고수준 작업 또는 상세한 저수준 작업 중 하나를 수행해야 하지만 둘 다 혼합해서는 안 된다는 것을 의미합니다.

그런데, 추상화가 정확히 무엇인가요?

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

![image](/assets/img/2024-07-22-MakeYourJavaCodeMoreReadableandMaintainableWiththeSLAPrinciple_0.png)

# SLAP 원칙 실천하기

파일에서 데이터를 읽고, 데이터를 처리하고, 처리된 데이터를 데이터베이스에 저장하는 시나리오를 고려해 봅시다. SLAP를 따르지 않는 코드 버전부터 시작하여 이 원칙을 준수하도록 코드를 리팩터링하겠습니다.

# SLAP 미적용 코드

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

처음 버전의 코드에서 processData 메서드는 다중 추상화 수준을 처리합니다.

- 파일에서 데이터 읽기 (저수준 작업)
- 데이터 처리 (중간 수준 작업)
- 데이터베이스에 데이터 저장 (고수준 작업)

```java
import java.io.*;
import java.nio.file.*;
import java.sql.*;

public class DataProcessor {

    public void processData(String filePath) {
        try {
            // 저수준 작업: 파일에서 데이터 읽기
            String data = new String(Files.readAllBytes(Paths.get(filePath)));
            
            // 중간 수준 작업: 데이터 처리
            String processedData = data.toUpperCase(); // 예시 데이터 처리
            
            // 고수준 작업: 데이터베이스에 데이터 저장
            saveToDatabase(processedData);
        } catch (IOException | SQLException exception) {
            exception.printStackTrace();
        }
    }

    private void saveToDatabase(String data) throws SQLException {
        // JDBC 연결이 있다고 가정
        // 데이터 저장
    }

    public static void main(String[] args) {
        DataProcessor processor = new DataProcessor();
        processor.processData("data.txt");
    }
}
```

# SLAP을 적용한 리팩토링된 코드

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

코드를 리팩토링하여 SLAP 원칙을 적용할 수 있습니다. 서로 다른 추상화 수준을 각각의 메소드로 분리하는 방법이 있어요.

```java
import java.io.*;
import java.nio.file.*;
import java.sql.*;

public class DataProcessor {

    public void processData(String filePath) {
        try {
            String data = readFile(filePath);        // 고수준 작업
            String processedData = process(data);    // 고수준 작업
            saveToDatabase(processedData);           // 고수준 작업
        } catch (IOException | SQLException exception) {
            exception.printStackTrace();
        }
    }

    private String readFile(String filePath) throws IOException {
        // 저수준 작업: 파일에서 데이터 읽기
        return new String(Files.readAllBytes(Paths.get(filePath)));
    }

    private String process(String data) {
        // 중간수준 작업: 데이터 처리
        return data.toUpperCase(); // 예시 처리
    }

    private void saveToDatabase(String data) throws SQLException {
        // 고수준 작업: 데이터베이스에 데이터 저장
        // 데이터 저장
    }

    public static void main(String[] args) {
        DataProcessor processor = new DataProcessor();
        processor.processData("data.txt");
    }
}
```

어쩌다보니 조건문 안에서 매우 사소한 조건을 만날 수도 있어요. 아래 코드 예시에서처럼요.

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

```js
private void saveToDatabase(String data) throws SQLException {
     if (Objects.isNull(data)) {  // <- 이 조건을 리팩토링할 필요가 없습니다
      return
     }
     // ...
  }
```

Objects.isNull(data)은 saveToDatabase 내에 하이-레벨 코드와 로우-레벨 코드가 섞여 있는 것입니다. SLAP를 적용하는 것이 좋지 않다고 생각하지만, 다른 개발자들이 어떤 조건을 테스트하려는지 이해할 수 있도록 다른 개발자들의 지능에 의존할 수 있습니다.

# SLAP의 이점

- 가독성 — 코드를 SLAP에 맞게 작성하면 자명성을 갖게 됩니다. 각 메서드 또는 컴포넌트는 특정 작업에 집중되어 있어 개발자가 그 목적을 이해하기 쉬워집니다.
- 유지보수성 — 관심 분리를 통해 코드를 물리적으로 분리하면 시스템의 관련 없는 부분에 영향을 주지 않고도 특정 코드 조각을 찾고 수정하기가 더 쉬워집니다.
- 테스트 용이성 — 단일 추상화 레벨을 갖는 메서드는 보통 더 쉽게 테스트할 수 있습니다. 왜냐하면 명확하게 정의된 입력과 출력을 갖기 때문입니다.
- 재사용성 — 관심사의 명확한 분리는 시스템의 다른 부분이나 다른 프로젝트에서도 추출하고 재사용할 수 있게 해줍니다.

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

# 관련 자료

JavaScript에서 단일 추상화 수준 (SLA) 원칙
코드를 쾅 써요

# 끝

요약하자면, 단일 추상화 수준 원칙 (SLAP)은 소프트웨어 디자인에서 중요한 개념으로, 코드의 가독성, 유지 보수성, 테스트 가능성 및 재사용성을 촉진합니다.

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

각 함수 또는 메서드가 하나의 추상화 수준에서 작동하도록 보장함으로써, 개발자들은 더 깨끗하고 효율적인 코드를 작성할 수 있습니다. 이는 이해하고 수정하기 쉬운 코드를 만들어냅니다.

자바나 다른 언어로 코딩 중이더라도 SLAP 원칙을 적용하면 코딩 관행과 소프트웨어 전체의 품질을 크게 향상시킬 수 있습니다.

이 게시물은 원본이 https://www.1kevinson.com에 게시되었습니다.

이 내용이 유익했기를 바라며, 이 튜토리얼이 도움이 되었는지 궁금합니다. 아래 댓글로 의견을 알려주세요.

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

다가오는 블로그 글을 놓치지 않으려면, 제 뉴스레터를 구독하는 걸 잊지 마세요.

또한 저를 LinkedIn • Twitter • GitHub에서 만나실 수 있습니다. 혹은 제 블로그도 방문해보세요.

SLA 원칙으로 자바 코드를 더 쉽게 작성하는 방법




<img src="/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_0.png" />

# 소개

2024년 3월에 소프트웨어 엔지니어로 일한지 4년째가 지났어요. 그 때는 구글에서 일하고 있었고 많은 코드를 작성했지만 제 커리어에서 막힌 느낌을 받았어요.

그래서 저는 어떻게 하면 시니어 엔지니어가 될 수 있는지 매니저에게 물어보았는데, 매니저는 '나루토'를 본 적이 있는지 물어보더라구요.

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


![Table not found](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_1.png)

"너가 처음에 아이가 정말 외롭다고 나오는 그 쇼 알지?"

모든 다른 소프트웨어 엔지니어처럼 들립니다만, 이것이 승진과 연관이 있는지 듣고 싶어졌어요.

나루토는 시작할 때 서로 잘 지내지도 않는 사람들과 함께 팀에서 여정을 시작합니다. 하지만 그는 그들에게 가까워지고 결국 함께 일하는 법을 배웁니다.


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

그러다 그는 같은 마을 팀들과 만납니다. 그들은 경쟁자가 아니지만, 함께 일하는 법을 배우는 데 시간이 좀 걸립니다.

쇼의 끝에서 나루토는 세상에서 가장 외로운 아이에서 "온 마을"의 지지를 받는 사람으로 변모합니다.

그래서 고급 엔지니어들과 무슨 관련이 있는 건가요?

그는 말합니다.

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

자신만으로는 아니라 모두와 협력하여 성장할 수 있어요.

# 반성

나에게 주어진 가장 중요한 조언 중 하나였어요.

그리고 조금 놀라운 건데, 소프트웨어 개발자로서 더 나아지기를 생각할 때, 사람들은 버그를 눈으로 바라만 봐도 고칠 수 있는 신이 나 프로그래머를 상상하곤 해요.

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

학교에서 수년 동안 코딩을 배워온 것에 대해 말하기는 이상한 일일수도 있지만, 더 많이 코딩하는 것이 당신의 커리어에 도움이 되지는 않을 거에요.

# 코딩 홍보의 오류

"더 많은 코드는 더 많은 승진을 의미하지 않습니다"

![이미지](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_2.png)

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

코딩은 당신의 일이며 누군가가 하는 것에 감탄하지 않습니다.

코드를 변경하는 것은 진전을 느끼게 해주고, 더 많이 해서 승진할 수 있을 것이라고 생각했습니다. 그러나 코드를 아는 것만으로는 특별한 사람이 되지 못합니다. 주변 사람들도 다 코드를 알기 때문이죠.

한 번 저에게 어느 시니어 엔지니어가 말한 글귀를 나누고 싶어요:

따라서 더 많은 책임을 질 수 있는 일을 해야 합니다. 그 전에 사람들과 신뢰를 쌓아야 하는데, 그것은 코딩을 통해 신뢰를 쌓는 것이 쉽지 않을 거예요.

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

## 시청자 수 제한

코딩의 문제는 코드를 검토하는 1~2명의 사람에게만 가시성이 제한된다는 점입니다. 더 나빠진 점은 동일한 두 명에게 계속해서 코드를 검토해 달라고 요청한다는 것입니다.

이렇게 되면 네트워크가 확장되지 않습니다. 이미 당신이 무엇을 할 수 있는지 알고 있는 사람들을 감탄시키는 것뿐이며, 당신의 작업을 검토하는 사람 이외에는 아무도 당신의 작업을 알지 못합니다.

또 다른 점은 사람들이 코드 변경 사항을 공유하지 않는다는 것입니다. 가끔씩 일어나긴 하지만, 모든 코드 변경 사항 중에 다른 사람과 연결되는 경우는 거의 없을 것입니다.

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

이제 실제로 주니어 개발 이상으로 커리어를 발전시키는 방법이 있어요.

# 도움 요청하기.

"하지만 나는 무서워."

![이미지](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_3.png)

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

도움을 요청하는 것은 어렵습니다. 도움을 요청해야 한다는 건 독립적일 방법을 모른다는 느낌이 듭니다. 그룹 채팅에서 코드 오류에 대해 질문했던 기억이 있습니다. 그 때 시니어 엔지니어가 나에게 구글 링크를 DM으로 보내주었죠.

물론 그때는 부끄럽고 창피했습니다.

하지만 동시에, 나루토처럼 외로운 상태로 머물러있다면 많은 어려움에 부딪힐 수 있습니다.

## 도움을 요청하는 올바른 방법.

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

도움을 요청해야 할 때는 조금이라도 직접 해결해보는 것이 올바른 방법입니다.

문서를 직접 확인하면 재미있는 도전이 될 수 있고 그 과정에서 무언가 배울 수도 있습니다.

하지만 2시간 동안 고민해도 해결되지 않는다면 시간을 절약하고 누군가에게 도움을 요청해야 합니다.

다른 사람이 15분 안에 해결책을 설명해 줄 수 있다면 문제에 하루를 허비할 시간은 없습니다. 이것이 당신의 경력에 해를 끼칠 뿐만 아니라 진행 중인 프로젝트를 늦출 수 있습니다.

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

만약 두려운 감정을 느낀다면, 다른 사람들이 도움을 주도록 하는 비밀을 공유해 드릴게요. 그것은 다른 사람들에게 가능한 쉽게 도와줄 수 있도록 만드는 것이에요.

이를 위해 

- 문제가 무엇인지 설명하고
- 그 문제를 해결하려는 이유와
- 문제를 해결하기 위해 시도해 본 것을 설명하는 걸로 시작해보세요.

예를 들어, 버그를 해결하여 API 호출 속도를 빠르게 하고 싶다면, 참고한 스택 오버플로 및 깃헙 이슈 링크를 언급할 수 있어요.

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

도움을 요청하는 것은 여러분을 더 나은 소프트웨어 엔지니어로 만들어 줄 것입니다. 하지만 현재 역할에서 진정으로 효율적이지 않다면 승진할 수 없을 거예요.

# 능숙해지세요.

"당연한 것처럼 보입니다"

![image](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_4.png)

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

## 능숙도가 중요한 이유

다음 단계로 가는 가장 빠른 방법은 현재 수준에서 신속하게 능숙해지는 것입니다. (놀랍지 않죠!)

왜냐하면 현재 역할에서 매우 능숙해지면, 다음 역할을 위해 승진시켜 줄 일을 할 시간이 생깁니다.

사람들을 놀라게 하는 것은 무언가 미친 듯이 1000시간 일하는 것과 같은 행동으로 평균을 넘어설 수는 없다는 것입니다.

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

해볼 수 있어요! 대부분의 사람들이 이렇게 하면 평균 이상이 됩니다:

- 평균이 되세요. 다른 사람들이 하는 대로 하세요.
- 그 이상을 조금만 하세요.

바로 '평균 이상'이란 건 이런 의미예요. 평균 이상으로 노력하는 거죠.

이러한 마인드셋 변화를 갖게 되면, 일에서 훨씬 더 잘 할 수 있을 거예요.

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

일할 때는 도구에 익숙해지고 디버깅 전략을 개선하며 사용하는 프로그래밍 언어에 익숙해지는 것을 의미합니다

결국 코딩에 능숙해질수록 당신을 제약하게 될 것입니다.

# 코딩을 멈추고 더 많이 글을 쓰세요.

"누구도 나에게 어떻게 글을 써야 하는지 가르쳐주지 않았다"

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


![이미지](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_5.png)

어떤 엔지니어도 코딩 이외의 다른 일을 하면서 경력을 키워나가는 것입니다.

가장 중요한 것은 무엇이든 적어두는 것입니다.

사람들은 코드 변경이 아닌 문서를 공유합니다. 작은 코드 조각보다 문서를 통해 더 중요한 사람들과의 미팅과 토론이 항상 더 많을 것입니다.


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

여러분이 작성한 문서는 몇 달 후에도 여전히 순환됩니다. 여러분의 업무 영향에 대해 상사에게 이야기할 때 사용하거나 신입사원들은 문서를 역사적 맥락을 이해하기 위해 읽을 수 있습니다.

문서를 작성하는 것은 여러분이 엔지니어로서 얼마나 많은 것을 알고 있는지 보여주어 가시성을 얻는 데 도움이 됩니다.

무서워 보일 수 있지만, 코드 변경 또는 시스템 설계 문서를 제안하는 방법은 직무 교육 시 배우는 것이기 때문입니다.

## 시스템 설계 문서 작성

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

줄거리:
가장 중요한 내용을 먼저 전달해주세요.

다음 순서로 문서의 첫 단락에 모든 내용을 작성해주세요:

- 문제에 대한 간단한 설명 써주세요.
- 영향이나 중요성을 써주세요.
- 결과를 써주세요.

이 순서로 써주세요. 대부분의 사람들이 문서 전체를 처음부터 끝까지 읽지 않을 거예요. 보통은 처음 부분을 조금 읽은 다음 넘어가게 될 거에요.

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

언젠가는 많은 문서를 작성하게 되어 사람들이 해당 분야의 전문가로 알아보게 될 거에요.

하지만 그와 동시에 모든 것을 문서화할 필요는 없어요. 엔지니어로서 받아들이기 어려운 점 중 하나는 모든 문제를 해결할 필요가 없다는 것이에요.

그리고 일을 선택하는 데 알았더라면 좋았을 것들에 대해 이야기해볼게요.

# 협업하여 일하기.

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

"일부 작업은 다른 것보다 더 중요합니다."

![이미지](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_6.png)

모든 작업이 동등하게 중요한 것은 아닙니다. 모든 문제를 해결해야 하는 것도 아닙니다.

만약 당신이 일상 생활 영상을 본 적이 있다면, 구글과 같은 기업들이 많은 과자를 갖고 있다는 것을 알 것입니다. 그러나 사람들이 많이 언급하지 않는 것은, 일부 사람들이 너무 많은 과자를 훔쳐가거나 다회보관한다는 것입니다.

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

모든 사람이 이 일이 일어난다는 것을 알고 있고, 모든 것을 자동판매기에 넣으면 문제가 해결될 수 있다고 생각하지만, 그것은 그다지 중요한 문제가 아닙니다.

내년에 승진할지 3년 후에 승진할지를 결정하는 것은 가져야 할 일을 알고 있는 것입니다.

일을 빠르게 처리하려면, 레버리지된 일을 선택하세요.

이 모든 것은 노력 대비 영향력과 가시성이 더 큰 일을 선택하는 것을 의미합니다.

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

## 노력

이 노력은 이 문제를 해결하는 데 많은 시간과 조정이 필요한지를 물어보는 것입니다.

몇 일이나 몇 주 안에 해결할 수 있나요? 혼자 하실 건가요 아니면 여러 사람과 함께 할 건가요?

## 가시성

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

가시성은 회사 내 다른 사람들에게 영향을 미치는지 여부와 관련이 있어요. 만약 다른 사람들도 이 문제를 인지한다면 그것은 가시성이 있습니다.

## 영향

영향은 단순히 숫자를 사용하여 고객 또는 회사 외부 사람들에게 어떤 영향을 미치는지를 측정하는 것을 의미해요.

노력이 적고, 영향력이 크며, 가시성이 높은 작업을 선택하세요.

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

## 사내 정치

레버리지된 일에 대해 흥미로운 점은 다른 사람들이 그것이 문제임을 알기 때문에 눈에 띈다는 것입니다. 그 말은 다른 누군가가 일을 맡아서 대신 인정을 받을 수도 있다는 뜻이에요.

저는 정말 사내 정치를 싫어하지만, 일을 요구하기 위해 사람들이 한 전략을 보았어요. 그들은 처음 페이지를 쓰는 것이었어요. 그들은 문제에 대한 1페이지 제안서를 30분 동안 쓰고 다른 사람들에게 자신이 그 일을 하고 있음을 알리곤 했어요.

일부 기술 회사들에서 이런 것을 다루는 것은 귀찮을 수 있어요.

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

하지만 정말 눈에 띄고 싶다면 모두가 당신의 작품에 대해 알도록 해야 해요.

# 모두에게 알려주세요.

"자랑이 아니에요"

![Image](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_7.png)

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

이 얘기는 커피 한 잔 마시면서 만난 테크 리드에게 영감을 받았어요. 나는 그에게 승진하는 방법을 물었고, 그는 5단계 프로세스를 설명해 주었어요.

단계 1. 먼저 시스템을 철저히 이해하세요.

단계 2. 모두에게 당신이 시스템을 철저히 이해한다는 것을 알리세요.

단계 3. 시스템에 대한 훌륭한 기여를 만들어 보세요.

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

4. 시스템에 멋진 기여를 한 것을 모두에게 알리세요.

5. 수익 창출. $$$

많은 시간을 들여 무언가를 작업했다면, 많은 사람들이 알 수 있도록 인정받는 것이 가치가 있습니다.

자랑스러운 느낌일 수 있지만, 사실 그렇지 않습니다.

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

당신이 그 분야의 전문가라는 것을 모두에게 알리는 중요한 역할을 하는 것이에요. 문제가 발생하면 당신에게 연락해야 할 것을 알게 될 거에요.

당신이 해결하면, 모두가 인상받고 당신의 작업을 인정할 거에요.

당신이 하는 일을 사람들에게 알리는 작은 방법들은 다음과 같아요:

- 매일 15분 동안 스탠드 업 중에.
- 모두가 볼 수 있는 그룹 채팅에서.
- 뉴스를 공유하기 위해 이메일 스레드를 작성하는 것.
- 새로운 지식에 대한 기술 강연을 시작하는 것.

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

당신이 하는 일에 대해 인정받아야 해요. 누구도 당신을 대변해 주지 않을 거에요.

하지만 그게 다른 사람을 대변하지 못한다는 걸 의미하지는 않아요.

# 누군가를 도와주세요.

“나는 아무것도 기여할 수 없는 주니어 엔지니어를 만난 적이 없어요"

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


![Image](/assets/img/2024-07-21-4YearsofCodingadviceinoneArticle_8.png)

과거에는 자신이 다른 사람을 도와주지 않을 것이라고 생각했었어요. 왜냐하면 아무도 나를 도와주지 않았거나, 제가 내 일에 집중하고 누군가를 돕을 시간이 없다고 생각했거든요.

하지만 나루토가 얼마나 많은 지지를 받았는지 기억하면, 다른 사람을 도와주는 것이 여러분의 목표를 이루는 데 도움이 될지도 모릅니다.

어떤 이유든간에, 아담 그란트의 책인 'Give and Take'를 통해 다른 사람을 돕는 두 가지 사상을 구분할 수 있었어요.


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

## 친절한 이유

누군가를 도와주는 것은 착한 성품을 가진 사람이라는 뜻이에요. 누군가를 도와주는 것은 일대일로 이어지는 것이 아니에요.

새로운 도구를 배우면, 다른 사람들에게 그 도구를 가르쳐줄 수 있어요. 팀 전체를 위한 문서를 작성하면, 팀 전체가 더 잘 할 수 있도록 돕는 거예요.

만약 모두가 이렇게 한다면, 스트레스를 받는 엔지니어들이 훨씬 줄어들 것이에요.

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

## 거래적 이유

동전의 또 다른 면은 거래적 이유로 사람들을 돕는 데 도움을 줍니다. 이들은 다른 사람을 돕는 것을 투자로 여기며 시간이 지남에 따라 승진과 같은 일에 나중에 그들을 도와줄 것입니다.

## 다른 사람 돕기 자체가 좋습니다.

당신이 무슨 이유로 하든, 누군가를 돕는 것은 모든 사람에게 좋은 결과입니다. 도움을 요청하는 것이 이미 무서운 일이라는 걸 알지만, 사람들에게 그것을 쉽게 만드는 것은 실제로 꽤 단순합니다.

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

이 동료들과 시간을 보내세요. 사무실에 가서 점심을 함께 하세요. 그들을 알아가세요.

그들이 무엇을 하고 있는지 알아보고, 그들이 모르는 것을 알고 있다면 생각해 보세요.

내 경험을 공유하고 싶은 이유가 여기에 있습니다.

# 떠나기 전에

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

- 박수 카운터가 50까지 올라간다는 거 알고 계셨나요?
- 유튜브 영상과 동일한 조언입니다.

Posts