Epam - Round 2 | Coding Rd | Java, Microservices, Spring Boot, Design Pattern, Kafka, AWS, SQL/JPA

Tech/engineering topics covered (from the Q&A / interview-style subtitles)

AWS

• Limited exposure to AWS, mainly via AWS Lambda (serverless computing).
• A POC was explored, but it couldn’t continue due to resource constraints.
• For Lambda, triggers may be needed, but the answer was constrained by the POC nature and limited observability.

Java (Java 8 features)

• Introduced Streams API.
• Functional interfaces and Lambda expressions / functional programming concepts.
• New Date/Time APIs.
• Mentions an engine to “understand native Java” (likely referring to Java 8 language/runtime improvements).
• CompletableFuture discussed in more detail.

CompletableFuture (key concepts)

• Described as non-blocking asynchronous computation.
• Used to obtain results using asynchronous/synchronous patterns without blocking.
• Emphasis on chaining multiple async stages (more flexible than prior Java 7 futures).
• Mentions functional building blocks like:
  • supplyAsync
  • chaining stages (then-style chaining)
  • thenApply / apply-style stages (captions vary, but the intent is standard CompletableFuture chaining)
• Benefit: avoid blocking during asynchronous execution.

JVM Garbage Collection (heap/minor/major)

• GC discussed in terms of minor and major areas:
  • Minor GC uses young-generation spaces such as Eden/Survivor (subtitles mention identifiers like s0, s1, sz, etc.).
• Objects move between minor spaces depending on reachability, and eventually may be handled by major GC based on the GC strategy.
• Focus: the general young/old generation lifecycle.

Core Java concurrency & collections

Runnable vs Callable

• Callable
  • Can return a value via generics.
  • Submitted to an Executor; results come from a Future.
• Runnable
  • No return value.

synchronized

• Used for mutual exclusion to guard a code block or method.

HashMap vs ConcurrentHashMap

• HashMap
  • Can throw ConcurrentModificationException when modified during iteration.
• ConcurrentHashMap
  • Designed for concurrent access.
  • Uses finer-grained concurrency (captions mention segment-level behavior rather than locking the whole map).

ArrayList vs LinkedList

• ArrayList: contiguous memory.
• LinkedList: pointer/discrete allocation; better for insertion/deletion, worse for search.

ThreadLocal

• Each thread gets its own instance/state (separate memory per thread).
• Used to isolate per-thread data during computation.

---

Spring / Spring Boot / Spring AOP / DI / testing concepts

Spring AOP (Aspect-Oriented Programming)

• Purpose: handle cross-cutting concerns (e.g., logging, security, auditing) separate from business logic.
• AOP components mentioned:
  • annotations (e.g., at the class level)
  • advice types: before/after/after-returning/after-throwing/around
  • pointcut
  • join point
• Advice and pointcuts are used to wrap or target specific method executions.

Spring Inversion of Control (IoC)

• Spring container manages object creation and lifecycle.
• App code doesn’t instantiate dependencies directly.
• Mentions annotations like @Autowired / @Bean (conceptually DI via the Spring container).

Thread pools in Java

• Mentions Executor / ExecutorService patterns.
• Concepts include fixed-size / cached-like pools.
• Notes about core size vs max size:
  • threads start up to core size
  • can grow to max size
  • beyond that may involve queueing or different execution behavior.

Swagger / REST API documentation

• REST endpoints should include:
  • correct HTTP method examples,
  • parameters (query/request),
  • correct response/status codes (e.g., 200, 201, 400, 500).
• Mentions organizing controllers/tags by functionality.

Design patterns & SOLID

• Design patterns mentioned:
  • Factory
  • Decorator (mentioned but not implemented)
  • Observer (implemented using observable/observer updates; magazine/subscriber analogy)
• SOLID principles explained:
  • S: Single responsibility (separate packages/layers: repository/entity/service/helper)
  • O: Open/closed (extend via interfaces rather than modifying implementations)
  • L: Liskov substitution
  • I: Interface segregation (and implied remaining principles)

Spring Boot Actuator / Starter / Conditional wiring

Spring Boot Actuator

• Monitoring endpoints such as /health and /info.
• Helps inspect beans, configuration, and metrics; supports production readiness.

Spring Boot Starter

• Uses transitive dependencies to reduce manual setup.

Conditional Autowiring / Conditional bean creation

• @ConditionalOn... patterns mentioned, e.g.:
  • conditional on machine/environment/db/property (example: Oracle vs DB2)
• Beans are created only when conditions evaluate to true.

---

Agile / process

• Mentions Scrum cadence:
  • ~1-month sprint broken into ~20s-day/~20-day planning/tracking intervals (captions unclear, but indicates typical sprint planning)
  • backlog grooming
  • sprint planning
  • story assignment
  • daily tracking

---

Microservices / distributed systems / architecture

Benefits of microservices

• Easier monitoring/logging when the service count is manageable.
• Faster production/deployment times.
• Independent scalability and reduced blast radius.
• Cost optimization and versioning.

Distributed transactions

• Approaches mentioned:
  • Two-phase commit (2PC)
  • Saga pattern
  • CQRS (mentioned alongside those patterns)
• Two-phase vs three-phase:
  • 2PC described as used for less highly scalable scenarios because it waits synchronously; otherwise compensation is needed.
• Saga:
  • Two variants referenced:
    • Orchestration: central controller coordinates forward/compensating steps
    • Choreography: each microservice coordinates its responsibilities
  • Emphasizes forward actions + compensating actions.

Distributed tracing / observability

• Tracing via:
  • Micrometer
  • Zipkin (captions suggest “zipin/…zipin”)
  • service mesh (mentioned for propagation/tracing)

Logging/monitoring stack

• Mentions:
  • Elasticsearch / Kibana for logs (ELK concept)
  • Kafka clusters/partitions for logging-related streaming (ELK + Kafka idea)

---

DevOps / CI/CD / Kubernetes / OpenShift concepts

CI/CD (Jenkins / Git / pipeline)

• Mentions CI pipeline migration/integration using Jenkins and Bitbucket.
• Pipeline stages:
  • fetch code/config
  • build images
  • deploy using Helm charts
  • output deployable artifacts/images

Docker / Docker Compose

• Confirms use of Dockerfile.
• Notes that OpenShift/Kubernetes handles image creation in their flow.
• Docker Compose: not really used by them (captions unclear on “understand” / uncertainty).

Kubernetes resources: Service vs Deployment

• Deployment
  • creates/manages Pods
  • supports load balancing and works with HPA
• Service
  • service discovery and routing traffic to pods
  • provides stable networking and traffic flow

ConfigMap

• Used to store application configuration and sometimes mount files/binary keys.

Mockito: @Mock vs @Spy

• @Mock: replaces dependency with a mock instance.
• @Spy: wraps/modifies behavior of a real object for tests.

---

Messaging / Kafka

Kafka basics

• Topic and partition:
  • Topic represents a logical stream for producers/consumers.
  • Partition distributes data for horizontal scaling and concurrency.

Message delivery guarantees

• Kafka described as used for asynchronous communication between microservices.
• Delivery does not require synchronous waiting for notification (exact guarantees/acks were cut off in the captions).

Implementing Kafka consumption/production

• Mentions certificate/config setup and annotations to start Kafka processing.
• Mentions enabling Kafka consumption after providing certificates and dependencies, then activating processing via annotations.

---

Databases / SQL / JPA (performance + design)

Query optimization tips (relational DB)

• Avoid SELECT *.
• Avoid inefficient wildcard patterns (e.g., leading/trailing % that degrade performance).
• Avoid incorrect comparisons; prefer appropriate operators (= / IS, etc.).
• Use CTEs (Common Table Expressions) for subqueries.
• Add indexes on columns used in WHERE conditions, especially for selective filters.
• Mentions multi-index improvements.

Index vs composite index

• Index: typically for one column.
• Composite index: multiple columns; useful when a single-column index is not enough for differentiation.

Execution plan

• Execution plans reveal:
  • where indexes are used,
  • computation cost per operation,
  • bottlenecks and what to optimize (e.g., around GROUP BY).

Spring Data JPA annotations mentioned

• @Entity, @Table, @Column, @JoinColumn, @OneToMany, @Transactional, @EnableTransactionManagement (plus others).

NoSQL vs RDBMS

• NoSQL supports semi-structured / non-structured data.
• NoSQL can store JSON-like documents; RDBMS stores structured tables/rows.
• NoSQL scales horizontally.
• They mention they haven’t used a specific NoSQL yet (captions suggest a possible “MongoDB/Cosmos” mention, but it’s unclear).

---

Tooling: Swagger, Zipkin, Kafka, ELK, Jenkins, Helm, Kubernetes/OpenShift

• Captions collectively reference an enterprise stack:
  • Swagger/OpenAPI for REST docs,
  • Zipkin for tracing,
  • ELK (Elasticsearch/Kibana) for logs,
  • Kafka for messaging,
  • Jenkins + Bitbucket for CI/CD,
  • Helm + Kubernetes/OpenShift for deployment.

---

Practice task mentioned

• A coding task to find students with the highest value (problem statement truncated).
• Requirement: use Java Streams API.

---

Main speakers / sources

• Interview panel / interviewer: asks most questions (AWS/Java/Spring/Kafka/K8s/SQL, etc.).
• Candidate (EPAM interviewee, “Kevin” referenced in subtitles): answers technical questions.
• Video context: “EPAM - Round 2 | Coding Rd | …” (interview round hosted by EPAM).