Marco T. Morazán

• Ph.D.
• Professor of Computer Science at Seton Hall University

Most Formal Languages and Automata Theory courses explore the duality between computation models to recognize words in a language and computation models to generate words in a language. For students unaccustomed to formal statements, these transformations are rarely intuitive. To assist students with such transformations, visualization tools can pl...

Congratulations! You have completed your first steps into the thought-provoking world of theoretical computer science. You have learned about different models of computation: their powers and their limitations. You have also learned about nondeterminism and the role it plays in computer science and in programming. The models you have studied have v...

This chapter introduces the fundamental concepts in automata theory and formal languages.

This chapter presents the equivalence of pushdown automata and context-free languages.

This chapter presents nondeterministic finite-state machines and their equivalence with deterministic finite-state machines.

This chapter introduces regular expressions and regular languages.

This chapter introduces the Church-Turing thesis and undecidability.

This chapter introduces the syntax of the FSM programming language.

This chapter introduces Turing machine extensions and programmable multitape Turing Machines.

This chapter introduces languages that are not regular and the pumping theorem for regular languages.

This chapter introduces context-sensitive grammars.

This chapter introduces Turing machines as language recognizers.

This chapter establishes that nondeterministic pushdown automata are more powerful than deterministic pushdown automata.

This chapter introduces context-free grammars.

This chapter introduces deterministic finite-state machines. In addition, it presents a design recipe for state machines. This chapter also discusses how to prove the correctness of a deterministic finite-state machine for a given language.

This chapter introduces the closure properties of the languages accepted by finite-state automatons and the equivalence between finite-state automatons and regular expressions.

This chapter introduces pushdown automata and their equivalence with context-free grammars.

This chapter introduces the basic proof techniques: formal logic proofs, mathematical induction proofs, pigeonhole principle proofs, proofs by contradiction, and diagonalization proofs.

This chapter introduces Turing machine composition.

This chapter presents that context-free languages are closed under union, concatenation, and Kleene star and are not closed under complement and intersection. In addition, it develops the pumping theorem for context-free languages and demonstrates that the intersection of a context-free language and a regular language is context-free.

This chapter introduces regular grammars and their equivalence with finite-state machines.

This chapter establishes the equivalence of deterministic and nondeterministic Turing machines. In addition, it introduces the complexity classes P and NP.

Regular expressions in an Automata Theory and Formal Languages course are mostly treated as a theoretical topic. That is, to some degree their mathematical properties and their role to describe languages is discussed. This approach fails to capture the interest of most Computer Science students. It is a missed opportunity to engage Computer Science...

This chapter introduces circular data and generalized constructors.

This chapter introduces vectors and designing functions that process vectors.

This chapter introduces accumulative recursion.

This chapter presents continuation-passing style.

This chapter presents searching algorithms based on generative recursion. These include binary search, depth-first search, and breadth-first search.

This chapter presents breadth-first search as an algorithm to prevent infinite recursion during and to find the shortest solution. This is done in the context of refining the N-puzzle game.

This chapter introduces in-place operations using reversing, quick sorting, heap sorting, and radix sorting a vector. In addition, it outlines an empirical study for the reader to perform.

This chapter presents sorting algorithms based on generative recursion. These include merge and quick sorting.

This chapter provides some generic hints for the reader about how to pursue his/her studies in programming and problem-solving.

This chapter presents heuristic searching and the Aˆ* algorithm using the N-puzzle game as motivation.

This chapter introduces state variables, mutation, and abstraction over state variables.

This chapter introduces while loops, Hoare logic, and program correctness.

This chapter emphasizes the importance of termination arguments by showing that depth-first search may generate an infinite recursion. This is done in the context of refining the N-puzzle game.

This chapter presents the use of accumulators in the N-puzzle problem. Accumulators are used to avoid falling into an infinite recursion when using depth-first search and to reduce the search space when using breadth-first search.

This chapter presents and implements the base code for an N-puzzle video game emphasizing program design.

This chapter introduces program design and implementation using generative recursion.

This chapter reviews lessons on program design, structural recursion, code refactoring, and abstract running time.

This chapter introduces the use of randomness in problem solving and programming.

This chapter introduces tail recursion, iteration, and functional abstraction over tail-recursive list-processing functions.

The use of functional programming languages in the first programming course at many universities is well-established and effective. Invariably, however, students must progress to study object-oriented programming. This article presents how the first steps of this transition have been successfully implemented at Seton Hall University. The developed...

Students introduced to programming using a design-based approach and a functional programming language become familiar with first-class functions. They rarely, however, connect first-class functions to objects and object-oriented program design. This is a missed opportunity because students inevitably go on to courses using an object-oriented progr...

Students introduced to programming using a design-based approach and a functional programming language become familiar with first-class functions. They rarely, however, connect first-class functions to objects and object-oriented program design. This is a missed opportunity because students inevitably go on to courses using an object-oriented progr...

This chapter presents thin server design. In addition, common distributed programming bugs such as loss of synchronization and deadlock are discussed.

This chapter presents the refinement of sequential Aliens Attack to use the data definitions needed for the multiplayer version of the video game.

The definition of generic structures and the need for data definitions to provide them with meaning are introduced. The need for careful testing is highlighted.

This chapter introduces recursive data definitions, lists, structural recursion, and generic data definitions.

This chapter introduces the design of compound functions using conditional expressions. An explicit connection is made between data definitions with varieties and compound functions. Function templates are introduced as a mechanism to manage the design of multiple functions for the same data definition.

This chapter presents integer intervals as compound data of arbitrary size and the design of functions to process processor intervals.

This chapter applies the lessons of abstraction to improve the implementation of the Aliens Attack video game.

The lessons on designing with union types are used to advance the design of Aliens Attack. Emphasis is placed on operations being defined for a type and not for the representation of a type.

This chapter presents thick-server design and distributed programming bugs such as communication overhead.

This chapter presents the development of the first version of the Aliens Attack video game. It introduces the idea that data representation strongly influences how problems are thought about and the importance of data definitions in program design.

This chapter presents common list operations including list summarizing, mapping, filtering, and searching.

This chapter presents functions as values and partial evaluation using curried functions.

This chapter presents binary trees, the design of functions to process a binary tree, complexity, and big O notation.

The chapter presents functional abstraction as a mechanism to eliminate code repetition. A design recipe for abstraction is presented to eliminate code repetition.

This chapter introduces a richer set of primitive types that include characters, symbols, Booleans, and images. It introduces the concept of divide and conquer as a strategy to manage the designing of solutions to problems.

Congratulations! You have reached the end of your first step into the world of problem solving and program design. There is still much more you can learn about problem solving and programming, but there is no doubt that now you have a solid foundation to continue on this journey.

This chapter presents natural numbers and the design of functions that process a natural number.

This chapter presents problem solving using for-loops and pattern matching.

This chapter introduces functions as an abstraction over expressions. It presents the first design recipes, top-down design, and bottom-up design.

This chapter presents interfaces, classes, objects, and polymorphic dispatch.

This chapter introduces structures to represent compound data of finite size and the design of structure-processing functions.

Video game development is presented as the design of functions to process computer events such as keystrokes. The use of an abstract procedure interface for video game development is introduced along with a design recipe for video game development.

This chapter presents the design of functions that consume multiple complex inputs.

This chapter presents communication protocols and distributed applications along with a design recipe for distributed computing.

This chapter presents encapsulation, lexical scoping, and exponential running time.

This chapter presents mutually recursive data definitions and the design of functions to process mutually recursive data. In addition, it presents (arbitrary) trees.

This chapter puts into practice lessons in structural recursion. In addition, it presents bugs that do not always manifest themselves are difficult to diagnose and presents a development that used both top-down and bottom-up designs.

This chapter puts into practice the lessons regarding defining compound data of finite size. It introduces subtypes, throwing errors, and testing error messages.

This chapter introduces the concept of a program as a solution to a problem. It presents the programming environment as an expression-evaluating mechanism and a program as a collection of expressions that include number, strings, and function applications.

This chapter introduces supertypes as union types and the design of functions to process instances of a supertype. In addition, it introduces code refactoring to improve design, structure, and efficiency without changing software functionality.

This article presents a visualization tool for designing and debugging deterministic finite-state machines in FSM -- a domain specific language for the automata theory classroom. Like other automata visualization tools, users can edit machines and observe their execution, given some input. Unlike other automata visualization tools, the user is not...

Introducing inner-city high school students to program design presents unique challenges. The typical assumptions of an introductory programming course, like students understand what variables and functions are, may not be safe. Therefore, asking students to define functions as part of the program design process may be an overwhelming task. Many st...

Beginning students find the syntactic construct known as a while loop difficult to master. The difficulties revolve around guaranteeing loop termination and around learning how to properly sequence mutations to solve a problem. In fact, both of these are intertwined and students need to be taught a model that helps them reason about how to design w...

Vector programming is an important topic in many Introduction to Computer Science courses. Despite the importance of vectors, learning vector programming is a source of frustration for many students. Much of the frustration is rooted in discovering the source of bugs that are manifested as out-of-bounds indexing. The problem is that such bugs are,...

Computer Science students, in general, find Automata Theory difficult and mostly unrelated to their area of study. To mitigate these perceptions, FSM, a library to program state machines and grammars, was developed to bring programming to the Automata Theory classroom. The results of the library's maiden voyage at Seton Hall University had a positi...

Vector programming is an important topic in many Introduction to Computer Science courses. Despite the importance of vectors, learning vector programming is a source for frustration to many students given that they feel left adrift when it comes to resolving vector indexing errors. Even though the size of a vector is a natural number, there have be...

Vector programming is an important topic in many Introduction to Computer Science courses. Despite the importance of vectors, learning vector programming is a source for frustration to many students given that they feel left adrift when it comes to resolving vector indexing errors. Even though the size of a vector is a natural number, there have be...

Compilers for functional languages are judged, in part, on how well they handle \(\lambda \)-expressions. The evaluation of \(\lambda \)-expressions traditionally requires closure allocations which can be intensive and can interact poorly with a garbage collector. Work on closure representation and garbage collection has successfully improved this...

A Computer Science introduction course ought to focus on exciting students about the subject matter and on problem solving through the methodical design of programs. An effective way to achieve both is through the development of functional video games. As most students are interested in video games, their development adds an exciting domain to any...