Board Games as a Framework for Computer Science Education

Board Game Academics, March 2025
Published in Vol 2.
DOI: https://doi.org/10.70380/vmrgi25po.

Stephen Hall
Computer Science & Engineering Librarian
University of Pennsylvania

INTRODUCTION

I was a gamer long before I was a programmer. A decade before I wrote my first “Hello World,” I was playing Power Grid, Puerto Rico, Nexus Ops, and the like. In those days, I attended regular gaming meetups, which helped connect me to other hobbyists in my area. This was around 2008 — a time when board games were still a quirky, hipster hobby — but it did not take me long to realize that a huge percentage of my gaming buddies worked in a very specific kind of job. They were from the “T” and “E” of “STEM,” working as engineers, computer scientists, and software developers.

Initially, I attributed this to the fact that Tucson, Arizona, where I lived, is home to aerospace giant Raytheon Missile Systems. With a gaggle of geeks on their payroll, it made sense that a geeky pastime might have become prevalent in the local community. As my exposure to the board game hobby grew, however, I realized that this connection was not isolated or unique to Tucson.

I could not understand why there was such a strong overlap in the Venn diagram of gamers and tech/engineering folks, and for two key reasons:

1. Board games are a fairly universal activity. Most everyone has played at least a few in their lifetime, and by the law of averages, I would not expect them to appeal more to any one type of person than another.
2. Board games are inherently non-technological.¹ Why, then, would people whose work is so technology-forward be especially interested in them?

It was not until I started learning to code that it hit me: Board games and computers operate on very similar logical principles. While an obvious distinction exists between their analog and digital modalities, both board games and computers function in terms of algorithms and rule-based systems. Once I had this realization, my entire outlook and understanding of computer science (and board games) changed. Of course people from the tech/engineering world would have an affinity for board games — their work is all about problem-solving, optimization, and efficiency! As anyone who has played a Eurogame knows, these are all key aspects of strategy games.

Being a gamer proved invaluable in my study of computer science. While programming initially felt arcane, confusing, and frustrating, putting it in terms of tabletop games made it make sense in a whole new way.

HISTORY

The parallels between board games and computer science are long-standing and remarkable. This is perhaps unsurprising when one considers famous human-versus-machine matchups like those of Garry Kasparov and Deep Blue or Lee Sedol and AlphaGo, but the connections extend far beyond these.

For decades, computer scientists have recognized board games as a strong framework for studying topics like artificial intelligence and game theory. In 1959, Arthur Samuel, considered by many the father of machine learning, wrote “A game provides a convenient vehicle for such study as contrasted with a problem taken from life, since many of the complications of detail are removed.”

Among the earliest examples of board games in computer science is Alan Turing’s 1948 chess program, Turochamp. Due to technical limitations of the time, Turochamp was not actually run on a computer; rather, it was written on paper and executed manually. Though crude in form, this program showed that a computer could, at least in theory, be taught to play chess (Stezano).

Around the same time, other computer scientists were independently exploring games. Arthur Samuel, working at IBM, developed a checkers-playing program that learned strategy from repeated plays (Samuel; “The Games”). Likewise, Claude Shannon, known today as the father of information theory, built a chess-playing machine (Shannon; Soni), and IBM’s Alex Bernstein wrote the first complete computer chess program in history (Deep Blue).

These pioneers foresaw the application of such inventions to other non-game tasks, many of which have since become commonplace for computers. As one author put it, “The idea that games could seriously model aspects of the real world was central to early computer science” (Hsu).

Chess, in particular, continued to be closely studied by computer scientists for decades thereafter. As new hardware improved machines’ ability to look ahead at potential moves, and as better heuristics were woven into their underlying algorithms, chess programs became increasingly adept.

This momentum came to a head in the mid-1990s when IBM’s Deep Blue computer famously competed against Garry Kasparov, the world chess champion. At their first meeting, in 1996, Kasparov lost the opening game but went on to win the overall match, four games to two. The following year, however, a rematch took place in which an improved Deep Blue prevailed. Afterward, Kasparov said, “I have to pay tribute. The computer is far stronger than anybody expected.” Indeed, Deep Blue had remarkable processing power and could evaluate up to 200 million board positions per second (Deep Blue).

In the half-century between Turochamp and Deep Blue, teams from major universities and laboratories were developing their own chess programs and competing against each other (Hsu). It should be noted, however, that chess was not the only game being studied at this time. In 1992, IBM researcher Gerald Tesauro developed a backgammon program called TD-Gammon. One of the earliest examples of a neural network, TD-Gammon competed at the 1992 Backgammon World Cup, winning half of the 38 games it played, a better performance than any other backgammon program of its day (“The Games”). Around the same time, simpler games were being solved outright, including Connect Four, Qubic, Nine Men’s Morris, and Go-Moku (Gasser).

Particularly after Deep Blue bested Kasparov, computer scientists began to turn their attention more broadly to machine learning and to studying the ancient game of Go (Hsu).² Building on the mid-century work of pioneers like Arthur Samuel, they sought to create programs that would play Go, but not in the way Deep Blue had played chess. Rather than relying on brute-force algorithms, they aimed to develop programs that would learn strategy from repeated plays and become better. This approach was especially important in the case of Go, a game with strategic depth far surpassing that of chess.³

By the early 2010s, great interest was brewing in the subfield of deep learning. This would lead to the now-famous AlphaGo tournament, which to many felt like a sequel to Deep Blue, another highly-publicized display of computers’ ability to master the seemingly unmasterable. In this tournament, Google DeepMind’s AlphaGo program played a five-game match against Lee Sedol, widely considered the best Go player in the world. AlphaGo won the match four games to one (AlphaGo).

Up to this point, the games computer scientists had studied had been quite narrow in scope. They were almost exclusively two-player abstract games, largely deterministic, and with perfect information. As machine learning became more widely understood and accessible, and with Go having been well studied and the top human players defeated, researchers expanded their focus to other kinds of games.⁴,⁵

Games involving elements like bluffing, negotiation, and imperfect information presented new types of challenges as they dealt with more emotion-driven, human aspects like hunches, dealmaking, and trust/distrust. (Needless to say, these are difficult to quantify in terms of pure math and logic.)

In recent years, large tech companies like Google and Meta have built AI agents that can play games such as Hanabi (Bard et al.), Stratego (Perolat et al.), Texas Hold’em (Brown and Sandholm), and Diplomacy⁶ (Kramár et al.). Each of these games presents novel challenges — the implicit communication of Hanabi, the staggering number of possible starting and mid-game states in Stratego, the bluffing and risk-taking of poker, and the allying and backstabbing of Diplomacy — but in each case, the AI agents have performed extraordinarily well, often surpassing even the best human players.

New breakthroughs continue to be made for other long-standing challenges, as well. In late 2023, a computer scientist solved Othello (Takizawa), a task long seen as a grand challenge in the field. About a month later, researchers at DeepMind found a previously unknown solution to the so-called “cap set problem” inspired by SET, a game long studied for its applications to combinatorics.

Side By Side

While board games have traditionally been used as a framework for high-level computer science research, they are also uniquely well-suited as a learning tool for beginners. For someone just starting programming, it is easy for concepts to feel abstract and confusing. If they are understood in terms of board game mechanisms, however, core computing concepts may well feel more familiar and understandable.

Consider the following comparisons of programming concepts to game rules/mechanisms:

Programming Concept	Board Game Equivalent/Example
(Pseudo) Random number generation	Rolling a die Drawing a card Spinning a spinner
Variables/Counting variables	Player scores Hit points Influence tracks
Conditionals	“If at any time, three of the five face-up cards are Locomotives, all five cards are immediately discarded and five new ones are turned face-up to replace them.” (Ticket to Ride, Days of Wonder, 2004)  “If the investigator passes the Combat check, he defeats the monster… If the investigator fails the check, the monster deals its combat damage to him.” (Arkham Horror, Fantasy Flight Games, 2005)
Loops	Game loop (the ongoing cycle of a game, which repeats until the game ends) “While a race is in progress — and before ‘No more bets!’ is called or a horse reaches the finish line — players may place each of their Bet Tokens…” (Ready Set Bet, AEG, 2022) “For each of the 4 Resource districts… count how many game pieces each player has. The player with the most in that district scores 3 Victory Points.” (Tekhenu: Obelisk of the Sun, Board&Dice, 2020)
Booleans	Game states (e.g. stone is/is not surrounded in Go, worker space is/is not available in Agricola, etc.) “A player is eliminated if both of the following conditions are true: None of his units are on the board He does not have enough rubium to purchase more units” (Nexus Ops, Fantasy Flight Games, 2012)
Mathematical comparison	“Roll a number of dice equal to your Might. Your opponent does the same. Whoever rolls a higher result inflicts physical damage to the other explorer or monster.” (Betrayal at House on the Hill, Avalon Hill, 2010) “Count the building tiles in each of the hotel chains involved [in the merger]…  The smaller hotel chain has been acquired, and its building tiles are now part of the larger chain.” (Acquire, Renegade Game Studios, 2023)
Classes/Instances	Each player can be thought of as an instance of a “Player” class, with characteristics like a score, a hand of cards, etc. A board or player tableau might also be an instance of a class, with its own functions for updating the game-state.
Functions	Actions a player can take (usually involving their own sub-processes) Steps followed for updating a game-state
Program code	Game rulebook (the skeletal framework of a game system)
Executing the program	Playing the game (the actions/decisions that give life to the rules framework)

When examined side by side, it becomes clear that many or most foundational programming concepts (even the more abstract ones) also appear in board games. As such, anyone who plays board games has likely interacted with these principles, even if they did not realize it. When learning to code, framing concepts in these terms can be immensely helpful, as it puts them in a familiar, understandable context.

OTHER APPLICATIONS OF BOARD GAMES IN COMPUTER SCIENCE

Beyond a side-by-side comparison of programming concepts to game mechanisms, board games have other notable applications in the study of computer science.

Game rulebooks, for instance, present a wealth of resources for new programmers. By their very nature, rulebooks are written (or should be, at least) in a highly technical style, and they are frequently sectioned off the way a well-structured computer program might be, divided into defined blocks of instructions according to specific functionalities. Just as new programmers might study conditionals by coding Rock-Paper-Scissors, they can explore other logic structures by trying to express game rules, in whole or in part, as code/pseudocode.

Take, for example, the following pseudocode, which outlines the logic for resource distribution in Catan:

result = roll_dice()

if result == 7:
     for player in game:
          if player.hand_size > 7:
               player.discard(math.floor(hand_size / 2))
     active_player.move_robber()
else:
     for space, token_num on board:
          if token_num == result and robber not in space:
               for player in space:
                    player.gain_resources()

Programming game logic can also be a great way to explore games at an enormous scale. To illustrate, consider the following visualizations, which were created by programs that perform the deductions for the Guess Who?-style game Dinosaur Tea Party (Restoration Games, 2018)⁷:

Figure 1: Results of 50,000 deductions from Dinosaur Tea Party, where questions are chosen at random with the stipulation that they must always reduce the number of remaining possibilities. When played this way, a player may deduce the answer in as few as two or as many as ten questions. The average number of questions necessary, by dinosaur, ranges from less than four to more than five questions. © Stephen Hall

Figure 2: Results of 50,000 deductions from Dinosaur Tea Party, where questions are chosen that will eliminate half, or as close to half as possible, of the remaining dinosaurs. When played this way, a player will reliably reach the answer in four or five questions, with much less variation in the average number of questions per character. © Stephen Hall

The first visual comes from a version of the program that chooses questions at random, with the stipulation that each question must reduce the number of remaining dinosaurs. The second comes from a slightly different version, in which questions are chosen that will eliminate half (or as close to half as possible) of the remaining dinosaurs. When compared, these charts show how different strategies might play out, and they reveal mathematical subtleties about the game that might not be apparent to a human player.

Likewise, the following graphic visualizes statistics for the children’s game First Orchard (HABA, 2009), taken from 10,000 plays⁸,⁹:

Figure 3: Results of 10,000 plays of First Orchard (HABA, 2009). © Stephen Hall

Once again, the data analysis provides meaningful insights about the game by exploring it at a scale far beyond what a human reasonably could.

One key distinction between the analog nature of a board game and the digital nature of a computer program is how much of it can be automated versus how much must be executed manually. When playing a board game, players must generally carry out all in-game procedures by hand, from setup and card shuffling to dice rolling and scoring. In the context of a program — say, a computer game or even a digital version of a board game — many of these operations can be done without the user’s involvement. Perhaps they are visually represented on the screen (e.g., a graphic of a deck being shuffled or a die being rolled), but the actual, logical operations are often carried out “under the hood,” within the program’s algorithms and without user action.

Take, for example, the digital version of Ticket to Ride (Days of Wonder, 2004). In this adaptation, players need not worry about moving their score markers or cycling the face-up cards if three Locomotives are showing, as the program will do these things automatically. This is in contrast to the physical version of the game, in which the onus is on players to remember these steps.

While this distinction may be seen as a counterpoint to the argument that board games provide a strong framework for studying computer science, it actually supports that argument. Since board games force players to carry out each and every in-game operation themselves, this means players execute, step-by-step, the “program” of the game. By performing actions like incrementing score markers, checking game states, and rolling dice, players mimic real computational processes and may, in turn, come to better understand their computer science equivalents.

Another distinction is the inherently discrete nature of board games, which, as Bezáková et al. note, differs from many modern computer games. However, these authors also note that, at least when it comes to basic computer science, “[b]oard games provide a natural context for introductory data structures and algorithms” since “a discrete model fits better with…searching algorithms and data structures ranging through arrays, lists, queues, and graphs.”

At a basic level, a board game can be considered a microcosm of reality, a self-contained world governed by a defined set of rules. Games can simulate things from real life, like supply and demand (e.g., Power Grid), insider stock trading (e.g., Stockpile), military conflicts¹⁰ (e.g., Twilight Struggle), and the spread of disease (e.g., Pandemic). Computers — especially amid the current boom of AI — are likewise being used to model real-world systems like weather patterns, earthquakes, and infectious diseases. Just as a game can simulate and help players understand concepts from the real world, so too can computer models aid in addressing real human challenges.

Board games also encourage algorithmic and computational thinking. In any given strategy game, players are asked to plan their moves based on logical sequences, akin to how a computer operates. In Dominion (Rio Grande Games, 2008), for example, players try to string together as many moves as possible to efficiently gain/lose cards, attack opponents, and increase their buying power. As anyone who has played this game knows, the order in which cards are resolved is often very important, meaning players have to examine their options, considering how different action sequences might play out to maximize their turns.

Shifting to a more abstract parallel, user experience is another key consideration in designing both board games and software programs. In each case, developers should design for accessible and intuitive use, considering questions like:

• If iconography is used, is it understandable and consistent?
• Is information presented clearly and in multiple ways (e.g., using colors and shapes, rather than just colors)?
• Is the interface usable by someone with low vision, color blindness, etc.?
• Are questions easily answered during use? (In a software program, this might mean a “Help” menu, and in a board game, it might mean a rules reference or on-board turn summary.)
• Is all necessary information clearly conveyed, leaving no room for ambiguity?
• Does the overall experience align with what a user expects?

Refining the user experience typically involves extensive, iterative testing, a critical facet of game and software design. The best games, like the best programs, are the ones that have been thoroughly tested for usability and quality. While individual tastes vary, most people would agree that a quality board game should be mathematically balanced and involve meaningful decisions. (Most people would also agree that it should be fun, but what defines “fun” is, of course, more subjective.) Testing methodologies are quite similar for games and programs, typically consisting of multiple rounds of testing, both supervised and unsupervised, using subjects with varying levels of experience and skill.

Furthermore, games are prone to vulnerabilities, just like software programs. Regardless of how much a game is tested, creative and/or chaotic players may find strategic exploits that cause things to break or fall apart in unexpected ways. As a few examples:

• In Scythe (Stonemaier Games, 2016), there are two separate Faction Mat/Player Mat combinations, which, when exploited in a certain manner, have been shown to be overpowered (Stegmaier).
• Shortly after its release, a strategy was discovered for A Few Acres of Snow (Treefrog Games, 2011) that gives the Britain player an extreme edge over the France player (Fritz).
• In the Spiel des Jahres-winning Focus (also called Domination and released by various publishers since the 1960s), ties can be guaranteed in a two-player game if one player simply mirrors all the moves of the other (Wray).

Vulnerabilities are, of course, a key concern in software design, as well. Software developers frequently hire penetration testers to simulate cyberattacks to identify problems. When vulnerabilities are found after a product’s release, developers often respond with new versions or software patches. In the context of a board game, vulnerabilities are generally found as the result of a player employing an irregular strategy or play-style. When such problems are identified, designers or publishers often respond with rules updates or errata, as they did in each of the examples above (Stegmaier; Wallace; Wray).¹¹

Given the numerous parallels between board games and computer science, a great opportunity exists to use games as a tool for computer science education. Though much scholarship exists about computers playing (and sometimes solving) specific games, far less exists about using board games, more broadly, as a framework for teaching programming concepts, computational thinking, etc. This intersection is especially relevant and opportune today as interest grows rapidly in both hobby board games and computer science (Generation CS; Machuqueiro and Piedade).

Several authors have written about using board games in support of a computer science curriculum, and they have consistently found them to be an effective teaching tool (Jordaan; Apostolellis et al.; Bezakova et al.; Drake and Sung; Berland and Lee; Berland and Duncan). Nonetheless, board games remain relatively uncommon in the computer science classroom today (Machuqueiro and Piedade). Given board games’ ability to engage students and improve their understanding of key concepts, instructors should seriously consider applying them in computer science education.

CONCLUSION

The connections between board games and computer science are strong and have deep historical roots. Since the earliest days of computers, games have been understood as a framework for studying algorithms, decision-making, and artificial intelligence. Beyond high-level computing research, however, games are also an excellent tool for beginner programmers to use when learning about computer science.

As interest in computer science grows alongside interest in hobby board games, the two go hand in hand, and computer science students may find it helpful to study them in tandem. Learning about one informs the other, as they share foundational logic principles. Board games provide a unique and engaging framework for computer science, and they will continue to be a lens through which it can be better understood.

---

1. While indeed, some modern games use integrated apps (e.g. Mansions of Madness: Second Edition, Return to Dark Tower), and a handful of old-school kids games involve goofy electronic gadgets (e.g. The Omega Virus, Electronic Mall Madness), these technologies are only in support of an otherwise static, unplugged experience. They also represent only a fraction of the games out there; of the 400,000+ entries in the BoardGameGeek.com database, just over 1,000 are categorized as “Electronic.” ↩︎
2. Go programs existed as early as the 1960s, but they were few and far between, and they could rarely compete with experienced human players (Kurenkov). ↩︎
3.  It is worth noting that this time period also marked the rise of both the internet and modern board games. The debut of seminal titles like El Grande and The Settlers of Catan, as well as the birth of BoardGameGeek.com and board game Usenet groups, helped to fuel a tabletop fervor that has spread throughout the world. ↩︎
4.  Though outside the scope of this article, this also included video games such as Breakout and StarCraft.
   ↩︎
5.  They also continued solving games, including Quarto (Goossens), Pentago (Irving), and even checkers (Schaeffer et al.). ↩︎
6.  Computer scientists had researched AI approaches for Diplomacy as early as the 1980s (Kramár et al.). ↩︎
7. These program files can be found at https://github.com/smhall817/dinosaurteaparty. ↩︎
8. This program plays optimally, such that when the “basket” (wild) result is rolled, the program chooses the type of fruit with the most remaining. ↩︎
9. The program file can be found at https://github.com/smhall817/firstorchard. ↩︎
10. Wargames, in particular, are well loved by a subset of hobbyists who use them to study famous conflicts, understand military tactics, and consider alternate histories/outcomes. ↩︎
11. Game designers and publishers do not always issue official updates/responses when a vulnerability is found. For example, the so-called “starvation strategy” in Stone Age (Hans im Glück, 2008), widely considered an overpowered exploit, does not seem to have ever been formally addressed, and it remains today a thorn in the side of many players. In other cases, like Magic: The Gathering, there are so many possible exploits/vulnerabilities that the publisher maintains an ever-evolving list of “Banned and Restricted” cards (“Banned”). ↩︎

WORKS CITED

AlphaGo. https://deepmind.google/research/breakthroughs/alphago/.

Apostolellis, Panagiotis, et al. “RaBit EscAPE: A Board Game for Computational Thinking.” Proceedings of the 2014 Conference on Interaction Design and Children, ACM, 2014, pp. 349–52. DOI.org (Crossref), https://doi.org/10.1145/2593968.2610489.

“Banned and Restricted Lists.” Magic: The Gathering, https://magic.wizards.com/en/banned-restricted-list.

Bard, Nolan, et al. “The Hanabi Challenge: A New Frontier for AI Research.” Artificial Intelligence, vol. 280, Mar. 2020, https://doi.org/10.1016/j.artint.2019.103216.

Berland, Matthew, and Sean Duncan. “Computational Thinking in the Wild: Uncovering Complex Collaborative Thinking Through Gameplay.” Educational Technology, vol. 56, no. 3, 2016, pp. 29–35.

Berland, Matthew, and Victor R. Lee. “Collaborative Strategic Board Games as a Site for Distributed Computational Thinking:” International Journal of Game-Based Learning, vol. 1, no. 2, Apr. 2011, pp. 65–81. DOI.org (Crossref), https://doi.org/10.4018/ijgbl.2011040105.

Bezakova, Ivona, et al. “On the Efficacy of Board Game Strategy Development as a First-Year CS Project.” Proceedings of the 45th ACM Technical Symposium on Computer Science Education, ACM, 2014, pp. 283–88. DOI.org (Crossref), https://doi.org/10.1145/2538862.2538904.

Brown, Noam, and Tuomas Sandholm. “Superhuman AI for Multiplayer Poker.” Science, vol. 365, no. 6456, Aug. 2019, pp. 885–90, https://doi.org/10.1126/science.aay2400.

Castelvecchi, Davide. “DeepMind AI Outdoes Human Mathematicians on Unsolved Problem.” Nature, vol. 625, no. 7993, Jan. 2024, pp. 12–13, https://doi.org/10.1038/d41586-023-04043-w.

Deep Blue. https://www.ibm.com/history/deep-blue.

Drake, Peter, and Kelvin Sung. “Teaching Introductory Programming with Popular Board Games.” Proceedings of the 42nd ACM Technical Symposium on Computer Science Education, ACM, 2011, pp. 619–24. DOI.org (Crossref), https://doi.org/10.1145/1953163.1953338.

Fritz, Michael. “Can France Beat Britain’s ‘Settle Halifax, Besiege Louisbourg, Besiege Quebec’ Strategy?” BoardGameGeek, 25 Sept. 2011, https://boardgamegeek.com/thread/703495/can-france-beat-britains-settle-halifax-besiege-lo.

Gasser, Ralph. “Solving Nine Men’s Morris.” Computational Intelligence, vol. 12, no. 1, Feb. 1996, pp. 24–41, https://doi.org/10.1111/j.1467-8640.1996.tb00251.x.

Generation CS: Computer Science Undergraduate Enrollments Surge Since 2006. Computing Research Association, 2017, http://cra.org/data/Generation-CS/.

Glick, Stephen, and L. Ian Charters. “War, Games, and Military History.” Journal of Contemporary History, vol. 18, no. 4, Oct. 1983, pp. 567–82.

Goossens, Luc. Quarto, 22 Feb. 2001, http://web.archive.org/web/20041012023358/http://ssel.vub.ac.be/Members/LucGoossens/quarto/quartotext.htm.

Hsu, Hansen. “AI and Play, Part 1: How Games Have Driven Two Schools of AI Research.” Computer History Museum, 23 July 2020, https://computerhistory.org/blog/ai-and-play-part-1-how-games-have-driven-two-schools-of-ai-research/.

Hsu, Hansen. “AI and Play, Part 2: Go and Deep Learning.” Computer History Museum, 5 Aug. 2020, https://computerhistory.org/blog/ai-and-play-part-2-go-and-deep-learning/.

Irving, Geoffrey. Pentago Is a First Player Win: Strongly Solving a Game Using Parallel In-Core Retrograde Analysis. Apr. 2014, https://doi.org/10.48550/ARXIV.1404.0743.

Jordaan, Dawid B. “Board Games in the Computer Science Class to Improve Students’ Knowledge of the Python Programming Language.” 2018 International Conference on Intelligent and Innovative Computing Applications (ICONIC), IEEE, 2018, pp. 1–5. DOI.org (Crossref), https://doi.org/10.1109/ICONIC.2018.8601207.

Kramár, János, et al. “Negotiation and Honesty in Artificial Intelligence Methods for the Board Game of Diplomacy.” Nature Communications, vol. 13, no. 1, Dec. 2022, https://doi.org/10.1038/s41467-022-34473-5.

Kurenkov, Andrey. “A ‘Brief’ History of Game AI Up to AlphaGo, Part 2.” Andrey Kurenkov, 18 Apr. 2016, https://www.andreykurenkov.com/writing/ai/a-brief-history-of-game-ai-part-2/.

Machuqueiro, Fábio, and João Piedade. “Game On: A Journey into Computational Thinking with Modern Board Games in Portuguese Primary Education.” Education Sciences, vol. 14, no. 11, Oct. 2024, p. 1182. DOI.org (Crossref), https://doi.org/10.3390/educsci14111182.

Panuncial, Diana. “Bookend: Gaming the (Library) System.” American Libraries Magazine, 1 Nov. 2019, https://americanlibrariesmagazine.org/2019/11/01/bookend-gaming-the-library-system/.

Perolat, Julien, et al. “Mastering the Game of Stratego With Model-Free Multiagent Reinforcement Learning.” Science, vol. 378, no. 6623, Dec. 2022, pp. 990–96, https://doi.org/10.1126/science.add4679.

Samuel, Arthur. “Some Studies in Machine Learning Using the Game of Checkers.” IBM Journal of Research and Development, vol. 3, no. 3, July 1959, pp. 211–29, https://doi.org/10.1147/rd.33.0210.

Schaeffer, Jonathan, et al. “Checkers Is Solved.” Science, vol. 317, no. 5844, Sept. 2007, pp. 1518–22, https://doi.org/10.1126/science.1144079.

Shannon, Claude. “A Chess-Playing Machine.” Scientific American, vol. 182, no. 2, Feb. 1950, pp. 48–51.

Shutts, Cindy. “Best Tabletop Games for the Library.” School Library Journal, 8 July 2019, https://www.slj.com/story/best-tabletop-games-for-the-library.

Soni, Jimmy. “The Man Who Built the Chess Machine.” Chess.Com, 16 Aug. 2017, https://www.chess.com/article/view/the-man-who-built-the-chess-machine.

Stegmaier, Jamey. “Officially Banned Combinations (Faction Mat/Player Mat).” BoardGameGeek, 30 Dec. 2018, https://boardgamegeek.com/thread/2121377/officially-banned-combinations-faction-matplayer-m.

Stekerhofa, Samanta. “Board Games in Libraries.” Princh, 31 Mar. 2022, https://princh.com/blog-board-games-in-libraries/.

Stezano, Martin. “In 1950, Alan Turing Created a Chess Computer Program That Prefigured A.I.” History, 29 Aug. 2017, https://www.history.com/news/in-1950-alan-turing-created-a-chess-computer-program-that-prefigured-a-i.

Takizawa, Hiroki. Othello Is Solved. 2 Jan. 2024, http://arxiv.org/abs/2310.19387.

“The Games That Helped AI Evolve.” IBM, https://www.ibm.com/history/early-games.

Wallace, Martin. “Rules Changes from Martin Wallace.” BoardGameGeek, 30 Dec. 2011, https://boardgamegeek.com/thread/743531/rules-changes-from-martin-wallace.

“Why Have Games In Libraries?” American Library Association, https://games.ala.org/why-have-games-in-libraries/.

Wray, Chris. “SdJ Re-Reviews #3: Focus (a.k.a. Domination).” The Opinionated Gamers, 19 May 2015, https://opinionatedgamers.com/2015/05/19/sdj-re-reviews-3-focus-a-k-a-domination/.