A reader's guide to

teaching beginners to
code
Table of Contents:
Introduction
Pg 3,
Chapter 1
Pg 4, Object-Oriented Vs Component-Oriented
Programming
Chapter 2
Pg, Programming languages
Chapter 3
Pg, Teaching Top-Down Vs Bottom-Up
 Dear Readers, Introduction

Throuou

For my readers guide I delved

deeper into the question “What is the
best way to teach a beginner to code” I
will learned many things through
various sources. I learned if top down
approach enables students to better
understand the structure of coding or
if bottom up approach does. Another
thing that I looked into was the
differences between object oriented
programming verses This guide was compiled as a
source for future research into how to teach beginners to code. I wish for
you to use this guide as a way to delve deeper into the argument
surrounding the best way to teach a beginner to code. Following is a
collection of scholarly articles, videos, papers, books, and interviews.
These will help explain how coding has been taught and how each
approach affects the student.
This guide will address many different ways in which one can
teach coding. The first chapter brings you through the differences
between object-oriented programming and component-oriented
programming. Chapter two explores the different programming
languages commonly taught to beginners. Finally, chapter three will
discuss the difference between teaching top-down and bottom-up.
This reader’s guide is not the end to all discussion on teaching
beginners to program but merely just another resource for future
researchers. A bias to my research that I may have is I have already
learned java and some C++ two languages that are object oriented and I
was taught in a top-down approach. Not only this but my research was
focused in a way that I personally found interesting there are other ways
in which one may research this topic and many directions one may take
with it. I hope this guide will aid you in your studies and that it will
possibly build on the current information on this topic.
Some words I will use to research this topic are words like coding language, coding style,

simplest, uncomplicated, unchallenging, effortless, straightforward, new students, novice,

fledgeling, and starter. These words will aid in the search for articles and books relating to my

topic. A preconception that I may have on this topic is I have already learned java and some C++

two languages that are very similar just with different syntax and I felt that they were both quite

easy to learn. A way I plan to address this is to focus on research for all languages and try not to

let what I have learned in the past influence what I read about each language.
 Chapter 1
Object-Oriented Vs Component-Oriented Programming

Learning through object-oriented or component-oriented programming gives the

coder different paths depending on which one they are taught through. This chapter

will explore the similarities and differences of these types of programming as well

as the most well known programming languages which branch off of each. For this

chapter, I will be discussing the following two sources:

1. “Objects never?: well, hardly ever” (2010) by Ben-Ari, Mordechai. This

article goes over object-oriented programming. It discusses the advantages
of object-oriented programming and how it is used in the real world. Not
only this but it delves into how nitpicky object oriented programming can be
and how this makes it challenging for new users to learn to code with it.
2. “Twenty-eight years of component-based software engineering”(2016) Vale,
Tassio, and Crnkovic, Ivica de Almeida and Eduardo Santana, Silveira
Neto and Paulo Anselmo Da Mota and Cavalcanti, Yguaratã Cerqueira
and Meira, Silvio Romero de Lemos. In this article it discussed component
based programming. The article describes how object-oriented programming
focuses on the relationships between classes that are combined into one large
binary executable. Verses how component-oriented programming focuses on
interchangeable code modules that work independently and don’t require the
programmer to be familiar with their inner workings to use them.

Mordechais’(2010) article shows how sometimes because there are so many

warnings and errors like “unfriendly environment” in object-oriented coding a

beginner may become frustrated and find it challenging. He goes over how
although learning to code with an object oriented language like java or C++ is

difficult, in the long run the person learning to code will be better off when they go

to learn their next language. By learning through object oriented programming the

user will have already met with some the most difficult issues they will face. Not

only this but he asks the reader if OOP is truly the more prevalent than component-

oriented. He argues that by:

Assessing the dominance of OOP, we have to watch out for proxies. The
extensive use of languages that support OOP proves nothing, because
languages are chosen for a myriad of reasons, not necessarily for their
suitability for OOP, nor for the suitability of OOP itself. Similarly, the use of
a CASE tool that supports OOP is another proxy; these tools might just be
convenient and effective for expressing the software design of a system,
whether OOP is being used or not. Furthermore, many practices associated
with OOP, such as decomposing software into modules and separating the
interface from the implementation, are not limited to OOP; they are simply
good software practice and have been supported by modern programming
languages and systems for years. (Mordechai, 32)
In the quote above Mordechai discusses why he believes that OOP is commonly

considered the most common. He describes how many of the languages that branch

off of OOP are supported because of good software practice instead of the

programmer themself. By doing this he opens the reader up to question OOP and to

listen to his arguments about the matter. He believes that programming languages

are chosen for a multitude of reasons and that one should not write some off just

because they do not fall under OOP.

Later on in this

article Mordechai

discusses one of the most

promising arguments for

OOP. He says that OOP

facilitates reuse. Since

OOP may be reused by the user this means that one will not need to spend

countless hours rewriting the same code to get the same output just with different

objects. He also discusses the drawbacks in reusing code with OOP he explains

how when one encapsulates everything in their code it becomes nearly impossible

to reuse the code.

Vale, Tassio, and Crnkovic, Almeida and Santana, Neto and Paulo Mota and

Cavalcanti, Cerqueira and Meira, Lemos’(2016) article discusses primarily

component-based or component-oriented programming. It describes some

component-oriented programming languages like COM, J2EE, CORBA, and

.NET. It also discusses how these languages give the infrastructure to connect

binary parts seamlessly. Finally, the article describes how the main difference

between the component-oriented languages is the ease in which they allow the user

to connect the binary components.

Component-oriented programming is a technique of developing software by

combining pre-existing and new components, the writers use the example of how

this is much like how automobiles are built from other components. Software

components are self-contained, self-describing packages that can functionality

contain definitions of types that expose both behavior and data. The writers discuss

how the programming language C# supports component-oriented programming

through the concepts of properties, methods, events, and attributes thus, allowing

self-contained and self-describing components called assemblies. Component

oriented programming heavily relies on: polymorphism, encapsulation, late

binding, inheritance (through interfaces) and most importantly binary re-usability.

With this being said some may argue that it functions much like OOP just without

objects to throw the program off. The writers believe that if a beginner is taught

Component oriented programming early on in their career as a programmer it may

make it easier for them in the future when expanding their knowledge and when

learning they will encounter fewer errors due to objects.