Tasks

Complete the task of the chosen difficulty level for your variant number.

Variants

Variant 1. A calculator

1. Initial level. Create a standalone JavaFX application “Calculator”: a grid of buttons, a calculation history, keyboard control. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Enter two finite numbers and an operation +, −, ×, or ÷; show the result; reject division by zero.

2. Basic level. Create a standalone JavaFX application “Calculator”: a grid of buttons, a calculation history, keyboard control. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Enter two finite numbers and an operation +, −, ×, or ÷; show the result; reject division by zero.

3. Advanced level. Create a standalone JavaFX application “Calculator”: a grid of buttons, a calculation history, keyboard control. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Enter two finite numbers and an operation +, −, ×, or ÷; show the result; reject division by zero.

Variant 2. A unit converter

1. Initial level. Create a standalone JavaFX application “Unit converter”: categories in a ComboBox, instant conversion, input validation. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Convert a length≥0 between m, cm, and km; show the value to 3 decimal places; do not allow unknown units.

2. Basic level. Create a standalone JavaFX application “Unit converter”: categories in a ComboBox, instant conversion, input validation. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Convert a length≥0 between m, cm, and km; show the value to 3 decimal places; do not allow unknown units.

3. Advanced level. Create a standalone JavaFX application “Unit converter”: categories in a ComboBox, instant conversion, input validation. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Convert a length≥0 between m, cm, and km; show the value to 3 decimal places; do not allow unknown units.

Variant 3. A Pomodoro timer

1. Initial level. Create a standalone JavaFX application “Pomodoro timer”: Timeline, phase switching, progress, and notifications. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Count down 25 min of work and a 5 min break; Start/Pause/Reset change the state; a repeated Start does not create a second timer.

2. Basic level. Create a standalone JavaFX application “Pomodoro timer”: Timeline, phase switching, progress, and notifications. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Count down 25 min of work and a 5 min break; Start/Pause/Reset change the state; a repeated Start does not create a second timer.

3. Advanced level. Create a standalone JavaFX application “Pomodoro timer”: Timeline, phase switching, progress, and notifications. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Count down 25 min of work and a 5 min break; Start/Pause/Reset change the state; a repeated Start does not create a second timer.

Variant 4. A graphics editor

1. Initial level. Create a standalone JavaFX application “Graphics editor”: drawing on a Canvas, colors, stroke width, saving to PNG. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Draw strokes on a Canvas with a color and a width of 1..20; Clear clears the canvas; Undo removes the last stroke.

2. Basic level. Create a standalone JavaFX application “Graphics editor”: drawing on a Canvas, colors, stroke width, saving to PNG. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Draw strokes on a Canvas with a color and a width of 1..20; Clear clears the canvas; Undo removes the last stroke.

3. Advanced level. Create a standalone JavaFX application “Graphics editor”: drawing on a Canvas, colors, stroke width, saving to PNG. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Draw strokes on a Canvas with a color and a width of 1..20; Clear clears the canvas; Undo removes the last stroke.

Variant 5. Tic-tac-toe

1. Initial level. Create a standalone JavaFX application “Tic-tac-toe”: a board of buttons, win detection, a game score. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. On a 3×3 board, alternate X/O and show the winner or a draw; an occupied cell and moves after the game ends are unavailable.

2. Basic level. Create a standalone JavaFX application “Tic-tac-toe”: a board of buttons, win detection, a game score. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. On a 3×3 board, alternate X/O and show the winner or a draw; an occupied cell and moves after the game ends are unavailable.

3. Advanced level. Create a standalone JavaFX application “Tic-tac-toe”: a board of buttons, win detection, a game score. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. On a 3×3 board, alternate X/O and show the winner or a draw; an occupied cell and moves after the game ends are unavailable.

Variant 6. A registration form

1. Initial level. Create a standalone JavaFX application “Registration form”: a form with field validation and a summary dialog. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Enter a name of 1..40 characters, an email with one @, and agreement to the rules; confirmation shows the summary only for valid data.

2. Basic level. Create a standalone JavaFX application “Registration form”: a form with field validation and a summary dialog. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Enter a name of 1..40 characters, an email with one @, and agreement to the rules; confirmation shows the summary only for valid data.

3. Advanced level. Create a standalone JavaFX application “Registration form”: a form with field validation and a summary dialog. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Enter a name of 1..40 characters, an email with one @, and agreement to the rules; confirmation shows the summary only for valid data.

Variant 7. An analog clock

1. Initial level. Create a standalone JavaFX application “Analog clock”: a clock on a Canvas with animated hands. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Show the system local time with hour, minute, and second hands; update every second, and stop the animation on close.

2. Basic level. Create a standalone JavaFX application “Analog clock”: a clock on a Canvas with animated hands. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Show the system local time with hour, minute, and second hands; update every second, and stop the animation on close.

3. Advanced level. Create a standalone JavaFX application “Analog clock”: a clock on a Canvas with animated hands. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Show the system local time with hour, minute, and second hands; update every second, and stop the animation on close.

Variant 8. An image viewer

1. Initial level. Create a standalone JavaFX application “Image viewer”: FileChooser, zooming, a folder slideshow. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Open a PNG/JPEG and change the zoom within 25..200 %; preserve the aspect ratio; canceling the selection does not change the image.

2. Basic level. Create a standalone JavaFX application “Image viewer”: FileChooser, zooming, a folder slideshow. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Open a PNG/JPEG and change the zoom within 25..200 %; preserve the aspect ratio; canceling the selection does not change the image.

3. Advanced level. Create a standalone JavaFX application “Image viewer”: FileChooser, zooming, a folder slideshow. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Open a PNG/JPEG and change the zoom within 25..200 %; preserve the aspect ratio; canceling the selection does not change the image.

Variant 9. A text editor

1. Initial level. Create a standalone JavaFX application “Text editor”: TextArea, a menu, opening and saving files. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Edit UTF-8 text, and open and save a file; before losing changes, ask to save; Cancel keeps the document.

2. Basic level. Create a standalone JavaFX application “Text editor”: TextArea, a menu, opening and saving files. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Edit UTF-8 text, and open and save a file; before losing changes, ask to save; Cancel keeps the document.

3. Advanced level. Create a standalone JavaFX application “Text editor”: TextArea, a menu, opening and saving files. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Edit UTF-8 text, and open and save a file; before losing changes, ask to save; Cancel keeps the document.

Variant 10. A BMI calculator

1. Initial level. Create a standalone JavaFX application “BMI calculator”: height and weight sliders, a colored result scale. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Enter a mass of 1..500 kg and a height of 0.5..2.5 m; show mass/height² to 1 decimal place without medical advice.

2. Basic level. Create a standalone JavaFX application “BMI calculator”: height and weight sliders, a colored result scale. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Enter a mass of 1..500 kg and a height of 0.5..2.5 m; show mass/height² to 1 decimal place without medical advice.

3. Advanced level. Create a standalone JavaFX application “BMI calculator”: height and weight sliders, a colored result scale. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Enter a mass of 1..500 kg and a height of 0.5..2.5 m; show mass/height² to 1 decimal place without medical advice.

Variant 11. A to-do list

1. Initial level. Create a standalone JavaFX application “To-do list”: a ListView with checkmarks, filters, and saving to a file. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Add a nonempty task, toggle completion, and delete the selected one; show the number of unfinished tasks; with no selection, delete nothing.

2. Basic level. Create a standalone JavaFX application “To-do list”: a ListView with checkmarks, filters, and saving to a file. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Add a nonempty task, toggle completion, and delete the selected one; show the number of unfinished tasks; with no selection, delete nothing.

3. Advanced level. Create a standalone JavaFX application “To-do list”: a ListView with checkmarks, filters, and saving to a file. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Add a nonempty task, toggle completion, and delete the selected one; show the number of unfinished tasks; with no selection, delete nothing.

Variant 12. Guess the number

1. Initial level. Create a standalone JavaFX application “Guess the number”: a graphical game with high scores and difficulty levels. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Generate an integer 1..100, accept guesses, and show higher/lower and the number of attempts; do not count out-of-range input.

2. Basic level. Create a standalone JavaFX application “Guess the number”: a graphical game with high scores and difficulty levels. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Generate an integer 1..100, accept guesses, and show higher/lower and the number of attempts; do not count out-of-range input.

3. Advanced level. Create a standalone JavaFX application “Guess the number”: a graphical game with high scores and difficulty levels. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Generate an integer 1..100, accept guesses, and show higher/lower and the number of attempts; do not count out-of-range input.

Variant 13. A loan calculator

1. Initial level. Create a standalone JavaFX application “Loan calculator”: a parameter form and a payment table. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Enter P>0, an annual interest rate r≥0, and n months>0; show the annuity P*i/(1-(1+i)^(-n)), i=r/1200; for r=0, use P/n.

2. Basic level. Create a standalone JavaFX application “Loan calculator”: a parameter form and a payment table. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Enter P>0, an annual interest rate r≥0, and n months>0; show the annuity P*i/(1-(1+i)^(-n)), i=r/1200; for r=0, use P/n.

3. Advanced level. Create a standalone JavaFX application “Loan calculator”: a parameter form and a payment table. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Enter P>0, an annual interest rate r≥0, and n months>0; show the annuity P*i/(1-(1+i)^(-n)), i=r/1200; for r=0, use P/n.

Variant 14. A traffic light

1. Initial level. Create a standalone JavaFX application “Traffic light”: phase animation and manual control buttons. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Cyclically show red for 5 s, yellow for 2 s, and green for 5 s; Stop freezes the state; Reset returns to red.

2. Basic level. Create a standalone JavaFX application “Traffic light”: phase animation and manual control buttons. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Cyclically show red for 5 s, yellow for 2 s, and green for 5 s; Stop freezes the state; Reset returns to red.

3. Advanced level. Create a standalone JavaFX application “Traffic light”: phase animation and manual control buttons. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Cyclically show red for 5 s, yellow for 2 s, and green for 5 s; Stop freezes the state; Reset returns to red.

Variant 15. Pixel art

1. Initial level. Create a standalone JavaFX application “Pixel art”: a grid of cells, a palette, image export. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. On a 16×16 grid, change a cell's color to the selected color; clear all cells; export saves a 16×16 PNG.

2. Basic level. Create a standalone JavaFX application “Pixel art”: a grid of cells, a palette, image export. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. On a 16×16 grid, change a cell's color to the selected color; clear all cells; export saves a 16×16 PNG.

3. Advanced level. Create a standalone JavaFX application “Pixel art”: a grid of cells, a palette, image export. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. On a 16×16 grid, change a cell's color to the selected color; clear all cells; export saves a 16×16 PNG.

Variant 16. A currency exchange

1. Initial level. Create a standalone JavaFX application “Currency exchange”: rates, exchange, a history of operations in a list. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Enter UAH≥0 and a positive manual UAH/EUR rate; show EUR to 2 decimal places with HALF_UP; reject a zero rate.

2. Basic level. Create a standalone JavaFX application “Currency exchange”: rates, exchange, a history of operations in a list. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Enter UAH≥0 and a positive manual UAH/EUR rate; show EUR to 2 decimal places with HALF_UP; reject a zero rate.

3. Advanced level. Create a standalone JavaFX application “Currency exchange”: rates, exchange, a history of operations in a list. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Enter UAH≥0 and a positive manual UAH/EUR rate; show EUR to 2 decimal places with HALF_UP; reject a zero rate.

Variant 17. Snake

1. Initial level. Create a standalone JavaFX application “Snake”: AnimationTimer, keyboard control, score, and speed. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. On a 20×20 board, move the snake one cell per step; food adds a segment, a collision ends the game, and a 180° turn is prohibited.

2. Basic level. Create a standalone JavaFX application “Snake”: AnimationTimer, keyboard control, score, and speed. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. On a 20×20 board, move the snake one cell per step; food adds a segment, a collision ends the game, and a 180° turn is prohibited.

3. Advanced level. Create a standalone JavaFX application “Snake”: AnimationTimer, keyboard control, score, and speed. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. On a 20×20 board, move the snake one cell per step; food adds a segment, a collision ends the game, and a 180° turn is prohibited.

Variant 18. Pizza ordering

1. Initial level. Create a standalone JavaFX application “Pizza ordering”: CheckBox, RadioButton, cost calculation. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Choose a diameter of 25/30/35 cm priced at UAH 150/200/250 and toppings: cheese 30, mushrooms 20; show the total and the composition.

2. Basic level. Create a standalone JavaFX application “Pizza ordering”: CheckBox, RadioButton, cost calculation. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Choose a diameter of 25/30/35 cm priced at UAH 150/200/250 and toppings: cheese 30, mushrooms 20; show the total and the composition.

3. Advanced level. Create a standalone JavaFX application “Pizza ordering”: CheckBox, RadioButton, cost calculation. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Choose a diameter of 25/30/35 cm priced at UAH 150/200/250 and toppings: cheese 30, mushrooms 20; show the total and the composition.

Variant 19. A stopwatch

1. Initial level. Create a standalone JavaFX application “Stopwatch”: laps, pause, exporting results to a file. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Start/Pause/Reset control measurement of monotonic time; show minutes, seconds, and hundredths; a repeated Start does not speed up the count.

2. Basic level. Create a standalone JavaFX application “Stopwatch”: laps, pause, exporting results to a file. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Start/Pause/Reset control measurement of monotonic time; show minutes, seconds, and hundredths; a repeated Start does not speed up the count.

3. Advanced level. Create a standalone JavaFX application “Stopwatch”: laps, pause, exporting results to a file. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Start/Pause/Reset control measurement of monotonic time; show minutes, seconds, and hundredths; a repeated Start does not speed up the count.

Variant 20. A color picker

1. Initial level. Create a standalone JavaFX application “Color picker”: ColorPicker, RGB sliders, CSS generation. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Three Sliders 0..255 set RGB; show a swatch and HEX #RRGGBB; changing any channel updates both results.

2. Basic level. Create a standalone JavaFX application “Color picker”: ColorPicker, RGB sliders, CSS generation. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Three Sliders 0..255 set RGB; show a swatch and HEX #RRGGBB; changing any channel updates both results.

3. Advanced level. Create a standalone JavaFX application “Color picker”: ColorPicker, RGB sliders, CSS generation. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Three Sliders 0..255 set RGB; show a swatch and HEX #RRGGBB; changing any channel updates both results.

Variant 21. A memory game

1. Initial level. Create a standalone JavaFX application “Memory game”: cards, finding pairs, a move counter. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Hide 8 pairs on a 4×4 board; open at most two cards; a match stays open; victory after 8 pairs.

2. Basic level. Create a standalone JavaFX application “Memory game”: cards, finding pairs, a move counter. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Hide 8 pairs on a 4×4 board; open at most two cards; a match stays open; victory after 8 pairs.

3. Advanced level. Create a standalone JavaFX application “Memory game”: cards, finding pairs, a move counter. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Hide 8 pairs on a 4×4 board; open at most two cards; a match stays open; victory after 8 pairs.

Variant 22. Function plots

1. Initial level. Create a standalone JavaFX application “Function plots”: a LineChart of functions with parameters and scaling. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Plot sin(x) and cos(x) on an entered interval a<b within -100..100 with a step of 0.1; label the axes and series.

2. Basic level. Create a standalone JavaFX application “Function plots”: a LineChart of functions with parameters and scaling. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Plot sin(x) and cos(x) on an entered interval a<b within -100..100 with a step of 0.1; label the axes and series.

3. Advanced level. Create a standalone JavaFX application “Function plots”: a LineChart of functions with parameters and scaling. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Plot sin(x) and cos(x) on an entered interval a<b within -100..100 with a step of 0.1; label the axes and series.

Variant 23. A poll

1. Initial level. Create a standalone JavaFX application “Poll”: choosing options and a PieChart of results. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Provide one question and three mutually exclusive answers; count votes and percentages; with no selection, do not add a vote.

2. Basic level. Create a standalone JavaFX application “Poll”: choosing options and a PieChart of results. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Provide one question and three mutually exclusive answers; count votes and percentages; with no selection, do not add a vote.

3. Advanced level. Create a standalone JavaFX application “Poll”: choosing options and a PieChart of results. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Provide one question and three mutually exclusive answers; count votes and percentages; with no selection, do not add a vote.

Variant 24. Tabbed notes

1. Initial level. Create a standalone JavaFX application “Tabbed notes”: a TabPane of notes, saving to files. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Create tabs with a title and text; when closing a modified tab, ask to save; canceling keeps the tab.

2. Basic level. Create a standalone JavaFX application “Tabbed notes”: a TabPane of notes, saving to files. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Create tabs with a title and text; when closing a modified tab, ask to save; canceling keeps the tab.

3. Advanced level. Create a standalone JavaFX application “Tabbed notes”: a TabPane of notes, saving to files. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Create tabs with a title and text; when closing a modified tab, ask to save; canceling keeps the tab.

Variant 25. A day planner

1. Initial level. Create a standalone JavaFX application “Day planner”: DatePicker, the day's events, list sorting. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Add an event with a title and a start/end time within one day; show events by time; reject overlapping intervals.

2. Basic level. Create a standalone JavaFX application “Day planner”: DatePicker, the day's events, list sorting. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Add an event with a title and a start/end time within one day; show events by time; reject overlapping intervals.

3. Advanced level. Create a standalone JavaFX application “Day planner”: DatePicker, the day's events, list sorting. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Add an event with a title and a start/end time within one day; show events by time; reject overlapping intervals.

Variant 26. A calorie counter

1. Initial level. Create a standalone JavaFX application “Calorie counter”: foods, portions, a nutrient chart. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Enter a food, grams>0, and kcal per 100 g≥0; show the calories of each row and the daily total; reject an empty name.

2. Basic level. Create a standalone JavaFX application “Calorie counter”: foods, portions, a nutrient chart. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Enter a food, grams>0, and kcal per 100 g≥0; show the calories of each row and the daily total; reject an empty name.

3. Advanced level. Create a standalone JavaFX application “Calorie counter”: foods, portions, a nutrient chart. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Enter a food, grams>0, and kcal per 100 g≥0; show the calories of each row and the daily total; reject an empty name.

Variant 27. A typing trainer

1. Initial level. Create a standalone JavaFX application “Typing trainer”: typing speed, errors, an exercise timer. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Show a given reference text, and measure the input time and the number of mismatched positions; speed=characters/min; do not finish on empty input.

2. Basic level. Create a standalone JavaFX application “Typing trainer”: typing speed, errors, an exercise timer. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Show a given reference text, and measure the input time and the number of mismatched positions; speed=characters/min; do not finish on empty input.

3. Advanced level. Create a standalone JavaFX application “Typing trainer”: typing speed, errors, an exercise timer. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Show a given reference text, and measure the input time and the number of mismatched positions; speed=characters/min; do not finish on empty input.

Variant 28. An airplane cabin

1. Initial level. Create a standalone JavaFX application “Airplane cabin”: seat selection with buttons, classes, and cost. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. On a layout of 10 rows of 4 seats, choose a free seat and confirm the booking; occupied seats are unavailable; Cancel clears the selection.

2. Basic level. Create a standalone JavaFX application “Airplane cabin”: seat selection with buttons, classes, and cost. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. On a layout of 10 rows of 4 seats, choose a free seat and confirm the booking; occupied seats are unavailable; Cancel clears the selection.

3. Advanced level. Create a standalone JavaFX application “Airplane cabin”: seat selection with buttons, classes, and cost. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. On a layout of 10 rows of 4 seats, choose a free seat and confirm the booking; occupied seats are unavailable; Cancel clears the selection.

Variant 29. Minesweeper

1. Initial level. Create a standalone JavaFX application “Minesweeper”: a game board, flags, a timer, and high scores. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Place 10 mines on an 8×8 board; open cells and place flags; a mine ends the game; make the first move safe.

2. Basic level. Create a standalone JavaFX application “Minesweeper”: a game board, flags, a timer, and high scores. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Place 10 mines on an 8×8 board; open cells and place flags; a mine ends the game; make the first move safe.

3. Advanced level. Create a standalone JavaFX application “Minesweeper”: a game board, flags, a timer, and high scores. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Place 10 mines on an 8×8 board; open cells and place flags; a mine ends the game; make the first move safe.

Variant 30. A metronome

1. Initial level. Create a standalone JavaFX application “Metronome”: tempo, time signature, beat animation. Implement the main action through a form with labeled fields and a button, and show the result or an error on the same screen. Use layout without absolute coordinates, and test empty input and value boundaries. Enter a tempo of 40..200 beats/min; show a visual pulse every 60/tempo seconds; Stop stops the pulses.

2. Basic level. Create a standalone JavaFX application “Metronome”: tempo, time signature, beat animation. Implement the complete scenario of the topic, a list of action history with stable identifiers, mode selection, and a confirmation dialog for clearing. Move the computation into a separate class, and add CSS, Enter handling, and window resizing; canceling the dialog leaves the data unchanged. Enter a tempo of 40..200 beats/min; show a visual pulse every 60/tempo seconds; Stop stops the pulses.

3. Advanced level. Create a standalone JavaFX application “Metronome”: tempo, time signature, beat animation. Separate the model from the UI, and implement an FXML form, input validation, saving settings, and error messages. Add --help, --config=path, and --check=field:value,...; the last mode performs a domain check without opening the GUI and prints an aligned table with a summary. Errors go to stderr; exit codes 0/2/1. For a normal launch, show the GUI; add JUnit tests of the model, test keyboard focus, and prepare a local runtime without installing it into the system. Enter a tempo of 40..200 beats/min; show a visual pulse every 60/tempo seconds; Stop stops the pulses.

Procedure

1. Create a Maven project with a pinned JavaFX version.
2. Design the node tree and the behavior in a narrow window.
3. Separate computation from control handlers.
4. Test valid, empty, and boundary input.
5. Test Enter, Tab, canceling a dialog, and closing.
6. Show the test report and the results of running the built project.