Backend Engineering with Java, Kotlin, and Modern Architectures

  Program Overview
  Terms and Conditions

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.

ملحوظة

البرنامج التدريبي يُنظَّم بعد ساعات العمل الرسمية، بدءًا من الساعة السادسة مساءً ولمدة أربع ساعات يوميًا.