Welcome! This is the main navigator for my educational projects.

• Task 280 Universal Storage: The Object Root V0.1 — In the Java type system, every class implicitly inherits from java.lang.Object. This project demonstrates a Universal Container pattern. By using a field of type Object, the StorageBox class can store any data type (Strings, Integers, or custom objects). This highlights both the flexibility of the Java class hierarchy and the limitations of losing specific type information, which is a foundational concept before exploring Polymorphism and Generics.

• Task 279 Text Analyzer: Local Class State V0.1 — In data processing applications, we often need temporary objects to hold intermediate results and provide specific formatting. This project demonstrates a Local Class (NameStatistics) with its own internal fields and multiple methods. By defining this class inside the generateNameReport method, we create a specialized reporting tool that encapsulates string transformation logic (uppercase conversion and length calculation) without exposing these temporary operations to the global scope of TextAnalyzer.
• Task 278 Special Calculator: Method Parameter Access V0.1 — In high-precision or specialized computing modules, certain operations require temporary data structures that exist only during a specific calculation. This project demonstrates Local Classes accessing method-level parameters. By defining SumResultPrinter inside the calculateAndDisplaySum method, we create a specialized unit that can directly utilize the input arguments numA and numB. This pattern ensures that the logic for displaying the result is tightly coupled with the calculation itself and hidden from the rest of the application.
• Task 277 Secret Keeper: Local Class Member Access V0.1 — In secure application development, strictly controlling access to sensitive data is paramount. This project demonstrates how a Local Class (TruthRevealer) can be used as a temporary agent to access and display a private field (hiddenSecret) of its outer class (SecretKeeper). By defining the class within the revealSecret method, we create a specialized tool that exists only for the duration of the method's execution, maintaining high levels of encapsulation while performing necessary data operations.
• Task 276 Interactive Board: Local Class Scope V0.1 — In advanced software design, encapsulation is key. Sometimes a helper class is so specific to a single operation that it shouldn't exist anywhere else. This project demonstrates Local Classes in Java. By defining GreetingDisplay inside the showTemporaryMessage method, we ensure that the class remains private to that specific logic block. This prevents namespace pollution and guarantees that the temporary message logic cannot be misused by other parts of the system.

• Task 275 Secret Laboratory: Private Data Access V0.1 — In secure software architectures, it is often necessary to encapsulate sensitive data while providing a strictly controlled mechanism for its retrieval. This project illustrates how an Anonymous Inner Class can access private instance fields of its Outer Class. By implementing the Runnable interface inside the revealSecret method, we create a temporary access bridge to the classifiedSecret field, demonstrating the deep integration between nested implementations and their parent contexts.
• Task 274 Production Line: Runnable Anonymous Implementation V0.1 — In industrial automation systems, certain tasks are executed once during a specific lifecycle event. This project demonstrates using an Anonymous Inner Class to implement the standard Java Runnable interface. By defining the logic directly within the startCountOperation method, we create a specialized, short-lived task. While this approach is functionally correct, it serves as a stepping stone toward understanding more modern functional programming patterns in Java.
• Task 273 Universal Translator: Interface Implementation V0.1 — In intergalactic travel and software engineering, speed is often essential. This project demonstrates how to use an Anonymous Inner Class to implement an interface (Communicator) without declaring a formal named class. This technique allows for the immediate creation of functional objects that adhere to a specific contract, providing a "Hello World!" greeting for any life form encountered.
• Task 272 Magical Farm: Anonymous Inner Classes V0.1 — In software development, we often encounter situations where we need to modify the behavior of a single object without creating a whole new class hierarchy. This project demonstrates Anonymous Inner Classes. We take a base class MagicalCreature and override its makeSound() method during instantiation. This approach is highly efficient for "one-off" logic, keeping the codebase clean and localized.

• Task 271 Book Publishing: Builder Pattern V0.1 — Constructing complex objects with multiple optional or required fields often leads to "telescoping constructors," which are hard to maintain. This project demonstrates the Builder Pattern implemented via a Static Nested Class. The Builder allows for step-by-step configuration of a Book object using a fluent API (method chaining). The final object is instantiated only when the build() method is called, ensuring that the Book remains immutable once created.
• Task 270 Artifact Chain: Linked Structures V0.1 — In low-level programming and algorithm design, linked structures are essential for dynamic data management. This project demonstrates how to build a simple Linked List using a Static Nested Class (Link). By making the Link class static and private, we encapsulate the internal mechanics of the chain, ensuring that the outside world only interacts with the ArtifactChain while the nodes themselves remain lightweight and independent of the parent object's instance state.
• Task 269 Security Vault: Static Member Access V0.1 — In secure system design, certain global parameters must be hidden from the outside world but accessible to internal monitoring modules. This project demonstrates how a Static Nested Class (SecurityDisplayUnit) can access a private static field (securityLevel) of its outer class (Vault). This pattern allows for clean logical grouping of utility or display components that depend on the global state of the parent class without requiring an instance of that parent.
• Task 268 Wizard Toolkit: Static Nested Classes V0.1 — In large systems, some components are logically related to a parent entity but do not require its state to function. This project demonstrates Static Nested Classes in Java. By declaring BasicCharm as static within Spellbook, we decouple the two. This allows the instantiation of BasicCharm without creating a Spellbook object, saving memory and simplifying the architecture when instance-specific data is not required.

• Task 267 Smart Home: Hierarchical Data Access V0.1 — In nested object structures, an inner class often needs to reference the state of its parent instance. This project demonstrates the use of a Non-static Inner Class (Room) within an outer class (House). It highlights the Outer.this syntax, which allows the inner class to explicitly access the outer class's private fields. This is essential for distinguishing between local instance data and the broader context provided by the parent object.
• Task 266 Magic Library: Inner Class Composition V0.1 — In software modeling, some objects are logically and physically inseparable from their parent container. This project demonstrates Inner Class Composition using a Library and its Scrolls. The Scroll class is nested within Library to show that a scroll's existence is defined by the library it belongs to. This structure allows the inner class to maintain its own state (scrollTitle) while remaining part of the outer class's domain.
• Task 265 AI Assistant: Inner Class Data Access V0.1 — In advanced Java applications, inner classes provide a unique way to organize code while maintaining strict encapsulation. This project demonstrates how a non-static inner class can directly access the private fields of its outer class. The Greeting class, nested within Person, retrieves the private userName variable without requiring public getters. This ensures that sensitive user data remains hidden from the rest of the application while remaining fully functional for internal components.
• Task 264 Warehouse Automation: Inner Classes V0.1 — In object-oriented design, some entities are so closely related that one cannot exist without the other. This project demonstrates the use of Non-static Inner Classes in Java. By nesting the Label class inside the Box class, we create a strong logical bond. An instance of Label is always tied to a specific instance of Box, reflecting real-world scenarios where a label is a physical part of a specific package.

• Task 263 User Profile: Shared Instance Initialization V0.1 — In systems with multiple ways to create an object (overloaded constructors), maintaining consistent initial state can be challenging. This project demonstrates how a non-static initialization block serves as a common entry point for all constructors. Regardless of whether a user chooses "Fast Registration" or "Full Profile," the system automatically assigns a default identifier before the specific constructor logic executes. This pattern promotes the "Don't Repeat Yourself" (DRY) principle and ensures mandatory setup tasks are never skipped.
• Task 262 System Component: Full Initialization Audit V0.1 — This project demonstrates the Execution Hierarchy within a Java class. It tracks the exact sequence of static initialization blocks (class-level) and instance initialization blocks (object-level) relative to the constructor. Understanding this order is vital for managing global state and ensuring that object-specific data is correctly prepared before the constructor finishes execution.
• Task 261 Pet Shelter: Instance Initialization Lifecycle V0.1 — When creating objects in Java, there is a specific sequence of events. This project demonstrates the Non-Static Initialization Block. Unlike static blocks (which run once per class), non-static blocks run every time a new instance is created. Crucially, they execute after the parent constructor (if any) but before the current class's constructor logic. This is useful for shared initialization logic that must run regardless of which constructor is called.
• Task 260 Module Initialization: Static Lifecycle V0.1 — In large-scale applications, some operations must occur exactly once when a component is first introduced to the system. This project explores the Static Initialization Block. Unlike constructors, which run every time an object is created, the static block runs only once — when the Java Virtual Machine (JVM) loads the class into memory. This mechanism ensures that the global state, such as moduleStatusMessage, is prepared before any instance-level logic begins.

• Task 259 Global Constants: Static Immutable Storage V0.1 — In application development, certain values like mathematical PI or the number of days in a year remain constant throughout the entire execution. This project demonstrates the creation of a Utility Class for global constants. By combining public, static, and final modifiers, we make these values globally accessible, shared across the JVM, and protected from any modification.
• Task 258 Application Configuration: Static Initialization V0.1 — Global constants often depend on the environment where the application is running. This project demonstrates how to use a static initialization block to calculate the value of a public static final field. By querying the system environment variable APP_LANG, the application dynamically chooses its default language at startup. This approach ensures that configuration remains immutable once set, while still being flexible enough to adapt to different system environments.
• Task 257 Student Identity Card: Data Immutability V0.1 — In security-sensitive systems, certain information must remain constant throughout the object's lifecycle. This project demonstrates Immutability using the final keyword in Java. By declaring the studentName field as final, we ensure that once the value is assigned in the constructor, it cannot be modified by any other part of the program. This pattern provides a high level of thread safety and data integrity.
• Task 256 Application Metrics: Static State V0.1 — In software architecture, some data belongs to the system as a whole rather than individual users or objects. This project introduces the static keyword. By declaring activeUserCount as a static field, we ensure that it is shared across the entire application. This variable exists independently of any object instances, allowing us to access and manage global metrics directly through the class name.

• Task 255 School Records: Data Integrity Guard V0.1 — Ensuring that a system contains valid data is a core responsibility of an object. This project demonstrates Defensive Programming through encapsulation. By making the currentAge field private and providing a "Smart Setter", we prevent the student's age from ever becoming negative. The object acts as a gatekeeper, rejecting invalid inputs and providing feedback while maintaining its internal consistency.
• Task 254 Smart Home: Boolean State Management V0.1 — In IoT and Smart Home systems, binary states (on/off, true/false) are fundamental. This project demonstrates Boolean Encapsulation. A key takeaway here is the Java naming convention: while numeric types use get, boolean fields use the is prefix for their getters. By encapsulating the isCurrentlyOn field, we provide a clean interface for the SmartLamp object, allowing the system to toggle and query its status securely.
• Task 253 Student Records: Dynamic Age Management V0.1 — In educational management systems, student data like age must be both initialized and periodically updated. This project demonstrates the complete Encapsulation Cycle. By using a private field studentAge, we prevent direct external tampering. Access is strictly mediated through a Parameterized Constructor for birth-state, a Getter for reading, and a Setter for updates. This ensures the object remains the "single source of truth" for its own data.
• Task 252 Warehouse System: State Mutation V0.1 — In dynamic inventory systems, data must be updatable. This project demonstrates State Mutation using the Setter Pattern. While the productName field remains private to prevent unauthorized external access, we provide a public setProductName() method. This controlled entry point allows the application to modify the object's state safely, maintaining a clear interface between the object's internal data and the external business logic.

• Task 251 Digital Library Manager: Access Control Matrix V0.1 — Security and modularity in Java are managed through access modifiers. This project simulates a library management system where different operations require different clearance levels. By implementing four methods with distinct modifiers, we visualize the accessibility hierarchy. The project demonstrates that while most operations are available to classes within the same package, strictly private tasks remain locked within the managing class itself.
• Task 250 Module Internal Collaboration: Package-Private Access V0.1 — In modular programming, certain functionalities should be shared among related classes but hidden from the rest of the application. This project explores Package-Private (Default) Access. By omitting access modifiers, we allow ModuleMain to interact with ModuleHelper's internal methods because they reside in the same package (com.yurii.pavlenko). This level of encapsulation creates a "trusted zone" where classes can collaborate without exposing their internal machinery to external packages.
• Task 249 Magic Calculator: Method Encapsulation V0.1 — Encapsulation applies to actions just as much as it does to data. This project explores Private Methods. While the addNumbers method is public and serves as the calculator's interface, the displayInternalResult method is a "hidden" helper. By making it private, we prevent other parts of the program from triggering internal logging or display mechanisms directly, ensuring that the class maintains strict control over its internal processes.
• Task 248 Digital Business Cards: Basic Encapsulation V0.1 — A business card is a record of identity that shouldn't be altered by third parties. This project models this concept using Encapsulation. By declaring the userName field as private and only providing a public getter, we create a secure object. The only way to set the name is at the moment of the object's creation via a constructor, making the card "read-only" for the rest of its lifecycle in the program.

• Task 247 Warehouse Inventory: Immutable Identity V0.1 — In data-sensitive systems, some attributes must remain constant throughout an object's life. This project demonstrates the creation of Read-Only Objects. By combining private fields with a parameterized constructor and providing only Getters, we create a "locked" entity. Once a Product is instantiated, its productID and productName are set forever, mimicking a physical non-erasable tag on a warehouse item.
• Task 246 Exclusive Club: The Smart Setter V0.1 — Raw data access is dangerous. This project demonstrates the ultimate goal of Encapsulation: protecting the object's state from invalid data. By implementing Setters with Validation, we ensure that a Person can never have a negative age. The object now possesses "self-awareness" and "self-protection" logic, rejecting incorrect inputs and maintaining data integrity throughout its lifecycle.
• Task 245 Exclusive Club: The Getter Pattern V0.1 — Encapsulation is not just about hiding data, but about managing access to it. In this project, we implement Getters—special methods that act as safe bridges to our private fields. We also introduce a Parameterized Constructor, which allows us to set the initial state of the Person object at the moment of birth. This design pattern ensures that once a club member is registered, their data is protected from accidental external modification while remaining accessible for reading.
• Task 244 Exclusive Club: The Walls of Encapsulation V0.1 — Data integrity is the foundation of secure software. This project introduces the private access modifier, the first step towards Encapsulation. By marking the memberName and memberAge fields as private, we hide the internal state of the Person object from the outside world. This exercise demonstrates that even if an object exists, its "private" parts are inaccessible to other classes, ensuring that the object has full control over its data.

• Task 243 Admission Process: Grade Tracking V0.1 — The object lifecycle in Java is not an instantaneous event but a sequence of steps. This project explores Sequential Instance Initialization. By using multiple initialization blocks, we simulate a multi-stage review process for a student's grade. We observe how Java executes these blocks in the order they appear in the source code, allowing us to track the transformation of state from the initial field assignment to the final object preparation.
• Task 242 Factory Automation: Initialization Sensors V0.1 — In advanced manufacturing, sensors must trigger as soon as a process begins. This project demonstrates Instance Initialization Blocks in Java. These blocks run every time an instance of the class is created, execution-wise placed between field initialization and the constructor. We use this mechanism to simulate a factory notification system that alerts the operator the moment a new Car object starts its "assembly" in memory.
• Task 241 Publishing House: Explicit Initialization V0.1 — In professional software, relying on system defaults like null or 0 can lead to errors. This project demonstrates Explicit Field Initialization. By assigning values directly at the point of declaration, we ensure that every Book object starts its lifecycle with valid, domain-specific data ("Untitled" and 100 pages). This provides a fallback mechanism that guarantees object consistency even when a default constructor is used.
• Task 240 Virtual Zoo: Default Characteristics V0.1 — What happens when an object is created without specific instructions? This project explores Default Field Initialization in Java. When we instantiate the Animal class without a constructor or manual assignment, Java automatically assigns "safe" values: 0 for numeric primitives (int) and null for object references (String). Understanding these defaults is crucial for avoiding NullPointerException and ensuring predictable program behavior.

• Task 239 Student Admission: Ultimate Flexibility V0.1 — An educational system must be resilient to incomplete data. This project implements a high-flexibility Student model using 4-level Constructor Chaining. Whether a student provides full dossiers or just a name, the system uses the this() keyword to delegate initialization logic up the chain. This architectural pattern eliminates code duplication and ensures that default values ("Unknown", 0) are applied consistently across all entry points.
• Task 238 Car Factory: Smart Assembly Line V0.1 — In industrial software design, DRY (Don't Repeat Yourself) is a critical principle. This project demonstrates Constructor Chaining in Java. By using the this() keyword, we link multiple constructors together. The "simple" constructors delegate their work to more "complex" ones, passing default values along the chain. This ensures that the core initialization logic resides in a single location, making the code robust and easy to maintain.
• Task 237 Online Service: User Profile Initialization V0.1 — In modern web services, user onboarding must be seamless. This project models a User entity with flexible registration paths. By using Constructor Overloading, we handle two common scenarios: anonymous "quick" registration and basic "named" registration. The system ensures that even without user input, every profile is initialized with safe default values ("Unknown" and age 0), maintaining data consistency across the platform.
• Task 236 Publishing House: Flexible Book Registration V0.1 — In the publishing industry, data arrives in stages. This project models a Book entity that can be registered even if its physical properties (like page count) are not yet finalized. By using Constructor Overloading, the system provides two entry points for data: one for early-stage titles and another for completed manuscripts. This approach ensures that every book in the database is properly initialized, maintaining a high level of data consistency.

• Task 235 Digital Library: Flexible Book Records V0.1 — A robust library system must handle books even when their full details are not yet known. This project demonstrates Constructor Overloading in Java. We provide two ways to instantiate a Book object: one that uses default placeholder values ("Без названия", 0) and another that accepts specific data upon creation. This ensures every book object in our system is consistently initialized, avoiding null pointers or uninitialized states.
• Task 234 Virtual Showroom: Independent Objects V0.1 — The power of OOP lies in the ability to create multiple instances from a single blueprint. This project demonstrates object independence. We define a Car class and then create two separate objects: a 2020 Toyota and a 2010 BMW. Each object maintains its own memory space, proving that while they share the same structure, their data remains distinct and isolated.
• Task 233 Digital Shelter: Instant Registration V0.1 — In a professional system, objects should not exist in an invalid state. This project models a digital dog shelter where every Dog is registered using a constructor. This ensures that the dog's name and age are assigned exactly at the moment of "arrival" (instantiation), preventing the creation of empty or anonymous records.
• Task 232 Virtual Pets: The Birth of Barsik V0.1 — The transition from a class (blueprint) to an object (instance) is the core of Java programming. This project demonstrates the "lifecycle" of a virtual pet. We declare a Cat template, allocate memory using the new keyword, and then manually define its unique characteristics: "Barsik", aged 3. This process, known as object instantiation, creates a concrete entity in the JVM's Heap memory.

• Task 231 Digital Bank: Flexible Account Management V0.1 — Modern banking systems require flexibility during customer onboarding. This project demonstrates Constructor Overloading, allowing a BankAccount to be initialized in multiple ways: with a starting balance or as an empty account. Additionally, it implements dynamic state updates through a parameterized deposit method, ensuring that the account balance accurately reflects financial transactions.
• Task 230 Game Mechanics: Digital Counter V0.1 — In gaming and interactive systems, tracking state changes (like score, clicks, or coins) is a fundamental task. This project implements a Counter object that maintains an internal state which changes over time. By calling the increment() method, the application modifies the object's data, demonstrating how objects encapsulate both their current status and the logic to transform that status.
• Task 229 Online School: Mandatory Initialization V0.1 — Manually setting fields after object creation is error-prone and tedious. This project introduces Constructors—special methods that run at the moment of "birth" (instantiation). By defining a parameterized constructor in the Student class, we guarantee that no student can exist in the system without a name and a grade, enforcing data integrity from the very start.
• Task 228 Virtual Showroom: Car Inventory V0.1 — In a professional automotive system, objects must be self-describing. This project models a Car entity that encapsulates both its specifications (brand and production year) and its presentation logic. By moving the display logic into the Car class itself, we ensure that every vehicle "knows" how to present its details to a potential customer, maintaining high cohesion within the object.

• Task 227 University Admin: Student Registration V0.1 — In a multi-user system, a single class must support many independent objects. This project demonstrates how to use the Student blueprint to register two distinct individuals. By creating separate instances for "Hana" and "Greg," we illustrate how Java manages unique data for each object in the heap memory, ensuring that updating one student's information does not affect the other.
• Task 226 Digital Library: Book Template V0.1 — In this project, we move beyond simple object creation to defining object behavior. We model a Book as a digital entity that not only stores data (title and pages) but also possesses the ability to describe itself through a dedicated method. This encapsulates both the state and the functionality within a single class structure.
• Task 225 Virtual Pets: Materializing a Cat V0.1 — An object-oriented program consists of classes and objects. While a class is just a template, an object is a specific "living" instance of that template. This project demonstrates how to declare a Cat class and then "summon" it into existence within the main method. This process allocates memory for the cat, allowing us to interact with it via the reference variable myCat.
• Task 224 Virtual Pets: Dog Blueprint V0.1 — Object-Oriented Programming (OOP) begins with defining structures. This project marks the first step in creating a virtual pet system by declaring a Dog class. This class acts as a template or "blueprint" that defines what a dog is in our digital world. While currently empty, it serves as the foundational container for future attributes (like name or breed) and behaviors (like barking or running).

• Task 223 Real Estate: Building Age Calculator V0.1 — Calculating the age of an asset is a common requirement in commercial applications. This project demonstrates how to use the java.time.Period class to determine the exact duration between two dates. Unlike simple day counting, the Period class provides a multi-unit breakdown, allowing the system to report age in human-readable terms: years, months, and days.
• Task 222 Project Manager: Deadline Countdown V0.1 — In project management, tracking the remaining time until a milestone is critical for resource allocation. This project demonstrates how to calculate the distance between two LocalDate objects. By using the ChronoUnit utility, the application determines exactly how many days are left from the current system date to a predefined project deadline (May 15, 2027).
• Task 221 Time Machine: Date Comparison V0.1 — In timeline-sensitive applications, it is crucial to determine if a specific event has already occurred or is still in the future. This project simulates a simple time machine check. It compares a historical or future milestone (January 1, 2025) against the current system date to provide a status update on the timeline.
• Task 220 Holiday Countdown: Date Arithmetic V0.1 — Planning for future events requires precise calendar calculations. This project demonstrates how to project a future date starting from the current system time. By utilizing the built-in arithmetic methods of the LocalDate class, the application calculates exactly which day will occur 10 days from today, serving as the starting point for a holiday countdown.

• Task 219 Order Management: Custom Timestamp Parsing V0.1 — In real-world applications, timestamps are frequently received in non-standard formats. This project demonstrates how to parse a complex string containing both date and time ("01.06.2025 14:30") into a functional LocalDateTime object. By defining a specific pattern that matches the input string, the application can accurately extract chronological data for order tracking and processing.
• Task 218 Organizer App: Localized Date Display V0.1 — User experience is highly dependent on how data is presented. This project demonstrates how to move away from technical ISO standards toward user-friendly date formats. By using a custom pattern string, the application transforms a LocalDate object into a human-readable string that follows common European and regional date conventions (Day.Month.Year).
• Task 217 Data Ingestion: ISO Date Parsing V0.1 — In many real-world scenarios, dates are received as plain text strings. This project demonstrates how to "rehydrate" such strings into rich LocalDate objects. By using the parse() method combined with the ISO_LOCAL_DATE formatter, we transform a static piece of text into an object capable of date arithmetic, comparison, and validation.
• Task 216 Daily Report System: ISO Formatting V0.1 — Uniformity in data presentation is critical for enterprise reporting systems. This project demonstrates how to transform a LocalDate object into a standardized string format using DateTimeFormatter. By utilizing the pre-defined ISO_LOCAL_DATE constant, the application ensures that every report generated adheres to the international ISO-8601 standard (YYYY-MM-DD).

• Task 215 Universal Chronicle: Absolute Time Tracking V0.1 — This project demonstrates the workflow of a professional global logging system. It focuses on the transition between zoned time and absolute time (Instant). By converting a specific event in Kyiv to a universal instant and then back to Tokyo time, the application showcases how a single moment remains synchronized regardless of regional timezone rules.
• Task 214 Global Teleportation: Timezone Synchronization V0.1 — This project simulates a high-precision synchronization task for a global teleportation system. It demonstrates how to take a specific event scheduled in one timezone (Minsk) and calculate exactly what time it will be in another part of the world (New York) at that very same moment. This ensures all participants, regardless of their location, are synchronized to the same absolute instant.
• Task 213 International Conference: Zoned Start Time V0.1 — When organizing international events, local time is insufficient for global coordination. This project demonstrates how to anchor a floating LocalDateTime to a specific geographical region. By applying the "Europe/Minsk" timezone to a scheduled conference start, we create a precise ZonedDateTime that can be accurately translated across all global regions.
• Task 212 Global Command Center: Timezone Display V0.1 — This project simulates a global time monitoring system. It utilizes the ZonedDateTime class to capture the current instant in three specific geographical regions: Minsk, New York, and Tokyo. This ensures that operators in the Command Center are aware of the precise local time in strategic locations across different continents.

• Task 211 Secret Operation: Time Adjustment V0.1 — In mission planning, precision is paramount. This project demonstrates how to adjust a pre-defined point in time using the Java Time API. Starting with an initial briefing timestamp, the application applies sequential modifications—adding hours and subtracting minutes—to calculate the final operational start time.
• Task 210 Secretary's Scheduler: Meeting Comparison V0.1 — This project implements a fundamental scheduling logic for time-sensitive applications. It compares two specific time objects—a morning meeting and an afternoon presentation—to verify their chronological sequence. By utilizing the modern Java Time API, the application ensures that the earlier event is correctly identified and displayed to the user.
• Task 209 Astrology App: Birth Day Finder V0.1 — This project focuses on extracting chronological properties from a specific date. By initializing a LocalDate object for a given birth date (March 25, 1969), the application retrieves the corresponding day of the week. This is a fundamental feature for applications providing astrological insights, historical context, or scheduling.
• Task 208 Clockmaster: Time Components V0.1 — This project demonstrates how to deconstruct a time object into its fundamental components. Using the LocalTime class, the application captures the current system time and extracts specific integer values for hours, minutes, and seconds. This granular control is essential for building custom clocks, timers, and scheduling logic.

• Task 207 Historical Event Logger V0.1 — This project demonstrates how to initialize a specific point in time using the Java Time API. Unlike retrieving the current system time, this task focus on creating an immutable LocalDateTime instance for a pre-defined historical moment (February 24, 2022, at 04:00 AM). This is essential for applications managing logs, archives, or schedules.
• Task 206 Futuristic Event Planner: Tomorrow V0.1 — This project focuses on forward-looking date manipulation within the Java Time API. It demonstrates how to accurately calculate the next calendar day based on the current system time. This functionality is a fundamental building block for scheduling systems, reminders, and future-oriented applications.
• Task 205 Historical Date Tracker: Yesterday V0.1 — This project focuses on date manipulation within the Java Time API. It demonstrates how to perform basic date arithmetic by moving the current system date one step into the past. This functionality is a core requirement for applications dealing with historical records, logs, or daily reports.
• Task 204 Digital Calendar: Date Tracker V0.1 — This project marks the beginning of a digital calendar module. Its primary function is to retrieve the current date from the local system and display it to the user. This is achieved using the LocalDate class from the modern java.time package, which provides a clean and thread-safe way to handle date information.

• Task 203 ISS Tracker: Manual JSON Parser V0.1 — This project focuses on extracting specific data from a JSON response without using third-party parsing libraries. By sending a request to the ISS Current Location API, the application retrieves a raw JSON string and manually identifies the positions of coordinates using String methods. This exercise strengthens foundational knowledge of text processing in Java.
• Task 202 Cat Fact Generator V0.1 — This project implements a simple client for the "CatFact Ninja" API. It demonstrates how to fetch random, dynamic data from a public REST API and display the raw JSON response. Each execution provides a new interesting fact about cats, making it a perfect starting point for entertainment-based applications.
• Task 201 ISS API Health Checker V0.1 — In space monitoring systems, verifying API availability is a critical task. This project implements a lightweight "ping" logic to check the International Space Station (ISS) location service. By using an optimized response handler, we extract only the HTTP status code without consuming bandwidth for the response body.
• Task 200 Weather API Integrator V0.1 — This project demonstrates how to interact with a real-world REST API to fetch weather data. It focuses on sending a GET request to the Open-Meteo service and retrieving the response as a raw JSON string. This is a foundational step for any application that consumes web services.

• Task 199 Image Metadata Downloader V0.1 — This project focuses on retrieving and processing HTTP response headers. It demonstrates how to use the java.net.http.HttpClient to extract metadata such as Content-Type and Content-Length before saving the actual binary content. This is essential for building smart downloaders that need to validate file types and sizes.
• Task 198 Smart Image Downloader V0.1 — This project demonstrates a robust approach to web resource retrieval using the java.net.http.HttpClient API. Unlike simpler methods, this implementation includes error handling by validating the HTTP response status code before attempting to save data to the local disk.
• Task 197 Streamlined Image Downloader V0.1 — This project demonstrates the most modern and efficient way to transfer data between streams in Java. By using the transferTo() method, we can pipe data from a network InputStream directly into a file OutputStream without manual buffer management or intermediate byte arrays.
• Task 196 Image Downloader Module V0.1 — This project demonstrates how to download binary content (an image) from a remote web server using Java's networking capabilities. It combines the java.net.URL class for establishing a connection with the java.nio.file.Files utility for streamlined file saving.

• Task 195 File Backup Utility V0.2 — This project demonstrates the process of creating a file backup. It involves reading the raw byte content of an existing binary file and writing that exact data into a new destination file. This ensures a 1:1 replica of the original data using modern Java 11+ syntax.
• Task 195 File Backup Utility V0.1 — This project demonstrates the process of creating a file backup. It involves reading the raw byte content of an existing binary file and writing that exact data into a new destination file. This ensures a 1:1 replica of the original data.
• Task 194 Binary Message Encryptor V0.1 — This project demonstrates how to work with binary data in Java. Instead of writing plain text, we manipulate raw bytes (ASCII values) and store them in a .bin file. This is a fundamental step in understanding encryption, image processing, and network protocols.
• Task 193 Digital Diary Reader V0.1 — This project focuses on the retrieval aspect of file management. It demonstrates how to use the java.nio.file package to read the contents of an existing text file. This is a critical skill for any application that needs to load settings, user data, or saved logs.
• Task 192 Digital Diary Note V0.1 — This project demonstrates the modern way to interact with the file system in Java using the java.nio.file package. The goal is to create a text file named note.txt and write a specific inspirational string to it. This approach is more robust and efficient than the legacy java.io.File methods.

• Task 191 Word Frequency Analyst V0.1 — This project focuses on basic text analysis using the HashMap collection. It demonstrates how to parse a string into individual words and count their occurrences. This algorithm is the foundation for search engines and data processing tools where frequency analysis is required.
• Task 190 User Registry Manager V0.1 — This project demonstrates how to manage a simple user database using HashMap. It specifically focuses on the remove() method, which is essential for deleting data based on a unique key. The program confirms successful deletion by attempting to retrieve the removed record and verifying it returns null.
• Task 189 Digital Gradebook V0.1 — This project simulates a teacher's digital gradebook. It demonstrates how to use the containsKey() method in a HashMap to verify if a specific entry exists before attempting to retrieve and process its value. This approach prevents potential null pointer issues and ensures data integrity.
• Task 188 Pocket Travel Translator V0.1 — This project introduces the HashMap collection in Java. Unlike lists that use numeric indexes, a HashMap allows storing data pairs where a unique "key" is mapped to a specific "value". This simulation demonstrates the basic operations of a travel phrasebook: storing a translation and retrieving it using the original word.

• Task 187 Interactive Task Assistant V0.1 — This project simulates an interactive assistant that records user tasks until an empty input is received. It demonstrates how to dynamically populate an ArrayList using the Scanner class and how to iterate through a collection in reverse order (LIFO - Last In, First Out logic).
• Task 186 Exclusive Club Guest List V0.1 — This project demonstrates how to check for the existence of an element within a dynamic list. Using a guest list scenario, it showcases the efficiency of the contains() method in ArrayList, which returns a boolean value based on whether the specified object is present in the collection.
• Task 185 Chef's Ingredient Manager V0.1 — This project simulates a chef managing a dynamic list of ingredients. It demonstrates essential ArrayList operations such as replacing an existing element, removing elements by index, and iterating through the collection to display its contents.
• Task 184 Digital Artifact Archive V0.1 — This project introduces the use of dynamic lists in Java. Unlike standard arrays, dynamic lists can grow in size as needed. In this simulation, we manage a digital archive where new artifact identifiers are stored and retrieved using the ArrayList collection.

• Task 183 Deep Call Trace Debugger V0.1 — This project simulates a multi-layered system architecture where requests pass through several processing stages. By intentionally triggering an ArrayIndexOutOfBoundsException at the deepest level of the call stack, we practice tracing the program's execution flow from the entry point (main) to the specific failure point.
• Task 182 Report System Detective V0.1 — This project demonstrates how to trace an error through multiple layers of method calls. By creating a chain of methods (main -> calculateReportData -> processRawNumbers), we simulate a complex system where a low-level mathematical error causes the entire application to crash. The focus is on reading the Stack Trace to understand the path the program took before the failure.
• Task 181 Inventory Debugger V0.1 — This project focuses on identifying and analyzing memory-related errors in Java. By attempting to access a non-existent array index (index 5 in a 3-slot array), we trigger an ArrayIndexOutOfBoundsException. The goal is to study the Stack Trace to find the specific line number where the boundary violation occurred.
• Task 180 Culinary Proportion Calculator V0.1 — This project is designed to help developers understand the Java Stack Trace. By intentionally causing a division by zero error, we simulate a critical bug in a culinary calculation module. The goal is to identify the exception type and the exact line of code responsible for the crash by analyzing the console output.

• Task 179 Gold Amount Converter V0.1 — This project demonstrates the propagation and handling of NumberFormatException. It simulates an RPG game where a player's string input is converted into a numeric gold amount. The utility method delegates the error handling to the caller, ensuring that invalid text input does not crash the game.
• Task 178 Data Extraction Utility V0.1 — This project demonstrates the propagation of multiple related exceptions using the throws keyword. It simulates a data pipeline component that reads the first line of a file, delegating both FileNotFoundException and IOException handling to the calling environment.
• Task 177 System Log Analyzer V0.1 — This project demonstrates the handling of IOException during file operations in Java. It simulates a log analysis utility that delegates the responsibility of handling input/output errors to the caller using the throws keyword.
• Task 176 Secret Document Access V0.1 — This project demonstrates the use of the throws keyword in Java to delegate exception handling. Instead of catching a FileNotFoundException locally, the method declares it in its signature, passing the responsibility of error management to the calling method.

• Task 175 User Registration Validator V0.1 — This project demonstrates the combined use of manual exception throwing and the finally block. It simulates a user registration system where the username must not be empty. The finally block is used to ensure that the validation status is reported regardless of whether the registration was successful or failed due to an exception.
• Task 174 Critical Resource Manager V0.1 — This project illustrates the behavior of the finally block when an exception occurs but is not caught by a catch block. It proves that the Java Virtual Machine guarantees the execution of the finally block before the program terminates due to a fatal error, which is essential for resource cleanup.
• Task 173 Game Score Validator V0.1 — This project demonstrates how to manually throw exceptions in Java using the throw keyword. It ensures that game scores remain positive by triggering an IllegalArgumentException when an invalid value is processed.
• Task 172 Cleaning Robot Manager V0.1 — This project demonstrates the usage of the finally block in Java. In software development, certain actions (like closing a database connection or sending a final status report) must occur regardless of whether an error occurred. This simulation uses a cleaning robot to show how the finally block guarantees execution of completion messages.

• Task 171 Mission Control System V0.1 — This project demonstrates the resilience of a Java application when facing critical runtime errors. In a mission-critical system, an error like division by zero should not halt the entire process. By using a try-catch block, we ensure that the exception is handled gracefully, allowing the program to proceed to its final logical conclusion.
• Task 170 Team Score Calculator V0.1 — This project focuses on retrieving detailed exception information in Java. When a system error results in an empty player list (numberOfPlayers = 0), dividing the total score by zero triggers an ArithmeticException. Instead of a generic message, this task demonstrates how to use the e.getMessage() method to obtain the exact technical reason for the failure as defined by the Java Virtual Machine.
• Task 169 RPG Inventory System V0.1 — This project demonstrates the ArrayIndexOutOfBoundsException in Java. It simulates an RPG inventory where a player attempts to access an item slot that does not exist. This helps in understanding how to handle errors when working with fixed-size data structures like arrays.
• Task 168 Smart Robot Explorer V0.1 — This project demonstrates how to handle one of the most common runtime exception in Java: the ArithmeticException. It occurs when the application attempts to divide an integer by zero. This simulation helps understand how try-catch blocks ensure the reliability of software in unpredictable environments, such as a robot with failing sensors.

• Task 167 Secret Agent Database V0.1 — This project demonstrates one of the most common runtime errors in Java: the NullPointerException. It occurs when the application attempts to use an object reference that has not been initialized (contains null). This simulation helps understand why null-checks are essential in production code.
• Task 166 Registration Input Validator V0.1 — This project simulates a common data-entry error where a user provides non-numeric text in a field expected to contain an integer (e.g., age). It focuses on Java's response to invalid format conversion through the Integer.parseInt() method.
• Task 165 Gem Collector Inventory V0.1 — This project explores how Java manages memory and array boundaries. In many programming languages, accessing an index outside an array's range might return garbage data, but Java's strict type safety and runtime checks prevent this by throwing a specific exception.
• Task 164 Galactic Energy Divider V0.1 — This project explores Java's behavior when encountering illegal mathematical operations. Specifically, it demonstrates what happens when an integer is divided by zero. This is a crucial lesson in exception handling and defensive programming for any Java developer.

• Task 163 Student Grading System V0.1 — This project showcases the advanced capabilities of Switch Expressions introduced in Java 14. Specifically, it demonstrates how to group multiple constants within a single case label using a comma-separated list. This approach significantly simplifies the logic when several inputs should result in the same output.
• Task 162 Modern Task Planner V0.1 — This project demonstrates the transition from legacy switch statements to modern Switch Expressions. By using the arrow syntax, we reduce boilerplate code and ensure that each case returns a value directly to a variable, which is a key pattern in functional-style Java programming.
• Task 161 Drone Control System V0.1 — This project demonstrates the use of Switch Expressions with String objects. It simulates a drone's command processing unit where incoming text commands are mapped to specific operational statuses. The modern arrow (->) syntax is used to ensure code conciseness and safety.
• Task 160 HTTP Response Handler V0.1 — This project demonstrates the use of the modern Switch Expression (introduced in Java 14). Unlike the traditional switch statement, the expression form is more concise, eliminates the risk of "fall-through" bugs by removing the need for break, and allows for direct variable assignment.

• Task 159 Celestial Navigation System V0.1 — This project simulates a spacecraft navigation module. It demonstrates the use of built-in Java enum methods to handle constant data. We explore how to retrieve the string name of a constant, its position (index) in the declaration list, and how to dynamically convert a string back into an enum constant.
• Task 158 Weekday Iterator V0.1 — This project demonstrates how to retrieve and iterate through all constants defined in a Java enum. By using the built-in values() method, we can programmatically access the entire set of days in a week, which is a fundamental requirement for building task schedulers and calendar applications.
• Task 157 Seasonal Message Generator V0.1 — This project demonstrates the synergy between Java enum types and the switch statement. By using an enum as the switch selector, we create a highly readable and type-safe branching logic that delivers personalized messages based on the current season.
• Task 156 Traffic Signal State Model V0.1 — This project demonstrates the use of Java enum to model a real-world system: a traffic light. Enums provide a type-safe way to represent a fixed set of constants, making the code more readable and preventing invalid values from being assigned to state variables.

• Task 155 Smartwatch Calculator V0.1 — This project implements a lightweight calculator designed for a smartwatch interface. It processes two integer inputs and a mathematical operator, demonstrating how to use the switch statement with the char data type to branch logic based on symbols.
• Task 154 Seasonal Activity Planner V0.1 — This project demonstrates how to group multiple case statements in a switch block to execute the same logic for different inputs. The application identifies the season based on a numeric month input (1-12), showcasing efficient multi-condition handling.
• Task 153 Robot Control Interface V0.1 — This project demonstrates the application of the switch statement for string comparisons. It simulates a basic command-line interface for a robot, where specific text inputs trigger corresponding actions, showcasing how to handle multiple logical branches efficiently.
• Task 152 Office Day Navigator V0.1 — This project demonstrates the use of the switch statement in Java. It serves as an efficient alternative to multiple if-else-if conditions when dealing with a single variable that can take several discrete values. The application maps numeric input to the corresponding day of the week.

• Task 151 Constant Protection Mechanism V0.1 — This project demonstrates the strict enforcement of the final modifier in Java. By attempting to reassign a value to a constant, we observe how the Java compiler prevents modifications, ensuring that critical parameters like server capacity remain fixed.
• Task 150 Global Constants and Static Access V0.1 — This project demonstrates how to create a globally accessible constant in Java. By combining public, static, and final modifiers, we create a value that belongs to the class itself, remains immutable, and can be accessed from any other part of the application without instantiating the class.
• Task 149 Constants in Java V0.1 — This project demonstrates how to define immutable values in Java using the final modifier. By declaring a variable as final, we ensure that its value remains constant throughout the execution of the program, which is critical for system-wide parameters like calendar rules.
• Task 148 Local Variable Type Inference V0.1 — This project explores the var keyword introduced in Java 10. While it allows the compiler to infer the data type based on the assigned value, its use is a subject of debate regarding code clarity and long-term maintenance.

• Task 147 Sensor Data NaN Validator V0.1 — An educational project focused on handling special floating-point values in Java. It demonstrates how to parse a "NaN" string into a double and verify it using built-in utility methods, which is crucial for processing telemetry and sensor data where invalid readings may occur.
• Task 146 Price Wrapper Logic V0.1 — An educational project exploring the transition between primitive types and their corresponding wrapper classes. It focuses on Autoboxing and Unboxing, which are essential when working with Java Collections or APIs that require objects instead of primitives.
• Task 145 Character Type Validator V0.1 — An educational project demonstrating character validation techniques in Java. It specifically focuses on identifying whether a given character belongs to the numeric digit category using the built-in utility methods of the Character wrapper class.
• Task 144 Player Score Converter V0.1 — An educational project focused on parsing numerical data from strings. This is a common task when handling user input or reading data from text files where numeric values are initially represented as text.

• Task 143 Advanced Text Editor V0.1 — This project demonstrates professional-grade text editing using StringBuilder. It covers the removal of specific fragments and the replacement of key terms, showcasing how to modify content efficiently without reallocating memory for new string objects.
• Task 142 Cryptographic Text Reverser V0.1 — An educational project demonstrating the power of the StringBuilder.reverse() method. This tool is essential for tasks requiring character order inversion, such as palindrome checking or simple cryptographic decoding.
• Task 141 Precision Text Inserter V0.1 — This project focuses on the mutable nature of StringBuilder, specifically utilizing the insert() method. This technique allows for adding content at any specific index within a string buffer, which is highly efficient for dynamic text generation like personalized chat-bot greetings.
• Task 140 Dynamic String Builder V0.1 — An educational project focused on efficient string manipulation using the StringBuilder class. This approach is highly optimized for scenarios where strings are built incrementally, preventing unnecessary memory allocation.

• Task 139 Registration Validator V0.1 — This project simulates a registration validation system. It demonstrates how to verify if two email addresses are identical regardless of casing and how to check if a specific domain or keyword exists within a registration message.
• Task 138 Lexicographical String Comparator V0.1 — An educational project that explores how Java compares strings alphabetically (lexicographically). By using the compareTo() method, we can determine the relative order of strings, which is essential for sorting algorithms and data organization.
• Task 137 Case-Insensitive Comparison V0.1 — An educational project demonstrating how to identify file types and extensions by analyzing string prefixes and suffixes. This technique is commonly used in file management systems and data processing pipelines.
• Task 136 Case-Insensitive Comparison V0.1 — A fundamental educational project demonstrating how to compare two strings in Java while ignoring their case (uppercase vs. lowercase). This is essential for creating user-friendly interfaces where "Admin" and "admin" should be treated as the same identity.
• Task 135 Secure Login Validator V0.1 — An educational project demonstrating the difference between case-sensitive and case-insensitive string comparison in Java. This simulation mirrors real-world login procedures where emails are flexible but passwords are strict.

• Task 134 Product Filter System V0.1 — An educational project demonstrating conditional string processing. It checks if a product name meets specific criteria (starts with 'E') and generates a 3-character abbreviation if the condition is met.
• Task 133 Dynamic String Surgeon V0.1 — An advanced look at substring extraction. Instead of hardcoding indices, this project demonstrates how to programmatically find the start and end positions of a fragment, making the code resilient to changes in the source string.
• Task 132 Substring Search Locator V0.1 — An educational project demonstrating how to find the position of a specific word within a string using the indexOf() method. This is a fundamental operation for search engines and text processing applications.
• Task 131 Secret Character Extraction V0.1 — An educational project focused on string manipulation. It demonstrates how to retrieve a specific character from a string using its index, highlighting that Java uses zero-based indexing.

• Task 130 Localized Result Formatter V0.1 — An educational project demonstrating how to handle internationalization (i18n) in Java. It specifically focuses on using Locale with String.format() to display decimal numbers according to regional standards (using a comma instead of a dot).
• Task 129 Warehouse Inventory Reporter V0.1 — This project demonstrates advanced string formatting techniques in Java to create structured, table-like console output. It focuses on field width specification and text alignment for professional reporting.
• Task 128 Financial Price Formatter V0.1 — An educational project focused on the precision of financial data display. It demonstrates how to use Java's formatting tools to round and display floating-point numbers with exactly two decimal places.
• Task 127 User Dossier Formatter V0.1 — An educational project demonstrating the power of String.format() for creating uniform and readable data strings in Java. This approach is essential for administrative panels and reporting systems.

• Task 126 Unicode Emoji Output V0.1 — This project demonstrates how to output special characters and emojis using their exact Unicode sequences (\uXXXX). This ensures consistent rendering across different environments and systems.
• Task 125 Formatted Slogan Output V0.1 — An educational project focused on complex string formatting using escape sequences. It demonstrates how to include double quotes within a string and how to use tabs for visual alignment.
• Task 124 Multi-line Text Output V0.1 — An educational project demonstrating how to use the newline escape sequence (\n) to output multiple lines of text using a single output command, adhering to code conventions.
• Task 123 Java Path Escaping Demo V0.1 — A simple educational project illustrating how to handle backslashes in Java strings. Backslashes are special characters used for escaping, so to print a literal backslash, it must be escaped with another backslash.

• Task 122 School Student Registry V0.1 — This project illustrates the core OOP principle of Encapsulation. It demonstrates how to protect sensitive data using access modifiers while providing controlled ways to interact with it.
• Task 121 Box Factory Management V0.1 — This project demonstrates the use of the this keyword in Java to resolve naming conflicts between instance variables and method parameters. The implementation follows a strict decoupled architecture with meaningful class naming to ensure that each component's purpose is clear.
• Task 120 Secure Bank Account Demo V0.1 — This project demonstrates strict encapsulation — one of the core principles of object-oriented programming. The account balance is completely hidden from external code (private field). Any modification of the balance is possible only through a controlled public method.
• Task 119 Football Village Registry System V0.1 — This project simulates an open village registry. It serves as a demonstration of Public Field Access within a professional N-Tier architecture. The system allows direct modification of a model's data while maintaining a strict pipeline for validation and formatting.

• Task 118 Football Magical Container Enchantment V0.1 — This project demonstrates the nuances of Java's "Pass-by-Value" mechanism for object references. It proves that while a method can successfully modify the fields of a passed object, it cannot reassign the original caller's reference to a new object instance.
• Task 117 Football Team Lineup Manager V0.1 — This project simulates a real-time team`s lineup management tool for a football manager. It demonstrates the fundamental algorithm for swapping two values within an array reference, ensuring that positional changes made in the logic layer persist throughout the application's lifecycle.
• Task 116 Bonus List Swap Experiment V0.1 — This project explores Java's memory model, specifically focusing on how object references are passed to methods. It demonstrates that while method calls can modify the internal state of an object (like an array's elements), reassigning the reference itself inside the method has no effect on the original caller's reference.
• Task 115 Robot Trajectory Reset V0.1 — This project simulates a robot control system that manages movement trajectories. It specifically demonstrates how Java handles array references, allowing a method to permanently modify the state of an array defined in a different layer of the application.

• Task 114 Student Grade Calculator V0.1 — This project simulates an automated teacher's assistant tool. It processes an array of exam results, calculates the total sum of grades using an iterative approach, and displays the result through a decoupled architectural pipeline.
• Task 113 Sports Results Analyzer V0.1 — This project implements a professional sports score analysis tool. It utilizes a layered architecture to determine the highest score among participants while maintaining strict separation between data entry, comparison logic, and output formatting.
• Task 112 Quiz Show Application V0.1 — This project demonstrates a strict unidirectional data pipeline. It ensures absolute separation of concerns: the data layer only provides data, the logic layer only performs calculations, and the formatting layer only manages visual appearance.
• Task 111 AI Assistant Greeting V0.1 — This project implements the core logic for an intelligent assistant's personalized greeting feature. It focuses on the effective use of return values to transfer processed data between architectural layers, allowing for flexible message handling.

• Task 110 Shape Designer Tool V0.1 — This project provides a professional tool for engineers and designers to quickly verify rectangular object parameters. It demonstrates the reuse of static methods with different arguments and showcases clean architectural separation into specialized packages.
• Task 109 HR Profile Manager V0.1 — This project simulates an automated system for managing employee records in an HR department. It demonstrates advanced code organization by separating responsibilities into different packages and classes, following the Single Responsibility Principle.
• Task 108 Store Cashier Automation V0.1 V0.2 — This project demonstrates two evolutionary steps of a store cashier automation system. Version 1 provides a quick, direct calculation, while Version 2 introduces functional decomposition by separating data calculation from the presentation layer.
• Task 107 Personal Greeter V0.1 — This project simulates a personal greeting feature for an interactive application. It focuses on creating a specialized function that addresses users by their name, demonstrating how to implement static methods with parameters to enhance user interaction.

• Task 106 Random Number Distribution V0.1 — This project simulates a statistical analysis of a random number generator. It generates 50 integers in the range of 1 to 10 and calculates how many times each specific digit appears. This demonstrates the use of frequency arrays to visualize data distribution and probability patterns.
• Task 105 Student Grade Analysis System V0.1 — This project simulates an academic grading system that processes scores across four different subjects for a group of students. It calculates the aggregate score for each individual and identifies the top performer using search algorithms, providing a clear and readable statistical report.
• Task 104 Number Classification System V0.1 — This project implements a numerical analysis tool that classifies integers into three categories: positive, negative, and zero. It processes a raw data sequence and generates a statistical summary using a mapped integer array, demonstrating basic data filtering and aggregation techniques.
• Task 103 Customer Purchase Aggregator V0.1 — This project automates the calculation of total expenditures for a group of 4 clients. It processes a complex 2D data structure representing daily transactions and aggregates them into a consolidated report. This simulation mirrors real-world billing systems where multiple entries must be summed per user account.
• Task 102 Letter Frequency Counter V0.1 — This project implements a frequency analysis tool for a specific set of characters ('a', 'b', 'c'). It processes a character array and uses a separate integer array to track how many times each character appears, demonstrating efficient data categorization logic.

• Task 101 Game Security Access Validator V0.1 — This project simulates a security validation system for a gaming environment. It compares two separate integer sequences (main and backup access codes) to ensure they are perfectly identical. The implementation highlights the importance of deep equality checks in Java to verify array contents rather than memory addresses.
• Task 100 Meteorological Data Extraction V0.1 — This project simulates a weather station data processing unit. It handles a sequence of daily temperature readings and extracts a specific "mid-day" subset for reporting purposes. The implementation demonstrates how to isolate data ranges within arrays efficiently using standard Java utility methods.
• Task 99 Warehouse Management System V0.1 — This project simulates the initialization of a warehouse storage grid. Instead of manual entry, it uses automated batch processing to set the initial state of all storage cells to "Empty". This ensures that the system starts with a clean and verified configuration before any inventory is added.
• Task 98 Athletic Race Results V0.1 — This project automates the organization of athletic competition results. It takes raw timing data from participants and sorts them from the fastest (lowest number) to the slowest (highest number) using Java's standard utility methods, ensuring official results are presented in a clear, ascending sequence.

• Task 97 Environmental Sensor Grid V0.1 — This project simulates an ecological monitoring system. It organizes sensor readings into a $2 \times 5$ matrix and implements a specific formatting logic to present the data as a clean, readable table. The primary technical focus is on managing whitespace and line breaks during 2D array traversal.
• Task 96 Warehouse Inventory Automation V0.1 — This project automates the population of an inventory grid for a warehouse system. It utilizes nested for loops to iterate through a 3x4 matrix, filling it with sequential numbers from 1 to 12. It also includes a visualization module to display the resulting grid in the console.
• Task 95 Digital Billboard Grid V0.1 — This project simulates a digital information board represented by a 3x2 grid. The objective is to place a specific message in the final panel (bottom-right corner) and verify its coordinates by rendering the entire grid structure to the console.
• Task 94 Theater Seating System V0.1 — This project simulates a seat-numbering system for a small theater hall with 2 rows and 3 seats per row. It introduces the concept of two-dimensional arrays, where data is organized into rows and columns, requiring two indices for access.

• Task 93 Edge-to-Center Palindrome Check V0.2 — This project implements the "Two Pointers" algorithm to verify if a character array is a palindrome. It avoids creating additional memory structures by comparing elements from the start and end of the array, progressively moving toward the center.
• Task 93 Palindrome Checker V0.1 — This project implements a palindrome check for character arrays. A palindrome is a sequence that reads the same forwards and backwards. This specific task demonstrates the Array Reversal and Comparison strategy.
• Task 92 Array Fill Demonstration V0.1 — This project demonstrates the process of initializing an array and populating all its elements with a single constant value. It highlights the efficiency of using loops for bulk data assignment compared to manual entry.
• Task 91 Smart Home Temperature Analysis V0.1 — This project simulates a data processing module for a "Smart Home" system. It implements an algorithm to find the maximum value within a set of temperature readings. This pattern is fundamental for monitoring peak loads, overheating, or any threshold-based alerts.
• Task 90 Shopping Cart Calculator V0.1 — This project simulates a basic checkout system for an online store. It focuses on initializing an array with predefined item prices and performing a mathematical summation of its contents to determine the total cost.
• Task 89 Movie Reverser V0.1 — This project demonstrates how to collect user-provided strings into an array and retrieve them in reverse order. It highlights the use of the Scanner class for interactive input and the logic of accessing array elements from the highest index down to the lowest.
• Task 88 Galactic Defender Leaderboard V0.1 — This project simulates a high score table for the "Galactic Defender" game. It focuses on Array Literals, a concise way to initialize and populate an array simultaneously, and demonstrates how to output data line-by-line for a leaderboard format.

• Task 87 Quarterly Array Mapping V0.1 — This project explores advanced indexing techniques by dividing a 120-element array into four logical checkpoints. It demonstrates how to perform arithmetic operations using values stored at specific calculated offsets within the array structure.
• Task 86 Array Tail Operations V0.1 — This project focuses on manipulating elements at the end of a large array using dynamic indexing. It demonstrates how to reference positions relative to the array length ($n-1$, $n-2$, etc.) and perform arithmetic operations between these elements.
• Task 85 Array Boundaries & Midpoint V0.1 — This project focuses on accessing specific strategic points within an array: the beginning, the end, and the mathematical middle. It demonstrates how to use the array size variable $n$ to calculate indices dynamically, which is essential for algorithms like binary search.
• Task 84 Array Basics V0.1 — This project introduces the fundamental concepts of arrays in Java. It demonstrates how to allocate memory for a fixed-size collection, assign values to specific positions using indices, and retrieve data from the start and end of the array.
• Task 83 Tournament Scoreboard V0.1 — This project simulates a tournament management system where scores are pre-calculated for each round. It focuses on using a for loop to automate data entry (sequential numbers 1 through 10) and simultaneous data display, mimicking a real-time scoreboard.
• Task 82 Weather Station Update Languages List V0.1 — This project simulates a weather station data management system. It focuses on the default initialization of floating-point arrays and the precise manipulation of data at a specific index. The task reinforces the concept of zero-based indexing and manual array traversal.
• Task 81 Fantasy Favorite Languages List V0.1 — This project simulates a simple blog entry preparation where a list of favorite programming languages is stored in a fixed-size array. The primary focus is understanding how to retrieve the total capacity of an array using the built-in length property.
• Task 80 Fantasy Inventory System V0.1 — This project simulates a basic inventory system for a fantasy game. It illustrates the fundamental concepts of array declaration, memory allocation for a specific capacity, and the use of zero-based indexing to store and retrieve data.

• Task 79 Academic Performance V0.1 — This project focuses on calculating a student's average score from mixed numeric sources. It demonstrates how to maintain precision during division by using double literals and how to truncate the final result for administrative reporting.
• Task 78 Weather Sensor V0.1 — This project simulates a data overflow scenario in a legacy weather sensor. It investigates the behavior of narrowing primitive conversion when an int value exceeds the 8-bit capacity of a byte, leading to unexpected results due to bit truncation and the two's complement representation.
• Task 77 Spy Cryptography V0.1 — This project simulates a cryptographic mission where characters are encoded into numbers and decoded back. It demonstrates the internal representation of the char data type in Java as a 16-bit Unicode integer and explores both implicit (automatic) and explicit type casting.
• Task 76 Warehouse Inventory V0.1 — This project simulates a warehouse calculation where raw material weight must be converted into a count of finished goods. It highlights the use of explicit type casting in Java to perform truncation, effectively discarding fractional data to find the number of whole units available.

• Task 75 Global Sales Reporting V0.1 — This project simulates the reporting system of a global corporate leader. It focuses on presenting massive financial figures in a human-readable format by utilizing the DecimalFormat grouping separator to distinguish thousands and maintain precise decimal alignment.
• Task 74 Financial Report V0.1 — This project simulates the preparation of a quarterly financial report for investors. It demonstrates how to use the DecimalFormat class in Java to maintain a consistent professional appearance by ensuring all monetary values are displayed with exactly two decimal places.
• Task 73 Magic Shop V0.1 — This project simulates a currency formatting system for a magical shop. It highlights a common task in software development: rounding a double value to exactly two decimal places for financial displays using the scaling and rounding technique.
• Task 72 Laser Calibration V0.1 — This project simulates resource management for space colonization. It focuses on converting high-precision engineering estimates into actionable logistics data by using the Math.round method to determine the nearest whole number of materials needed.

• Task 71 Laser Calibration V0.1 — This project simulates the calibration process of a high-precision laser system. It demonstrates a critical engineering practice in software development: using a tolerance (epsilon) to compare floating-point values, ensuring that minor numerical fluctuations do not cause logic errors.
• Task 70 Mystic Numbers V0.1 — This project simulates an exploration into undefined mathematical territories. It demonstrates how Java's double type handles operations that do not result in a real number, specifically the square root of a negative value, resulting in the NaN (Not a Number) constant.
• Task 69 Cosmic Boundary V0.1 — This project simulates an exploration into the limits of numerical calculations. It investigates how Java's double type handles division by zero, representing states like Infinity that exist beyond standard arithmetic results.
• Task 68 Chemical Experiment V0.1 V0.2 V0.3 — This project simulates a laboratory experiment in which a scientist mixes two precisely measured components (0.1 and 0.2) to achieve a target concentration of 0.3. It demonstrates the inherent precision issues of the double data type when performing floating-point operations in Java and offers a professional solution, as well as a creative hack for simple calculations.

• Task 67 Magic Apples V0.1 — This project simulates the distribution of magical items where fractional parts are required. It highlights a common pitfall in Java: integer division, and demonstrates how to use type casting to obtain a precise double result from int operands.
• Task 66 Price Formatter V0.1 — This project demonstrates the critical difference between visual formatting and mathematical rounding. It ensures financial integrity by synchronizing the stored variable value with the displayed price, preventing discrepancies between customer receipts and internal accounting records.
• Task 65 Vending Machine V0.1 — This project simulates the payment processing unit of a smart vending machine. It introduces interactive user input using the Scanner class, allowing the system to capture real-time payment data in a floating-point format.
• Task 64 Space Navigation V0.1 — This project simulates a navigation calculation for a spacecraft. It demonstrates how to perform division using the double data type to ensure high precision in mission-critical calculations.

• Task 63 Cyrillic Rune V0.1 — This project concludes the series of character studies by exploring a Cyrillic symbol. It demonstrates that Java's char type natively supports a wide range of global characters through the Unicode standard.
• Task 62 Rune Decryptor V0.1 — This project simulates the decryption of an ancient rune. It focuses on the relationship between the char data type and its underlying ASCII numeric representation, demonstrating how Java handles character encoding.
• Task 61 Dragon Hoard V0.1 — This project focuses on handling numeric data that exceeds the 32-bit limit of the standard int type. It demonstrates how to correctly declare a 64-bit long variable for massive values, such as a dragon's hoard, using underscores for readability and the mandatory suffix.
• Task 60 Hero Inventory V0.1 — This project simulates the creation of a base inventory for an RPG (Role-Playing Game) hero. It demonstrates how to choose and declare appropriate numeric primitive types in Java based on the nature and range of the data being stored.

• Task 56 Daily Sales Tracker V1.1 — An enhanced version of the sales tracking utility. This iteration introduces advanced flow control using an infinite loop (while(true)), demonstrating how to selectively process data using continue to skip insignificant entries (zeros) and break to terminate the sequence.
• Task 56 Daily Sales Tracker V0.1 — This application simulates a point-of-sale system that records daily transactions. It aggregates multiple sales entries into a single total. The program utilizes a sentinel-controlled loop where a negative value serves as the termination signal for the workday.
• Task 55 Password Validator V0.1 — This project simulates a secure registration form component. It focuses on string validation using a Do-While Loop, ensuring that the user provides a password that meets specific security requirements (minimum length of 6 characters).
• Task 54 Console Menu V0.1 — This project implements a basic interactive command-line menu using a Do-While Loop. It allows users to perform specific actions (like printing a greeting) repeatedly without restarting the application. The program maintains an active state until the user explicitly chooses to exit.
• Task 53 ATM PIN Validator V0.1 — This project simulates an ATM user interface for PIN-code validation. It utilizes the Do-While Loop to repeatedly request input from the user until a valid four-digit positive integer (between 1000 and 9999) is provided.
• Task 52 Game Bootstrapper V0.1 — This project demonstrates the unique behavior of the Do-While Loop in Java. Unlike a standard while loop, the do-while structure ensures that the code block is executed at least once because the exit condition is checked only after the iteration is complete.

🧩 Nested for-loops: working with 2D grids.

• Task 59 Password Finder V0.1 — This project simulates a brute-force search for a "perfect password" consisting of two numbers. It employs nested for-loops to iterate through possible combinations and utilizes an early exit strategy once the target condition (sum equals 13) is met.
• Task 58 Asteroid Field Visualization V0.1 — This program simulates a space shuttle's radar view of an asteroid field. It uses nested for-loops to generate a precise 5x7 grid of star symbols (⭐). The project demonstrates basic 2-dimensional rendering in a console environment.
• Task 57 Radar Coordinate System V0.1 — This project simulates a radar scanning grid by generating a 3x4 coordinate table. It utilizes nested for-loops to iterate through rows (i) and columns (j), outputting the precise position of each cell in an i,j format.

🧩 Single-level Iterations: flow control and sequence management.

• Task 51 Coordinate Tracker V0.1 — This project simulates the tracking of two objects moving in opposite directions. It utilizes an advanced For Loop structure where two variables are initialized, updated, and evaluated simultaneously within a single loop header.
• Task 50 Product Cost Calculator V0.1 — This project implements a calculation engine for a dynamic pricing model. In this scenario, the price of an item is directly proportional to its position in the sequence (e.g., the 1st item costs 1, the 2nd costs 2, etc.). It utilizes a For Loop to aggregate the total cost for a set number of products (N).
• Task 49 Train Seating V0.1 — This project simulates the identification of even-numbered seats in a train carriage. It utilizes a For Loop to iterate through a range of numbers (0 to 10) and incorporates an If Statement with the Modulo Operator (%) to filter and display only even values.
• Task 48 New Year Countdown V0.1 — This project simulates a festive New Year's Eve countdown. It utilizes a For Loop to iterate backwards from 5 to 1, demonstrating precise control over loop initialization, termination conditions, and decrementing steps.

• Task 47 Coffee Expense Tracker V0.1 — This project implements a budget-tracking utility specifically for coffee expenses. It utilizes a While Loop to continuously collect user input for beverage costs. The sequence is terminated when a negative value is detected, acting as a sentinel signal.
• Task 46 Cinema Seats V0.1 — This project simulates the display of available seating in a cinema row. It utilizes a While Loop to iterate through seat numbers starting from 2, incrementing by 2, until reaching the limit of 10.
• Task 45 Smartphone Unlock V0.1 — This project simulates a smartphone security interface. It employs a While Loop integrated with the Scanner class to continuously prompt the user for a password until the predefined correct value ("java") is entered.
• Task 44 Spaceship Launch V0.1 — This project simulates a spaceship ignition sequence. It utilizes a While Loop to perform a controlled reverse countdown from a starting value to one, followed by a launch signal.

• Task 43 Amusement Park Ticketing System V0.1 — This project implements a multi-tier age categorization logic for an amusement park. It utilizes Nested Ternary Operators to evaluate four distinct age groups within a single expression.
• Task 42 Dynamic Greeting System V0.1 — This project implements a simple time-aware greeting mechanism. It utilizes the Ternary Operator to evaluate the current hour and select between two different greeting strings ("Good morning" or "Good day").
• Task 41 Online Store Order Parity Checker V0.1 — This project simulates a basic order sorting mechanism for an e-commerce platform. It utilizes the Ternary Operator to perform a parity check on order numbers, classifying them as either "Even" or "Odd".
• Task 40 Sports Performance Analysis V0.1 — This project simulates a sports timing system. It focuses on the Ternary Operator, a concise alternative to the standard if-else statement for simple value assignments based on a condition.

• Task 39 Bank Loan Approval Logic V0.1 — This project simulates a banking decision system using two distinct sets of evaluation rules. It focuses on Complex Logical Expressions and the strategic use of parentheses to enforce specific business requirements using the same applicant data.
• Task 38 Party Access Logic V0.1 — This project explores the Associativity of Logical Operators. It tests the admission logic for a private event by evaluating three mandatory conditions using the logical AND (&&) operator with different grouping strategies.
• Task 37 Concert Ticket Purchase Logic V0.1 — This project analyzes the impact of Operator Grouping on logical expressions. It compares standard Java precedence rules with custom-defined logic using parentheses to determine concert ticket eligibility.
• Task 36 Vacation Planner Logic V0.1 — This project simulates a vacation feasibility check. It focuses on the Precedence of Logical Operators, demonstrating how Java evaluates complex boolean expressions containing both || (OR) and && (AND) without explicit parentheses.

• Task 35 Smart Thermostat Logic V0.1 — This project simulates the core logic of a smart thermostat. It focuses on Range Validation, using logical operators to check if a numeric value resides between defined inclusive boundaries (20°C to 25°C).
• Task 34 Picnic Planner Logic V0.1 — This project simulates a decision-making algorithm for weekend planning. It focuses on Advanced Logical Operators to evaluate multiple boolean conditions simultaneously.
• Task 33 Football Match Result Recorder V0.1 — This project simulates a basic sports scoring system. It demonstrates how to use Relational Operators to compare two numeric values and store the resulting truth value in a boolean variable.
• Task 32 Boolean Fundamentals V0.1 — This project introduces the Boolean Primitive Type in Java. It demonstrates how to store and display logical truth values, which serve as the foundation for conditional execution and decision-making in programming.

• Task 31 Loyalty Program Discount Calculator V0.1 — This project simulates a loyalty program logic. It utilizes Nested Conditional Logic to calculate specific discount percentages based on user demographics (age) and membership status (club card).
• Task 30 Conference Access Management V0.1 — This project simulates a conference registration system. It utilizes Complex Nested Conditionals to perform high-level visitor filtering based on age and specialized invitation categories (VIP vs. GUEST).
• Task 29 Exclusive Club Entry System V0.1 — This project simulates an entry control system for an exclusive club. It utilizes Nested Conditional Logic to validate a user's eligibility based on two factors: minimum age and specific residency (Prague).
• Task 28 Secure Access System V0.1 — This project simulates a two-factor security gate. It utilizes Nested Conditional Logic to perform a hierarchical check of user credentials: age verification followed by a secret code validation.

• Task 27 Time-based Greeting System V0.1 — This project simulates an adaptive greeting system. It utilizes Multi-Branch Conditional Logic to analyze time-of-day data and return a context-specific greeting.
• Task 26 Simple Login System V0.1 — This project simulates a basic security gate. It focuses on the Single-Branch Conditional structure (if without else) and introduces the concept of string value comparison.
• Task 25 Clothing Advisor V0.1 — This project simulates a simple weather assistant. It uses conditional branching to analyze temperature data and provide appropriate clothing recommendations.
• Task 24 Cinema Access Control V0.1 — This project simulates a cinema ticketing system. It introduces the fundamental concept of Conditional Logic, where the program executes different blocks of code based on a boolean condition (age verification).

• Task 23 Digital Business Card V0.1 — This project simulates a digital business card generator. It focuses on handling mixed data types (String and int) and demonstrates professional string manipulation.
• Task 22 Cashier System V0.1 — This project simulates a simple cashier terminal. It focuses on basic arithmetic operations and handling multiple integer inputs sequentially.
• Task 21 Player Registration System V1.1 — This project is a transitional milestone in Java learning journey. While the base task requires simple console input/output, this implementation elevates the solution into an enterprise-ready architecture.
• Task 21 Player Registration System V0.2 — This project represents the basic foundation of a Player Registration System. Added console queries for user input.
• Task 21 Player Registration System V0.1 — This project represents the basic foundation of a Player Registration System.
• Task 20 Login System — This project demonstrates how to handle user input in Java using the Scanner class to read and display a password from the keyboard.

• Task 19 Game Score Calculator — This project demonstrates how to parse string-based numeric data (including negative values) into integers and perform arithmetic operations on the resulting data.
• Task 18 Movie Year Extractor — This project demonstrates how to convert numeric data stored as a String into a primitive int type to enable mathematical operations.
• Task 17 Flight Tracker — This project demonstrates string concatenation in Java by combining numeric flight data with destination text to create a complete status message.
• Task 16 Access Code Formatter — This project demonstrates how to convert primitive numeric data types into string representations for data transmission or messaging purposes.

• Task 15.1 Anagram Encoder V0.1 — An advanced continuation of string manipulation topics. This is project implements a complex algorithm to reverse only letters within words while preserving the exact positions of all non-letter characters. It demonstrates professional-grade coding with JUnit 5 testing, Maven lifecycle management, and efficient use of StringBuilder.
• Task 15 String data cleaning and manipulation — This project focuses on data normalization using the String class. It simulates a real-world scenario where user-provided data (like a city name) contains unnecessary spaces and needs to be formatted.
• Task 14 Escaping a quote by Yurii Gagarin — This project demonstrates the use of escaping characters in Java strings. It shows how to include special characters, such as double quotes, inside a String object literal without breaking the code structure.
• Task 13 User Profile Creation — This project demonstrates string concatenation in Java. It shows how to combine multiple object types (String) into a single output using the + operator.
• Task 12 Message from the future — This project focuses on the String class in Java. It demonstrates how to declare a variable of an object type, initialize it with a string literal containing a message "from the future", and print the stored character sequence to the console.

• Task 11 Hero Health Tracking — This project simulates tracking a character's health in a game environment. It demonstrates the practical use of unary operators: increment (++) and decrement (--).
• Task 10 Prize Distribution Logic — This project demonstrates the use of integer division and the modulo operator (%) in Java. It simulates a scenario where a set number of prizes must be distributed equally among teams, and the remainder is calculated.
• Task 09 Single-Line Variable Management — This project demonstrates Java's ability to declare and initialize multiple variables of the same type in a single statement. While this approach increases compactness, it is explored here primarily for syntax understanding.

• Task 08 Bank Account Transactions — This project simulates basic banking operations using integer variables. It demonstrates how to perform balance transfers between accounts and apply bonuses using fundamental arithmetic operations in Java.
• Task 07 Memory Allocation & Concatenation — This project focuses on understanding the memory footprint of different primitive data types in Java. It demonstrates how to combine descriptive text with actual variable values using string concatenation.
• Task 06 String Manipulation & Immutability — This project demonstrates how Java handles String variables and references. It explores the concept of object assignment and string immutability by creating a copy of a variable and modifying it independently.
• Task 05 Game Character Profile — This project demonstrates the use of various Java primitive and reference data types. The goal was to create a profile for a game character by storing different types of information (level, gold, rating, and name) and displaying them in the console.

• Task 04 Compilation Error Analysis & Clean Code — This project focuses on debugging a non-compilable Java program. The objective was to identify, analyze, and comment out lines that cause compilation errors or violate task constraints, ensuring the program runs without.
• Task 03 Code Blocking & Shortcuts — This project focuses on the use of single-line comments (//) to control code execution. The primary goal was to demonstrate how to block the execution of all commands in a Java program so that it produces no output, as per the task requirements.

• Task 02 Phrase Assembly with Console Output — This project demonstrates the difference between System.out.print() and System.out.println() methods in Java. The goal is to assemble phrases from individual words by controlling the cursor position on the console, ensuring that words appear on the same line or move to a new one as required.
• Task 01 Console Output Basics — This is a foundational Java project designed to demonstrate basic console output operations. The goal of the task is to correctly use standard output streams to display mixed data types (integers and Unicode characters) on separate lines.

• PostgreSQL integration (in progress).
• ...
• Multithreading and GitLab tasks (Petro).

• Social preview illustration found via open sources.