Course Java + AI

Introduction. What is an algorithm. The basic constructs of a programming language.

• Understanding what is variable and if, simple data types, how to type.
• Understanding how to properly name variables, camel cases.
• Understanding what they are and the difference between for, while, and do-while loops.
• Understanding the order in which operations are performed.
• Understanding what "compilation" is.
• Understanding what kind of projects Java is used for.

Advanced set of constructs and operators.

• Knowledge of mathematical, binary (including shift), logical operators.
• Understanding of binary system, conversion to or from decimal, column addition, shift.
• Understanding of Boolean algebra, truth table, XOR, OR, AND, NOT.
• Understanding the ternary operator (Elvis Operator).
• Git (introductory).

An extended set of constructs and operators (practice).

Arrays and multidimensional arrays.

• Understanding what a one-dimensional array is.
• Understanding what a matrix and a multidimensional array are.
• Being able to bypass an array, understanding ArrayIndexOutOfBound.
• Understanding the sorting task and being able to do bubble sort.
• Understanding how an array differs from a variable and what data can be stored.

Arrays and Multidimensional Arrays (Practice).

The concept of class and object. Functions of methods. Recursion. Debugging.

• Understanding what a class and object are (without inheritance, encapsulation, or polymorphism).
• Understanding what a function is.
• Understanding how to name functions correctly.
• Understanding what a call stack is.
• Understanding how and why code should be divided into functions (refactoring).
• Understanding what recursion and getting out of recursion are.
• Understanding StackOverflowException.
• Understanding how to put a break point, where to see the call stack, how to walk through code.

Git version control systems.

• Understanding what commitments are, history.
• Understanding what branches are.
• Understanding push, fetch, merge, pull.
• Understanding what a pull request is.
• Understanding how Git is used in real-world projects (master, feature branches, code reviews).

Tests.

• What are tests and what are they for?
• Types of code and application testing in general.
• What is TDD and TLD.
• Getting to know maven.

The beginning of object-oriented programming.

• Understanding what a heap is and how it differs from a stack.
• Understanding of interface, marker interface, class and object.
• Understanding fields and methods, static fields and methods.
• Familiarity with the term domain model and understanding that we model it.
• Understanding classical inheritance, final classes.
• Understanding how constructors work.
• Understanding inheritance through composition.

Object-oriented programming. Continued.

• Abstract classes. How they differ from interfaces.
• Understanding polymorphism. Early and late binding. The virtual method table.
• Understanding Enumerations.
• Understanding hashCode and equals().
• Different types of references.

Exceptions. API development. What if a method returns null?

• Understanding the different approaches to error handling: code status return, exit(), special object return, exceptions.
• Understanding why exceptions are needed.
• Understanding Enumerations.
• Understanding the difference between checked, unchecked.
• Understanding try-catch-finally, rethrow.
• Understanding NullPointerException.
• Understanding the semantics of IllegalException, IllegalArgumentException.
• Understanding null safety, NPE.
• Understanding what approaches there are instead of returning null: exceptions, Optional, null object, empty list.
• Understanding Optional.
• Understanding Null-Object Pattern.
• Understanding Nullable annotations.

The complexity of the algorithms, O-large.

• Understanding what is O-big, O-small, theta.
• Understanding the merge sorting algorithm.
• Understanding linear and binary search.

Generics, collections.

• Understanding simple generic.
• Understanding extends, <?>.
• Understanding how to make a generic method.
• Syntax for calling a static method from generics.
• Understanding collections, list, set, map.
• Understanding modern collections (Guava).
• Understanding boxing/unboxing.

Collections, data structures, continued 1.

• Understanding Queue, Dequeue and its successors, what is FIFO, LIFO.
• Understanding HashSet, HashMap, why we need equals and hashCode.
• Being able to make an Iterator.

Collections, data structures, continued 2.

• Understanding what a binary tree is, traversing a binary tree.
• Understanding what a graph is, types of graphs.
• Understanding graph traversal algorithms.

Stream API.

• Functional interface, lambda-expression.
• Stream pipelines, terminal & conveyor operations.
• Collectors.

IO/NIO.

• Understanding how to read a file byte-by-byte.
• Understanding how to write a file byte-by-byte.
• Understanding how to read and write a file as a string.
• Understanding the use of Files.
• Understanding try-with-resources.
• A general understanding of the difference between synchronous and asynchronous programming.

Java Annotations, Reflection.

• Understanding why annotations are used.
• The ability to create an instruction.
• Understanding RetentionPolicy, Target, etc.
• The ability to bypass methods defined in an instruction.

SQL, JDBC.

• Understanding what a relational model is.
• Understanding of primary keys, 1, 2, 3 normal form.
• Understanding of simple DQL, DDL.
• Understanding what a transaction (ACID) is.
• Understanding how to "go to" the database from Java.

SQL. Hibernate.

• What is ORM, what tasks it solves.
• What is entity-manager in hibernate.
• Entity creation and relationships between entities.
• A brief introduction to HQL.

MongoDB. Writing a simple ORM.

• Understanding what JSON and BSON are.
• Understanding the difference between SQL and NoSQL databases.
• Understanding what Mongo is.
• Understanding how to read and write to a database.

The basics of operating systems.

• Understanding what tasks the operating system solves.
• Understanding the differences between the major operating systems.
• Understanding of processes and threads, mutexes, semaphores.

Linux OS.

• Understanding how the file system works.
• Understanding stdout, stderr. Understanding >, &>, 2>1, etc.
• Basic terminal commands: working with files, cat, less, tail, ps, top, kill.
• Understanding Piping.
• Basic bash scripts.

Object-oriented design.

• Understanding all the letters in SOLID.
• Understanding the basics of Unix philosophy.
• Understanding of tiny types.
• Understanding improbability, deep copies.
• First pattern factory method. Hence: understanding the private constructor, creating an instance statically.
• General understanding of the difference between synchronous and asynchronous programming

Multithreading.

• Understanding what Thread and Runnable are.
• Understanding, API of threads.
• Understanding how to create and run one thread, many threads.
• Understanding of race condition and dead lock.
• Understanding volatile.
• Understanding synchronized.
• Ability to use mutex and semaphore in java.
• Understanding atomic operations.
• Basic concurrency package tools.
• Understanding how to solve dead lock and race condition.
• Understanding the Observer pattern, the word callback.

Networking, HTTP, Web.

• Understanding the OSI model.
• Understanding HTTP methods, their limitations.
• Understanding headers and cookies.
• Understanding the request life cycle from browser to program and back. Stats.

Servlets, Chain Of Responsibility.

• The ability to create a project with modules in maven.
• Understanding how to implement Servlet.
• Understanding how to send an HTTP request using curl.
• What filters are.
• Understanding the Chain of Responsibility pattern.

Introduction to the theory of microservices.

• Cluster managers. The concept of scaling.
• Understanding what a monolithic architecture is, its pros and cons.
• Understanding what a microservice architecture is and its pros and cons.

REST API.

• Getting familiar with web and routing http requests and practice working with web and routing http requests.

Introduction to the Spring Framework.

• What is IoC, DI?
• How the container is built, the principle of operation.

Spring Boot, MVC and data.

• What is Spring Boot for?
• The highlights of working with MVC in Spring Boot.
• Spring Boot repositories.

Setting the task for the final project.

• Understanding what task will be performed.
• Understanding what technology will be used.
• Understanding what is expected at the end.
• Understanding how, where, and why to write Javadoc.
• Thinking through the architecture of the project.
• Getting to know Agile.

API development. Pattern Review.

• Understanding Proxy, Facade, Bridge, Adapter patterns and the difference between them.

HTML basics.

• Understanding the structure of an HTML document.
• Understanding tags and attributes.
• Ability to create headings, paragraphs, lists, and links.
• Understanding semantic tags (header, footer, section).
• Ability to work with forms and input elements.

CSS Basics.

• Understanding selectors and properties.
• Understanding block and inline models.
• Basics of working with flexbox and grid.
• Using colors, fonts, and indents.
• Responsive layout (media queries).

JavaScript basics.

• Understanding variables, functions, and loops.
• Events and event handling in the browser.
• Working with DOM: searching for elements, changing content, styles.
• Basics of working with fetch API for HTTP requests.
• Understanding asynchrony (async/await, promises).

Frontend Practice.

• Creating a simple page with a form.
• Creating an interactive interface with buttons and event handlers.
• Integrating the frontend with a simple REST API.

Introduction to AI for developers.

• What is artificial intelligence and large language models (LLMs).
• How AI helps in creating web applications.
• Examples of AI application in real projects.

Lovable.

• Introduction to the Lovable tool for rapid web application development.
• Automatic frontend generation.
• Backend integration.
• Practice creating an application prototype.

Using AI for front-end.

• How to generate HTML/CSS/JS using AI.
• Tools for auto-generating components.
• Examples of integration into the workflow.

Prompt engineering.

• Understanding what a prompt is.
• How to correctly formulate requests to AI.
• Techniques for refining and optimizing prompts.
• Practice writing prompts for code and interface generation.

Description.

• The project involves the implementation of a web application or website that contains several pages. At the practical level, students demonstrate the knowledge they have acquired, during their studies. Work with databases is used, usually the data is stored in one of the SQL DB and must be saved between runs of the program.

Defense of the project.

• It is necessary to pass the practice, which provides a demonstration of the working project, answers to any questions related to the project, a demonstration of the code on demand. And separately, theory on the entire course program and on all topics is passed. Theory is passed in the format of an interview for Junior Developer position, to an outside, independent expert. You can get from 0 to 100 points for both blocks.