Stage 1: Hello, coffee!
Write a program that puts basic information on the screen: give the machine a chance to tell the customers what it’s doing!

Stage 2: Machines have needs
Program the machine to calculate the amount of ingredients it needs depending on how many people want some coffee.

Stage 3: Enough coffee for everyone
Working with conditions, program the machine to estimate how many creamy coffees it can make based on the amount of ingredients we enter.

Stage 4: Action!
Upgrade your knowledge of methods - set the machine to perform three basic actions: collect the money, renew the supplies, and serve the coffee.

Stage 5: On a coffee loop
Program the machine to display on the screen the amount of supplies left. Set the main loop: now the menu keeps updating until you press exit.

Stage 6: Brush your code
Time for some final touch-ups: structure the code so that it runs smoothly.

Stage 1: Print a state of the game field
Write a program that displays some information on the screen.

Stage 2: Create a simple game field
Start working with data using arrays to store the current game state.
Learn to work with user input.

Stage 3: Print the game state
Analyze your data and display the result on the screen.

Stage 4: Create a human move
---Learn how to map coordinates that you input to the field ---
---Learn how to change the field based on coordinates you input---

Stage 5: Find errors in user input
Learn to handle invalid user input

Stage 6: Make an "easy" difficulty level
Start using random digit generator to create a bot that will make random moves.

Stage 7: Create a game loop
Use loops to play with the bot you’ve created.

Stage 8: Create a start menu
Create a menu for your game where you can determine who will play. Person vs person, person vs bot, bot vs bot.

Stage 9: Make a "medium" difficulty level
Make your bot more clever and teach it to analyze the game and make smart moves.

Stage 10: Make a "hard" difficulty level
Learn about recursion and create an unbeatable bot. If you play against it best case scenario you’ll get a tie.

Stage 1: Greeting
Write a program that displays some information on the screen.

Stage 2: Introducing yourself
Start handling user’s input and working with math operations.

Stage 3: Guessing the age
Use loops for repeating a command.

Stage 4: Testing knowledge
Start writing your own methods that will allow you to reuse chunks of code.

Stage 1: For example
Start with outputs and the binary system: print a line with an example conversion.

Stage 2: Almost an octopus
Learn the basics of working with Scanner class: teach the converter to determine the last digit of the octal number, converted from the decimal system.

Stage 3: Convert decimals
With the help of switch operator and prefixes, convert the number to any system of your choice.

Stage 4: Any which radix
Upgrade your converter: enable it to convert numbers from and to any numeral system. Practice arrays, loops and strings.

Stage 5: Converting fractions
Make it possible for the converter to work with fractions as well (that is, float and double datatypes).

Stage 6: Error!
Mistakes are inevitable: teach your converter to handle them and report errors if they occur.

Stage 1: 2+2
Your calculator is taking the first steps: teach it to calculate the sum of two integers and display the result on the screen.

Stage 2: 2+2+
Enable your calculator to keep adding the numbers on a loop until the user presses “exit”

Stage 3: Count them all
With the help of arrays and strings, make it possible to calculate sums of multiple integers.

Stage 4: Add subtractions
Where there is a plus, there is a minus. Using your knowledge of arrays and strings, enable to calculator to deal with subtraction as well as addition.

Stage 5: Error!
There’s no math without errors: teach your program to notify the user about errors in case of invalid input.

Stage 6: Variables
Working with Map class, enable the calculator to use variables as well.

Stage 7: I’ve got the power
Time to upgrade and add even more possible operations: multiplication, division, powers and calculations in brackets.

Stage 8: Very big
Get to know BigInterger class in order to manipulate big, large, long integers in calculations.

Stage 1: Simple and real
Start with real numbers and simple equations of (a*x = b) type.

Stage 2: X and Y
Let’s get serious: enable the program to solve systems with two variables.

Stage 3: Equations
Practice working with multidimensional arrays, files and the command line: get data from a file and solve multiple linear equations.

Stage 4: When things get complicated
Learn to handle special cases where there is no or infinite possible solutions for the equations.

Stage 5: Complex numbers
Finally, teach your program to solve equations with complex numbers.

Stage 1: String theory
Set two strings (where to search and what to search) for the program to return an index of the searched word or report “not found”.

Stage 2: Expand the search
With the help of arrays and linear search, add more strings to the program and search for specific data from that input.

Stage 3: User menu
Using switch operator and methods, create a user menu for your search engine.

Stage 4: X-files
Enable your search engine to search for data stored in the files.

Stage 5: Inverted Index search
Working with lists and maps, build the inverted index to enhance your search.

Stage 6: Search strategies
Get familiar with patterns and learn to deal with more complex types of search.

Stage 1: Let there be light
Create something out of nothing: generate a starting combination and specify the field.

Stage 2: Generations
Using classes and arrays, enable the player to enter the number of generations and see what the outcome is.

Stage 3: Life goes by
Make your game truly entertaining by letting the player observe your universe live and evolve.

Stage 4: Looking good!
Practice using Swing and multithreading: create a nice interface for your game of life.

Stage 5: Gamify it
Almost done! Add some extra functions (pausing and unpausing, speed regulation) to make your game more engaging and various.

Stage 1: Neuron creator
This is so exciting: create not one but nine neurons in order to recognize ones and zeros in a 3x3 net.

Stage 2: The joy of recognition
You have a 3x5 net with digits; teach the network to recognize simple numbers.

Stage 3: Learning time
Time to work with machine learning: based on ideal examples, improve the recognition process.

Stage 4: Layers
With the help of some linear algebra, make your neural network multi-layered.

Stage 5: On a bigger scale
Move from a modest 5x3 net to a 28x28 insanity, process thousands of images and test the result.

Stage 6: Backpropagation
Learn the art of backpropagation algorithm, and don’t let the formulae scare you.

Stage 1: A window to editing
Using your competence in inheritance and newly acquired knowledge of SWING, create a window where the user can enter a text.

Stage 2: Saved and loaded
Get familiar with files and buttons in SWING library: add the buttons and enable the user to save files.

Stage 3: Menu, please!
Create a menu for a user to save the text, exit the program etc.

Stage 4: Searching
Using regular expressions and multithreading, enable the user to search in a file.

Stage 1: Blockchain essentials
Get to know the structure of blockchains: learn how to create blocks and make them secured and connected.

Stage 2: Serialization applied
Make cryptocurrency mining possible in your virtual world: generate magic numbers and store them in blocks.

Stage 3: Miner mania
Generate random numbers in several threads; when a miner finds the magic number, a blockchain is created, and mining goes on.

Stage 4: You’ve got a message
Learn to store data in the blocks: add messages to your blockchain.

Stage 5: Matters of security
Add encryption with private and public keys to ensure a high level of privacy and security.

Stage 6: Local currency
Create a cryptocurrency in your program: starting with a sorry amount of zero coins, your virtual miners will get an hundred for each block they mine.

Stage 1: Crawl through the window
Review what you know about Swing and inheritance in order to create a simple interface: a window with text.

Stage 2: Links, links
Feed the first link to your program so that it displays the page’s content.

Stage 3: Titles
Practice working with regular expressions: teach the program to parse and display the page’s title.

Stage 4: Collect them all!
With the help of collections and multidimensional arrays, enable the program to scan pages, collect links and their titles and display them altogether.

Stage 5: Save the results
You’ve got to save what you found: program your Crawler to store links in a file and save them.

Stage 6: Complicated matters
Practice the art of multithreading: small tasks have to be handled in the meantime as well! Make the parameters of depth and time regulatable in the program.