Code: E001

Duration: 210 Hours (50+ Days)

Part 1: Technical Program

Overview

• This track provides a comprehensive foundation and advanced skills for backend engineering, covering Java and Kotlin, modern frameworks like Spring Boot, API and security best practices, microservices architecture, SQL/NoSQL databases, containerization and orchestration with Docker & Kubernetes, and workflow automation with Camunda.
• Learners will gain hands-on experience in building secure, scalable, and maintainable backend systems suitable for enterprise-grade applications.

Target Audience

• Software engineers aiming to specialize in backend development.
• Java developers transitioning to Kotlin and Spring Boot.
• Computer science graduates or professionals seeking enterprise backend skills.
• Engineers interested in microservices, cloud-native development, and DevOps practices.

Pre-requisites

• Basic programming knowledge (preferably Java or another OOP language).
• Understanding of fundamental data structures and algorithms.
• Familiarity with relational databases and SQL basics.
• General knowledge of client-server architecture.

Content

Java Essentials

• Getting Started with Java
  • Introduction to Java and its ecosystem (JVM, JRE, JDK).
  • Setting up the development environment (JDK installation, IDE configuration).
  • Basic Java syntax: variables, data types, operators.
  • Control flow statements: if/else, switch, for, while, do-while loops.
  • Arrays and strings.
  • Command-line compilation and execution.
• Object-Oriented Programming (OOP) Fundamentals
  • Core OOP concepts: Class, Object, Encapsulation, Abstraction, Inheritance, Polymorphism.
  • Classes and objects: constructors, methods, fields.
  • Access modifiers (public, private, protected, default).
  • Method overloading and overriding.
  • Introduction to this and super keywords.
• Advanced OOP and Principles
  • Abstract classes and interfaces.
  • The final keyword.
  • SOLID Principles
  • Single Responsibility Principle (SRP).
  • Open/Closed Principle (OCP).
  • Liskov Substitution Principle (LSP).
  • Interface Segregation Principle (ISP).
  • Dependency Inversion Principle (DIP).
• Collections and Streams
  • Java Collections Framework:
  • Hierarchy overview: Collection, List, Set, Map.
  • Common implementations: ArrayList, LinkedList, HashSet, TreeSet, HashMap, LinkedHashMap.
  • Iterators and enhanced for-loops.
  • Introduction to Java Streams:
  • What are streams and why use them?
  • Intermediate operations (filter, map, sorted).
  • Terminal operations (forEach, collect, reduce).
  • Working with Optional.
• Exception Handling
  • Understanding the exception hierarchy (Throwable, Exception, Runtime Exception).
  • Checked vs. unchecked exceptions.
  • try-catch-finally blocks.
  • The throws and throw keywords.
  • Creating custom exceptions.

Concurrency & Multithreading

• Thread Fundamentals
  • Introduction to concurrency and parallelism.
  • The Java Memory Model (JMM).
  • Creating threads: Thread class and Runnable interface.
  • Thread lifecycle: New, Runnable, Blocked, Waiting, Timed Waiting, Terminated.
  • Managing threads: start, run, sleep, join.
• Synchronization and Atomicity
  • Race conditions and critical sections.
  • The synchronized keyword (methods and blocks).
  • Thread communication with wait, notify, notify All.
  • The volatile keyword.
  • Introduction to atomic variables from the java.util.concurrent.atomic package.
• The java.util.concurrent Package
  • Executors and Thread Pools.
  • ExecutorService and ScheduledExecutorService.
  • Future and Callable interfaces.
  • Locks: ReentrantLock.
  • Semaphores and CountDownLatches.
• Advanced Concurrency Concepts
  • Concurrent Collections: ConcurrentHashMap, CopyOnWriteArrayList.
  • Fork/Join Framework for parallel tasks.
  • Deadlock, livelock, and starvation.
  • Best practices for designing concurrent applications.

I/O & File Handling, Java Memory Management, Networking

• Java Memory Management
  • 1: Java Memory Management.
  • JVM Architecture: Class Loader, Runtime Data Areas (Method Area, Heap, Stack, PC Register).
  • Garbage Collection (GC) overview: what it is and how it works.
  • Generational garbage collection.
  • Memory leaks in Java and how to prevent them.
• Networking with Sockets
  • Introduction to networking concepts (TCP/IP, ports, sockets).
  • Creating a simple client-server application with Socket and ServerSocket.
  • Handling multiple clients with multithreading.

Design Patterns & Clean Code Principles

• Clean Code Fundamentals
  • What is “Clean Code”?
  • Meaningful names and functions.
  • Commenting and formatting best practices.
  • Refactoring techniques.
  • Avoiding common code smells.
• Creational Design Patterns
  • Introduction to design patterns.
  • Singleton: ensuring a class has only one instance.
  • Factory Method: defining an interface for creating objects.
  • Abstract Factory: creating families of related objects.
  • Builder: separating construction from representation.
  • Prototype: creating new objects from an existing object.
• Structural Design Patterns
  • Adapter: converting the interface of a class into another interface clients expect.
  • Decorator: dynamically adding new functionality to an object.
  • Composite: composing objects into tree structures.
  • Facade: providing a simplified interface to a complex system.
  • Proxy: providing a surrogate or placeholder for another object.
• Behavioural Design Patterns
  • Observer: defining a one-to-many dependency.
  • Strategy: defining a family of algorithms, encapsulating each one.
  • Command: encapsulating a request as an object.
  • Iterator: accessing elements of a collection sequentially.

Kotlin for Backend

• Core Kotlin Concepts
  • Introduction to Kotlin and its advantages for backend development.
  • Setting up the environment and migrating from Java.
  • Basic syntax: variables (val, var), data types, functions.
  • Control flow and loops.
  • Classes, properties, and constructors.
• Null Safety and Advanced Features
  • Null Safety
  • Nullable types (String?) vs. non-null types (String).
  • Safe calls (?.), Elvis operator (?:), and the not-null assertion operator (!!).
  • Working with nullable collections.
  • Data classes.
  • Extension functions.
  • Companion objects and singleton pattern.
• JVM Interoperability and Coroutines
  • JVM Interoperability
  • Calling Java from Kotlin and vice versa.
  • Annotation processing and seamless integration.
  • Introduction to Coroutines for asynchronous programming.
  • Coroutines vs. Threads.
  • Structured concurrency.
  • Using coroutines with Spring Boot.

Spring Boot

• Spring Boot with Kotlin
  • Setting up a Spring Boot project with Kotlin.
  • Writing controllers, services, and repositories in Kotlin.
  • Using data classes for entities and DTOs.
  • Best practices for combining Kotlin and Spring.
• Aspect-Oriented Programming (AOP)
  • Introduction to AOP: Cross-cutting concerns.
  • AOP concepts: Aspect, Join Point, Advice (Before, After, Around).
  • Creating custom aspects with @Aspect.
• Unit & Integration Testing
  • Introduction to testing in Spring Boot.
  • Unit testing with JUnit and Mockito.
  • Integration testing with @SpringBootTest.
  • Testing REST controllers with MockMvc.
  • Testcontainers for integration testing with real databases.

API Design & Security

• REST Principles
  • Understanding RESTful architecture.
  • HTTP methods (GET, POST, PUT, DELETE, PATCH).
  • HTTP status codes.
  • Resource naming conventions.
  • Versioning APIs.
  • Pagination and filtering.
• JWT Authentication
  • What is JWT? Structure (Header, Payload, Signature).
  • How JWT works for authentication.
  • Implementing a JWT-based authentication system.
  • Generating and validating tokens.
  • Creating custom JWT filters.
• OAuth2 Overview
  • Introduction to OAuth2 and its purpose.
  • Roles in OAuth2: Client, Resource Owner, Authorization Server, Resource Server.
  • The Authorization Code Grant flow.
  • Scopes and permissions.
  • Using an OAuth2 client in an application.
• Validation & Error Handling
  • Bean validation with annotations (@NotNull, @Size, @Valid).
  • Creating custom validation constraints.
  • Global exception handling with @ControllerAdvice.
  • Customizing error responses and providing meaningful messages.

Microservices Patterns, Docker, and Kubernetes

• Microservices Patterns
  • Monolithic vs. Microservices architecture.
  • Core patterns: Service Discovery, API Gateway, Circuit Breaker.
  • Data management patterns: Database per Service.
  • Communication patterns: Synchronous (REST), Asynchronous (Messaging).
  • Distributed tracing and logging.
• Docker Basics
  • Introduction to containers and Docker.
  • Docker architecture: Docker Engine, Images, Containers.
  • Basic Docker commands (run, build, pull, push).
  • Creating Dockerfiles for Java/Kotlin applications.
  • Docker Compose for multi-container applications.
• 3: Inter-service Communication
  • Synchronous communication with REST and Feign clients.
  • Asynchronous communication with message queues (e.g., RabbitMQ, Kafka).
  • Event-driven architecture.
• Kubernetes Basics
  • Introduction to Kubernetes and its key concepts.
  • Kubernetes architecture: Master, Nodes, Pods.
  • Key components: kube-api-server, kube-scheduler, kubelet.
  • Deploying applications with Deployments.
  • Services and Ingress for network routing.
• Advanced Kubernetes
  • ConfigMaps and Secrets.
  • StatefulSets.
  • Persistent Volumes and Persistent Volume Claims.
  • Health checks and readiness probes.

SQL Databases (Oracle/PostgreSQL)

• Performance & Optimization
  • Database indexing: B-Tree and other index types.
  • Understanding query execution plans.
  • Optimizing slow queries.
  • Stored procedures and functions.
  • Views and materialized views.
• DDatabase Versioning
  • The need for database versioning.
  • Introduction to tools like Flyway.
  • Creating and applying migrations.
  • Managing schema and data changes.
  • Rollback strategies.

 

Workflow Automation and BPMN Models with Camunda

• Introduction to BPMN & Camunda
  • What is Business Process Management (BPM)?
  • Introduction to BPMN 2.0 notation.
  • Core BPMN elements: Start/End Events, Tasks, Gateways, Sequence Flows.
  • Introduction to Camunda as a workflow engine.
  • Setting up the Camunda platform (with Spring Boot).

• Executable Processes
  • Creating your first executable BPMN model.
  • User Tasks and task forms.
  • Service Tasks and implementing them with Java code.
  • Handling different types of gateways (Exclusive, Parallel).
  • Variables and data management within a process.
• Advanced BPMN & External Systems
  • Timer and Message Events.
  • Boundary Events and Error Handling.
  • Calling external services with REST connectors.
  • Introduction to DMN (Decision Model and Notation) for business rules.
  • Monitoring and troubleshooting processes with the Camunda Cockpit.