Marco Morazan

Followers

Following

Public Views

Interests

Uploads

Papers by Marco Morazan

Vector Programming Using Structural Recursion

arXiv (Cornell University), May 11, 2018

Vector programming is an important topic in many Introduction to Computer Science courses. Despit... more 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 been no efforts to define a useful recursive data definition to help beginners design vector processing functions. This article defines the concept of a vector interval and describes how to exploit its recursive structure to design vector processing functions. The described methodology provides a context beginners can use to reason about proper vector indexing instead of leaving them adrift with this responsibility. A key feature of properly using the described methodology is that if students process the correct vector interval then vector indexing errors can not arise. The classroom deployment of this approach is described in detail. Students, to date, have found vector intervals helpful in avoiding out-of-bounds indexing errors when all the vector elements of the interval are processed.

Download

Regular Expressions in a CS Formal Languages Course

Electronic proceedings in theoretical computer science, Aug 11, 2023

Regular expressions in an Automata Theory and Formal Languages course are mostly treated as a the... more 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 students that are far more motivated by practical applications of theory. To this end, regular expressions may be discussed as the description of an algorithm to generate words in a language that is easily programmed. This article describes a programming-based methodology to introduce students to regular expressions in an Automata Theory and Formal Languages course. The language of instruction is FSM in which there is a regular expression type. Thus, facilitating the study of regular expressions and of algorithms based on regular expressions.

Download

FSM Error Messages

arXiv (Cornell University), 2018

Computer Science students, in general, find Automata Theory difficult and mostly unrelated to the... more 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 positive impact on students, but the students found the library difficult to use due to the error messages generated. These messages were generated by the host language meaning that students needed to be familiar with the library's implementation to make sense of them. This article presents the design of and results obtained from using an error-messaging system tailor-made for FSM. The effectiveness of the library was measured by both a control group study and a survey. The results strongly suggest that the error-messaging system has had a positive impact on students' attitude towards automata theory, towards programming in FSM, and towards FSM error messages. The consequence has been a marked improvement on students' ability to implement algorithms developed as part of constructive proofs by making the debugging of FSM programs easier.

Download

Vector Programming Using Generative Recursion

Vector programming is an important topic in many Introduction to Computer Science courses. Despit... more 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, sometimes, rooted in incorrectly computing an index. Other times, however, these errors are rooted in mistaken reasoning about how to correctly process a vector. Unfortunately, either way, all too often beginners are left adrift to resolve indexing errors on their own. This article extends the work done on vector programming using vector intervals and structural recursion to using generative recursion. As for problems solved using structural recursion, vector intervals provide beginners with a useful framework for designing code that properly indexes vectors. This article presents the methodology and concrete examples that others may use to build their own CS1 modules involving vector programming using any programming language.

Download

Bytecode Closures

This article describes a new project to study the memory performance of three new implementation ... more This article describes a new project to study the memory performance of three new implementation strategies for closures coined bytecode closures. The project proposes to compare the new implementation strategies to the classical strategy that dynamically allocates flat closures as heap data structures. The new closure representations are based on dynamically creating specialized bytecode instead of allocating a data structure. The first new strategy creates specialized functions by inlining the bindings of free variables. The second uses memoization to reduce the number of dynamically created functions. The third dynamically creates memoized specialized functions that treat free variables like parameters at runtime. Empirical results from a preliminary case-study using three small benchmarks are presented as a proof-of-concept. The data suggests that dynamically created bytecode closures in conjunction with memoization can allocate significantly less memory, as much as three orders...

Download

Bytecode and Memoized Closure Performance

Lecture Notes in Computer Science, 2014

This article describes a new project to study the memory performance of different closure-impleme... more This article describes a new project to study the memory performance of different closure-implementation strategies in terms of memory allocation and runtime performance. At the heart of the project are four new implementation strategies for closures: three bytecode closures and memoized flat closures. The project proposes to compare the new implementation strategies to the classical strategy that dynamically allocates flat closures as heap data structures. The new bytecode closure representations are based on dynamically creating specialized bytecode instead of allocating a data structure. The first new strategy creates specialized functions by inlining the bindings of free variables. The second uses memoization to reduce the number of dynamically created functions. The third dynamically creates memoized specialized functions that treat free variables as parameters at runtime. The fourth memoizes flat closures. Empirical results from a preliminary byetcode-closure case-study using three small benchmarks are presented as a proof-of-concept. The data suggests that dynamically created bytecode closures in conjunction with memoization can allocate significantly less memory, as much as three orders of magnitude less memory in the presented benchmarks, than a flat closure implementation. In addition to studying the memory footprint of the different closure representations, the project will also compare runtime efficiency of these new strategies with traditional flat closures and flat closures that are unpacked onto the stack.

Download

Using Video Game Development to Motivate Program Design and Algebra Among Inner-City High School Students

arXiv (Cornell University), Aug 24, 2020

Introducing inner-city high school students to program design presents unique challenges. The typ... more 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 students do not understand that a function is an abstraction over similar expressions and that parameters represent the differences among these expressions. This articles presents a novel approach to teaching program design to high school students while simultaneously reinforcing high school algebra. The approach is based on a design recipe to help students develop the abstractions that lead to functions. Using a bottom-up approach, students are taught how to abstract over similar expressions. They are then taught how to use high school algebra concepts, like compound functions and function composition, to also design functions. In addition, the article also presents empirical data collected from students to measure their reaction to the course. For the students in the course, the empirical data suggests that high school algebra concepts are successfully reinforced and that students feel they become better problem solvers, find programming intellectually stimulating, and walk away with an interest in programming.

Download

Composing Turing Machines in FSM

Proceedings of the 2023 ACM SIGPLAN International Symposium on SPLASH-E

For Computer Science students, designing Turing machines is a Herculean task. Formal Languages an... more For Computer Science students, designing Turing machines is a Herculean task. Formal Languages and Automata Theory textbooks aid students by introducing a graphical notation for Turing machine composition. The difficulty of the task remains unchanged, because design principles are not emphasized and students rarely have the opportunity to program their designs in a textual programming language which allows them to write unit tests. To aid students that are trained as programmers, FSM-a domain-specific language for the Automata Theory classroom-has been developed. Using FSM, students design, program, validate, and establish the correctness of their Turing machines. Once they are familiar with Turing machines, students are introduced to Turing machine composition much like they are introduced to function composition when they learn to design programs. To compose Turing machines in FSM, there is an embedded domain-specific language that students may use. In this manner, students' training in programming is made relevant in the course. This article discusses how students are taught to design, program, validate, and establish the correctness of composed Turing machines. CCS Concepts: • Theory of computation → Formal languages and automata theory; • Applied computing → Education.

Download

Memoized Flat Closures for CPS

Lecture Notes in Computer Science, 2018

Compilers for functional languages are judged, in part, on how well they handle \(\lambda \)-expr... more 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 interaction. This work, however, does not address the actual allocation of closures in the first place. This is important, because the only closures that do not have to be garbage collected are the closures that are never allocated. This article explores a novel mechanism to reduce flat-closure allocations based on memoization. To test this new mechanism, a compiler has been developed that uses continuation-passing style as an intermediate representation–which makes closure allocation ubiquitous. Empirical results strongly suggest that flat-closure memoization is an important optimization that significantly reduces running time as well as memory and closure allocation.

Introduction to Functional Classes in CS1

Electronic Proceedings in Theoretical Computer Science

Students introduced to programming using a design-based approach and a functional programming lan... more 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 programming language. This article describes how students are introduced to objects within the setting of a design-based introduction to programming that uses a functional language. The methodology exposes students to interfaces, classes, objects, and polymorphic dispatch. Initial student feedback suggests that students benefit from the approach.

Download

Design of Classes I

Electronic Proceedings in Theoretical Computer Science

The use of functional programming languages in the first programming course at many universities ... more 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 methodology builds on the students' experience with type-based design acquired in their previous introduction to programming courses. The transition is made smooth by explicitly showing students that the design lessons they have internalized are relevant in object-oriented programming. This allows for new abstractions offered by object-oriented programming languages to be more easily taught and used by students. Empirical evidence collected from students in the course suggests that the approach developed is effective and that the transition is smooth.

Download

From Structural Recursion to Generative and Accumulative Recursion

The use of video games to teach introduction courses to pro- gramming and Computer Science is a t... more The use of video games to teach introduction courses to pro- gramming and Computer Science is a trend that is currently flourishing. One of the most successful and promising approaches uses functional video games to get students interested and engaged in programming. This approach is successful, in part, because functional video games pro- vide a domain of interest to most Computer Science undergraduates and remove the need to reason about designing state-based programs. A plethora of examples exist that have students develop games exploiting structural recursion which resemble such classics as Space Invaders and Snake. Once students master the basics of structural recursion the time comes to move beyond structural recursion to generative and accumula- tive recursion. It is up to the instructor to harness the enthusiasm and appetite that students have to develop more video games. This requires finding games that require the generation of subproblems in the same class as the input pr...

Download

Functional Video Games in the CS1 Classroom Appears in: Trends in Functional Programming 11 th International Symposium TFP 2010 Norman, OK, USA, May 17-19, 2010 Revised Selected Papers

Over the past decade enrollments in Computer Science un- dergraduate programs have drastically dr... more Over the past decade enrollments in Computer Science un- dergraduate programs have drastically dropped while simultaneously see- ing demand for computer scientists in the job market increase. The reason for this disconnect is, in part, due to the perception new potential stu- dents have of programming as a dull activity requiring no creativity, very little social interaction, and endless hours of coding in front of a mon- itor. The question then is how can we capture the imagination of new students and perk their interest in a way that gets them excited while at the same time giving them a solid foundation in computer programming and Computer Science. This article puts forth the thesis that develop- ing video games using functional programming should be a new trend in the CS1 classroom. The article describes the approach implemented at Seton Hall University using video game programming and Felleisen et al.'s textbook How to Design Programs. The first-year programming curriculum ...

Infusing an HtDP-based CS1 with distributed programming using functional video games

Journal of Functional Programming, 2018

A Computer Science introduction course ought to focus on exciting students about the subject matt... more 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 introduction to programming. This article advocates that an exciting crowning achievement for students in such a course is the design and implementation of a multiplayer distributed video game. By exploiting a domain that is popular with students, they are taught about design principles, communication protocols, and pitfalls in distributed programming. This article puts forth a successfully used design recipe that places distributed programming well within the reach of beginning students and outlines the use of this design recipe in the classroom. For those teaching beginners, this article presents a model for developing their own distribu...

Download

Optimal Lambda Lifting in Quadratic Time

Lecture Notes in Computer Science

The process of lambda lifting flattens a program by lifting all local function definitions to the... more The process of lambda lifting flattens a program by lifting all local function definitions to the global level. Optimal lambda lifting computes the minimal set of extraneous parameters needed by each function as is done by the O(n 3) equation-based algorithm proposed by Johnsson. In contrast, modern lambda lifting algorithms have used a graphbased approach to compute the set of extraneous parameters needed by each function. Danvy and Schultz proposed an algorithm that reduced the complexity of lambda lifting from O(n 3) to O(n 2). Their algorithm, however, is an approximation of optimal lambda lifting. Morazán and Mucha proposed an optimal graph-based algorithm at the expense of raising the complexity to O(n 3). Their algorithm, however, suggested that dominator trees might be used to develop an O(n 2) algorithm. This article explores the relationship between the call graph of a program, its dominator tree, and lambda lifting by developing algorithms for successively richer sets of programs. The result of this exploration is an O(n 2) optimal lambda lifting algorithm.

Download

Beautiful Imperative Code

Lecture Notes in Computer Science, 2013

The beauty of functional programs stems from clear semantics, referential transparency, and the h... more The beauty of functional programs stems from clear semantics, referential transparency, and the high-level of abstraction that permits programmers to focus on problem solving. In contrast, this beauty is rarely seen or appreciated in imperative code. In addition to solving a problem, imperative programmers focus on the bug-prone sequencing of assignment statements to obtain efficient code. Imperative programmers that learn functional programming, however, can derive an efficient imperative program from a functional program. This is achieved through a small series of meaning-preserving transformations. This article illustrates the transformations using a small example that yields code that is beautiful and efficient.

List-Heap Paging in a Distributed Virtual Memory System for Functional Languages

Paging in a distributed virtual memory

ABSTRACT Poor memory performance has been associated with functional languages. The MT System is ... more ABSTRACT Poor memory performance has been associated with functional languages. The MT System is being developed to study the design choices in the development of an all-software based distributed virtual memory for a pure list-based functional language. Of key importance is to understand the virtual memory behaviour of the different components of a pure functional system. In this paper, we present results obtained from observing the paging behaviour of the MT heap that demonstrate the virtual memory benefits of using the MT allocation algorithm over allocation algorithms that box their data. FIFO performs nearly as well as LRU for list-based memory on a set of benchmarks which include a metacircular evaluator for MT. The empirical results are explained by the paging behaviour of three frequent high-level memory accessing operations.

The MT architecture and allocation algorithm

Animated Problem Solving

Texts in Computer Science, 2022

Titles in this series now included in the Thomson Reuters Book Citation Index! 'Texts in Computer... more Titles in this series now included in the Thomson Reuters Book Citation Index! 'Texts in Computer Science' (TCS) delivers high-quality instructional content for undergraduates and graduates in all areas of computing and information science, with a strong emphasis on core foundational and theoretical material but inclusive of some prominent applications-related content. TCS books should be reasonably self-contained and aim to provide students with modern and clear accounts of topics ranging across the computing curriculum. As a result, the books are ideal for semester courses or for individual self-study in cases where people need to expand their knowledge. All texts are authored by established experts in their fields, reviewed internally and by the series editors, and provide numerous examples, problems, and other pedagogical tools; many contain fully worked solutions. The TCS series is comprised of high-quality, self-contained books that have broad and comprehensive coverage and are generally in hardback format and sometimes contain color. For undergraduate textbooks that are likely to be more brief and modular in their approach, require only black and white, and are under 275 pages, Springer offers the flexibly designed Undergraduate Topics in Computer Science series, to which we refer potential authors.

Download

Marco Morazan

Uploads

Papers by Marco Morazan

Log In