I have known for a while now that most learners today don't share my love of big thick books, and to be honest, I rarely read those books in their entirety. Those big books often had a lot more exposition about the code than was probably needed. As a book buyer I wanted to make sure that I was getting my money's worth so the thicker they were, the better. It is much more common these days for learners to consume blog based tutorials and videos.

If you're learning to code right now, you've probably experienced the frustration of these formats too. I want to share something I've been working on that might help.

Blogs and Videos

Blog-style tutorials mix code and the explanation of it in a top-to-bottom fashion. Scrolling through these web-based explanations feels familiar and one can copy and paste with ease. However, linking the explanation of the code and the code itself has always been less than ideal. Often I find myself jumping around the blog post wishing I could see the entire code example while working through the explanation. Instead, I am only able to see small parts of the code and it is challenging to see how those parts relate to other parts.

Video tutorials are very popular these days. They solve some of the problems associated with blog-style tutorials. Videos are great because you get two streams of information: the author's audible narrative and the code being written. A viewer can focus on the two streams simultaneously. However, videos have some problems too.

Viewing Videos

From the perspective of the viewer, videos are hard to search through and are not useful as a copy and paste source or a code reference. More importantly, though, they discourage the viewer from taking their time and reflecting on the material. Often, when I am viewing a video tutorial I don't pause and let concepts sink in before the video moves on. Yes, I could be more disciplined and pause and rewind more often but usually I don't.

Making videos

From the perspective of the video creator, it is clear that not all code being developed is interesting to watch. Some of it is not really worth showing the viewer. Not all video creators can keep the narrative interesting the whole time.

I know I struggle with the 'performance' aspect of making videos (you won't find me coding on Twitch anytime soon). Many times after I am done making a video, as I review it, I wish I had mentioned something that I forgot. It is hard to go back and edit the video without scrapping it and starting over.

Storyteller

I have created a new medium to guide viewers through code examples. It combines the best of books, blog posts, and videos. This new medium allows a developer to write code using a top-notch editor (Visual Studio Code) and then replay the development of that code in the browser.

The author can add comments at important points in the evolution of the code. The comments can include text, hand drawn pictures, screenshots, and audio and video recordings. This allows the author to add visualizations that we have in our heads but don't make it into the code itself. The tool is called Storyteller.

Here are a few examples of a 'playback':

• Enlarging a Picture (Python)

• Dynamic Variables and Pointers (C++)

These work best on a big screen. If you are viewing a playback on a small screen you can view it in 'blog' mode (there is button in the top right to switch from 'code' mode to 'blog' mode).

I have created groups of these guided code walk-throughs to help me teach different topics to my students. These are all free and hosted on a website I created called Playback Press. Here are some of the 'books' I have created so far:

• An Animated Introduction to Programming in C++

• An Animated Introduction to Programming with Python

• An Introduction to Web Development from Back to Front

• An Animated Introduction to Clojure

• An Animated Introduction to Elixir

• Database Design and SQL for Beginners

• Mobile App Development with Dart and Flutter

• OO Design Patterns with Java

I usually assign these as readings in my classes instead of using expensive textbooks. It is a lot easier for me to write several programs than it is to find a perfect textbook.

I also use them for in-class demos instead of writing code live. This makes code demos flow much faster and smoother. If I make an interesting mistake while preparing the code I can still highlight it with a comment. If I make an uninteresting or embarrassing mistake I can just ignore it and the students won't focus on it.

The Advantages of Code Playbacks:

• The primary focus is on the code. It is always visible and easy to search and navigate.

• Since the code is so accessible, the explanation of it tends to be short and concise.

• The narrative can include whiteboard style drawings, screenshots, or videos of running code in addition to a text explanation.

• As an author, I can review the code several times and add/edit comments each time I go through it. I don't have to give a perfect performance like I do with a video.

• Comment points highlight when the author wants the viewer to take a moment to really think about the code and reflect on it. The playback only moves forward when the viewer is ready.

• The code mentioned in a comment can be highlighted so the viewer knows exactly where they should be looking.

• The code can be downloaded at any point in the playback. Then a viewer can run it, change it, and add to it.

• The tool is a language independent editor plug-in and can be used to describe programs in any language.

• Viewers only need a web browser to go through a playback.

Recently, I've been exploring how to make playbacks even more useful for learners.

AI as an Infinitely Patient Tutor

I have extended code playbacks to include an AI tutor. One thing I've learned in my years of teaching is that students often hesitate to ask questions. They worry about looking foolish, or they don't want to slow down the class, or they simply can't articulate what's confusing them.

What if every student had access to a patient tutor who never got frustrated with repeated questions and could explain concepts in multiple ways until something clicked?

I've integrated AI directly into the playback experience. As students work through a playback, they can ask questions about anything they're seeing. This might be a specific line of code, a concept I mentioned in a comment, or how something connects to material from earlier in the playback. The AI has full context. It can see the code, it understands where the student is in the playback, and it can provide explanations tailored to that exact moment. The AI is right there with the student, looking at the same code, understanding the same context.

The AI can also generate self-grading multiple choice questions based on the code and comments in a playback. These low-stakes quizzes make the learning experience more engaging and help learners check their understanding as they go.

Let me be clear: the AI doesn't replace me as an instructor. I still create the playbacks. I still decide what concepts to cover, what order to present them, and what examples best illustrate the ideas. The AI is an extension of my teaching, not a replacement for it.

Note: The AI features are available to registered users on Playback Press. Registration is free but logging in is required to access the AI tutor. If you want to see what this feels like, try one of the playbacks linked above and ask the AI a question about what you're seeing.

Conclusion

My goal has always been to help people learn to code. Books gave us depth but demanded commitment. Blogs gave us accessibility but fragmented the code. Videos gave us narrative but took away control. Playbacks keep the code front and center while letting learners move at their own pace and reflect when they need to. Adding AI doesn't change that philosophy, it just means there's always someone available to answer questions. Together, they get closer to the experience of having an expert sit beside you and walk you through a program. That's what I've been trying to build, and I think we're getting there.

Modern mobile development requires understanding widgets, state management, navigation, and data storage. The ecosystem includes thousands of free packages that give you access to device sensors, cloud services, and more.

This tutorial covers Dart fundamentals, Flutter basics, and some data storage options. There are 20 programs that walk you through building mobile apps from scratch. It’s built around a group of annotated code playbacks.

Each playback shows how I built a program step-by-step. They include a built-in AI tutor if you have any questions that I didn't cover. For a quick demo of how code playbacks work, watch this short video:

You can access the free tutorial here: https://playbackpress.com/books/flutterbook

Prerequisites: This is not a general introduction to programming, so you’ll need some basic programming knowledge to follow along. If you understand variables, loops, functions, and classes in any language, you should be fine. If you need an introduction to programming, check out my other tutorials in C++ or Python on Playback Press.

Table of Contents

1. Dart

• 1.1 Hello World!!! and Flutter/Dart Install Instructions

• 1.2 Simple Types in Dart

• 1.3 Lists (Array Based Containers)

• 1.4 Maps and Sets

• 1.5 Altering the Flow of Control

• 1.6 Closures

• 1.7 Asynchronous Code in Dart

• 1.8 Classes in Dart

2. Flutter

• 2.1 Flutter Hello World

• 2.2 flutter create demo_app

• 2.3 ListViews

• 2.4 Laying Out Widgets

• 2.5 Navigation in Flutter

• 2.6 Forms

• 2.7 Using Packages in Flutter

3. Storing an App's Data

• 3.1 Storing App Data in a File

• 3.2 Storing App Data in a SQLite Database

• 3.3 Storing App Data in a Server

• 3.4 Storing App Data in the Firebase Cloud Firestore

• 3.5 Firebase Authentication

Get Started

Start with the Dart chapter if you're new to the language. If you have JavaScript, Java, or C# experience, it should feel familiar. Then, move on to the Flutter playbacks. Work through the playbacks at your own pace.

Questions or feedback? Contact me at mark@playbackpress.com

In 1958, Frank Rosenblatt demonstrated something remarkable to reporters in Washington, D.C. His "perceptron" could look at cards with shapes on them and tell which side the shape was on. The remarkable thing about this was that the system wasn't explicitly programmed how to do this – it learned how to do it by looking at examples.

In traditional systems, a programmer thinks about a program’s inputs and comes up with data structures and algorithms to solve the problem and produce valuable outputs. The human programmer is the star of the show.

Machine learning systems don’t require that a programmer specify how to solve a problem. With supervised machine learning, the system’s inputs and outputs are used to train the system. This is a fundamental shift in building systems so that they can recognize patterns in fresh inputs and predict outputs. Learning is the star of the show.

This code playback recreates Rosenblatt's experiment using modern object-oriented programming techniques. You'll see two solutions to the same problem. The first uses traditional programming where I come up with an algorithm to solve the problem. The other is a very simple use of machine learning that learns how to solve the problem.

The Problem

Each card has a rectangular shape on either the left or right side of it. In Rosenblatt’s original demo, the cards are photographed and then turned into 20x20 pixel images. In this program, I simulate the cards and the images. The program’s job is to look at new cards and predict which side the shape is on.

The Traditional Approach

The code playback starts with a solution that I came up with. I thought about the inputs to the system, 400 pixels from an image, and developed an algorithm to count the active pixels on each side of it. Whichever side has more pixels is the side that I ‘predict’ has the shape.

This works well. All 500 test cards get predicted correctly. But I had to tell the computer exactly what to do.

The Machine Learning Approach

Next comes the perceptron, it was one of the first examples of machine learning. It is given many different inputs (400 pixel images) and outputs (labels associated with each card that states which side the shape is on). The perceptron takes the inputs and outputs and learns how to predict where a shape is.

As the programmer, I don’t tell it how to do this. I set up the program so that it can learn from the examples it sees during training.

My perceptron uses 400 weights (one for each pixel position). Initially, all of the weights are set to zero. The perceptron makes predictions by multiplying each pixel value by its corresponding weight value, then summing everything up. If the sum is negative, it will predict left. Otherwise, it will predict right.

The perceptron trains on labeled examples. When it makes a wrong prediction, it learns by adjusting the relevant weights. After training, it does a really good job of predicting test cards correctly.

What You'll Learn

The code playback walks you through:

• Creating the card representation and pixel data

• Implementing the non-AI solution (so you can see the traditional approach)

• Building a perceptron class with weights

• Understanding the prediction mechanism (sum of products)

• Seeing how training updates the weights based on errors

• Watching the weights evolve from random values to learned patterns

• Understanding why some initial approaches fail and how to fix them

You'll see the actual weight values after training. Some patterns are obvious. Some are surprising. The playback challenges you to understand and explain these patterns.

Why This Matters

This is one of the simplest examples of machine learning that you can study. The perceptron is essentially a single neuron. Modern neural networks stack many neurons in layers. They can learn vastly more complex patterns, but the core idea is the same. This is a great way to begin your journey if you want to learn about neural networks, machine learning, and AI.

Interactive Learning

View the complete code playback here

The playback includes a few challenges by asking some questions along the way. Can you figure out how many training examples are actually needed? When does the perceptron stop making mistakes during training? The code is available for you to download and experiment with, allowing you to recreate a piece of AI history. Rosenblatt's perceptron is where it all began.

The code playback medium is different from traditional videos or tutorials. You are guided through the code with a narrative and you get to see my thought processes. If you like this format, I have even more free content on my site, Playback Press. Feel free to share your comments, questions, or feedback via email: mark@playbackpress.com.

SQLite powers more applications than you might think. It's in every smartphone, most web browsers, and countless desktop applications. Your phone probably has hundreds of SQLite databases on it right now. Despite handling billions of databases worldwide, many developers aren't familiar with all of the cool things that you can do with SQLite.

This tutorial introduces SQLite through practical examples in C/C++, Python, and Java. You can pick and choose the languages that suit your needs. No language wars here. You'll learn how to integrate SQLite into real applications. Whether you're building a desktop app, a web API, or just need local data storage without the drama of a full database server, SQLite has your back.

Code Playbacks

Code playbacks are a unique way to learn about programming. They are guided walkthroughs of code, allowing you to see not just the code itself but also the thought process behind it. This approach helps you understand not only what the code does, but why it was written that way. Here is a short video to show how to move through a code playback:

By registering on Playback Press, you'll gain access to an AI assistant that can answer your questions about the code. This makes learning even more interactive and personalized. Watch this video to see how to work with it:

A Brief Introduction to SQLite

You can find my entire collection of SQLite code playbacks in my free book, "Programming with SQLite".

Here's what you'll learn:

Chapter 1: Database Design and SQL

In this chapter, I cover the basics of relational database design and SQL. I keep it simple and practical. If you'd like more introductory SQL content like this go to my Intro SQL book. If you'd like some SQL problems to work through, check out 30 Worked SQL Examples. If you already dream in SELECT statements, skip ahead to the chapter that best suits your needs.

• 1.1 Database Design and Basic SQL

• 1.2 One-to-Many Relationships and More SQL

• 1.3 Many-to-Many Relationships and Even More SQL

Chapter 2: SQLite in C/C++

In this chapter, I discuss how to use the low level SQLite API from a C or C++ program. You have a lot of power when using the API and I cover ACID transactions. Yes, we're going to talk about pointers and memory management. Even if you're not a C/C++ programmer and haven't touched a pointer since college, I recommend looking at this chapter. Understanding what's happening under the hood will make the other chapters clearer. Plus, you can impress your friends at parties by casually mentioning you know how database transactions really work.

• 2.1 Using the SQLite C/C++ API

• 2.2 An Object Oriented Auction Program

• 2.3 SQLite Transactions

Chapter 3: SQLite in Python

Learn how to use SQLite in any Python program including Flask web apps. No ORMs hiding what's really happening. Just clean, direct database access. I cover how to query and create SQLite databases and then show how to build an API using Flask. By the end, you'll have a working web API that didn't require installing PostgreSQL, configuring connection pools, or sacrificing a weekend to database administration.

• 3.1 Using a SQLite Database in a Python Program

• 3.2 Creating SQLite Databases

• 3.3 Using SQLite in a Flask Web Application

• 3.4 Creating a Web API with Flask and SQLite

Chapter 4: SQLite in Java

In this final chapter I give an example in Java using JDBC. Because sometimes you need to write enterprise code, and SQLite works there too. Who says you need Oracle for everything?

• 4.1 Using a SQLite Database in a Java Program

Conclusion

Ready to explore SQLite? Start with the first playback and see how fun database programming can be. Each example builds on the previous one, giving you practical experience with real code. Real code solving real problems.

I'd love to hear your thoughts! Feel free to share your comments, questions, or feedback via email: mark@playbackpress.com. Your input helps me improve and create even better content.

If you've found this tutorial helpful, consider supporting my work through GitHub Sponsors. Your contributions help cover hosting costs and keep Playback Press free for everyone. Thank you for helping me continue creating educational resources for the developer community!

While many modern languages offer similar features, Ruby consistently delivers a seamless and joyful experience. Whether you're building a startup MVP, a scalable enterprise application, or a lightweight API, Ruby has you covered with frameworks like Rails and Sinatra.

Despite the growing popularity of JavaScript and Python, Ruby remains a valuable language to learn, not just for its utility, but for how it teaches you to write clean, expressive, and maintainable code.

If you've heard of Ruby but never used it, this tutorial is the perfect starting point. Designed to be completed in an afternoon, it offers a glimpse into what makes Ruby so beloved by developers. While it doesn't cover every aspect of the language, Ruby's intuitive nature ensures you'll be well prepared to dive right into frameworks like Sinatra or Rails after completing it.

Code Playbacks

Code playbacks are a unique way to learn about programming. They are guided walkthroughs of code, allowing you to see not just the code itself but also the thought process behind it. This approach helps you understand not only what the code does, but why it was written that way. Here is a short video to show how to move through a code playback:

By registering on Playback Press, you’ll gain access to an AI assistant that can answer your questions about the code. This makes learning even more interactive and personalized. Watch this video to see how to work with it:

A Brief Introduction to Ruby

You can find my entire collection of Ruby code playbacks in my free book, "A Brief Introduction to Ruby". Here's a quick look at what you'll learn:

Highlights

• 1.1 Hello Ruby!!!: Write your first Ruby program and learn how to run it from the terminal.

• 1.2 Variables and Types: Explore Ruby's variables, constants, and string interpolation.

• 1.3 Selection and Looping: Master control flow with if statements, loops, and ranges.

• 1.4 Arrays: Work with arrays, one of Ruby's most versatile data structures.

• 1.5 Hashes: Learn about hashes, Ruby's equivalent of dictionaries or associative arrays.

• 1.6 Methods: Write reusable code with methods, parameters, and return values.

• 1.7 Closures: Discover how to pass code into methods and execute it with yield.

• 1.8 Iterators: Simplify data iteration with Ruby's powerful higher-order methods.

• 1.9 Classes in Ruby: Build objects with classes, instance variables, and inheritance.

• 1.10 Interacting Classes: Create cooperating classes and explore Ruby's "duck typing."

• 1.11 Unit Testing in Ruby: Write tests to ensure your code works as expected.

Conclusion

Ready to start your Ruby journey? Begin with the first playback and experience how fun and intuitive Ruby can be. Whether you're a complete beginner or an experienced developer, there's something here for everyone!

I’d love to hear your thoughts! Feel free to share your comments, questions, or feedback via email: mark@playbackpress.com. Your input helps me improve and create even better content.

If you’ve found this tutorial helpful, consider supporting my work through GitHub Sponsors. Your contributions help cover hosting costs and keep Playback Press free for everyone. Thank you for helping me continue creating educational resources for the developer community!

A design pattern attempts to describe an effective solution to the problem in a generic way so that it can be applied to a specific set of circumstances.

I will use Java to build an example of each pattern. I’m assuming that you have some programming experience in Java. In particular, you should be (at least somewhat) familiar with the concepts of inheritance and polymorphism. These design patterns really show the power of inheritance and polymorphism, so if you are just learning about these topics this is a great opportunity to dig deeper.

What if you not a Java programmer? If you are familiar with any Object-Oriented language you will probably still get a lot out of the examples. Give it a shot!

Code Playbacks

To make design patterns more approachable, I developed an interactive tutorial that uses annotated code playbacks to walk through key design pattern features step-by-step.

Each design pattern is presented as a code playback that shows how a program changes over time along with my explanation about what's happening. This format helps you focus on the reasoning behind the code changes.

You can access the free 'book' of code playbacks here:

OO Design Patterns with Java, by Mark Mahoney (that’s me)

To view a code playback, click on the comments in the left panel. Each comment updates the code in the editor and highlights any changes. Read the explanation and study the code. If you get stuck, use the AI assistant like a tutor to help explain what is happening in the code.

For more information about code playbacks, you can watch a short demo here.

Key Design Patterns You Should Know

Strategy Pattern

The Strategy Pattern is used to define a 'family' of algorithms, encapsulate each one, and make them interchangeable. Software developers use the Strategy pattern when they know there are many different ways of accomplishing some behavior. Rather than include all the different ways in a single class, they separate them out into individual classes and plug them in when necessary.

This program creates some classes to hold student grades. Some instructors like to adjust the entire course’s grades to make them higher. Some instructors do this by dropping every student's lowest grade. Other instructors 'curve' each assignment. Since there are several different options, I will use the Strategy Pattern to isolate them and let the client choose which one they prefer.

Start by looking at the Assignment, Student, and Course classes. Once you are familiar with the core classes, watch as I change the code to implement two different approaches to curving the grades using the Strategy Pattern:

Strategy Pattern Adjusting Grades in a Course

Singleton Pattern

There are times when you need to make sure there is only one instance of a class and it is accessible everywhere in your code. This is the problem that the Singleton Pattern solves.

In this program, I will create a class that generates random numbers. I will rely on Java's built-in Random class but will be able to reproduce the exact same sequence of random numbers when in 'test mode'. I'll make sure that there is only one instance of this random number generator using the Singleton Pattern:

Singleton Pattern A Testable Random Number Class

Composite Pattern

Often, we’ll create whole/part containment tree structures. For example, in a file system there are simple files. I call these simple elements, primitives. We can group primitives together to form larger composites. Files can be grouped into directories. These composites (directories) can be grouped into still larger composites, and so on.

We could treat composites and primitives differently. But it often makes sense to treat them the same. Having to distinguish between the object types makes the application more complex.

The Composite Pattern describes how to use recursive composition so that clients don't need to make this distinction.

This program creates classes for printing a hierarchical collection of files and directories using the Composite Pattern:

Composite Pattern Displaying a Hierarchical File System

Decorator Pattern

Sometimes we want to add responsibilities to individual objects, not an entire class. The Decorator Pattern allows us to create decorators to provide a flexible alternative to inheritance for extending a class.

In this program, I create an interface for logging messages while a program is running. I use the interface to create a ConsoleLogger that prints the log messages to the screen. Then I start to add decorator objects that surround, or wrap, the ConsoleLogger. I add decorators to attach the date, author name, and time to the log messages using the Decorator Pattern:

Decorator Pattern Logging with Decorators

State Pattern

Sometimes there are systems that react differently based on the 'state' that they are in. A state is a period of time during which a system will react to events according to certain rules. This state-based behavior is implemented using the State Pattern.

I’ll show you how to move through the characters in a string and parse it to account for quotes within it. For example, the following string:

"hamburgers chips 'hot dogs' pickles 'french fries'"

can be split into a collection like this:

["hamburgers", "chips", "hot dogs", "pickles", "french fries"]

There are may ways to accomplish this in Java, but I’ll show a state-based approach. When a single quote is encountered within a string I will use that as an event and move between different states using the State Pattern:

State Pattern String Splitting for Search Bars

Observer Pattern

The Observer Pattern is used when the update of a single piece of data in one object needs to be propagated to a collection of other objects.

For example, when the value of a cell in a spreadsheet changes, several other cells may need to be notified of that change so that they can update themselves. Similarly, in a social network application when a user makes a post, all of their friends need to be notified so that their feeds can be updated. Both of these are essentially the same problem that the Observer Pattern solves.

This program creates a class to hold a time in a day called MyTime. Then I create two different types of Observers that will be notified when the time changes. The two observers will re-display the time every time it changes using the Observer Pattern:

Observer Pattern Observing the Time Change

Proxy Pattern

Sometimes we design a set of objects that have a client/server relationship but later decide that the two objects should not interact directly. This program shows how to use the Proxy Pattern to place some new functionality in between two previously cooperating classes.

I create a Card and Deck class for card games. The Deck starts out being hosted on the same machine as the Driver. Then I split the Driver and the Deck class so that they can be run on different machines using the Proxy Pattern:

Proxy Pattern Dealing Cards from a Remote Deck

Factory Pattern

The Factory Pattern provides a mechanism for creating 'families' of related objects without specifying their concrete classes. Instantiating concrete objects in an application makes it hard to change those objects later.

In this program, I will create two different families of classes for a help system for two different computing platforms using the Factory Pattern:

Factory Pattern Getting Help in Mac and Windows

Visitor Pattern

The Visitor Pattern lets you add functionality to a hierarchy of classes without changing its interface.

The reason why this is important is that there are times when we cannot change an existing hierarchy of classes. Perhaps I am using a hierarchy of classes that I am not in control of but I want to add some new functionality to it anyway. This is where the Visitor Pattern comes in.

In this program, I’ll add functionality to the File and Directory classes from the Composite program that I wrote earlier with minimal changes to those classes.

I create a visitor to count the number of files and directories in a topmost directory. Then I write a visitor to collect only the filenames in a directory including its sub-directories using the Visitor Pattern:

Visitor Pattern Adding Functionality to a Hierarchy of Classes (File and Directory)

Conclusion

I hope you enjoyed learning about object-oriented design patterns. If you are interested in other programming paradigms, you can check out some of my other 'books' here.

Questions and feedback are always welcome here: mark@playbackpress.com

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

This tutorial will teach you how to build a complete game from scratch. You'll implement advanced data structures (Trie), optimize search algorithms (recursion), and create a polished user interface (HTML/CSS). By the end, you will build a fully playable game and learn techniques that you can apply to any web project.

This tutorial covers:

• Implementing a Trie data structure for lightning-fast word search including partial word validation

• Using recursion to efficiently explore millions of possible paths through a game board

• Analyzing 20,000+ dictionary words to create balanced gameplay

• Creating a build system that pre-processes data for better performance

• Building a responsive UI that handles complex user interactions

The Inspiration

When playing Boggle with my family, I have designated myself as the 'checker' of other peoples' words when we are tabulating scores. All of the other players will list the words that they found while I point them out on the board to make sure that they are valid. Once you know that a word is on the board, finding it feels a whole lot easier than searching for it blindly.

I enjoy this process almost as much as playing the game. So, I built a game that focuses on that experience.

The rules are simple. The game presents 49 random letter groupings in a 7x7 grid. Starting with the longest words that can be found, players are presented with words and are asked to find them. Players click on adjacent letter groupings (horizontally, vertically, or diagonally) to form words. Each letter group can be used once per game. The challenge is to find as many valid words as possible in the shortest amount of time.

You can play the finished game here: https://markm208.github.io/wordZearch/.

An Interactive Tutorial on Building Word Zearch

To share how I built Word Zearch, I created "How I Built It: Word Zearch". It is a collection of annotated code playbacks that walk through the entire development process. These playbacks show every line of code I wrote, from implementing the core data structures to polishing the user interface.

To view a code playback, click on the comments in the left panel. Each comment updates the code in the editor and highlights the change. Read the explanation, study the code, and use the built-in AI assistant if you have questions. For more information about code playbacks, you can watch a short demo here.

Prerequisites

You should have some programming experience to follow along. I use object-oriented programming, recursion, and DOM manipulation throughout the tutorial.

If you're new to web development, this offers a complete start-to-finish project that will help put all of the pieces together. If this tutorial moves too fast for you, consider starting with my introductory web development 'book' first: An Introduction to Web Development from Back to Front

What You'll Learn

1. Building a Trie Data Structure

https://playbackpress.com/books/wordzearchbook/chapter/1/1

Learn how to implement a Trie (prefix tree) for fast word validation. This data structure is the foundation of the game's performance.

Starting with a dictionary file, I parse 20,000+ words into a nested object structure. Each level represents a letter position. The implementation includes a search method that returns three values: FOUND, NOT FOUND, or PARTIAL.

This PARTIAL value is crucial. It indicates when the beginning of a dictionary word is found but it is not a complete word. Later on when searching for words on the board, it tells the algorithm when to stop searching, preventing millions of unnecessary operations during gameplay.

2. Modeling Letter Frequencies

https://playbackpress.com/books/wordzearchbook/chapter/1/2

Here, I analyze letter frequencies from the words in the dictionary to create weighted distributions for generating game boards randomly. I start by tracking how often single letters, two-letter combinations, and three-letter combinations appear across all dictionary words. This approach will work for words in any language as long as you have a dictionary file filled with words.

For each word, I extract all possible letter groupings of each size and count their occurrences. After processing the entire dictionary, I sort these groupings by frequency and select the most common ones. To ensure interesting game boards, I create proportional arrays where more frequent letter groups appear multiple times relative to their frequency. I'll use this data to create a balanced game board that reflects real language usage by picking the most used groups of letters at random.

3. A Simple Web App

https://playbackpress.com/books/wordzearchbook/chapter/1/3

In this playback, I set up the foundation for the web application and create an efficient build process. Rather than rebuilding the Trie and calculating letter frequencies every time someone plays the game, I develop a build system that pre-generates these data structures.

Then I reorganize the project by creating a build folder and a template file. The BuildTrie class will read the dictionary, construct the word map and letter frequencies, and inject this data into a template file to generate a static Trie.js file. This approach significantly improves performance since the computationally expensive dictionary processing happens once during the build phase rather than on every page load.

4. Building the Game Board

https://playbackpress.com/books/wordzearchbook/chapter/1/4

Next, I implement the WordBoard class, which manages the 7x7 game board and contains the core algorithm for finding valid words. The board is configured to hold 49 letter groups with customizable distributions of single, double, and triple letter combinations.

The heart of the implementation is a recursive search algorithm in the solve method that explores all possible word paths. Starting from each position on the board, the algorithm moves in eight directions (horizontally, vertically, and diagonally), building up potential words by concatenating adjacent letter groups. To prevent infinite loops and ensure game rules are followed, I track visited positions so each letter group can only be used once per word.

The Trie integration provides a crucial optimization. When a letter sequence isn't found in the Trie, the algorithm stops exploring that path, preventing unnecessary searching. Found words are organized by length in a results array, with each result storing the complete path through the board. The playback concludes with testing the WordBoard, demonstrating how it successfully identifies all valid words that can be formed from the randomly generated letter groups.

5. The Front End

https://playbackpress.com/books/wordzearchbook/chapter/1/5

In this final playback, I build the complete user interface for Word Zearch. I start by creating a 7x7 HTML table where each cell displays a letter group from the WordBoard.

I implement click handling that allows players to select adjacent letter groups, visually highlighting them as they build words. The core gameplay logic compares the player's selected path against the pre-calculated valid word paths from the WordBoard's solve method.

When a match is found, I add visual feedback including directional arrows showing the word's path, color coding for completed words, and preventing reuse of letter groups by marking them as solved. Found words are displayed in a results list with timestamps and links to their definitions. The interface also includes hover effects to highlight previously found words on the board and handles game completion by showing total time and offering a replay option.

The result is a fully interactive word search game with intuitive visual feedback and smooth gameplay.

Start Building

Word games make excellent programming projects. They combine interesting computer science concepts with practical web development skills.

Try playing the game first to understand what I'm building. Then dive into the code playbacks to see how it all comes together. If you get stuck, use the AI assistant like a tutor to help explain what is happening in the code. Afterwards, if you are feeling adventurous, try modifying the code, optimizing it, adding new features, or building your own word game!

Questions and feedback are always welcome here: mark@playbackpress.com

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

Web development has evolved significantly over the past decade. Today's developers work with sophisticated frameworks, build APIs, manage databases, and create responsive user interfaces. The ecosystem continues to grow with new tools emerging regularly.

This tutorial will get you started learning some of the most used tools and technologies of the trade. You'll learn about JavaScript, HTTP, Node, Express, JSON, SQLite, Mongo, HTML, CSS, Web Components, React, and GraphQL.

Even though there are 35 different programs in it, there are a lot of cool technologies that I am not covering. Hopefully, this material sparks your interest and you begin a journey to learn about the wonderful ecosystem built around the web.

An Animated Introduction to Web Development

To make learning web development more accessible, I have created an interactive tutorial called "An Introduction to Web Development from Back to Front." This 'book' uses annotated code playbacks to demonstrate how to build web applications step by step.

Unlike traditional tutorials that mix partial code snippets with partial explanations, code playbacks make all of the code visible with links to it in the explanation. You'll see exactly how I build up each program.

To view a code playback, click on the comments in the left panel. Each comment updates the code in the editor and highlights the change. Read the explanation, study the code, and use the built-in AI tutor if you have questions. For more information about code playbacks, you can watch a short demo here.

You can access the free 'book' of code playbacks here: https://playbackpress.com/books/webdevbook

Note on Prerequisites: This is not an introduction to programming. You should have some programming experience as I won't cover basics like if statements, loops, and functions. If you've programmed before in any language, you should be able to follow along.

If you are looking for an introduction to programming, I do have other books that introduce programming in C++ and Python along with others on the Playback Press site.

Table of Contents

1. JavaScript

• Ancient JavaScript

• Modern JavaScript

• JavaScript and Types

• Closures

• Classes in JavaScript

• Promises and async/await

• More with async and await

2. The Back End: Node, Express, SQLite, and Mongo

• Node Modules and npm

• Creating Your Own Modules

• The Http Module

• Express Basics

• Returning JSON Data

• Reading and Writing Data to a JSON File

• Express and SQLite

• Express and MongoDB

3. The Front End: HTML, CSS, Bootstrap, and Express Views

• Basic HTML and CSS

• HTML5 and More CSS

• Bootstrap

• Using Views in Express

• Dynamic JavaScript

• Sessions and Password Hashing

• A Very Brief Introduction to the Firebase Cloud Firestore

• Web Components Part 1: LegendHeader

• Web Components Part 2: LegendTable

• Web Components Part 3: NewLegendForm

• Web Components Part 4: AuthBox

4. React

• Basic React

• Using Vite to Create a React App

• Using React and Express Together

5. GraphQL

• A Traditional API

• GraphQL Query Syntax

• A GraphQL Server Without a Database

• A GraphQL Server that Uses a Database

• Accessing a GraphQL Server Using fetch() and graphql-request

• Using React to Access a GraphQL Server

Get Started

I hope this animated introduction helps you grasp the fundamental concepts of web development and empowers you to start building your own web applications. Dive in, experiment, and let me know what you think!

If you have any questions or feedback, I'd love to hear it. Comments and thoughts are welcome anytime: mark@playbackpress.com

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

Python's popularity stems from its versatility and ease of use, making it an excellent choice for a broad range of applications. Its extensive standard library provides tools for numerous tasks, from web development and data analysis to artificial intelligence and scientific computing.

The language's clear syntax and active, supportive community also contribute to its widespread adoption among both beginners and experienced developers.

Python is employed across a wide array of domains, including:

• Data Analysis and Visualization: Processing, analyzing, and visualizing large datasets using libraries such as Pandas, NumPy, and Matplotlib.

• Artificial Intelligence and Machine Learning: Developing AI models, machine learning algorithms, and deep learning applications with frameworks like TensorFlow and PyTorch.

• Scientific and Numeric Computing: Performing complex calculations and simulations in fields like physics, engineering, and mathematics.

• Web Development: Building server-side web applications with frameworks like Django and Flask.

• Automation and Scripting: Automating repetitive tasks, system administration, and network configuration.

• Software Testing and Quality Assurance: Writing scripts for automated testing.

• Education: Widely used as a first language for teaching programming concepts due to its simplicity and readability.

An Animated Introduction to Programming with Python

To make learning about Python programming more accessible, I developed an interactive tutorial called "An Animated Introduction to Programming with Python." This resource utilizes annotated code playbacks to demonstrate key language features step-by-step. From fundamental syntax to media manipulation, each concept is presented through executable code and accompanying visual explanations.

You can access the free 'book' of code playbacks here: https://playbackpress.com/books/pybook.

For more information about code playbacks, you can watch a short demo.

A Focus on Media Computation with JES

A portion of this book utilizes Mark Guzdial's pioneering "Media Computation" approach, which teaches programming concepts through the manipulation of digital media (images, sounds, and videos). Some of the examples in the book use the Jython Environment for Students (JES).

A Note on JES:

JES was developed at Georgia Tech and has been a highly effective pedagogical tool for many years. The main idea is to manipulate pixels in images for understanding fundamental programming concepts like iteration, conditionals, and functions in a visual and tangible way.

Even if JES isn't as widely used today, the lessons learned from manipulating pixels transfers to almost all other areas of computing. In other words, even if you don’t use JES it is still worth going through the playbacks marked with JES.**

Table of Contents

1. Flow of Control and Simple Data

   1. Printing and flow

   2. Arithmetic and comparing numbers

   3. Programming with Data

   4. Distance Between Two Points

   5. More with Strings

   6. JES: Prompting the User for Some Information

   7. JES: Showing a Picture

   8. JES: Accessing Pixels

   9. JES: Adding a Caption to a Picture

2. Iterating Over Data

   1. Iterating Through a String

   2. Lists and Iteration

   3. Splitting Strings

   4. Ranges

   5. Reading from a File

   6. Writing to a File

   7. JES: Iterating Through Pixels

   8. JES: Graying an Image

   9. JES: Copying an Image

   10. JES: Enlarging a Picture

3. Conditions with if and while

   1. Comparisons by the Computer

   2. if, if/else, and if/else if/else Statements

   3. Logical Operators

   4. Loops

   5. JES: Adding a Border to a Picture

   6. JES: Finding the Predominant Color in a Row

4. Data Containers

   1. Python Lists

   2. Python Dictionaries

   3. Python Sets

   4. JES: Storing User Supplied Data in a Dictionary

5. Functions

   1. A First Function

   2. Function Return Values

   3. Parameters

   4. Scope of Variables

   5. Pass by Reference or Pass by Value

   6. Sorting with Functions

   7. JES: Adding Text (Again) and Saving a File Using Functions

   8. JES: Shrinking a Picture

   9. JES: Making a Movie with Moving Text

6. Classes

   1. Classes

   2. Class with Data and Methods

   3. Classes that Interact with Each Other

   4. Inheritance

   5. JES: Photo Resizing/Rotating Class

I hope this animated introduction helps you grasp the fundamental concepts of Python and empowers you to start building your own applications. Dive in, experiment, and let me know what you think! If you have any questions or feedback, I'd love to hear it. Comments and feedback are welcome anytime: mark@playbackpress.com

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

Elixir is based on another language called Erlang. Erlang was developed by Ericsson in the 1980s for telecom applications requiring extreme reliability and availability. It includes built-in support for concurrency, distribution, and fault-tolerance. Elixir, created by José Valim, brings a more approachable and expressive syntax to the Erlang VM. It lowers the barrier to entry for using Erlang's powerful features.

In Elixir, functions are the primary building blocks of programs, similar to how classes and methods are the core units in object-oriented languages. But instead of modeling behavior through stateful objects, functional languages like Elixir treat computation as a series of pure functions that take input and produce output without side effects.

This paradigm offers several benefits:

• Immutability: Data is immutable by default. Once a variable is bound, it can't be changed. This avoids hard to track bugs caused by side effects.

• Functions as first-class citizens: Functions can be assigned to variables, passed as arguments, and returned from other functions. This enables powerful abstractions and code reuse.

• Pattern matching: Elixir uses pattern matching to bind variables, unpack data structures, and control program flow. This leads to concise and declarative code.

• Recursion: Looping is typically achieved through recursion. Elixir optimizes recursive calls to avoid stack overflow issues.

While functional programming requires a shift in thinking, it can lead to more predictable and maintainable systems. Elixir makes this paradigm friendly and accessible.

One of Elixir's standout features is its concurrency model. It uses lightweight processes to achieve massive scalability:

• Processes are isolated and share no memory, communicating only via message passing.

• The Erlang VM can run millions of processes concurrently on a single machine.

• Fault-tolerance is achieved by supervising and restarting failed processes.

This architecture enables building distributed, real-time systems that efficiently use modern multi-core hardware.

An Animated Introduction to Elixir

To make Elixir's functional and concurrent nature more approachable, I developed an interactive tutorial called "An Animated Introduction to Elixir". It uses annotated code playbacks to walk through key language features step-by-step. From basic syntax to advanced topics like concurrency, each concept is explained through code and accompanying visuals.

You can access the free 'book' of code playbacks here: https://playbackpress.com/books/exbook.

For more info about code playbacks, you can watch a short demo:

Part 1 of the book focuses on core Elixir – syntax basics, pattern matching, functions and modules, key data structures like tuples, maps, lists, functional concepts like closures, recursion, enumeration, and efficient immutability.

• 1.1 Hello Elixir!!!

• 1.2 Numbers and the Match Operator

• 1.3 Functions and More Matching

• 1.4 Modules and More Matching with SimpleMath

• 1.5 Closures

• 1.6 Ranges and the Enum Module

• 1.7 Tuples

• 1.8 Maps

• 1.9 SimpleDateFormatter Module with Maps

• 1.10 Lists, Matching, and Recursion

• 1.11 Poker Probabilities

• 1.12 Recursion in Elixir

Part 2 explores Elixir's concurrency model – working with processes, message passing between processes, dividing work across processes, and real-world examples and benchmarking. The concepts are applied to practical problems like estimating poker probabilities and generating calendars.

• 2.1 Adding Tests to the Mix

• 2.2 Process Basics

• 2.3 Prime Sieve

• 2.4 Calendar with Processes

• 2.5 Poker with Processes

Why Learn Elixir?

Learning Elixir is beneficial for programmers for several compelling reasons. Elixir's functional paradigm and immutable data structures promote writing cleaner, more predictable, and maintainable code.

Its actor-based concurrency model, built on the robust Erlang VM, enables developing highly scalable, fault-tolerant, and distributed systems that can efficiently leverage multi-core processors and handle massive numbers of simultaneous users. Also, Elixir has a friendly, expressive syntax that lowers the barrier to entry for using these powerful features.

Finally, Elixir has a rapidly growing, vibrant community and ecosystem. For example, the Elixir ecosystem includes powerful web frameworks like Phoenix for building scalable web applications, Nerves for creating embedded software for devices, and Ecto for writing database queries and interacting with different databases.

If you have any questions or feedback, I'd love to hear it. Comments and feedback are welcome anytime: mark@playbackpress.com.

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

Web Components are a set of standardized browser APIs that allow you to create custom, reusable HTML elements with encapsulated functionality. They help developers create self-contained components that can be used across different frameworks or even without any framework at all.

This tutorial assumes you have some basic programming experience and are comfortable reading and writing JavaScript. You should understand variables, functions, loops, objects, classes, and how JavaScript works in the browser. You don’t need to know anything about Web Components to get started.

The four lessons presented here are taken from my free book of code playbacks:

An Introduction to Web Development from Back to Front
By Mark Mahoney

This book is available for free on Playback Press. The book is a hands-on guide to modern web development, covering everything from core JavaScript features to building full-stack apps with various tools and technologies.

Each lesson is presented as a code playback, which is an interactive code walkthrough that shows how a program changes over time along with my explanation about what's happening. This format helps you focus on the reasoning behind the code changes.

To view a playback, click on the comments in the left panel. Each comment updates the code in the editor and highlights the change. Read the explanation, study the code, and use the built-in AI tutor if you have questions. Here's a short video that shows how to use a code playback:

After this introduction, you might want to explore the official Web Components resources: MDN Web Components Guide.

Table of Contents

• Web Components Part 1: Your First Custom Element

• Web Components Part 2: Data Communication

• Web Components Part 3: Custom Events

• Web Components Part 4: Building a Complete App

• React vs Web Components Comparison

Web Components Part 1: Your First Custom Element

This first lesson introduces building user interfaces using Web Components, which let you bundle together HTML, CSS, and JavaScript into a single reusable element.

These elements can be treated just like built-in HTML elements such as h1, div, and img. They're particularly useful when you want to break a page into smaller, self-contained, and reusable parts like headers, tables, or forms, while keeping the code for each organized and isolated.

In this playback, you'll learn:

• How to create a JavaScript class that represents a custom HTML element

• How to access the attributes of the web component

• How to create and use a web component in HTML

The lesson focuses on creating a LegendHeader component that can be reused throughout a web application. You'll see how custom elements can have attributes just like regular HTML elements (such as src in an img tag), and how these attributes can be changed from JavaScript code, triggering methods in response.

View the playback here: Web Components Part 1- LegendHeader

Web Components Part 2: Data Communication

Building on the previous lesson, this playback demonstrates how to create multiple components that share data. I'll enhance the LegendHeader component to display the count of legends being tracked, and add a new LegendTable component that displays all the CS legends in a database using an HTML table.

A key concept introduced in this lesson is having a top-level element hold the web app's data and letting it communicate changes to the components that rely on it. This approach makes component management more organized and maintainable.

In this playback, you'll learn:

• How to create and work with multiple components

• How to set up and use 'observable attributes' in a web component

• How a top-level element can manage data and inform components when data changes

View the playback here: Web Components Part 2- LegendTable

Web Components Part 3: Custom Events

This lesson expands the application by adding a NewLegendForm component that allows users to add new legends to the database. The playback introduces the concept of custom events that 'bubble' up through the DOM, enabling top-level elements to control requests for data.

You'll learn why it's often better for components not to manage app-wide data themselves. Having a top-level element manage the entire web app's data makes components simpler and more reusable, as they don't need to know about each other or communicate directly.

In this playback, you'll learn:

• How components can generate custom events to request data instead of managing it themselves

• How a top-level element can listen for events and handle them

• How a top-level element accesses data and passes it to components that need it

View the playback here: Web Components Part 3- NewLegendForm

Web Components Part 4: Building a Complete App

In this final lesson, I bring everything together to create a complete application with authentication. I'll add a new AuthBox component and implement a light authentication system so that only registered, logged-in users can add new legends to the database.

The playback uses sessions on the server to control user access and reinforces the importance of centralized data management in component-based architecture.

In this playback, you'll learn:

• How to implement user authentication with a web component

• How to integrate all components into a complete, functional application

• Best practices for data management in component-based web applications

View the playback here: Web Components Part 4- AuthBox

React vs Web Components Comparison

Some of the main differences between React and web components can be summarized like this:

Wrapping Up

These four lessons cover the fundamentals of Web Components, but there's much more to explore. Web Components provide a standards-based way to create reusable elements without the need for external libraries or frameworks, making them particularly valuable for building maintainable and portable code.

If you found this format helpful, explore the rest of the book to see how full web apps are built from scratch using modern tools and approaches.

Web Components represent just one approach to component-based web development. Keep building, keep reading, and try out the other playbacks when you're ready to go further.

If you have feedback about the playbacks I'd love to hear from you. You can reach me here mark@playbackpress.com.

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

This guide assumes you have some basic programming experience and are comfortable reading and writing JavaScript. You should understand variables, functions, loops, objects, and how JavaScript works in the browser. You don’t need to know React or any build tools, as those are introduced along the way.

How this Guide Works

The three lessons presented here are taken from my free book of code playbacks:
An Introduction to Web Development from Back to Front.

This book is available for free on Playback Press. The book is a hands-on guide to modern web development, covering everything from core JavaScript features to building full-stack apps with tools like Node, Express, SQLite, Mongo, and GraphQL.

Each lesson is presented as a code playback, which is an interactive code walkthrough that shows how a program changes over time along with my explanation about what's happening. This format helps you focus on the reasoning behind the code changes.

To view a playback, click on the comments in the left panel. Each comment updates the code in the editor and highlights the change. Read the explanation, study the code, and use the built-in AI tutor if you have questions. Here's a short video that shows how to use a code playback:

There are plenty of other great React resources out there. After you finish with this short introduction, check out the React team's official tutorial: https://react.dev/learn.

Table of Contents

• Introduction to React: Your First Component

• Building a React App with Vite

• Connecting React to a Real Backend with Express

Introduction to React: Your First Component

This first lesson introduces building user interfaces using small, reusable React components. Instead of writing code to directly update the DOM, you define what the UI should look like, and React takes care of syncing the DOM with your data.

The playback shows how to use ReactDOM.render with React.createElement, and then how to write the same component using JSX. Over the course of the three lessons, I'll create a site that displays some computer science legends (and one imposter).

The lesson then moves on to creating a CustomHeader component that takes properties or props. It shows how to pass data into a component and how destructuring can make that easier. By the end, you'll know how to write and reuse simple components that can be used in larger React apps.

View the playback here: Basic React

Building a React App with Vite

The next lesson shows how to create a modern React project using Vite. Vite takes care of the setup by creating a project folder, installing libraries, running a development server, and preparing a build for production. This lets you skip any manual configuration and start building your app right away.

I'll build on the CS Legends app from the first playback, but this time inside a project directory. I'll separate components into different files and use JSX. The playback also introduces useState for managing dynamic data and shows how to pass data and event handlers between components. The result is a working front-end app with clear structure and reusable code.

View the playback here: Using Vite to Create a React App

Connecting React to a Real Backend with Express

This final lesson extends the Vite + React app by adding a database-backed Express backend. Instead of storing the legend data in React's local state, the app will fetch and update data using an Express API. You'll create a second folder for the backend server, connect it to a database, and write routes to get and add data.

I use the useEffect hook to load the data from the Express server when the app starts. You'll also set up the cors package to allow the frontend and backend to talk to each other during development. Once everything works, the React app is built into a static bundle and is served by the Express server. The result is a full-stack web app, ready to be deployed.

View the playback here: Using React and Express Together

Wrapping Up

These three lessons cover the basics, but there's much more to learn. If you found this format helpful, explore the rest of the book to see how full web apps are built from scratch using modern tools and frameworks.

React is just one piece of the web development puzzle. Keep building, keep reading, and try out the other playbacks when you're ready to go further.

If you have feedback about the playbacks I’d love to hear from you. You can reach me here mark@playbackpress.com.

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

SQL is not a traditional programming language. In Python or Java, you write step-by-step instructions that tell the computer exactly how to do something. This is called imperative programming.

SQL works differently. First, you understand what data is stored in your tables. Then you write a query describing what data you want and you give it to a database management system. The database management system figures out how to get it. This declarative style is part of what makes SQL powerful (and fun to use).

You don’t need to be a programmer to learn SQL, but having some programming experience helps. Concepts like conditional logic and comparing values to see if something is true or false will feel familiar if you’ve coded before.

If you want an introduction to the basics, check out some of my programming language tutorials listed below.

Tutorial Structure

This tutorial is built around three books of interactive code playbacks I use in my database courses:

• Database Design and SQL for Beginners

• Worked SQL Examples

• Programming with SQLite

Each section of this tutorial includes worked examples where I show how I write SQL step-by-step, explaining my thought process along the way. You’ll see me experiment, refine, and build queries piece by piece, just like a real developer would. I rely heavily on Entity-Relationship Diagrams and Schemas to help me visualize the data stored in the databases.

Here’s how the tutorial is organized:

Part 1: A Whirlwind Tour of SQL

(from Database Design and SQL for Beginners)

I start by exploring a simple database for a fictional pet adoption center called the Paw Prints Adoption Center. I introduce essential concepts like:

• Entity-Relationship (ER) diagrams

• Schemas

• Table structure and relationships

This foundation sets the stage for everything that follows. If you're new to database design, spend some time here before moving on.

Part 2: Core SQL Concepts and Keywords

(also from Database Design and SQL for Beginners)

I cover the most important SQL keywords and ideas. Each topic is explained in its own playback with examples:

• CREATE TABLE, ALTER TABLE

• SELECT, FROM, WHERE, JOIN

• ORDER BY, GROUP BY, HAVING

• INSERT, UPDATE, DELETE

• Nested queries, Common Table Expressions, and set operations (UNION, INTERSECT, EXCEPT)

• Indexes and transactions

This section works as a reference. If you're stuck on a query or forget what a keyword does, come back here.

Part 3: Practice Problems

(from Worked SQL Examples)

Practice is how you really learn. I’ve included 36 practice problems using the Paw Prints database and a new university database. Each problem has an animated playback showing how I worked through the solution step-by-step.

Try writing your own query before watching the solution. Struggling with the problem first will help you learn much more than just watching me provide the answer.

These problems build your skills gradually and help reinforce the use of ER diagrams and schemas in real scenarios.

Part 4: Using SQLite in Programs

(from Programming with SQLite)

In this final optional section, I show how to connect SQL to real code. You’ll learn how to use the SQLite database in:

• C/C++

• Python and Flask

• Java

Running Queries

A database management system (DBMS) is the software used to manage and query data in a database. Many DBMSs require significant configuration and often a separate server to respond to query requests. Setting these up can be challenging for newcomers.

SQLite is a simple DBMS that doesn’t require much setup. It’s a great tool to start with. It doesn’t need a standalone server and stores the entire database in a single file.

To make it easier to view and edit your databases, I recommend using DB Browser for SQLite. It’s a free, open-source tool with a simple interface and all of SQLite’s functionality built in. You can open database files, browse tables, run queries, and edit data using an intuitive user interface. It’s especially useful when you’re learning and want to quickly see how your queries affect the data.

Optional: Web-Based Alternative to DB Browser

If you prefer not to install any software, you can use a web-based tool like SQLite Viewer or SQLite Online. These let you upload a .sqlite file, run queries, and explore a database from your browser.

• SQLite Viewer: A simple, read-only viewer. Good for inspecting tables and testing basic queries.

• SQLite Online: A full-featured SQLite IDE. You can create databases, upload files, run queries, and even save your work.

Both tools are great for quick experiments or checking your work without installing anything.

Code Playbacks

This tutorial is not a traditional video or static text. Each section includes links to interactive code playbacks that animate how the code or query was built, step-by-step. You can pause and rewind to see each change as it happens.

Each playback includes a narrative, screenshots, whiteboard-style drawings, and self-grading multiple-choice questions to reinforce what you’ve learned.

If you haven’t seen a code playback before, don’t worry. They’re easy to use and allow you to see how queries evolve over time. Here’s a short video showing how to view a code playback:

Playback Press

Playback Press is the platform where I publish my interactive code walkthroughs. Each book includes step-by-step animations, AI tutoring, and built-in quizzes.

I also created Storyteller, the free, open-source tool that powers these playbacks.

AI Tutor

While you're viewing a code playback, you can ask an AI tutor questions about the queries. It gives clear, focused answers and doesn’t rush you. You can also ask it to create new self-grading multiple-choice questions to test your understanding.

To use the AI tutor and quizzes, create a free account on Playback Press and add one of the books to your bookshelf.

Table of Contents

• Part 1: A Whirlwind Tour of SQL

• Part 2: A Beginner’s Reference to SQL

• Part 3: Practice Problems — Paw Prints and University Databases

• Part 4: Using SQLite in Programs

• Conclusion

• Comments and Feedback

Part 1: A Whirlwind Tour of SQL

When someone is asked to manage some data, most people's first instinct is to use a spreadsheet. Spreadsheets are easy to use and flexible. But as your data grows more complex, they start to show some weaknesses.

One major issue is redundant data. When the same piece of information appears in multiple places, there's a risk that one copy might change while the others stay the same. This can lead to inconsistencies, errors, and confusing results.

Relational databases help solve this by organizing data in a structured way that reduces redundancy by design. Before building a database, it’s helpful to model the data using an Entity-Relationship (ER) diagram.

Entity-Relationship Diagrams

An ER diagram is a planning tool used to visualize the structure of a database. It helps you figure out what kinds of data you need to store and how those pieces of data relate to each other.

• Entities are the main objects or concepts in your system, like Person, Course, or Dog. Entities have attributes that describe them. A Person might have name, date of birth, and address attributes, for example.

• Relationships describe how entities are connected. For example, a Person might adopt a Dog, or a Student might enroll in a Course.

By laying this out in a diagram, you can clearly see what data is being stored and how the entities are related to each other. This makes it easier to design the tables in your database correctly.

Here is an example of an ER diagram used in this part of the tutorial:

Schemas

A schema is another way to describe the structure of a database. It shows the same information as the ER diagram, but in a more technical and precise format focused on how the data will actually be stored. Each element of a schema will become a table in a database.

Instead of lines connecting boxes, a schema uses primary keys and foreign keys:

• A primary key uniquely identifies each row in a table. Primary keys have a solid underline.

• A foreign key refers to the primary key in another table, linking the two together. Foreign keys have a dashed underline.

Here is an example of a schema used in this part of the tutorial:

While an ER diagram is more visual and conceptual, a schema is more concrete and closer to the actual implementation in the DBMS. You’ll see both used throughout this tutorial as I move from planning to writing SQL.

Try It: Explore a Relational Database in Action

To see how these concepts work in practice, take a look at the following three code playbacks. They walk through the design of a relational database for a fictional pet adoption center called Paw Prints. These examples will help you understand how entities, relationships, and schemas come together in a real database and how to write simple SQL queries to explore that data.

Start with the first playback and move through all three in order:

1. Database Design and Simple SQL: Introduces the Paw Prints database and shows how to write basic SQL queries.

2. One-to-Many Relationships and More SQL: Covers one-to-many relationships and how to join related tables.

3. Many-to-Many Relationships and Even More SQL: Shows how to handle many-to-many relationships using join tables and more advanced queries.

As you watch, pause to make sure you understand how the data is structured and how each SQL query is written. You can always refer back to this section later if something in the next chapters isn’t clear.

Part 2: A Beginner’s Reference to SQL

This section takes a closer look at the core SQL commands introduced in the whirlwind tour. Each playback focuses on one topic and shows how to use it through step-by-step examples. I continue to use the Paw Prints database in these examples.

Think of this as a reference section. You don’t need to go through everything in order but you may want to go through them all at least once before beginning to practice in part 3. Come back here whenever you need a refresher on a particular SQL concept.

Here are the key concepts we’ll cover:

CREATE TABLE and ALTER TABLE

Learn how to define tables in a relational database. This playback shows how to create tables from scratch and how to change them later using ALTER TABLE.

INSERT

See how to add new rows of data to a table. This example shows how to use the INSERT command and make sure your data matches the table structure.

SELECT

This playback introduces the SELECT keyword in SQL. You’ll learn how to retrieve specific columns (or attributes) from a table and see what the result set looks like.

FROM

Explore how the FROM clause specifies which tables your data comes from. This sets the stage for combining data from multiple sources using a Cartesian product. You’ll also see how to JOIN tables together.

WHERE

Learn how to filter results using conditions. The WHERE clause helps narrow down the rows returned by a query. This playback also shows how to join tables by matching foreign keys to primary keys.

UPDATE and DELETE

Learn how to change existing data in the database with UPDATE and remove data using DELETE. You’ll also see how to avoid accidental changes by using WHERE conditions carefully.

ORDER BY

Sort your results using ORDER BY. You’ll learn how to control the order of your output using one or more attributes.

Aggregate Operators, GROUP BY, and HAVING

Group rows and calculate summary values using aggregate functions like COUNT, AVG, MIN, MAX, and SUM. This playback also shows how to use GROUP BY and HAVING to work with grouped results.

Nested Queries with IN and Common Table Expressions

Learn how to use nested queries – queries inside other queries – to build more flexible logic. This playback also shows how to write cleaner queries using Common Table Expressions (CTEs).

UNION, INTERSECT, EXCEPT

See how to combine the results of multiple queries. This example shows how UNION, INTERSECT, and EXCEPT help you work with data from different queries as if it were one set.

Transactions

Learn how to group multiple SQL commands into a single transaction, so they all succeed or fail together. Transactions help protect your data from partial updates.

CREATE INDEX

Improve query performance using indexes. This playback shows how to create an index on one or more columns and explains why that makes certain queries run faster.

Part 3: Practice Problems — Paw Prints and University Databases

Now it’s time to apply what you’ve learned.

Below are six practice problems that use the Paw Prints database from earlier examples. If you haven't recreated it yourself, here is a link to the SQLite file dogsFinal.sqlite. Each one asks a specific question that requires you to write a SQL query to find the answer. Try solving each one on your own before watching the solution.

Don’t worry if you don’t get it right on the first try. Writing SQL often involves trial and error, even for experienced developers. The goal is to think through the problem and make progress, not to be perfect. Start small and build your queries up through an iterative process.

Click each link to view the playback after you've made your attempt:

1. Which Dogs Have Had the Most Visits?

Figure out how to count visits for each dog and sort them to find the most frequently visited ones.

2. Number of Adoptions and Average Age

Find the total number of adoptions and the average age of adopted dogs. You'll need to filter the data appropriately.

3. Locations with Least/Most Aggressive Dogs

Use grouping to compare aggression levels across locations and determine where the most and fewest aggressive dogs are housed.

4. Average Time to Adoption By Location

Calculate the average time it takes for dogs to be adopted, broken down by location.

5. Finding Available Capacity at Each Location

Determine how much space is left at each shelter location by comparing total capacity to current occupancy.

6. Who Visited then Adopted an Aggressive Dog

This complex query asks you to track user actions over time, first visiting, then adopting an aggressive dog. A good challenge!

University Database

Next, you’ll work with a more complex database that models a university’s course and grading system. You’ll use it to analyze real-world relationships between students, professors, courses, and departments.

Download the SQLite version of the database here:
studentGrades.sqlite

Here are the entities in the database:

• Students

• Sections

• Courses

• Professors

• Departments

And here are the relationships between them:

• Each student takes zero or more sections. (Every student receives a grade.)

• Each section has zero or more students taking it.

• Each section is an instance of a course.

• Each course has zero or more sections.

• Each section is taught by a single professor.

• Each professor teaches zero or more sections.

• Each professor belongs to zero or more departments.

• Each department has zero or more professors.

• Each department has, at most, one professor who is its chairperson.

• Each professor may chair, at most, one department.

• Each course is offered by a department.

• Each department offers zero or more courses.

The code playbacks highlight how I use ER diagrams and schemas to help me build my queries. You can preview them here:

Try each query on your own before watching the solution.

7. List every course name, section number, and professor name in chronological order for every section that has ever been offered

8. List every course name and section number for every course offered by the computer science department

9. Find the name of every professor who has ever taught CSCI111

10. List all of the professor names and their departments

11. List the names of the professors who have taught both CSCI111 and CSCI112

12. List the names of all of the students of professor Mark Mahoney who are greater than or equal to 21 years old

13. List the names of all of the students who are taught by a department chair

14. List all of the course names and section numbers of every course ever taught by a department chair

15. List all of the courses with the oldest student

16. List all of the courses and section numbers with the youngest average student age

17. List all of the course names and section numbers of courses with less than four credits

18. List all of the course names and section numbers with the smallest enrollment

19. List all of the student names who have taken more than one course with Mark Mahoney

20. List all of the student names who have taken a course with both Mark Mahoney and Eric Whendon

21. List all the course names and section numbers that had two or more students earn A's

22. Find the names of all the students who have taken CSCI111

23. Find the names of all professors in the computer science department who are not chairs of a department

24. Find the names of all professors who are the chair of a department

25. Find the ssn, first and last name, course name, and grade earned for all courses taken in spring 2007

26. Find the course name and section number of all the courses that have ever been offered in the fall

27. Find the names of all of the professors teaching in spring 2007

28. Find the names of all of the students who have received an A and a B in any course

29. Find out how many students have ever taken CSCI111

30. Find the average age of all students who ever had a course with Mark Mahoney

31. Find the names of all of the professors who have never taught a course

32. Find the names of all of the professors who have taught May Jones

33. Find the names of the students who have had a course in Fall 2006 or Spring 2007

34. Find the names of the students who have taken a course from a professor who has more than one appointment to a department

35. Find the average age of students who took courses in Spring 2007

36. Find the sum of all of the credit hours offered by the computer science department in 2007

Part 4: Using SQLite in Programs

So far, you’ve learned how to write SQL queries and design relational databases. In this optional section, you’ll see how to use SQLite in actual code. Each playback walks through a working program that reads from and writes to a SQLite database.

Why Use SQLite in Programs?

SQLite’s simplicity makes it a great choice for quick projects, prototypes, and small applications. You don’t need to run a server, and everything is stored in a single file.

These playbacks show how to embed SQL directly into your code, so your programs can store and retrieve data as part of their normal workflow. I really love using it in my projects!

Here’s an overview of the playbacks:

C/C++

1. The C++ SQLite API

Shows how to set up and use the SQLite C++ API. You’ll open a database, run basic queries, and handle results.

2. An Object-Oriented Auction Program

Builds a more complex C++ program that tracks bids, items, and users. This example shows how to structure a real-world application with SQLite.

3. SQLite Transactions

Explains how to group multiple database operations into a single transaction. This protects your data from partial updates.

Python and Flask

1. Querying a SQLite Database

Connects a Python script to a SQLite database, runs queries, and processes the results using Python’s built-in libraries.

2. Creating SQLite Databases

Shows how to create new SQLite databases directly from Python, defining tables and inserting initial data.

3. Flask Basics

Introduces Flask. You’ll see how to build a simple web application that can serve pages and connect to your SQLite database.

4. Creating an API

Takes Flask further by creating a RESTful API that interacts with a SQLite database, letting you perform CRUD operations on a SQLite database.

Java

1. Using a SQLite Database in a Java Program

Shows how to integrate the SQLite driver into a Java application. You’ll learn how to open a connection, run queries, and handle exceptions properly.

Conclusion

By now, you’ve learned how to read and write real SQL. You’ve seen how to design a database, how to write queries that retrieve and modify data, and how to tackle increasingly complex questions using the tools SQL gives you.

If you worked through the practice problems you’ve already done what many developers do on the job: examine unfamiliar data, figure out the relationships, and write queries to answer real questions.

SQL is a skill that gets sharper the more you use it. Don’t worry if you still feel a little unsure. Repetition and exploration will build your confidence. Keep experimenting, break things, and try to fix them. That’s how you really learn.

If you’re planning to use SQL in your own projects, try building a small database from scratch or connecting SQLite to one of your programs. You’ll learn a lot by seeing what questions your own data brings up.

Thanks for reading. I hope these playbacks helped make SQL a little easier to understand. Good luck with your next SQL project.

Comments and Feedback

You can find all of these code playbacks and more in one of my free books:

• Database Design and SQL for Beginners

• Worked SQL Examples

• Programming with SQLite

• An Animated Introduction to Programming in C++

• An Animated Introduction to Programming with Python

• An Introduction to Web Development from Back to Front

• An Animated Introduction to Clojure

• An Animated Introduction to Elixir

• A Brief Introduction to Ruby

• Mobile App Development with Dart and Flutter

• OO Design Patterns with Java

• How I Built It: Word Zearch

Comments and feedback are welcome anytime: mark@playbackpress.com.

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

You'll need to have some previous programming experience in another language to get the most out of this tutorial. Clojure is so different from most imperative programming languages that it doesn't really matter where you are coming from as long as you know the basics (variables, if statements, loops, and functions).

If you are looking for a complete beginner's guide to programming, you can find some of my other programming content below.

Here, I will cover functions, data structures, immutability, closures, tail recursion, lazy sequences, macros, and concurrency.

Clojure is a functional programming language. In it, the function is king and data is immutable. This may be a different paradigm than you are used to, but there are some compelling reasons to use it. Clojure's immutability is particularly good for programs that need to take advantage of modern hardware on laptops and mobile phones (multiple processors sharing a single memory).

Clojure runs on the JVM. It can be difficult to set up Clojure because it involves installing Java, Leiningen, and sometimes an editor plugin. To make things easier, I recommend starting with a web-based IDE. There is no easier way to start programming in Clojure than using replit. I recommend using it to write your first programs in Clojure. If you feel up to it, check out these docs to get started on your own machine.

Even if you don't use Clojure every day, learning it will change how you think about programming. It will help you understand recursion, higher-order functions, and data transformations in a new way. These ideas transfer well to other languages like JavaScript, Python, or Rust. In short, learning Clojure will make you a better programmer.

Code Playbacks

This material will not be delivered like traditional online tutorials or video series. Each section includes links to interactive code playbacks that visually animate changes made to a program in a step-by-step manner, helping you understand how it was written.

A code playback shows how a program evolves by replaying all the steps in its development. It has an author-supplied narrative, screenshots, whiteboard-style drawings, and self-grading multiple choice questions to make the learning process more dynamic and interactive.

Here's a short YouTube video explaining how to view a code playback:

Playback Press

Playback Press is a platform for sharing interactive code walkthroughs that I created. I’m Mark, by the way, a professor of computer science. These books provide interactive programming lessons through step-by-step animations, AI tutoring, and quizzes.

If you want to see the full Clojure 'book', you can go here:

An Animated Introduction to Clojure, by Mark Mahoney

I also built Storyteller, the free and open-source tool that powers code playbacks.

AI Tutor

When viewing a code playback, you can ask an AI tutor about the code. It answers questions clearly and patiently, making it a helpful resource for learners. You can also ask the AI tutor to generate new self-grading multiple-choice questions to test your knowledge of what you are learning.

To access the AI tutor and self-grading quizzes, simply create a free account on Playback Press and add the book to your bookshelf.

Table of Contents

• Introduction to Clojure

• Functions

• Closures

• Recursion

• Lazy Sequences

• Macros

• Concurrency

Introduction to Clojure

These first few programs show how to print to the screen, perform basic arithmetic, and store some data. Go through each of these now:

• Hello World!!!

• Readers/evaluators and simple arithmetic

• Dog age converter

This program shows how to use the Java capability that it built into to the JVM.

• Java interoperability

These programs show some basic data structures in Clojure and how they are immutable.

• Clojure data structures

• Efficient immutability (more with data structures)

Hands-On Practice

Problem 1

Write a Clojure program that prompts the user for the length and width of a wooden board in inches. Then display the number of whole square feet that are in the board. For example, if the height is 27 inches and the width is 34 inches, then the number of square feet is 6.375.

Problem 2

Write a program that creates an empty list and use def to store a reference to it called empty-list. Use cons to add your name to it and store it in a new list called my-name.

Use conj to add all of your siblings to a list called me-and-my-siblings (if you don't have any or don't have that many you can use some of the Kardashians).

Print all the names in me-and-my-siblings. Then print the third name on the list me-and-my-siblings.

Create a map with all of your siblings' names as keys and their birth years as values. Use assoc to add your name and birth year to the map. Use the map to print everyone's name and their age in the year 2050.

Problem 3

Create a map with the number of days in each of the months called days-in-months. Use Clojure keywords like :jan and :feb as the keys and the number of days in the months as the values.

Create a second map from the first that has 29 days for February. Call this one days-in-months-leapyear. Make sure to do this efficiently, use assoc to create a new value for February. Finally, print each of the maps.

Functions

Next, I'll discuss creating and calling functions in Clojure. Clojure is a functional programming language so this is a pretty important topic.

The first two programs show how to write functions in Clojure.

• Functions in Clojure

• Fizz Buzz

This program shows how to use a map to encapsulate data along with some functions that manipulate the data.

• Maps as objects

These programs show how to read and write to a file using functions.

• Reading from a file (with CS poetry)

• Writing to a file

Hands-On Practice

Problem 1

Write three mathematical functions:

• square squares a passed in parameter

• cube cubes a passed in parameter

• pow raises a base number to an exponent

For this group of functions, do not use any built-in mathematical functions.

Hint: look at the Clojure function repeat and reduce for the pow function. Use the let function to hold temporary values so that they can be referred to later.

Problem 2

Write a function that takes a number and will calculate the factorial value for that number.

5! is 5 * 4 * 3 * 2 * 1 = 120

10! is 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 = 3,628,800

Hint: this type of problem is typically done with recursion. But for now, try to do it without recursion. Look at the Clojure range and reduce functions.

Problem 3

Write a function that determines whether a number is prime or not. Use the range and filter functions to filter out non-primes in a range of values.

Hint: look at the not-any? and mod functions for determining whether a number is prime or not.

Problem 4

Write a function that takes one or more string parameters, converts them to numbers, and then adds them together and returns the sum.

(println (add-strings "10")) ;prints 10

(println (add-strings "10" "20")) ;prints 30

(println (add-strings "10" "20" "30")) ;prints 60

(println (add-strings "10" "20" "30" "40")) ;prints 100

Use Clojure's reduce function or apply to turn the strings into numbers and then add them together.

Closures

A closure is a way to associate data permanently with a function.

The first program shows how to bind data to a function.

• Closures

The second program shows a more complex example of using closures.

• Interest in an account

Hands-On Practice

Problem 1

Write a function that returns a function. The Fibonacci numbers are a sequence of numbers that are generated by summing the previous two numbers together:

0 1 1 2 3 5 8 13 21 34 ...

Usually, the first two numbers are assumed to be 0 and 1. But in this case, return a function that uses the specified first two numbers in the sequence. Then generate and print out the requested numbers in the sequence.

(defn fibs-fn[firstFib secondFib] ...) ;;fill this in

(def another-fib (fibs-fn 10 15)) ;;create a fib function that prints starting with 10 and 15

(another-fib 5) ;;print first 5 fibs: 10 15 25 40 65

Recursion

A recursive function is one that calls itself. Since every function call results in a stack frame being placed on the call stack, regular recursion runs the risk of 'blowing up the call stack'. Tail recursion, with recur, is an efficient way to simulate recursion without the downsides.

• Tail Recursion

• Recursion and Fizz-Buzz

• Recursion and Square Roots

• Converting a String to an Integer in the Bases 2-16

• Mortgage Scheduler

Hands-On Practice

Problem 1

Write a recursive function to reverse the letters of a string.

(reverse-string "Mark Mahoney") ;;returns "yenohaM kraM"

You may need to create a recursive 'helper' function that takes a different number of parameters than the non-recursive function or use the loop form. Make sure you use recursion with the recur form so that you do not 'blow the stack'.

Problem 2

Write a function that will join a series of strings together separated by another string. The function should create and return a new string. Use recursion with recur.

(defn join [separator & parts]
   ;;your code here)

(join ", " "Mark" "Laura" "Buddy" "Patrick" "Willy") ;;"Mark, Laura, Buddy, Patrick, Willy"

Problem 3

Write a function that takes in an integer and converts it to a string. The user can specify the base that the string is in from 2-10. The program should use recursion and recur (either a recursive function or the loop form).

(to-string 100 10) ;;"100" decimal
(to-string 7 2) ;;"111" binary

Lazy Sequences

A lazy sequence defers the cost of creating values until they are needed. The first program shows how to create a lazy sequence. The next two are more concrete examples.

• Lazy sequences

• Lazy Prime Generator (Fizz Buzz part 3)

• Poker Probabilities

Hands-On Practice

Problem 1

Create a function that generates a lazy sequence of squares. For example, (1 4 9 16 ... to infinity). Use it to print the first 10 squared values.

Then write a function that generates a lazy sequence of values raised to a power:

(defn lazy-pow [start-val power]
  ...)

(take 6 (lazy-pow 10 2)) ;(100 121 144 169 196 225)
(take 6 (lazy-pow 10 3)) ;(1000 1331 1728 2197 2744 3375)

Problem 2

Write a function that generates an infinite lazy sequence of possible permutations of the passed in sequence.

(take 3 (lazy-perm ["a" "b" "c"]))
;("a" "b" "c")

(take 12 (lazy-perm ["a" "b" "c"])) 
;("a" "b" "c" "aa" "ab" "ac" "ba" "bb" "bc" "ca" "cb" "cc")

(take 39 (lazy-perm ["a" "b" "c"])) 
;("a" "b" "c" "aa" "ab" "ac" "ba" "bb" "bc" "ca" "cb" "cc" "aaa" "aab" "aac" "aba" "abb" "abc" "aca" "acb" "acc" "baa" "bab" "bac" "bba" "bbb" "bbc" "bca" "bcb" "bcc" "caa" "cab" "cac" "cba" "cbb" "cbc" "cca" "ccb" "ccc")

(take 120 (lazy-perm ["a" "b" "c"]))
;("a" "b" "c" "aa" "ab" "ac" "ba" "bb" "bc" "ca" "cb" "cc" "aaa" "aab" "aac" "aba" "abb" "abc" "aca" "acb" "acc" "baa" "bab" "bac" "bba" "bbb" "bbc" "bca" "bcb" "bcc" "caa" "cab" "cac" "cba" "cbb" "cbc" "cca" "ccb" "ccc" "aaaa" "aaab" "aaac" "aaba" "aabb" "aabc" "aaca" "aacb" "aacc" "abaa" "abab" "abac" "abba" "abbb" "abbc" "abca" "abcb" "abcc" "acaa" "acab" "acac" "acba" "acbb" "acbc" "acca" "accb" "accc" "baaa" "baab" "baac" "baba" "babb" "babc" "baca" "bacb" "bacc" "bbaa" "bbab" "bbac" "bbba" "bbbb" "bbbc" "bbca" "bbcb" "bbcc" "bcaa" "bcab" "bcac" "bcba" "bcbb" "bcbc" "bcca" "bccb" "bccc" "caaa" "caab" "caac" "caba" "cabb" "cabc" "caca" "cacb" "cacc" "cbaa" "cbab" "cbac" "cbba" "cbbb" "cbbc" "cbca" "cbcb" "cbcc" "ccaa" "ccab" "ccac" "ccba" "ccbb" "ccbc" "ccca" "cccb" "cccc")

Macros

A macro specifies some code to be executed, sort of like a function, but it also allows some of that code to be replaced with values that come from the user.

The code in a macro is kind of like a template that can be altered to suit the caller’s needs. With this powerful feature, the language can be expanded to do things that the language inventor never thought to add.

• Macros

• Set macros

Hands-On Practice

Problem 1

Write a macro that takes in a grade earned on a student assignment (on a 0-100 scale) and some code to execute if the grade is a passing or failing.

(defmacro eval-grade [grade if-passing if-failing] ...)

And use it to print or call a function based on the value of the grade

(def users-grade 43)

(eval-grade users-grade (println "Passing") (println "Failing")) ;;"Failing"

(eval-grade users-grade (praise users-grade) (warning users-grade)) ;;call the warning function

Concurrency

Concurrency in Clojure is a big topic. I start by discussing threads. Then I talk about different strategies for dealing with data that is shared among different threads.

• Threads

• Threaded poker

• refs and threads

• Atoms

• Poker with atoms

• Thread logging with agents

• Simpler concurrency

Hands-On Practice

Problem 1

This lab asks you to create a Clojure program that will count how many primes are in a given range.

Create a thread pool and have each thread check a single number in the range. If it finds a prime, it will increase a counter (which should be an atom since it is shared by all of the threads). Look at the program above on Atoms as a starting point.

Conclusion

If you've made it this far, you’ve already taken meaningful steps toward learning a language that can change how you write and think about code.

Clojure offers a fresh perspective on programming, one that focuses on simplicity, immutability, and the power of functions. Learning Clojure will change your brain and you will take these lessons with you to other languages as well.

So keep experimenting, keep asking questions, and keep practicing to sharpen your skills.

Comments and Feedback

You can find all of these code playbacks in the free 'book', An Animated Introduction to Clojure. There are more free books here:

• An Animated Introduction to Programming in C++

• An Animated Introduction to Programming with Python

• Database Design and SQL for Beginners

• Worked SQL Examples

• Programming with SQLite

• An Introduction to Web Development from Back to Front

• An Animated Introduction to Clojure

• An Animated Introduction to Elixir

• A Brief Introduction to Ruby

• Mobile App Development with Dart and Flutter

• OO Design Patterns with Java

• How I Built It: Word Zearch

Comments and feedback are welcome via email: mark@playbackpress.com.

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!

Along the way, you will learn about the flow of control, variables, conditional statements, loops, arrays, functions, structured data, pointers and dynamic memory, classes, common data structures, and working with databases.

Integrated Development Environments (IDE’s) are tools that allow you to write, run, and debug C++ programs. There are some great free C++ IDE’s out there.

If you own a Windows computer, I recommend using Visual Studio Community Edition. If you own a Mac, I recommend using Xcode. These provide robust features and excellent support for C++ development. If you're looking for a lightweight install on any platform, CLion is a fantastic choice.

For those who prefer not to install any software or are unable to, replit is a convenient web-based IDE that allows you to start coding immediately.

There are practice problems in each section so that you can use to practice while learning from the content. These are in the 'Hands-On Practice' portion of each section. You will use your IDE to write and run these practice programs.

Code Playbacks

This is not a traditional online tutorial or video series. Each section will have links to interactive ‘code playbacks’ that visually animate the changes made to a program in a step-by-step manner.

A code playback shows how a program evolves by replaying all the steps in its development. It has an author-supplied narrative, screenshots, whiteboard-style drawings, and self-grading multiple choice questions to make the learning process more dynamic and interactive. Just click on the numbered comments on the left hand side of the screen to drive the playback forward.

Watch this short YouTube video which explains how to view a code playback in more detail.

Playback Press

Playback Press is a platform for sharing code playbacks. The site contains collections of code playbacks grouped together by language/technology into different ‘books’. If you want to see the full C++ book, you can go here: An Animated Introduction to Programming in C++.

Code playbacks on the platform include AI tutoring, mini-quizzes, and text-to-speech features.

Storyteller is the free and open-source tool that powers code playbacks.

AI Tutor

When viewing a code playback, you can ask an AI tutor about the code. It answers questions clearly and patiently, making it a helpful resource for learners. You can also ask the AI tutor to generate new self-grading multiple choice questions to test your knowledge of what you are learning.

In order to access the AI tutor and to generate new multiple choice questions, simply create a free account on Playback Press and add the book to your bookshelf. It is still free, but you do need to register in order to access the AI features.

Table of Contents

• Part 1: Variables

• Part 2: Selection

• Part 3: Looping

• Part 4: Arrays

• Part 5: Functions

• Part 6: Vectors

• Part 7: Structured Data

• Part 8: Pointers

• Part 9: Object-Oriented Programming

• Part 10: Data Structures

• Part 11: SQLite Databases

• Comments and Feedback

C++ Overview

C++ is a powerful, high-performance programming language that is widely used in various domains such as system development, game development, real-time simulations, and high-performance applications. It is an extension of the C programming language, adding object-oriented features, which makes it suitable for large-scale software engineering projects.

C++ provides fine-grained control over system resources and memory management, which can lead to highly optimized and efficient code. C++ remains a popular choice due to its versatility, performance, and the vast ecosystem of libraries and tools available.

Part 1: Variables

Simply watching an experienced artist paint is not enough to say that you have learned how to become a painter. Watching an experienced artist is an important part of the learning process, but you can only call yourself a painter after struggling to make your own paintings first.

There are a lot of similarities between learning to paint and learning to program. The only way to truly learn programming is through practice!

So, let's get started. Follow along with the code playbacks below. Click the links below to load each code playback (it may help to open them in a new tab). Click on the playback comments on the left-hand side of the playback screen to step through the code's development.

Flow of Control

The following playback explains the flow of control in a program by describing how to print to the screen from it:

• 1.1 Name printer program

Variables and Types

This next group of programs describes declaring variables to hold data in a program. All variables have a type which specifies what can be stored in them and what operations can be performed on them.

• 1.2 Distance formula

• 1.3 Basic types in C++

• 1.4 Number types

• 1.5 Characters and strings

Reading from the Keyboard

This final group of programs builds on previous concepts and shows how to prompt the user for input.

• 1.6 Weekly pay calculator

• 1.7 Distance formula revisited

• 1.8 Gas Mileage

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that prompts the user for three integers: one representing an hour, one representing a minute, and one representing a second. Next, calculate the number of seconds until midnight based on the time that was input. Print the number of seconds until midnight on the screen.

Then, prompt the user for a single integer representing the number of seconds until midnight. From that value, do the reverse calculation to find the hour, minute, and second of that time. Print it to the screen in a time format HH:MM:SS.

Part 2: Selection

This section discusses altering the flow of control with if/else statements. These statements ask the computer to evaluate whether a condition is true or false and changes the flow of control based on the answer. It also explains the data type, bool, which can hold either true or false and it shows a few examples of how to use selection with if, if/else, if/else if/else, and switch statements.

• 2.1 Booleans

• 2.2 Even/odd calculator

• 2.3 Overtime pay with an if/else

• 2.4 Water temperature

• 2.5 Switch

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, try to write a few programs:

Problem 1

Problem 1 asks you to write a program to determine if one date comes after another. The program will ask for two sets of dates. Next, the program will determine if the first date comes before, is equal to, or comes after.

Enter in the first month: 2
Enter in the first day: 21
Enter in the first year: 2012

Enter in the second month: 2
Enter in the second day: 22
Enter in the second year: 2011

The first date comes after the second.

Problem 2

Problem 2 asks you to write a program that prompts the user for a date and determines if that date is valid. For example, 9/19/2017 is a valid date, but these are not valid dates:

• 4/31/2006 (only 30 days in April)

• 2/29/2005 (not a leap year)

• 16/1/2010 (invalid month)

• 4/59/2013 (invalid day)

If the date is correct, print it out. If it is incorrect, display an error message explaining why the date is not correct.

Problem 3

Problem 3 asks you to write a program that will calculate change for a sales purchase. Your program should prompt for a sales price. Validate that the data entered is a number greater than 0. If the data entered is incorrect, display an error message and end the program.

Next, prompt the user for the amount that the customer will pay to the cashier. Validate that this value is greater than or equal to the sales price. If it is not, display an error message and end the program.

If the entry is correct, your program must calculate the amount of change to return to the user. Next, calculate what bills and coins that the the cashier needs to return to the customer. The fewest number of paper bills and coins should be returned. You can make change in many different combinations, but the only correct implementation is the one that returns the fewest paper bills and coins.

Display the number of each of the bills and coins. Here is a sample run of the program:

Enter in a sales amount: $20.38
Enter in the amount the customer pays: $30.00

The change due back is $9.62

You should give the customer this change:
0 $100 bills
0 $50 bills
0 $20 bills
0 $10 bills
1 $5 bills
4 $1 bills
1 Half Dollars
0 Quarters
1 Dimes
0 Nickels
2 Pennies

Because of the way arithmetic works with float variables, storing the monetary values as floats may cause some problems.

For example, if you had a float variable that held 1.29 to represent $1.29 and you subtracted the .05 from it (to represent giving back a nickel), you would think that you would be left with exactly 1.24. Unfortunately, the computer might store that value or it might store 1.2399999 or 1.2400001 instead of exactly 1.24.

These very small inconsistencies can cause a problem calculating the number of pennies to return. Consider converting the amounts into ints to solve this problem.

Part 3: Looping

This group of playbacks discusses repeatedly executing the same code over and over again in a loop. They show how to create count controlled and event controlled loops with the while keyword, nested loops, a for loop, and how to exit a loop with break and continue.

• 3.1 A simple loop

• 3.2 More loops

• 3.3 Summation

• 3.4 Nested loop

• 3.5 for loop

• 3.6 Capitalization

• 3.7 break and continue

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to write a program that will calculate the sum of the squares from 1 up to and including that number. For example, if the user entered in the value 5, then the sum of the squares for the numbers one through five would be (1 + 4 + 9 + 16 + 25) = 55.

Your program should repeatedly calculate this value until the user enters in a value of -99. This is the sentinel value that the program uses to determine when to quit.

Enter in an integer number(ex. 10), -99 to quit: 5
The sum of the squares up to 5 is 55

Enter in an integer number(ex. 10), -99 to quit: 4
The sum of the squares up to 4 is 30

Enter in an integer number(ex. 10), -99 to quit: -99
Have a nice day!

Problem 2

Problem 2 asks you to write a program that will determine whether a number is prime or not. A prime number is any number that is evenly divisible only by the number one and itself.

7 is prime because the only numbers that divide into it without a remainder are 1 and 7.

12 is not prime because the numbers that divide into it evenly are 1, 2, 3, 4, 6, and 12.

Your program will prompt for a number and then display whether the number is prime or not. The number entered must be a positive number. Repeatedly prompt for a number until a positive number is entered.

Problem 3

Problem 3 asks you to calculate a mortgage schedule for someone thinking of buying a new house. The inputs to determine a monthly schedule are the principal loan amount and the annual interest rate. Assume this will be a conventional 30 year loan.

Your program should prompt for these inputs and find a monthly payment using this calculation:

                                   monthly interest rate                                              
monthly payment =  ------------------------------------------------- * principal
                   1 - (1 + monthly interest rate)^-number of months

Notice that you will have to calculate the monthly interest rate (the annual interest rate divided by 12.0) and number of months (360 for a 30 year loan). The ^ in this formula means raise one number to a power. There is a function called pow() which raises one number to another and returns the result. For example, if you wanted to raise 2 to the -3rd power, you would do this:

float result = pow(2.0, -3.0);

After you have calculated the monthly payment, create a summary of the loan characteristics. Display the loan amount, the interest rate, the monthly payment, the total amount paid for the loan, the total amount of interest paid, and the ratio of amount paid over the principal.

After you have printed the summary, you can begin to make the schedule. Prompt the user for the ending month to display in the schedule. The schedule should display the month number, the monthly payment, the amount paid in principal in that month, the amount paid in interest in that month, and the amount remaining in the principal (the amount paid in principle each month is deducted from the remaining principle). A month's interest amount is equal to monthly interest rate times the remaining principal. The monthly principal is the difference between the monthly payment and the monthly interest paid. Remember to update the remaining principal after every month.

After each year of the schedule has been printed, display a message with the year number.

Part 4: Arrays

This batch of programs shows how to use arrays in C/C++. An array is a collection of variables (all of the same type) that have a single name and sit next to each other in memory. Loops are almost always used to go through the elements of an array. They show how to create two and three dimensional arrays and use the random number generator in C/C++.

• 4.1 Arrays

• 4.2 Average and standard deviation of an array of values

• 4.3 Problems with arrays

• 4.4 Flipping coins

• 4.5 Multi-dimensional arrays

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to write a program that displays a menu with three options.

The first option allows the user to enter in a month number (between 1-12) and a day number within that month (1-31) and calculates the day number in the year. January 1 is day 1. January 31 is day 31. February 1 is day 32. February 28 is day 59. December 31 is day 365 (don’t worry about leap years). If the user enters an invalid combination (like February 31) the program should continuously prompt the user to enter in a new value until they enter a valid date.

The second menu option allows the user to enter in a day number (1-365) and prints out the month name and day number of that month. If the user enters in 59, the program should print out:

Day 59 is February 28

If the user enters an invalid day number, the program should continuously prompt the user to enter in a new value until it is in the correct range.

The last menu option allows the user to quit the program. The menu should repeatedly be displayed until the user chooses to quit the program.

Use an array of integers to hold the number of days in each of the months. Use the array to keep a running sum to help with your day calculations. You may also want to create an array of strings with the month names.

int numDaysInMonths[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

Here is a sample run of the program:

1. Enter in a month and day
2. Enter in a day number
3. Quit
Enter in a menu option: 1

Enter in a month number: 2
Enter in a day number: 1

February 1 is day 32

1. Enter in a month and day
2. Enter in a day number
3. Quit
Enter in a menu option: 2

Enter in a day number: 59
Day 59 is February 28

1. Enter in a month and day
2. Enter in a day number
3. Quit
Enter in a menu option: 3

Problem 2

Problem 2 asks you to create a program that will find the number of days in between two dates.

For example, say a user would like to know how many days are in between two dates (1/1/2000) and (3/19/2030). The program must find out how many whole days are in between these two dates (include the starting and ending date).

If the two dates are in the same year, then the algorithm to find the number of days may be different than if the dates are in different years. Your program must handle each case.

Here is a sample run of the program:

Enter in a start month: 1
Enter in a start day: 1
Enter in a start year: 2000

Enter in an end month: 3
Enter in an end day: 19
Enter in an end year: 2030

There are 11035 days in between 1/1/2000 and 3/19/2030

Part 5: Functions

This group of playbacks describes another flow of control-altering mechanism called functions. A function is a named block of code that can be called and the flow of control will jump to it.

When calling a function, some data can be passed into it (called parameters) and the function can return a piece of data when it is complete (called a return value). These playbacks discuss passing in data 'by value' versus 'by reference'. They show that every variable has a limited lifetime that it sits in memory, or scope.

• 5.1 Functions

• 5.2 Value returning functions

• 5.3 Functions with parameters

• 5.4 Passing parameters by reference

• 5.5 The scope of variables

• 5.6 Prime number function

• 5.7 Passing arrays to functions

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to extend the prime number problem from a previous section. Write a program that includes a function that will print all the prime numbers in a range. The program will ask for a lower bound and an upper bound and print all the primes in that range.

Problem 2

Problem 2 asks you to write a function that takes an integer year number and returns a bool whether that year is a leap year or not. The calculation for leap year is as follows:

• most years evenly divisible by four are leap years

• if a year is divisible by four and is a century year, like 1800 or 1900, then it is NOT a leap year

• if a century year also happens to be divisible by 400, like 2000 or 2400, then it is a leap year

The function should look something like this:

bool isLeapYear(int year)
{
    //calculate if it is leap year or not and return true or false
}

Problem 3

Problem 3 asks you to write a program that will print a calendar for a whole year given the day that January 1st falls on. Your program will prompt for the day that January 1st falls on and the year. You must print the calendar for all 12 months of that year. The options for the first day of the year will be entered with the first three letters of each of the seven days of the week from Sunday ('sun') to Saturday ('sat').

The year does not need to be validated, but the day of the week does. You should not allow the user to enter in a value other than 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', or 'sat'.

The format of your calendar should be very similar to the example below. You must use at least one function in addition to the main function. Pass data between functions, do not use global variables.

The final requirement is that your program should only display one month at a time and then wait for some user input before continuing.

It is very important that you come up with a plan to solve this program before you begin coding (as it is with every program). Think about how you would print a single month's calendar given the day of the month that it begins on.

Sample Output:

What year do you want the calendar for?
2003

What day of the week does January 1st fall on (sun for Sunday, mon for Monday, etc..)?
s
Invalid Entry - please enter the first three letters of the day

What day of the week does January 1st fall on (sun for Sunday, mon for Monday, etc..)?
wed

    January 2003
 S  M  T  W  T  F  S
---------------------
          1  2  3  4
 5  6  7  8  9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31

Do you want to continue? y

   February 2003
 S  M  T  W  T  F  S
---------------------
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28

Do you want to continue? y
...
...

Part 6: Vectors

C++ comes with the Standard Template Library (STL) which is a collection of different containers. This section will cover vectors. A vector is an array-based container that holds data very much like an array does but it is smarter. It knows how many elements are in it and it can grow as the program is running. It also shows how to read and write data from a file, efficiently search through an array-based container, sort values, and more.

• 6.1 vector

• 6.2 Passing a vector to a function

• 6.3 Advanced features of vectors

• 6.4 Reading from a file and storing in a vector

• 6.5 Linear search and binary search

• 6.6 Bubble sort

• 6.7 Writing to a file

• 6.8 Two dimensional vectors

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program to read in whole words from a file and store them in a vector of strings. Create a simple text file (.txt) using your coding editor. Then add a few sentences of text to it. Strip any punctuation marks from the words and make them all lowercase letters. Only store a word in the vector if it is not already present.

Part 7: Structured Data

This section describes how to use structured data types. Structured data types allow you to group related data together so that it can be passed around easily.

• 7.1 Simple struct

• 7.2 Hierarchical structs

• 7.3 vectors as members of structs

• 7.4 structs with a vector of objects

• 7.5 Calculus with structs

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that has a struct to represent a cell phone. Every cell phone has a model name and manufacturer along with a camera with a mega-pixel resolution. For example, a user may want to store information about an Apple IPhone X with a 12 MP camera or a Google Pixel 4 with a 16 MP camera.

Your program will create three cell phone objects, fill them, and then add them to a vector. Lastly, print out the information about each cell phone on the screen.

Write a function that takes a cell phone object by reference and prompts the user to enter in the model, manufacturer, and camera resolution. Write another function that prints information about a cell phone. Write a function that takes a vector of cell phones and prints each one.

Part 8: Pointers

This section describes pointers in C/C++. A pointer is a variable that holds the address of another variable. Pointers are important because they allow us to use a special section of memory called the 'heap'. This section discusses the different types of memory that can be used in a program (global, local, and dynamic).

• 8.1 Simple pointers

• 8.2 Pointer to an object

• 8.3 Vectors of pointers

• 8.4 Arrays are pointers

• 8.5 Passing data to functions with pointers

• 8.6 Comparing pointers

• 8.7 Three types of variables- global, local, and dynamic

• 8.8 Dynamic variables example

• 8.9 Dangling pointers and null pointers

• 8.10 Dynamic array of students

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that will read a sequence of words from the keyboard and store them in a dynamic array of strings. Use the word 'quit' as the word that terminates the input. Print the words back to the screen in the order in which they were entered, each on its own line. Do not store the same word twice.

Up until now, the size of an array has been determined at compile time. Now that you know about pointers and about the keyword new, write a program which is not restricted to selecting an upper bound at compile time for the number of words which can be read in.

One way to do this is to use new to create arrays of strings on the fly. Each time an array fills up, dynamically create an array which is twice as large, copy over the contents of the existing array to the new array, and continue (remember to delete the original array). Start with an array of 5 elements.

Here is an example of the output:

Enter in some text and end with the word quit:
This lab asks you to write a program that will read a sequence of words from the keyboard and store them in a dynamic array of strings. Use the word 'quit' as the word that terminates the input. Print the words back to the screen in the order in which they were entered each on its own line. Do not store the same word twice. quit

Doubling Array from 5 to 10
Doubling Array from 10 to 20
Doubling Array from 20 to 40
Doubling Array from 40 to 80
1. This
2. lab
3. asks
4. you
5. to
6. write
7. a
8. program
9. that
10. will
11. read
12. sequence
13. of
14. words
15. from
16. the
17. keyboard
18. and
19. store
20. them
21. in
22. dynamic
23. array
24. strings.
25. Use
26. word
27. 'quit'
28. as
29. terminates
30. input.
31. Print
32. back
33. screen
34. order
35. which
36. they
37. were
38. entered
39. each
40. on
41. its
42. own
43. line.
44. Do
45. not
46. same
47. twice.
Press any key to continue . . .

Part 9: Object-Oriented Programming

This section discusses object-oriented programming using classes in C++. A class is like a struct, except that in addition to collecting data, it also collects methods that work on that data. This is called encapsulation. It also discusses inheritance and polymorphism that make it easier to reuse code.

• 9.1 Simple class

• 9.2 A class with data members

• 9.3 A class with objects for data members

• 9.4 Common word analysis

• 9.5 Student and course registration system

• 9.6 Inheritance and polymorphism

• 9.7 Shape inheritance hierarchy

• 9.8 Inheritance and polymorphism in C++

• 9.9 Copy Constructor Example

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to create a Date class to represent a date.

There should be an int for the day number, month number, and year number declared in the private section. Instead of having a setter for each of those, have one method called setDate(int m, int d, int y) that sets the date. You can have a getter method for each piece of data.

Add two constructors: one that takes no data and sets the date to 1/1/2000, and another that takes three ints to set the date.

Include a print() method that will print the date in this format: MM/DD/YYYY and a method called printLong() that prints in this format: MonthName Day, Year. For example, the first day of the 21st century should print January 1, 2000.

Include a method to add some number of days, months, and years to a Date:

void addDays(int d)
void addMonths(int m)
void addYears(int y)

Problem 2

Problem 2 asks you to create some related classes for playing card games. The data needed to be stored for a card is a numeric value and a suit. A card is responsible for being able to display itself. For example, when we want to display a two of hearts, ten of diamonds, jack of clubs, or ace of spades, the output would look like this:

2 of Hearts
10 of Diamonds
J of Clubs
A of Spades

Next, create a deck class. A deck is a collection of fifty-two cards. Each card is unique. There should be a card with a numeric value from two to the ace in each of the four suits. The responsibilities of the deck class are that it must be able to shuffle itself and deal out some number of cards from the deck. To shuffle the deck, you will need to randomly move cards around in the deck. You can generate a random number in C++ using the rand() function.

When dealing out cards, the user will ask the deck for some number of cards. If there are enough cards in the deck, it should deal those cards out. Once a card is dealt from the deck, it cannot be dealt again from the same deck. The user will pass in a vector of cards and the deck will fill it with the number of cards requested. If there aren't enough cards in the deck, print an error message and then kill the program with an exit(0).

When creating a class, you always have to think about the data needed for the class and the responsibilities of the class. The data for the class should be private and an interface to the class should be provided.

Think about how each card and deck should be constructed. Write at least one constructor for each class. Write the card class first and test it in a driver program. Then work on the deck class.

To test the deck, create a deck object, ask for 52 cards, and print each of those cards to the screen.

Next, alter the program so that it will allow a person to evaluate the probabilities of getting certain poker hands. Poker is a card game played with a deck of 52 cards. In this program, you only need to handle the five card variety of poker. The program will repeatedly get groups of five cards from the deck and count how many times each hand occurs.

In most variations of poker, the precedence of hands goes like this:

Royal Flush - 5 cards that are a straight (5 cards in numeric order) and a flush (5 cards that are the same suit) from the 10 to the Ace.
Straight Flush - 5 cards that are a straight (5 cards in numeric order) and a flush (5 cards that are the same suit).
Four of a Kind - any 4 cards with the same number.
Full House - three of a kind (3 cards with the same number) and a pair (two cards with the same number).
Flush - any 5 cards of the same suit.
Straight - any 5 cards in numeric order.
Three of a Kind - any 3 cards with the same number.
Two Pair - 2 sets of pairs.
Pair - any 2 cards with the same number.
High Card in your Hand - if you don't have any of the above, your high card is the best hand.

You will need to create additional classes with more responsibilities than the Deck and Card classes.

Your program needs an 'evaluator' that can look at a collection of cards and determine the best hand that can be made from those cards. In order to determine probabilities, deal a great number of hands and keep track of how many times each hand shows up.

In other words, your program might create 100,000 collections of five cards to be evaluated. The evaluator will count how many times a royal flush comes up, how many times a straight flush comes up, an so on. Your program will show the probabilities as percentages of the likelihood of getting each hand.

Below is a driver to illustrate how to use the evaluator:

int main()
{
    //five card evaluator
    //create a poker evaluator for 5 card poker
    PokerEvaluator fiveCardPokerEvaluator;

    //set the number of hands to play - one hundred thousand this time
    fiveCardPokerEvaluator.setNumberOfHandsToPlay(100000);

    //play all the hands and track the statistics, then print the results to the screen
    fiveCardPokerEvaluator.playAndDisplay();

    return 0;
}

Part 10: Data Structures

This section describes how to build some common data structures: a hash table, a binary search tree, and a graph. It also describes how to use the STL unordered_map class.

• 10.1 Simple linked list

• 10.2 Simple hash table

• 10.3 More complex hash table

• 10.4 STL unordered_map

• 10.5 Binary search tree

• 10.6 Graph adjacency matrix

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that includes a class which is equivalent of the vector called SafeArray. SafeArray has a method called at that returns the element at the specified position.

A SafeArray maintains a pointer to an array on the heap. Use the pointer to make the array grow and shrink with calls to push_back and pop_back.

The SafeArray will have a method called size that returns the number of items in it. Include a default constructor that sets the initial size of the underlying array to hold 10 elements. Include a destructor to delete the array when the SafeArray falls out of scope.

Part 11: SQLite Databases

This section describes working with a SQLite database. SQLite is my favorite Database Management System (DBMS), because it is powerful and easy to add to any program. This section assumes that you are familiar with relational database design and SQL.

The first program shows how to use the API to write and run SQL queries in a C++ program. In the second, some of the repetitive code is abstracted into a separate class. In the third, transactions in SQLite are explained and it shows that they can be used to ensure the ACID properties of a database:

• 11.1 The C++ SQLite API

• 11.2 An Object Oriented Auction Program

• 11.3 SQLite Transactions

Hands-On Practice

Extend the auction program from the second playback to include a method that prints the names and email addresses of all of the users who won an auction. Then write a method that prints an item followed by the names and email addresses of anyone who made a bid on the item.

Comments and Feedback

You can find all of these code playbacks in my free book, An Animated Introduction to Programming in C++. There are more free books here:

• An Animated Introduction to Programming with Python

• Database Design and SQL for Beginners

• Worked SQL Examples

• Programming with SQLite

• An Introduction to Web Development from Back to Front

• An Animated Introduction to Clojure

• An Animated Introduction to Elixir

• A Brief Introduction to Ruby

• Mobile App Development with Dart and Flutter

• OO Design Patterns with Java

• How I Built It: Word Zearch

Comments and feedback are welcome via email: mark@playbackpress.com.

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!