Rod Stephens

Rod Stephens started out as a mathematician, but discovered the fun of algorithms and has been programming ever since. He was a Microsoft Visual Basic Most Valuable Professional (MVP) for 15 years, has spoken for user groups and conferences and has taught introductory programming courses. He has written more than 30 books including Essential Algorithms: A Practical Approach to Computer Algorithms Using Python and C#, and Beginning Software Engineering, which include material related to this series of liveProjects.

projects by Rod Stephens

Four AI Algorithm Projects with Python

4 weeks · 4-6 hours per week average · INTERMEDIATE

In this series of liveProjects, you’ll learn how some of the most common AI algorithms work under the hood by using them to solve fun and engaging problems. You don’t need expert Python skills or lots of math knowledge to get started. Dive right in by creating a classification algorithm model that can turn scribbles into phone numbers, then explore particle swarm optimization and the Boids algorithm to model flocks of birds. Next, you’ll delve into Expert Systems—a classic approach to artificial intelligence—and use them to create an AI to help identify what kind of animal a zoo attendee is looking at. Finally, you’ll build a working neural network to help a bank demystify their customer’s handwritten deposit slips.

Expert Systems

1 week · 2-4 hours per week · INTERMEDIATE

In this liveProject, you'll take over administering a zoo automatically by crafting three different kinds of expert systems to help customers determine what animal they’re looking at. An expert system captures an expert's know-how by encoding it in a knowledge base. You’ll create a prototype 20-Questions-style game expert system, then expand it with logical rules and Boolean statements to build more powerful and realistic expert systems.

Neural Networks

1 week · 4-6 hours per week · INTERMEDIATE

In this liveProject, you’ll build neural nets for a bank that are capable of classifying the numbers written on deposit slips. Customers often write out their important account details by hand, and you need to create a model capable of effectively reading their handwriting. You’ll use a feedforward network trained with backpropagation to identify hand-drawn digits with a high percentage of accuracy. Plus, this project contains an optional bonus milestone! Further your knowledge of neural networks by using the TensorFlow and Keras libraries to create an alternative and more flexible version of your first model. You’ll get hands-on experience with these tools' standard libraries, and with your new model you will be able to easily analyze the network's success rate and experiment with different activation functions.

Swarms

1 week · 4-6 hours per week · INTERMEDIATE

In this liveProject, you'll implement particle swarm optimization and the Boids algorithm to develop computational models to track flocks of finches. You’ll start with a simple flock simulator, then modify it to adapt to obstacles, take a different approach with Gravity Boids, and finally use a swarm-inspired algorithm to find the highest point on a complex mathematical surface. You’ll soon have an algorithm that can predict the movements of everything from flocks of finches to swaying concertgoers!

Simple Classification

1 week · 4-6 hours per week · INTERMEDIATE

This liveProject puts you on the front lines at an indie bookstore, where poorly scrawled notes threaten to bring sales to a standstill. Learning classification algorithms from the ground up, you'll use four different and surprisingly simple classifiers to develop an AI solution that turns illegible scribbles into recognizable numbers.

Four Small Algorithm Projects with Rust

4 weeks · 5-7 hours per week average · INTERMEDIATE

Algorithms make the computer science world go round—and they’re a vital skill for any developer to master. In this series of liveProjects, you’ll explore four essential algorithm topics through engaging, hands-on Rust challenges. You’ll learn how to use sorting algorithms to make sense of messy, unorganized data; solve the tricky Tower of Hanoi puzzle with recursion; secure messages with RSA encryption; and even tackle the infamous 0-1 knapsack problem with dynamic programming techniques. The series is a workout for the programmer’s brain, perfectly suited for building Rust muscles.

Dynamic Programming

1 week · 4-6 hours per week · INTERMEDIATE

When your house is on fire, and you need to save your priceless art in a panic room, what are you going to do? Write a Rust program to solve the “knapsack problem” of course! In this liveProject, you’ll tackle this problem—one of the more challenging ones in computer science. The knapsack problem is known for its difficulty, as its possible solutions grow exponentially as the number of items increases. You’ll work with different methods to solve the problem, including recursion and dynamic programming techniques.

Public Key Cryptography

1 week · 6-8 hours per week · INTERMEDIATE

In this liveProject, you’ll use Rust and RSA encryption to secure the emails of your antique marble collection business. You’ll steadily build up different parts of the RSA encryption process before bringing each together in a working RSA example that can both encrypt and decrypt your email messages. Throughout the journey, you will acquire knowledge about prime number identification, factoring, probabilistic generation of random primes, and rapid exponentiation techniques.

Problem-Solving with Recursion

1 week · 4-6 hours per week · INTERMEDIATE

The Tower of Hanoi is one of the most famous (and fun!) mathematical puzzles you can tackle. In this liveProject, you’ll set out to solve this tricky challenge using recursive functions in the Rust programming language. Kickstart your journey with factorials, then calculate Fibonacci numbers and solve the Knight’s Tour and N-Queens problems. Then, you’ll be ready to take on the Tower of Hanoi—and transfer your new recursion skills to multiple other problems.

Sorting and Searching

1 week · 4-6 hours per week · INTERMEDIATE

Sorting is one of the most important skills you can learn to make sense of messy data—and in this liveProject, you’ll discover sorting algorithms you can implement with Rust. You don’t need advanced Rust knowledge. With only the basics, you’ll tackle three of the huge number of sorting algorithms available: bubble sort, quicksort, and counting sort. But that’s not all: You’ll also experiment with a pair of search algorithms for linear and binary search. Before long, you’ll have an excellent grasp of the best sort and search algorithms for your needs.

Six Small Algorithm Projects with Go

6 weeks · 4-6 hours per week average · BEGINNER

Algorithms are the recipes for success that allow programs to accomplish difficult tasks quickly and correctly. In this series of liveProjects, you’ll play six roles in six diverse and interesting situations that spotlight algorithms in a wide range of applications using the Go programming language. You’ll learn by doing as you tackle tasks such as implementing classic sorting and searching algorithms, building an RSA encryption program, and solving the classic knapsack problem.

The Knapsack Problem

1 week · 4-6 hours per week · BEGINNER

Picture this: You’ve amassed a fortune selling Instagram filters and you’re cruising the Bermuda Triangle on one of your yachts when you strike a USO (unidentified submerged object). Now you’re sinking! Your life raft isn’t big enough to salvage all of your 200 valuable objects (of varying sizes, weights, and values). To help you decide which of your treasures—the Monet, the Degas, the bust by Canova—to take with you on the raft, you’ll write a Go program that uses different approaches, including exhaustive search, branch and bound, Rod’s technique, and dynamic programming to solve the knapsack problem, a classic in computer science for situations just like this. When you’re finished, you’ll learn what the tradeoffs are, and you’ll know which of your valuables you’ll be able to save and which will end up at the bottom of the ocean!

Public Key Cryptography with RSA

1 week · 6-8 hours per week · BEGINNER

You’re the new head of IT at The Fright Stuff, a small Halloween store, and it’s up to you to prevent a scary security breach! To ensure your customers’ sensitive data is secure, you’ll build an RSA public key encryption program. Along the way, you’ll learn interesting mathematical techniques such as calculating greatest common divisors and least common multiples, performing fast exponentiation, building a sieve of Eratosthenes, testing for primality, and other vital encryption skills. When you’re done, your customers’ data will be safer than ever before, and you’ll have learned essential skills for RSA encryption.

Lookups with Hash Tables

1 week · 4-6 hours per week · BEGINNER

As a summer intern at Ginormous Megadata Inc, you’ve been tasked with building a phone directory of the company’s 130,000 employees. The catch? Your boss won’t spring for an off-the-shelf database, the company’s firewall prevents you from searching for what you need online, and the summer isn’t long enough for you to build a full-fledged database from scratch. To complete your task, you decide to create a hash table, a data structure that enables you to use keys to store and retrieve items. You’ll experiment with different hash tables methods, including chaining, open addressing, and quadratic probing. When you’re finished, you’ll have hands-on experience creating a functional hash table you can use to build Ginormous Megadata’s phone directory, as well as a solid understanding of the trade-offs between different kinds of hash tables.

Problem-Solving with Recursion

1 week · 2-4 hours per week · BEGINNER

You’re an avid chess player who’s asked by Alexis, a fellow chess club member, “How many queens can you place on a chessboard without any of them being able to attack any of the others?” To discover the answer, you’ll write a recursive program that will enable you to examine all of the possible queen arrangements. You’ll start with simpler functions, including calculating factorials and Fibonacci numbers, to warm up your recursive brain muscles. Then, you’ll advance to solving the knight’s tour problem, the Tower of Hanoi puzzle, and finally, the N-queens problem—the one that will satisfy Alexis’s curiosity. When you’re finished, you’ll have elevated your recursive function game by solving well-known problems and learning important techniques along the way.

Linked Data Structures

1 week · 4-6 hours per week · BEGINNER

Play the role of chief guest engagement officer at an amusement park. You’ve decided to model the visitor experience by using a queue data structure to simulate guests waiting in line for a ride. The park’s sales and marketing department would also like you to study what might happen if VIP (very important pocketbook!) visitors are allowed to jump to the front of various park attraction lines using a special pass. As you carry out these tasks, you’ll experiment with different types of queues, write a function to detect loops in a linked list, build a queue using a doubly linked list, and create trees, fundamental data structures in many algorithms. When you’re done, you’ll have the experience and skills you need to build a complete waiting-customer model and other programs using linked data structures in Go.

Sorting and Searching

1 week · 4-6 hours per week · BEGINNER

There’s a lot of buzz about the Bug of the Month club you started, but the fly in the ointment is that a few customers aren’t paying their bills on time. You have no choice but to halt their monthly shipments of fine insect-based foods. But to do that, you must first identify the delinquent customers. Using three different Go sorting algorithms—bubble sort, quicksort, and counting sort—you’ll sort your list of customers by balance owed. Once your data is sorted, making it easier to search, you’ll implement a linear search as well as a binary search to locate the non-paying culprits. When you’re done, you’ll have firsthand experience implementing widely used Go sort algorithms and search methods and a firm grasp on their performance.

Six Small Algorithm Projects with C#

6 weeks · 4-8 hours per week average · INTERMEDIATE

Algorithms make the world go round! In this series, you’ll wear six different hats in six diverse projects that spotlight algorithms in a wide range of applications. You’ll build task-scheduling tools, draw organizational charts, and dive into fractals. Throughout this series of liveProjects, you’ll go hands-on to discover a variety of algorithmic techniques, including recursive data structures, image processing, and finding shortest paths. When you’re finished, you’ll have practical experience that you can use to solve real-world problems.

Fractals

1 week · 8-10 hours per week · INTERMEDIATE

Take a trip into the fascinating world of fractals! Here, you’re an art director for a documentary on the 1960s psychedelic movement. Your goal is to wow your audience with a mind-bending title image—a perfect application for fractals. You’ll build programs that create fractals by drawing lines recursively, create ghostly multi-dimensional shapes, and draw escape-time fractals using the Mandelbrot set (the most popular fractal in the world).

Work Assignment

1 week · 4-6 hours per week · INTERMEDIATE

Maximize productivity with maximum flow algorithms and some basic C# programming. You play the role of a nuclear power plant operations manager. Your challenge is to assign jobs to your group of employees, and your goal is to achieve maximum productivity. You’ll build a program that generates networks for testing maximal flow algorithms, as well as a program that finds maximal flows through a network of capabilities. Then, you’ll put your maximal flow program to work to match employees with jobs while ensuring that as many jobs as possible are completed.

Image Processing

1 week · 6-8 hours per week · INTERMEDIATE

A picture says a thousand words, but make sure they’re the right ones. Today’s cell phones come with amazing digital cameras, but without a guarantee that you’ll never take another bad picture. Learn to use image processing algorithms, geometry, point operations, and filters to transform images by adjusting brightness, contrast, color, size, and shape. You’ll also create interesting effects such as highlighting edges, embossing, and blurring.

Scheduling

1 week · 4-6 hours per week · INTERMEDIATE

Enter the realm of project management: your job is to oversee the construction of a castle, ensuring that the project is completed on time. Many of the tasks in the schedule are dependent on other tasks, and some will inevitably fail to be done by their due dates, risking the delay of the entire project—and the wrath of the Evil Overlord. To prevent this catastrophe, you’ll perform topological sorting to determine which tasks can be scheduled, use the critical path method to find out which tasks will be delayed by the delay of another task, and build PERT and Gantt charts to see critical paths and task dependencies in a visual way.

Shortest Paths

1 week · 6-8 hours per week · INTERMEDIATE

The shortest distance between two points…is the most cost-effective. You’re the fleet manager at APS (Acme Parcel Service), a company whose fleet of thousands of trucks drives more than 10 million miles per year. Your goal is to write a program that finds the shortest path between stops, shaving a few percent off the total mileage—and scoring points with your CEO. You’ll learn to store networks in files, draw networks in WPF, test your networks, select start and end nodes, and find the shortest path between them using shortest path algorithms.

Trees

1 week · 8-10 hours per week · INTERMEDIATE

Exciting things are happening at Generigloop, and the senior vice executive’s undersecretary needs help keeping things organized. They’ve asked you, their junior assistant, to create a tool for drawing organizational charts. Seizing the opportunity to impress—and learn valuable skills while getting paid—you volunteer to research what it will take to create a chart-drawing tool using Python and C#. You’ll learn techniques for drawing family trees, hierarchical component diagrams, document hierarchies, and other tree structures.

Six Small Algorithm Projects with Python

6 weeks · 6-8 hours per week average · BEGINNER

Algorithms are the foundations of computer science. In this series of liveProjects, you’ll learn how to use specific algorithms to solve some important programming problems. You’ll learn how to use recursion to draw complex shapes, search linked data structures, and layout and draw trees. You’ll learn how to use network algorithms to find shortest paths and assign employees to jobs. Tackle all the projects in this series, and you’ll get useful hands-on experience with a variety of algorithmic topics, data structures, and general programming techniques.

Image Processing

1 week · 6-8 hours per week · BEGINNER

In this liveProject, you’ll use the Python Imaging Library (PIL) to tackle common image processing tasks. You’ll learn about some of the algorithms that let you apply filters to images, and you’ll use PIL to adjust image brightness, contrast, and color tone. You’ll crop, rotate, reflect, and perform other geometric operations on images.

Work Assignment

1 week · 4-6 hours per week · BEGINNER

In this liveProject, you’ll utilize Python and maximal flow algorithms to create an application that can match jobs with the correct workers. Running all the possible combinations of jobs and workers with the correct skills would be impossible to scale manually, but is easy to do with Python. You’ll start by finding the maximal flows in your network, then quickly move on to creating a program that assigns jobs based on your algorithm.

Fractals

1 week · 8-10 hours per week · BEGINNER

In this liveProject, you’ll use recursive and non-recursive algorithms to generate fractals for graphic design. Fractals are shapes that have fractional dimensions and can produce very beautiful and interesting visualizations. You’ll start by exploring recursive line-drawing fractals, move on to strange attractors, and finish up with escape-time fractals.

Scheduling

1 week · 4-6 hours per week · BEGINNER

In this liveProject, you’ll take on the role of a project manager for a construction company and utilize Python to help schedule your construction’s tasks. You’ll utilize tried and tested methods like topological sorting, PERT charts, and Gantt charts to create a task scheduling tool that can both track deadlines and automatically update delivery dates for when deadlines are missed.

Shortest Paths

1 week · 6-8 hours per week · BEGINNER

In this liveProject, you’ll use Python algorithms to help find the shortest path between stops for a fleet management company. With trucks driving over 10 million miles per year, even slight time saving can be a huge cost reduction. You’ll build network classes, save, restore, and draw networks, use network algorithms to find shortest paths between locations, and lay the groundwork for future network applications.

Trees

1 week · 8-10 hours per week · BEGINNER

In this liveProject, you’ll use Python and algorithms that work on binary and N-ary trees to sort data and draw organizational charts. You’ll store, find, and remove data in sorted trees, and you’ll experiment with different layout approaches for organizational charts.