Jak wreszcie przekuć podstawy Javy w większe projekty (Git, Maven, Testy)

Overview

The video is a webinar about turning Java fundamentals into “real” projects by using the same tooling and practices expected in professional development:

• IntelliJ IDEA
• Git / GitHub
• Maven / Gradle
• JUnit 5 / AssertJ
• unit testing and basic Java practices

A toy application (“Foodfinder”) is built throughout the webinar to demonstrate the workflow end-to-end.

---

1) Project setup in IntelliJ with Git/GitHub

Goal: Build a larger Java project while using Git from the start, without learning Git only via the terminal.

Workflow shown inside IntelliJ

• Create a new project (Java 17) and choose Maven vs Gradle
• Enable version control (Git) in IntelliJ
• Learn Git concepts through the UI:
  • Git provides version history, letting you revert to earlier working states
  • Files appear as changes (e.g., red) until they’re staged and committed
• Create a .gitignore (e.g., ignore IntelliJ config folders like .idea and other temporary/build outputs)
• Commit often using IntelliJ shortcuts (commit mapping like Ctrl+K)
• Review commits and diffs:
  • use the commit history UI
  • compare older vs newer versions
• Push changes:
  • commits remain local until you push to the remote
  • conceptually: commit = Ctrl+K, push = Ctrl+Shift+K (as described)
• Publish to GitHub:
  • use “Share project on GitHub”
  • shows cloning on GitHub and how teams handle conflicts/branches
• Branching + Pull Request concept:
  • work in a feature branch
  • open a pull request to review and merge into master

---

2) Maven vs Gradle (what they’re used for)

The explanation is framed from a workplace perspective.

Core purpose

• Manage dependencies
  • bring in third-party libraries without rewriting them

Example use cases mentioned

• Testing libraries:
  • JUnit 5
  • AssertJ
• Frameworks (conceptually), such as:
  • Spring for building/deploying applications

Maven-specific details

• pom.xml is the core configuration file for dependencies and build settings
• Versioning concept:
  • snapshot vs released versions
  • snapshot isn’t for clients; releases bump the version
• Maven responsibilities:
  • build the app
  • run tests
  • check compilation
  • package and release versions

Beginner guidance

• Focus more on application logic first
• Maven/Gradle “wiring” is described as less logical difficulty than implementing business functionality

---

3) Unit tests driven by requirements (and “good practices”)

A core theme is that unit tests map directly to requirements.

Requirements-file approach

The speaker demonstrates writing requirements in a requirements.txt-style file, such as:

• user can enter max N ingredients
• messages for invalid input
• ingredient existence rules
• database constraints, etc.

They suggest adding requirements to Git so others (e.g., recruiters) can see forethought.

“Happy path” + edge cases

• First test the valid scenario (e.g., exactly the allowed number of ingredients)
• Then add edge cases:
  • too few ingredients
  • too many ingredients
  • invalid ingredients not present in the database

Architecture / packaging for testing and modules

• Introduces the concept of a module (a unit responsible for a process)
• Encourages keeping code organized so modules communicate through boundaries
  • mentions communication via data objects
• Packaging visibility guidance:
  • enable IntelliJ “show visibility icons” to see public vs private
  • prefer private packaging
  • idea: UI layers (console/REST) and tests can use a public “starter” class, while domain logic stays non-public inside the module/package

Test approach shown

• Add testing dependencies in pom.xml:
  • JUnit 5
  • AssertJ
• Test style:
  • call the application “start” method (refactor console/main logic into a starter)
  • the start method returns a result / DTO containing:
    • status/message (success/error)
    • recipe output (stringified recipe for assertions)
• Assertions:
  • use AssertJ to verify that the returned result matches expectations

Value demonstrated

• If code is changed incorrectly, tests fail
• This provides safety for business requirements and helps prevent accidental regression

---

4) Example features built in the demo app (“Foodfinder”)

The demo evolves from simple structure to richer domain modeling:

• introduction of records/domain DTOs (e.g., a Recipe record)
• a method that creates a recipe based on ingredients
  • logic starts simplified/hardcoded for demonstration

Tests validate:

• the output recipe
• the success status based on input constraints

---

5) Webinar organization / promotional content (course offer)

The speaker also includes promotional material for their Java training course (“Get Pro Java”), highlighting:

• practical workplace-focused essentials (Git/GitHub, Maven/Gradle, unit tests)
• tasks + example solutions + group support
• video code reviews
• certificate
• IntelliJ Ultimate license, etc.

This is presented as not part of the technical tutorial, but as a major product feature of the overall content.

---

Main speakers / sources

• Bartek Kalka — webinar presenter (Java/Kotlin/Spring programmer and mentor)