Enrollment closed

Java Course


Duration of lecture
3 hours
Duration of education (Mon,Wed,Fri)
3,5 months
Duration of paid internship (5 days/week, 8 hours/day):
2.5 months
* The program provides the possibility of additional classes on Saturday, the final schedule will be sent to the applicants, who get enrolled in the program.

Course description

We designed the program for beginners who want to learn how to write code in Java from scratch. Students will gain skills in designing and writing software code of sufficient quality for further use in real products and projects.

Course creators focused program on practical skills in the following topics:

- basic Java designs

- the most used Java packages

- work with databases and the web

- frameworks for building software in a cloud environment

As a bonus, we added to the program DevOps practices focusing on the java toolkit.


Students will develop three projects during the course, based on which the judging committee will determine which graduates are selected for further study/internship.

The projects cover all the material that is learned during the previous modules and allow to consolidate the gained knowledge in practice.


Students must complete homework assignments and academic projects during the educational process, based on which the judging committee grades their practical skills, knowledge, and teamwork capabilities.


Artur Ashyrov
Artur Ashyrov
Head of Engineering
Andrii Ryzhenko
Andrii Ryzhenko
Senior Scala Developer
Mykola Ivaniuk
Mykola Ivaniuk
Java Dev Lead
Volodymyr Chyzhevskyi
Volodymyr Chyzhevskyi
Scala Tech Lead
Yevhen Hryshchenko
Yevhen Hryshchenko
Middle Java Developer
Oleg Beletskyi
Oleg Beletskyi
DevOps Team Lead

Course structure

Intro. Toolkit setup. IDE/VCS

Intro. Toolkit setup. IDE/VCS

  • JDK, JRE, JVM, bytecode, compiling vs interpreting
    IDE: Idea
    VCS: Git, GitHub, GitLab, Bitbucket
  • Creating git repos.
    Basic git flow: commit/push/fetch/pull
    Branches: merging, pull requests, tags

Java 101: hello world

  • Java Basic Syntax, comments, classes, methods, entry point, HelloWorld App
    Data types, sizes, static vs dynamic typing, min and max, default values
    Java command line
  • Maven, dependencies
    Compiling, running, testing from command line
  • Conditionals, ternary operator, switch (+break), readability switch vs if
    Iterations: for / while / do while
    Enums. Limited set of values. impossibility to represent incorrect values
  • Arrays, declarations
    Finding a value, sorting, copying, slicing
    Passing as a parameter, returning as a result
  • Strings. Basic operations
    Immutability, StringPool

Java OOP

  • OOP intro - split declaration, instantiation (object creation) and behavior
    Java modifiers: private, public, protected, package private
    Encapsulation, polymorphism, interfaces, nested classes
  • Object Equality
    Equals, hashcode, relations between them, Lombok
    Custom equality, know your data! Write proper hashcode

Java Exceptions

  • Exceptions
    Errors, Checked, Unchecked, try / catch / finally syntax
    How to deal, where to catch. try / catch with resources

Java collections

  • Collections, basic types, basic operations
    List, Set
    Generics idea, primitive wrappers, boxing / unboxing, Power and Limitations, Type erasure
  • Linked List
    Stack, Queue
  • Set, Map, unique, absence of ordering, common behavior
    Common usecases
    Iteration over Set and Map
  • Comparator / Comparable
    Iterator / Iterable
    Sorting with custom comparator

Streams and Functions

  • Streams
    Combining, Splitterator
  • lambda syntax, method reference, constructor reference
    Functional Interfaces, high-order functions
    Optional type

Java misc: IO, working with date&time, annotations

  • Java reflection, annotations
    Custom annotation writing and processing
    Complexity & caveats
  • Input / Output Streams, Readers, Writers
    File operations. Reading/Writing files
  • Java8 DataTIme API
    Instant, LocalDataTime
    Parsing, formatting

Java Multi-threading

  • Multithreading. Problem
    Threads model in Java
    Different abstraction levels: synchronization, volatile
  • Java memory Model, primitives vs referential, classes vs objects
    ClassLoader / stack / heap, null as a reference to nothing
    Static examples, patterns, antipatterns, Garbage Collection
  • Concurrent primitives: Barriers, Latches, Locks
    Concurrent Data Structures: Atomic*, ConcurrentCollections
    Future, CompletableFuture, Executors, ExecutorPools

Working with databases: SQL&NoSQL

  • SQL abstraction, syntax
    PostgreSQL: creating database in PGAdmin
    Select, insert, update, delete, where
  • Join: left, right, inner, outer, full
    Aggregation: count, min, max, avg, sum
    Nested queries, constraints, primary, foreign keys
  • NoSQL vs SQL dbs

  • JDBC connection, statement
    JDBC resultSet
    JDBC transactions

Working with HTTP

  • HTTP Server, URL, URI, Servlet, Request, Response, Lifecycle
    Mappings, GET, POST, Parameter passing. Redirects
    Tomcat app server
  • Serialization
    Jackson library
  • REST principles
    conventions: verb/noun, signular/plural
    API versioning

Design patterns: basics

  • Design patterns. Generative, structural, behavioral
    Generative patterns: factory, builder
    Structural patterns: facade, proxy
  • Dependency Injection
    DAO: InMemory / File / SQL Implementations

Spring Boot

  • Spring framework
    Spring Beans
    Spring Dependency Injection
  • Spring Boot
    Bootstrap file vs application yml
    Overriding parameters in boot app
  • View vs Data, Controller vs RestController
    Parameters/Entities passing
  • Exception Handling
    Application-wide error handling, custom 40X,500
  • SpringData. CrudRepo, PagingAndSortingRepo, JpaRepo
    DTO Pattern, findByExample, ModelMapper
    H2 for testing
  • Database migration. Necessity of metadata manage
    Basic Examples
  • Spring Boot Test
    Writing integration tests
    Mocking beans

Algorithms. Recursion. Complexities

  • Algorithms. Complexity
    N vs LogN difference
  • Algorithms. Recursion
    Length, count, factorial, fibonacci
    Head recursion vs tail recursion
  • Algorithms. Linked Lists
    Merging two sorted lists
    Add/remove by index/value
  • Algorithms. Binary search
    Recursive / non-recursive
    Position to insert missing item

Java + DevOps: CI/CD

  • ci-cd: concept, problems, solutions
    ci-cd: .gitlabci.yaml, runners, services, building docker images
    ci-cd: gitlabci: stages
  • ci-cd: gitlabci: build\publish docker image

Java + DevOps: Docker

  • Linux process abstraction
    virtualization history. virtualization vs isolation. vm vs container, docker
    docker concepts: container, image, layers, network, volumes
  • docker install on Linux, macOS
    build docker image: Dockerfile, build command
    docker registry: pull, push
  • main docker commands: build, run exec
    docker compose: concept, network, volumes
    docker compose: multicontainer examples

Java + DevOps: K8S

  • k8s: concepts, problem, solution
    k8s: control plane, data plane, components, architecture
    k8s: resources: node, pod, service, deployment, ingress
  • k8s: katacoda
    k8s: minikube
    k8s: k3s


Java + DevOps: Monitoring

  • best practices: cloud-native apps
    k8s - startup, liveness,readiness probes, handling sigterm
  • telemetry - prometheus overview
    exposing metrics - jmx

    stafanprodan/podinfo overview

What will
students get

  • Knowledge of Java basics
  • IDE skills 
  • Software design skills
  • Understanding and practical skills of TDD
  • Understanding of modern approaches to product development in a team
  • Basic DevOps skills — ability to deliver your code to end-users
  • Understanding of microservice architectures and the problems associated with them
Enrollment closed
Fill in the form