Spotlight: Jay Wengrow (Author) Interview and AMA!

Jay Wengrow

Author Spotlight:
Jay Wengrow (@jaywengrow)

Jay Wengrow founded Actualize, a Chicago-based coding boot camp. We recently sat down with the author of A Common Sense Guide to Data Structures and Algorithms and A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1 to chat about the bread and butter work of developers and why it’s important to break academic conventions and translate complex concepts into plain English that everyone can read, understand, and (importantly) use in their work day.

This is also an AMA. Everyone commenting or asking a question will automatically be entered into our drawing to win a copy of either edition of A Common Sense Guide to Data Structures and Algorithms!

1 Like

Hi, please introduce yourself.

Hello, my name is Jay Wengrow. Among other things, A Common Sense Guide to Data Structures and Algorithms…<pause, laugh>…in all its various editions.

What do you do when you’re not writing books?

I’m the founder and CEO of a coding bootcamp called Actualize. Our headquarters is in Chicago, where I also reside. We’ve been in operation since 2014. For a long time, we provided in-person classes and later introduced an online live version of our course in 2017. Due to Covid, we only offer the online course now, which has been running smoothly. As the CEO, I handle the operations and management of the bootcamp.

Tell me about your book.

The book came from the bootcamp. A bootcamp always has a lot of material. We cram a ton of information into a short four-month timeframe. There’s always so much to teach, and we struggle with what to include and what to leave out.

Data structures and algorithms are important in Computer Science but not necessarily the first thing new programmers need to learn. We touch on them briefly in the bootcamp but don’t go into depth. However, it’s still important for programmers to understand these concepts because it helps them level up their programming.

Knowing data structures and algorithms helps them write faster code, more elegant code, more space efficient code. In the bootcamp, our main focus is on helping students quickly acquire the skills they need to secure employment as programmers - by writing working code. When it comes to pushing their skills further, that typically happens once they are actually working in the field.

As a result, we don’t delve deeply into that aspect. However, there were a few students who wanted to learn more about it. They mentioned that they had trouble finding resources that addressed this topic clearly. So, I took it upon myself to create a small manual that would teach them the basics of data structures and algorithms, enough to get them started. I opened a Google Doc and began writing. And I kept on writing, adding more and more content as I went along.

Before I knew it, I had a hundred pages of content. And this is what we gave out to students. At some point, it occurred to me, like, Hey, this is a lot. This could be a book. It’s a hundred pages long.

So on a whim, I decided to send a proposal to my favorite publisher, the Pragmatic Bookshelf. I’ve always found the books to be of amazing quality. They were the first and only publishing book company that I submitted the manuscript to. I’m fortunate that they said, “Yes, this has potential.” They also said, “But…we definitely cannot use the content as is, it has to be totally rewritten according to our standards. But we like the idea.”

Honestly, having to rewrite the book according to their standards was the best thing that could have happened. It became a lot better after going through the editorial process. The editors I worked with at PragProg have been great. In 2017, we released the first edition of the book titled A Common Sense Guide to Data Structures and Algorithms. Admittedly, it has a very long title .

I’m grateful that it was popular. A few years later, we decided to do a second edition. The second edition is not a sequel to the first edition, it’s just a new edition of the same book. However, it does have roughly twice the amount of material as the first book. The first book was roughly 250 pages, and the second edition is close to 500.

In the second edition, I made several changes. Firstly, I worked on revising and enhancing the existing material. Secondly, I added over 200 additional pages of content. This includes new chapters and topics in the book. Moreover, we introduced exercises at the end of each chapter and provided solutions to those exercises at the back of the book.

The second edition was released in 2020, with positive reception. I added a note at the end of the preface, inviting readers to connect with me on LinkedIn, and many have taken up that offer. It’s been a fortunate experience to receive what I call “fan mail” from people around the world who have found me on LinkedIn and reached out to share kind words appreciating the book.

Tell me about the book

If you’ve ever read a textbook or any book about data structures and algorithms, you know it can be confusing. These books are filled with mathematical formulas that can be difficult to grasp unless you have a background in math.

But it’s not just about the math. Even the regular text, the regular prose is obtuse and hard to understand. And even for me, I have a certain amount of familiarity with this topic and I get frustrated reading these books. I have to read and reread, you know, even the same paragraph many times in order to start to have an inkling of what they’re talking about.

My background is not just in computer programming, but also in education. I have master’s degrees in both of those areas. My specialty is taking complex concepts and breaking them down into plain English step by step. That’s the whole premise of this book.

I take complex concepts, namely, data structures and algorithms and explain them in plain English. These concepts are not actually complex; people think they’re complex because they read books that discuss them in a complicated manner. People are easily intimidated by these topics. In reality, any complex concept can be broken down into simpler concepts that are easily understood. That’s why the book’s title refers to it as “common sense”.

I take complex concepts, namely, data structures and algorithms and explain them in plain English.

When discussing with the editors at PragProg, we grappled with a question: what language should the book use? There is a substantial amount of code, code snippets, and code samples within the book, and we need to decide what language to use.

The concepts of data structures and algorithms are not limited to a specific programming language. They are universal concepts that apply to almost every language. We had a discussion about this - if we use a specific language like Python, we didn’t want it to become just a Python book. We didn’t want people to think, “Oh, this is only about Python.” Because again, the topics are universal to all programming languages.

What we did to deal with this was to use multiple languages throughout the book. We chose three languages - Ruby, JavaScript, and Python. We alternate between them by chapter and sometimes even within the same chapter. This is to convey the message that these concepts are universal across all languages and to show how they can be applied across multiple languages.

However, we received a lot of feedback from people who liked the book but preferred it to be written in a single language. People want it to be in their language, that is, the language they personally use. But more importantly, they also want it to have a consistent language, without the need to mentally switch between different chapters.

Now, most of these languages are similar, and I tried to write the code in a similar style, despite using multiple languages. However, the feedback made sense, so now we’re creating three new editions of the same book. These will be three different versions of what I’ve been referring to as the second edition. From now on, I’ll call it the polyglot edition.

The polyglot edition involves multiple languages. We’re creating three language-specific editions of the polyglot book. One of them is in Python, and it’s almost done. There will also be a JavaScript version and a Java version, choosing the three most popular languages out there.

Java was not present in the polyglot version. However, we are now going to have three special versions: Python, JavaScript, and Java. The text of the book is mostly the same, almost identical, except for the code snippets which will be exclusively in each language for each respective book. Some of the text, particularly the part that explains the code, has to change accordingly.

Those are the three new editions of the book that are coming out. However, there’s another book coming out, which is the sequel. So besides these three additions with Java, JavaScript, and Python, we’re now calling them Volume One. I am now writing a sequel called the Common Sense Guide to Data Structures and Algorithms Volume Two, which continues from where volume one left off. However, this book will first come out as Python-specific.

The topic of data structures and algorithms is truly infinite because computer scientists are continuously discovering, developing, and designing new algorithms every day. There is a lot to discuss in this area. Although we covered data structures and algorithms extensively in the original volume one with 500 pages, there is still much more to discuss.

I’ve started writing and I’m already in the middle of the seventh chapter of Volume Two. It’s going even better than I had hoped, flowing nicely. I’m really excited about it. The plan is to make Volume two in Python first, and then have JavaScript and Java editions of the same book. Whether there will be a Volume two of the polyglot edition is still unknown. There are a lot of different editions and volumes happening here, and I’m working on multiple ones simultaneously, which is a lot of fun.

What is the philosophy behind the topics you covered? I see practical and useful things. These are things that anyone in the coding field will touch on daily. How did you decide and make sure to include everything that everybody needs to know for Volume One?

One of the initial challenges I faced in writing Volume one was that the classic data structures and algorithms textbooks out there, although, you know, besides being hard to understand, are also written very theoretically. It’s all theory. They don’t really explain how to practically use all this stuff or how it impacts a programmer’s daily work.

It’s all theory. They don’t really explain how to practically use all this stuff or how it impacts a programmer’s daily work.

When I wrote the 100-page Google Doc, it was also along those lines. It was really just to give them the theory. But Prag’s book philosophy, which I really appreciate and now run with, is that everything needs to be useful and impact your day-to-day work and make it better. At the same time, I also wanted the book to be a supplement and to help people who are in university and college using those obtuse textbooks. They have to because they’re assigned to them in the course.

I wanted the book to align with those concepts. I own many data structures and algorithms textbooks. Going through them, I got a sense of the biggest concepts covered in the introductory courses to data structures and algorithms in both the textbooks and university courses.

I mapped out and wrote a list of the big concepts: arrays, hash tables, linked lists, and various algorithms associated with them. Also, graphs and classic algorithms like Dijkstra’s algorithm. I knew I wanted to cover all the classics typically taught in a university course and tie them to practical use.

Let’s take bubble sort for example - you never want to actually use it in real life. So I wanted to teach bubble sort since it’s necessary to learn it in university courses and I wanted to explain it so people could understand it.

The trick I had to figure out was how to cover all the classic topics but make everything practical. I have a chapter dedicated to bubble sort, but the takeaway from that chapter isn’t about bubble sort itself, but rather using it as a springboard to explain concepts involving Big O notation that are practical and day-to-day use of Big O.

The trick I had to figure out was how to cover all the classic topics but make everything practical.

In choosing these topics, I wanted to make sure I covered the classics and tie them to practical use. I don’t cover topics just for the sake of it being a classic; there’s always a way to apply them to regular day-to-day programming.

How did you get from big concepts to the wonderful small examples in your book?

A lot of the work I do in creating these books and in the work I do in my bootcamp is identifying complex concepts and breaking them down into simpler components. I have a knack for that. While I don’t have an exact scientific method, I can see how complex concepts can be broken into parts. Even when I break it down, I also have to decide what order to teach the parts in.

Sometimes one of the four simpler concepts may require you to already know one of the others. It’s a big prerequisite game. This frustrates me about more obtuse classic textbooks: they often don’t explain the prerequisites for many concepts. Later, in the book they will explain a particular concept, but it was already referenced earlier without being explained. You end up turning pages back and forth. I try to identify from the outset not only the simplest concepts, but the order in which they should be taught.

When I take a simple concept, I try to find the ultimate simplest example to get it across. For example, if I wanted to teach big O notation, I’d deliberately find the simplest example to demonstrate it. Why use a complex example to teach the simple concept?

If I can use a simple example to teach a concept, the example must be good enough to cover the concept. I don’t want to leave anything out. I always try to determine the best example for each concept. For example, when discussing dynamic programming which can be a complex topic, I don’t choose the first one that comes to mind. Instead, I identify multiple examples and select the simplest one for my audience to relate to. If the example requires a certain prerequisite, I make sure to cover that beforehand.

Do you have a specific audience?

There are a few distinct audiences with a lot of commonality between them: practicing developers, wannabe developers, those who completed boot camps, and university graduates looking for their first job. Knowing all the concepts from this book won’t make or break someone’s career, but it will certainly make them a better developer.

I’m teaching anyone who is not yet familiar with these concepts. A lot of people know they should learn it. So I’m writing to a wide array of people - from those who’ve been coding for 10 years to those who have just learned to code. Even if someone has graduated from a course or bootcamp, I try to make sure the language is accessible to all.

Self-taught developers may not have encountered many of these concepts, as it’s possible to start a career without them. However, it’s important that people come back to them, allowing them to write more efficient code.

How does the second set of books relate to the first?

It’s a true sequel. I could have written the same material but the same material in a cookbook fashion. However, as I speak I’ve been doing my research on these topics and have begun outlining and writing. There are still fundamental concepts that I didn’t cover in volume one. Perhaps they’re not quite as fundamental as the concepts in number one, given that there are a lot of people who know them. But these concepts in volume two are still foundational. I’m only about sixty to seventy pages into volume two as of this moment.

So far, everything has been foundational. However, I have found it easier to write Volume Two because, as I will explain in the preface, I am expecting that readers are familiar with Volume One or have read it. Writing the first half of Volume One is difficult because I have to take the reader from zero knowledge to a level of understanding the fundamental concepts in the most understandable way.

To take someone from 60 to a hundred is easier. It’s a lot of fun to write because it’s like, I know they already have the basics down now so we can do some more advanced, fun things. However, many of these topics are still fundamental. Can someone still be a great programmer without reading volume two? Sure. But if they want to learn some more advanced but still fundamental things, they should head over to volume two.

To take someone from 60 to a hundred is easier. It’s a lot of fun to write because it’s like, I know they already have the basics down now so we can do some more advanced, fun things.

Currently I’m writing a chapter on caching, which is a fundamental concept. My list of upcoming chapters includes topics like randomized data structures, such as tries. I’ll be introducing tries with red-black trees, a non-randomized version of a similar data structure. We’ll use tries to show how randomization can improve upon red-black trees in certain areas. I also plan to cover Monte Carlo algorithms and probabilistic data structures. I’ll definitely be touching on NP-complete and NP-hard problems and how to handle them. I’ll also cover external memory algorithms and B-trees.

The final part of the book may be more of a “cookbook kind of thing,” but I think I’ll figure out how to make it go more smoothly by the time I get there. I want to cover a lot of areas within strings, like the Rabin-Karp algorithm and explain how regular expressions work under the hood. I also want to cover important concepts in graphs, like minimum spanning trees, topological sorts, and bipartite matching. Maybe I’ll talk about data compression and definitely introduce the idea of parallel algorithms. Those are some of the things I have planned.

You are not legally bound to anything you just said,

I hope not.

What do people get out of the book’s exercise?

There’s a big difference between sitting back and listening to a lecture and applying those concepts. We use this in the bootcamp by alternating between teaching with lecture and instruction, and exercises or labs, as some people call it.

In the bootcamp, we understand that talking at you and teaching a concept is only the first step; to really understand it, you have to apply it yourself. That’s the philosophy behind the exercises. They’re not asking you to repeat what was just said but rather to apply the knowledge in the real world.

So, it’s not recall, it’s synthesis?

There you go. That’s the educational way to say it. That’s the philosophy. Sometimes I use exercises to teach a concept that I didn’t deem important enough to cover in the book proper. But I think it might be kind of cool. I allow them to discover something new and then I explain the solution, saying, “Hey, you just discovered this other algorithm! It wasn’t something I considered fundamental to cover in the book, but it allowed them to discover something new for themselves.”

How do readers evaluate their progress and growth?

Exercises are a good way to evaluate your understanding of a concept. You can use them to synthesize what you know, and if you get through them that’s a good sign you understand it. If you don’t, it’s a chance to assess what you don’t understand. The book also has a useful index to look up concepts you remembered while working on a project.

Exercises are a good way to evaluate your understanding of a concept. You can use them to synthesize what you know…

Some people have told me they’ve read the book more than once. I never understand how people read novels more than once when they already know the ending. But people like doing that. People have also told me they reread textbooks and programming books, since there are no spoilers.

People may want to do this for a few reasons. First, they could go through the book once and get something out of it. Going back to it a second time will give them a better understanding of the material since the concepts will be somewhat familiar. It could also allow them to understand the content on a deeper level.

What are some of the nicest and some of the most unexpected feedback you’ve gotten from readers?

I am grateful to readers, especially if they like the book. I have received some really nice messages from people who were at first intimidated by concepts - they had attempted to learn them and failed. After reading my book, they said they understood it - and they found it wasn’t so intimidating after all. Sometimes I get messages from students saying I only got through my class because of the book - I love that kind of feedback.

What are the qualities of good instruction?

A lot of it relates to breaking down complex concepts into their simpler components. Often, people don’t realize that or teachers don’t consider this. They just teach the complex concept as is without breaking it down, which can make it hard for some people to understand. Therefore, breaking it down into simple concepts is important. Similarly, the order in which you teach the concepts is crucial. I recall one of my university professors teaching design patterns: he would teach a design pattern first and then afterwards explain the problem it solves.

The order in which you teach the concepts is crucial.

I thought to myself, “You could have said all the same words in a different order - explain the problem, then teach the design pattern and how it solves the problem.” But they didn’t. Also there are a lot of big pieces when it comes to in-person or live instruction such as charisma, engagement, humor, etc.

In my book I try to inject humor. I’ve gotten good feedback from people appreciating that. The Prag editors have tried to contain me and some of those things as they have said I’ve gone off the rails with the humor, they tell me to “Keep it textbook please.” But I try to sneak in conversational elements to make it more engaging.

It’s obvious when you open the book that there are lots of diagrams and visuals to help with understanding. Visualization is key in my mind, since people often find concepts easier to understand when visuals are present. In my diagrams I break concepts out into individual diagrams, rather than cramming multiple concepts into one. So if I need to demonstrate five different points, I’ll provide five different diagrams.I 'm not going to try to throw it all into the same diagram where it’s hard to understand what’s going on.

I use diagrams to walk through all the algorithms in the book, not just pros. I also use code. But I go the extra mile and provide a diagram for each step. Whereas other authors might give just a few steps followed by an expectation for readers to understand the rest - I make sure I’ve gone through the entire algorithm and provided as much clarity as possible. I err on the side of writing too much if it helps people understand. Even if they could have figured it out themselves, if they want extra visualization I’m going to give it to them.

So visualization is another big piece.

What do you do with yourself when you are not teaching or writing?

I’m very fortunate to have five children ages 16 and under. That’s enough to keep me busy. I do like escape rooms, but don’t get to do that as often as I’d like. I also help out with community projects, and am involved with different communal aspects.

How can people keep track of what you’re doing and what you’re up to?

I’m pretty introverted, a bit closed off. I’m not the type to document my every move on Insta Story, but I do use LinkedIn. I invite readers to connect with me there and use LinkedIn occasionally to announce things. I don’t like to overpromise and underdeliver. That’s why I won’t blast out about upcoming editions until they’re on the cusp of emerging. If you want to find out what I’m doing in advance, it’s harder, but if you want to learn about what I’m doing as new books are almost ready, LinkedIn is a good place.

Thank you!


Drop any questions or feedback you have for Jay Wengrow (@jaywengrow) into this thread. Everyone commenting or asking a question will automatically be entered into a drawing to win a copy of the original A Common Sense Guide to Data Structures and Algorithms or A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1 ebook!

If you don’t want to wait, you can pick up your copy of A Common Sense Guide today!

Don’t forget you get 35 percent off with the coupon code!


Hi Jay,

First of all, I want to express my gratitude for your excellent work in crafting these books. I had the pleasure of delving into your first book through O’Reilly and found it truly captivating.

A significant portion of our community members here at DevTalk has come from ElixirForum. I’m curious if you have any plans of writing Elixir edition of your book?


Excited for Volume 2 :slight_smile:

1 Like

What’s the difference between versions P1.0 and P2.0? I’m seeing this in " A Common-Sense Guide to Data Structures and Algorithms, Second Edition" release section:

* P2.0 2023/09/28
* P1.0 2020/08/13

Contents changed/added/removed?


Will you consider to mention some of those very practical implementation of algorithm like timsort?

I often hope there would be a data structure book using the data structures libraries to talk about how the program is designed in the actual implementation we use, rather than some high level concepts.

1 Like

Hi! For right now, the language-specific editions planned are Python, JavaScript, and Java. While I don’t have an Elixir book planned at the moment, I wouldn’t rule it out as a future possibility.



Thanks! I’m excited about it too, lol. In the middle of Chapter 7 right now :grin:


P2 has fixed some errata. Otherwise it’s the same book.


Hi Jay,

Great interview and I look forward to some new additions to my pragprog library!

Re: Elixir (I’m from ElixirForum too…) - I’m guessing that immutable data would make some of the data structures & algorithms a bit more “interesting”.


does the book cover amortized analysis?

1 Like

Great interview!
With increasing focus on sustainability do you cover the consumption implications of using different algorithms?
F.ex for use in IoT devices that might run on batteries or with limited CPU or memory capacity.

Looking forward to hopefully read it this year, sounds very interesting!