Naman Dugar

24 June 2019
ENGW3315 Project 1 Final
Professor Musselman
APA
Word Count - 1547

How I learned to get away from the shortest lie in computing

Growing up, I have always wished of having my own tech startup. Come on, isn’t the idea of

working and hustling on something new and innovative with a small group of people really cool?

I am really passionate about technology. However, sitting at a desk and constantly hitting keys

on my laptop is not something that I am particularly fond of. I have known that my interests are

interdisciplinary in the sense that I have always wanted to pursue two fields: Computer Science

and Business Administration. With Northeastern University offering a combined program in both

disciplines, I was certain I had found the right college for me. Having just finished my first year of

college, I can safely say I made the correct choice. What and how I have been taught in college,

however, has been really different compared to what I have experienced in the past and I have

been introduced to new ways of learning in both my disciplines. Studying computer science in

high school was more about reading textbooks and attempting to understand and write code

without having an idea of its applications or uses. And while I have always hated how I was

taught computer science in school, I originally felt the same about it in college.

An approach to programming that the Computer Science faculty at Northeastern tries to instill in

students is that of “The Design Recipe”. I was introduced to the idea of it when I took

‘Fundamentals of Computer Science 1’ in my first semester at Northeastern. While we

programmed in a language called Racket, we were told that the aim of the class was not to

teach us the language, but to make us understand “The Design Recipe” or programming by

design. I, like everyone else, hated the concept and was made to wonder why following such

strict guidelines was necessary. Now here’s the thing. Having strict guidelines to help me

approach computer science in a certain way was exactly what I lacked in school. I studied Java

in high school and while what I learnt was enough to get me through my exams, I never really

understood it and I could not write a program myself. I would keep altering my code until I found

something that worked, and that was it. This was due to theoretical concepts, like how I could

“loop” certain functions for a set period of time or the fact that recursive algorithms are efficient,

being thrown at us without any reasonable explanation or understanding. I wasn’t taught the

language in a systematic and disciplined way. Even after two years of studying Computer

Science in high school, I didn’t really end up learning much. As time has passed in college and

as I have learnt more about the world of computing, I have grown to understand the importance

of maintaining design, structure and following a uniform approach to coding.

While theory influences every field, its influence is not that simple in the world of Computer

Science. The field that we know as Computer Science is significantly newer compared to other

fields. Therefore the major research done by theorists is relatively recent. You see, technology

is something that changes rapidly and keeps evolving over time. It does not stay constant. While

the content or concepts change over time, certain ideas or approaches to learning and teaching

in computing have stayed the same. “The Design Recipe” lists eight steps which include four for

creating new pieces of data and four for creating new functions. Every time a new assignment

was posted online, we were constantly reminded to strictly follow the design recipe. And yes, it

did annoy me quite a bit. It meant that we had to define our data, interpret it, create examples of
it and provide a template to generalize it. In order to create functions, we had to first list what

types of data it would take, write the purpose of the function, write tests to make sure our

function works and finally the actual code itself. At first, I was really confused as I felt that doing

such things was taking the learning away from what I thought we would actually learn: coding. It

is only after experiencing it did I realize that following the design recipe is the way to go about

learning how to code. It helped me understand precisely what I failed to understand in high

school. Through this approach to learning, I knew what my code meant, I could have others

read my code and understand what I was doing, I could check for errors by testing every

scenario and most importantly, understand how the language and logic go hand in hand.

This particularly helped me with my assignments, specifically one where I had to recreate the

popular game, “Minesweeper”. After reading what I had to do, I felt really overwhelmed, and

unsure about how to start. I knew that I had to use certain logic to build the game and that I had

to somehow keep track of the number of neighboring “mines” for each cell. I just did not know

where to start and I felt really lost. I went to a TA during office hours looking for help, but all I

was told was to follow the design recipe. There’s no point in hiding it; I was disappointed and a

little annoyed that literally all I was told was to follow the recipe. I wanted help but all I was told

was something that I was already reminded of every day. But at that point, I didn't really have a

choice. I scrapped whatever I had done and began planning everything on a whiteboard from

the ground up. I realized that to build a complex game, I had to plan out what I had to do before

actually doing it. I had to look at the small pieces of data (like the cells, the mines, the neighbors

and the images) and construct them, with finding a way to link everything being something that

would be done later. Originally, I just kept typing code without any formatting or descriptions as I

was so fed up with not being able to do anything. That’s exactly where I went wrong as
describing my variables and code was crucial as we had to work with a partner who would need

to have an idea of what my code meant. By strictly following the recipe, I was able to

systematically plan my entire project, work on individual parts and ultimately get the entire game

working. I have followed this approach throughout my time here and it has really benefited me.

It was fascinating to know that the concept of maintaining proper design and structure is

something that all modern day programmers are encouraged to do. The ‘Program By Design’

project exists for that specific reason. It is a project for “computing education that combines

motivation with principles” ("Program by Design," 2019). The team behind it spent over fifteen

years developing the curriculum with the intent to address the common problems faced by

students. Everything that I have learnt at Northeastern about Computer Science has been

based on this curriculum and this idea to make learning better. My first semester introduced me

to the design recipe by programming on Racket, while my second semester extended the

applications of what I had learnt by applying it to Java. It was started by one of Northeastern’s

Computer Science professors, Matthias Felleisen. He, along with a team of professors, secured

funding from the United States Department of Education in order to implement the project. A

textbook, ‘How to Design Programs’ by Felleisen, Robert Bruce Findler, Matthew Flatt and

Shriram Krishnamurthi was written with the same aim of changing how introductory computer

science is taught. The preface of the book accurately summarizes what the writers want to

change.

“​The typical course on programming teaches a “tinker until it works” approach. When it works,

students exclaim “It works!” and move on. Sadly, this phrase is also the shortest lie in

computing, and it has cost many people many hours of their lives. In contrast, this book focuses
 ​ ood programming,​ addressing both professional and vocational programmers.”
on habits of g

(Felleisen, Findler, Flatt, & Krishnamurthi, 2018)

Yes, I was originally hesitant and unsure about approaching my tasks on such a simplified level

but as time has passed, I have understood its importance. While programming is not something

I am the biggest fan of, the way we learn to approach it has not only affected my learning in

computer science but also how I approach other problems and my outlook on my future goals.

The design recipe is not just applicable to the field of computing but also key areas of life. Even

when I am looking to start a business in the future, I have to remember to plan out my vision

and ideas for the business. In order to better communicate with my co-workers and possible

investors, I have to remember to describe what my plans are. Experimenting with ideas until

they work can have serious negative consequences to a business, and a systematic and

planned approach is necessary. I am looking forward to my future learning at Northeastern and

always remembering to follow the design recipe!

Acknowledgements

I would like to thank Jackie Lucia and Dara Sostek for peer reviewing my paper, and Professor

Musselman for her comments and feedback.

 References

Felleisen, M., Findler, R. B., Flatt, M., & Krishnamurthi, S. (2018). ​How to Design Programs: An

Introduction to Programming and Computing.​ Cambridge, MA: MIT Press.

Program by Design. (n.d.). ​Program by Design​. Retrieved June 24, 2019, from

https://programbydesign.org