BUKIDNON STATE UNIVERSITY

Malaybalay City, Bukidnon 8700

Tel (088) 813-5661 to 5663; TeleFax (088) 813-2717, www.buksu.edu.ph

COLLEGE OF TECHNOLOGIES
Information Technology Department
IT113 – IT FUNDAMENTALS – Course Outcome 1

A case study analysis on

Effects of Instruction on the Misconceptions

About Programming in BASIC

Name of the Programming Language: BASIC

Author(s): Luann Stemler
Date of Publication: 1989

By:
Abutanmo, Reggie Michael
Acodili, Kenneth
Basadre, Jay Lloyd
Cahimtong, Jan Mari
Carillo, Hazel Ann
Gabia, Rowell Gerald
Miasco, Gwyneth
Rodriguez, Mark Jim
Sanglay, Daniel Cedrick
Ybañez, Alistair
 Table of Content

1. Introduction
Background Information
Purpose of the Case Study
2. Overview of the Programming
Language
Key Features
Design Philosophy
Target Audience/Use Cases
3. Historical Context and Evolution
Development Timeline
Key Influences
4. Comparative Analysis
Comparison with Other Languages
Adoption and Community Support
5. Case Study Details
Problem/Challenge Addressed
Methodology
Findings and Analysis
6. Impact and Implications
Industry Impact
Future Prospects
Lessons Learned
7. Conclusion
Summary
Personal Reflection/Opinion

8. References
Citations in APA 7th Edition
 Introduction

Background Information

Beginner's All-purpose Symbolic Instruction Code, also known as BASIC, is a

programming language that was developed in the early 1960s by John G. Kemeny and
Thomas E. Kurtz. BASIC programming language features simple syntax and is
designed for teaching programming and making programming accessible to
beginners, such as students. In spite of the fact that BASIC programming language is
accessible to beginners and students as well as to teach programming, BASIC
programming language is not commonly utilized in universities, schools, and other
institutions to teach students and beginners, resulting in misconceptions and
difficulties with the BASIC programming language. According to Stemler (1989),
learning programming is newly implemented in curriculums; therefore, there is a
limited understanding of how students learn to program, the difficulties they have,
and the misconceptions they develop.

A study by Mayer (1979), "A Psychology of Learning BASIC," mentioned to his

study that BASIC programming language is becoming a part of everyday business
and home life and the demands for teaching BASIC to non-professionals will likely
increase; hence, it is important to address matters such as misconceptions and solve
the difficulties faced in BASIC programming language for future development in
teaching programming.

Purpose of the Case Study

The major purpose of this study was to further comprehend the study "Effects
of instruction on the misconceptions about programming in BASIC" (Stemler, 1989)
which the study determines if the common misconceptions which high school
students have about syntax and semantics in the BASIC programming language can
be decreased by specific instruction in the problem areas.
 Overview of the Programming Language

Key Features
This section highlights the significant features of the BASIC programming
language.

1. Simple Syntax. The design of BASIC was to make it simple to use and learn.
Because of its simple syntax, even non-programmers and beginners may
understand it. New users can rapidly grasp and create code because of its
simplicity.

2. Line Numbers. To arrange and sequence code, early versions of BASIC

employed line numbers. A number that may be used to reference or modify
particular lines of code preceded each line of code.

3. Interactive Environment. BASIC frequently offers a read-eval-print loop

(REPL) that allows users to execute code line by line, allowing for quick
experimentation and feedback.

4. GOTO Statements. GOTO statements are a feature of BASIC that enables the
program to leap to a specific line number, enabling control flow. Although this
feature is frequently seen as less structured by modern standards, it was helpful
in the early days of programming.

5. Beginners’ ease of use. BASIC was created with a focus on education and was
intended to be user-friendly. It makes it possible for novices to understand
basic programming principles without being intimidated by intricate syntax or
structures.

6. Built-in Functions. Standard programming tasks can be completed more easily

and without requiring a lot of coding thanks to BASIC's built-in functions,
which include a variety of functions for manipulating strings, performing
mathematical operations, and input/output activities.
 7. Data Types. While integers, floating-point numbers, strings, and arrays were
not supported in earlier iterations of BASIC, they are now in more recent
versions, enabling more sophisticated data processing.

8. Procedures and Functions. By encapsulating code into reusable blocks,

procedures and functions enable modular programming. They were supported
in later versions of BASIC.

Design Philosophy

The guiding principle of the development of the BASIC programming language

was to create a language that was easy to use and accessible to non-technical users.
According to Thomas E. Kurtz, one of the creators of BASIC, "We gradually settled on
a fourfold approach. First, we would have to devise a computer system that would be
friendly, easy to learn and use, and not require students to go out of their way" (Kurtz,
1981, p. 519).

This principle was driven by the need to make computing accessible to a wider
audience, particularly non-science students. As Kurtz noted, "The majority would
balk at the seemingly pointless detail" of traditional programming languages (Kurtz,
1981, p. 519). The goal was to create a language that would allow users to focus on the
problem they were trying to solve, rather than getting bogged down in the details of
the language itself.

John Kemeny, the other creator of BASIC, also emphasized the importance of
ease of use and accessibility. According to Kemeny, "We wanted to make it possible
for students to use the computer without having to learn a lot of technical details"
(Kemeny & Kurtz, 1964, p. 1).

To achieve this goal, the developers of BASIC focused on creating a language

that was simple, intuitive, and easy to learn. They drew on their experience with other
programming languages, such as FORTRAN and ALGOL, but also sought to simplify
and streamline the language to make it more accessible to non-technical users.

As Kurtz explained, "We were concerned lest interpretative execution times

would be prohibitive for any but the smallest programs" (Kurtz, 1981, p. 522).
Therefore, they opted for a compiled language, which would allow for faster
execution times and make the language more practical for a wider range of users.

The guiding principle of ease of use and accessibility is also reflected in the
design of the BASIC language itself. For example, the language uses simple, English-
like syntax and provides a range of built-in functions and commands that make it easy
for users to perform common tasks.

In conclusion, the guiding principle of the development of the BASIC

programming language was to create a language that was easy to use and accessible
to non-technical users. This principle drove the design of the language and its features,
and helped to make BASIC one of the most widely used programming languages of
its time.

Target Audience/Use Cases

The BASIC programming language, originally developed in 1963 by John G.

Kemeny and Thomas E. Kurtz at Dartmouth College, was designed to make computer
programming accessible to students and generalists in various fields, not just scientists
and mathematicians. Here are some of the intended uses and industries that BASIC
aims to solve:

1. Education. BASIC was initially created as a teaching tool to help students learn
programming concepts easily. It was widely adopted in educational
institutions to introduce programming to beginners (Bellis, 2019).

2. Business Applications. BASIC has been used in business environments for

custom office automation, particularly through Visual Basic for Applications
(VBA) macros in Microsoft Office products like Excel and Access. This allows
for efficient data processing and reporting (History Tools, 2024).

3. Software Development. BASIC, especially in its Visual Basic and Visual Basic
.NET forms, has been used for developing Windows applications. It remains
 popular for creating smaller, in-house line-of-business (LOB) applications
(History Tools, 2024).

4. Hobbyist Programming. BASIC gained popularity among hobbyists and early

personal computer users. It was often the first programming language
available on home computers, enabling users to write their own programs and
games (Bellis, 2019).

5. Custom Automation. BASIC is also used for scripting and automating tasks in
various industries, making it a versatile tool for custom solutions (History
Tools, 2024).
 Historical Context and Evolution

Development Timeline

BASIC also known as Beginner's All-purpose Symbolic Instruction Code is a

high-level programming language designed to be simple and easy to use. Its evolution
over the decades reflects changes in technology and programming needs. Timeline of
significant milestones in the development of BASIC:
Table 1. Development Timeline of BASIC.

Year Description

1964 Creation of BASIC. John G. Kemeny and Thomas E. Kurtz at

Dartmouth College develop BASIC to help students learn
programming and perform computations easily. It was originally
designed for Dartmouth's time-sharing system.

1968 First Public Release. The initial version of BASIC is made available to
the public, rapidly gaining popularity in educational institutions.

1975 Altair 8800 and the Rise of Personal Computers. The Altair 8800, one
of the first personal computers, was released with a version of BASIC
written by Bill Gates and Paul Allen, which became widely known as
Altair BASIC. This event is pivotal in bringing BASIC to a broader
audience.

1976 Microsoft and BASIC. Microsoft, founded by Gates and Allen,

develops and licenses BASIC to various hardware manufacturers,
helping establish it as a key language for personal computers.

1978 BASIC on the Apple II. The Apple II, a highly successful early
personal computer, includes a version of BASIC called Integer BASIC.
This contributes to the widespread adoption of BASIC in-home
computing.
1981 IBM PC and GW-BASIC. IBM's introduction of the IBM PC includes
a version of BASIC known as GW-BASIC, which became a standard
for early IBM-compatible PCs.

1983 Introduction of Microsoft QuickBASIC. QuickBASIC is introduced

with more advanced features and a user-friendly integrated
development environment (IDE).

1985 BASIC for the Macintosh. Apple introduces MacBASIC for the
Macintosh, illustrating BASIC’s ongoing role in personal computing.

1991 Visual Basic 4.0. Microsoft releases Visual Basic 4.0, a major update
that includes support for 32-bit Windows applications and introduces
object-oriented programming concepts.

1998 Visual Basic 6.0. This version, which includes significant

enhancements like improved GUI design tools and support for
ActiveX controls, becomes highly popular for developing Windows
applications.

2001 Introduction of .NET Framework. Visual Basic .NET is introduced,

integrating with Microsoft's .NET Framework and introducing new
features like a more modern object-oriented programming model and
improved performance.

2008 Visual Basic 2008. Part of Visual Studio 2008, this release improves
language features and IDE tools, continuing to evolve with
advancements in software development practices.

2012 Visual Basic 2012. Microsoft released this version as part of Visual
Studio 2012, focusing on enhancing the language’s features and
improving development productivity.

2014 Visual Basic 2015. This version is included with Visual Studio 2015,
bringing enhancements in language features and development tools.
 2020 Visual Basic 16.0. As part of Visual Studio 2019, this version continues
to support modern programming paradigms while maintaining
compatibility with older versions.

2022 Transition and Modernization. While Visual Basic remains

supported, its role in new software development has decreased in
favor of more contemporary languages. The focus shifts towards
maintaining compatibility and supporting legacy systems.

BASIC's evolution reflects broader trends in computing, including the growth

of personal computing, the rise of graphical user interfaces, and the shift towards
modern programming paradigms. Despite its reduced prominence in recent years,
BASIC has had a lasting impact on programming and education.

Key Influences

Languages such as Java and Python have become among the most widely used
in the present time, but BASIC deserves a lot of credit from everyone. Despite its
simplicity, a small company called Microsoft was inspired to create the high-level
Microsoft BASIC language in the middle of the 1970s.

BASIC was inspired by the FORTRAN programming language, adopted a one-

instruction-per-line format, and incorporated Boolean instructions like IF and THEN
(How BASIC Inspired Today’s Important Programming Languages, 2019). Because of
its great adaptability, small size, and intuitive accessibility, BASIC gained popularity
among hardware engineers and was a standard component of the personal computing
revolution that happened in the 1980s. It was a component of well-known devices
such the BBC Micro, Apple II, and ZX Spectrum, one of which was infamous for its
loud screeching noises produced when loading software from a cassette.

It is also worth noting that 55 years after its creation, BASIC continues to remain
in use. Microsoft's enthusiasm for the language inspired them to develop Visual Basic
in 1991, which updated the original architecture with a visual form builder. Visual
Basic remains an established programming language today; a developer from 1980
would be familiar with its functions and Boolean statements. Similarly, Turbo Basic,
which was first released in 1985, is still available under the name PowerBASIC. Future
generations of programmers and software specialists may grow up to recognize
BASIC as essential to their career and personal growth, just as previous generations
have.

Dartmouth BASIC, similar to FORTRAN II, included time-sharing

compatibility features and was influenced by ALGOL 60 (Techopedia, 2016). BASIC’s
initial release concentrated on mathematical work with matrix arithmetic support,
followed by full string capability added in 1965. BASIC grew in popularity during the
1970s-80s. (Techopedia, 2016).
 Comparative Analysis

Comparison with Other Languages

This section highlights the similarities, differences, strengths, and weaknesses

of the BASIC programming language to the other programming languages. The table
shows the comparison between BASIC to other programming languages—Pascal,
Python, and JavaScript:

Table 2. Comparison of BASIC with Other Languages.

Features BASIC PASCAL PYTHON JAVASCRIPT

Purpose: Primarily used Was originally General- Primarily

for education designed as a purpose used for
purposes and teaching programming client-side
simple language, language web
programming intended to suitable for a development,
introduce wide range of but can also
students to applications be used for
structured server-side
programming development
concepts

Syntax: Simple and More Readable and Similar to

easy to learn, structured concise, Java, but with
often featuring syntax with a emphasizing a more
line numbers stricter typing readability dynamic
rule and a nature
focus on code
reliability

Paradigm: Procedural Emphasizing Object- Object-

structured oriented, oriented
programming. Procedural,
Functional

Application: Basic Utilized for a Web Web

calculations, wider range of development, development,
text processing applications, Data analysis, Game
including machine development,
system learning server-side
programming scripting
and education
Strengths: Simplicity: Structured Versatility: Ubiquity:
Easy to learn programming: Can be used Built into web
making it Encourages for a wide browsers,
suitable for code range of making it
beginners organization applications, essential for
and including web web
Educational: A readability development, developing
great tool for data analysis
teaching Strong typing: and machine Versatility:
programming Helps prevent learning Can be used
concepts common for both
Widely programming Readability: client-side
available: mistakes Clean and easy and server-
Found on Influence on to read syntax side
many early other development
computer and language: Has Large
systems influenced community: A Dynamic
other strong nature:
programming community Allows for
languages, and an flexible and
including C++ extensive dynamic
and Java library programming

Rapid Large
development: ecosystem: A
Allows for vast
quick ecosystem of
prototyping libraries and
and frameworks
development

Weaknesses: Limited Steeper Performance: Complexity:

capabilities: learning curve: can be slower can be more
Not as Can be than compiled complicated
powerful or challenging to language like than Python
versatile as beginner C++ or Java for for beginners
other programmers computationall
programming due to its y intensive Browser
languages stricter syntax task compatibility:
and structure Can be
Older syntax: Indentation- challenging to
Outdated Less flexible: sensitive: ensure
syntax compare compared to requires strict compatibility
to other some other adherence to across
modern languages, indentation different
language PASCAL can rules, which browsers
be less flexible can be
Less widely in terms of challenging for Performance:
 used: Less syntax and beginners Can be
popular in structure slower than
modern compiled
development Less widely languages for
used: Not as computationa
popular in lly intensive
modern task
development
as other
language

Adoption and Community Support

Beginner’s All-Purpose Symbolic Instruction Code (BASIC), developed in the

1960s, was a popular programming language in the 1970s and 80s, especially for
beginners and home computers like the Apple II and Commodore 64. It was widely
adopted in schools and by early personal computers but lost popularity as more
powerful languages like C and Java emerged.

Today, BASIC is mostly used in niche areas or legacy systems. Visual Basic (VB)
and its modern version, VB.NET, still see some use in business applications, especially
for automating tasks in Microsoft Office, though other languages like Python are
becoming more common.

The BASIC community, once large, is now smaller but still active among
hobbyists and retro computing enthusiasts. Some dedicated groups continue to work
with modern versions of BASIC, though it's no longer widely used in the tech
industry.

In conclusion, BASIC was a popular beginner's programming language in the

1970s and 80s, but its use has declined with the rise of more powerful languages. While
mostly used in niche areas today, it still has a small, dedicated community.
 Case Study Details

Problem/Challenge Addressed

According to the study, students frequently hold certain misconceptions about

the syntax and semantics of BASIC programming. The major purpose of this study
was to determine if the common misconceptions which high school students have
about syntax and semantics in the BASIC programming language can be reduced by
specific instruction in the problem areas.

Methodology

This section provides a comprehensive overview of the methodology

employed in the case study, detailing the specific procedures, techniques, and tools
used to gather and analyze data.

The study involved 33 high school juniors and seniors, consisting of 19 girls
and 14 boys, enrolled in an introductory BASIC programming course during the
spring semester of 1987. This course is an elective in the high school curriculum and
has no prerequisites. Participants were divided into two groups: the control group,
consisting of 11 students receiving routine instruction, and the experimental group,
comprising two classes of 11 students each, receiving enhanced instruction designed
to address common misconceptions in BASIC programming. Prior to taking the
course, five of the students had taken a two-week introductory course in computers
offered prior to 1984. The remaining students had no prior knowledge of BASIC
programming.

Analysis of Covariance (ANCOVA) and t-tests were employed to evaluate the

programming performance of students. To assess the effectiveness of the instructional
methods, all students took the Test of BASIC Misconceptions as both a pretest at the
beginning of the semester and a posttest during the final week. This test evaluated
students' understanding and misconceptions related to BASIC programming.

Posttest scores of both groups were compared to measure the effectiveness of

the enhanced instructional methods used with the experimental group. The same
programming assignments were made for both groups during the semester. Each
student was required to submit working (error-free) programs and a record of the
number of times each program was executed before it was error-free.

Both groups received the same amount of instructional time (55 minutes per
day) and used the same textbook, Understanding BASIC A Structured Approach by
Steven and Colleen Mandell. The control group followed a traditional instructional
method that involved reading chapters from the textbook, completing vocabulary and
questions at the end of each chapter, and performing programming assignments and
tests. In addition to textbook instruction, the experimental group participated in
specific activities aimed at reducing misconceptions. These activities included:
Debugging programs with syntax and logic errors, completing a program
demonstrating an iterative control structure, reading and predicting the output of
short programs, constructing flowcharts before coding, and writing short programs in
class.

The homework assignments, Activities 1 to 4, were completed outside of class

to keep both the control and experimental groups on the same pace during the
semester. Students from both groups were required to complete three programming
tasks and keep track of how many times they ran each program before getting the
correct solution. The programs involved different structures: the first had simple
sequential statements, the second included selection control (IF-THEN), and the third
required iteration (FOR-NEXT). Both groups submitted error-free programs and their
run counts, which were then compared between the two groups.

Findings and Analysis

This section presents the findings and analysis of data collected from 33
students enrolled in three sections of an introductory BASIC programming course.

The study evaluated whether explicit instruction to address misconceptions in

programming would lead to better long-term performance compared to routine
instruction. The hypothesis that explicit instruction would enhance performance was
not rejected, potentially due to the short duration of the instruction period. The results
suggested that students who received explicit instruction about common flow control
difficulties had fewer logic and syntax errors, less time spent correcting errors, and
overall increased productivity. This finding aligns with Sleeman & Gong’s (1985)
study, which showed that misconceptions could be effectively addressed through
explicit training, prediction of program outcomes, and interactive feedback.

The study found significant differences for programs involving selection and
iterative control structures, but not for sequential statements. Possibly because this
type of program was introduced early in the semester and was equally manageable
for both groups.

An informal observation noted that constructing flowcharts, required only for

the experimental group, appeared to provide better direction for their programming
tasks. Students who created flowcharts spent less time on development and
debugging. This aligns with Wallace’s (1987) study, which suggested that flowcharts
help in early error detection by focusing on problem solutions from the start.

In contrast, students in the control group often lacked clear direction, resorting
to trial-and-error debugging, which aligns with Dalbey and Linn’s (1985) findings that
students without explicit debugging training tend to make unsystematic attempts to
fix errors. Additionally, both groups struggled with reading and predicting program
outputs, indicating a need for more instruction and practice in this area for novice
programmers.
 Impact and Implications

Industry Impact

Since its development in the 1960s, BASIC (Beginner's All-purpose Symbolic

Instruction Code) programming language has had a significant impact on industry
and other domains.

BASIC became prominent in educational settings, particularly high schools and

colleges, for teaching fundamental programming concepts and problem-solving skills.
As mentioned by Dan Maycock, “It was designed to be understood without a deep
background in mathematics or computer science, which made it incredibly popular
among beginners and casual users who were just beginning to explore the possibilities
of personal computers” (Weiss, 2024). He also stated that BASIC's 60-year history has
had a significant impact on a large number of students, developers, and businesses
since its introduction in 1964.

The development of Microsoft's version of BASIC for the Altair 8800 was a
turning point in the company's history. It established the foundation for Microsoft's
future success and dominance in the software industry. Over time, various BASIC
versions and dialects have been standardized and used in a variety of domains,
including business applications and educational software. Many early computer
professionals and software engineers learned to code in BASIC. It served as a starting
point for more advanced programming languages and technologies.

Future Prospects

The BASIC programming language, though considered quite old, has potential
avenues for future development. Some possible directions include:

1. Modern Syntax and Features. BASIC can incorporate modern programming

features from high level programming languages like object-oriented
programming, functional programming concepts, and enhanced error
handling.
 2. Integration with Modern Technologies. Updating BASIC to work perfectly
with modern technologies like web development frameworks, cloud services,
and mobile app development.

3. Enhanced Performance. Optimizing the language's interpreter or compiler to

improve performance, potentially making it suitable for more performance-
critical applications.

4. Cross-Platform Compatibility. Ensuring that BASIC programs can run across

various platforms, including modern operating systems and hardware,
without major modifications.

These developments could help BASIC remain relevant in a rapidly changing

tech industry, especially as a tool for learning and prototyping.

Lessons Learned

This section presents the information gathered by the researchers from the case
study.

According to Abutanmo, the study demonstrates that students hold a

misunderstanding about the BASIC programming language as it was suddenly
introduced. The reason is due to the recent implementation of the programming
language. Some students lack understanding and are struggling. BASIC has been
made simpler and easier to understand through its straightforward syntax, interactive
platform, user-friendly for beginners, and ultimately to promote and recognize the
BASIC programming language. BASIC programming language plays a significant role
in the evolution of the IT industry. They created a programming language that can be
understood even without programming experience. It is beneficial to enhance
programming knowledge. As a beginner student, starting with BASIC is
recommended, but sticking with it may hinder progress in programming. Keep in
mind, this language was created in 1964, and our previous generation was considered
cutting-edge. Because today's programming is so advanced, it might be challenging
to grasp BASIC. Our current programming language stands out due to its diverse
functions and designs. Individuals should prioritize new programming languages
over older languages, but they must still acknowledge and incorporate older
languages as they shape and evolve new, complex programming languages.

According to Acodili, programmers have revealed that there are types of false
beliefs that students frequently hold about the syntax and semantics of programming
in BASIC. The purpose of this study was to determine if these misunderstandings
could be reduced by focusing instruction on the misconceptions.

According to Basadre, the case study on misconceptions in BASIC

programming highlights several important lessons. Targeted instruction effectively
reduces misunderstandings, especially when combined with hands-on activities like
debugging and flowcharting. A structured learning approach is crucial for beginners,
as it helps them grasp programming concepts more easily. Debugging exercises also
develop critical thinking skills. The study shows that prior experience with computers
does not guarantee better performance, emphasizing the importance of foundational
teaching. Additionally, inclusive instruction benefits all students, regardless of
gender, and progress can be effectively measured through pre- and post-testing.

As stated by Cahimtong, one important takeaway from the case study on

BASIC programming language is that specific teaching can effectively address
common misconceptions and improve comprehension of basic programming
concepts. Though its concept is simple, BASIC can be difficult for first-time users to
understand in its subtleties. This emphasizes the more general educational idea that
even basic tools require precise, targeted instruction in order to be properly
understood and applied.

According to Carillo, students who are new to a specific programming

language may have some misconceptions and struggles with syntax. Just like in the
case study of the BASIC programming language, Teachers should provide clear and
understandable instruction in those problem areas so that it could lessen the
misconceptions of the students. These problem areas include the assignment
statements, print statements, read statements, variables, loop construction, if
statements, other flow control difficulties, and tracing and debugging. It was found
out that the instruction provided by the teachers was beneficial, but many students
still needed more experience with tracing programs and predicting the output.
Programming is not easy to learn, but if students are passionate or interested enough
in learning programming, then it would be easy for some of them.

According to Gabia, he already have some knowledge about the programming

language BASIC but that was just the surface of it, the programming language offered
quite well in terms of it being a beginner's programming language, with that it was
pretty abundant in early computers with people at their homes doing programming
with their personal computers like the Apple II, it is a big impact towards the IT
industry as it will create more aspires to be programmers it is also beneficial as it.

As believed by Miasco, one of the lessons that can be learned through the study
was that although the BASIC programming language was designed to be accessible to
beginners as well as features simple syntax, the misconceptions of the language are
still present. In reducing misconceptions regarding specific programming concepts,
such as BASIC, targeted instruction was proven effective to lessen the misconceptions.
The BASIC programming language is easy to learn and is a great tool for teaching
programming concepts; however, it is not as powerful as other programming
languages, and its syntax is outdated. To conclude, there are always misconceptions
present, even at the most basic things.

According to Rodriguez, without the BASIC programming language, the field

of Information Technology would be significantly more difficult to enter as all
previous coding languages were complex and not very user-friendly since coding
languages at the time required a deep understanding of advanced math and data
structures, which is very difficult for novices, thus resulting in the creation of the
BASIC Coding Language for hobbyists and amateurs. The BASIC programming
language was invented in 1964 by two professors at Dartmouth College:
mathematician John Kemeny and computer scientist Thomas Kurtz. Their goal was to
create a simplified programming language usable by: "Undergraduate students who
had no prior computing experience... would use the time-sharing system without
having to enroll in a computer science course." BASIC has an English-like syntax that
lends itself to readability and learning compared to predecessors of its time. Without
BASIC, coding would be very different today, as coding may only be accessible to the
few with an advanced understanding of math and data structures. Everyone are
fortunate to be living today where everything has been simplified to make coding not
just more accessible but also easier to do.

According to Sanglay, BASIC also known as Beginner's All-purpose Symbolic

Instruction Code is a high-level programming language designed to be simple and
easy to use. Its evolution over the decades reflects changes in technology and
programming needs. BASIC is often disbelieved as obsolete and it is frequently
misunderstood as incapable of handling modern programming needs. Initially
designed for educational purposes, BASIC has evolved significantly, offering robust
features in various and making it accessible for beginners, building a foundation for
learning more complex languages. One study reported numerous misconceptions
held by high school students in beginning BASIC programming courses. These
misconceptions were associated with assignment statements, print statements, read
statements, variables, loop construction, if statements, other flow control difficulties,
and tracing and debugging. These frequent errors and challenges due to
misconceptions can undermine students' confidence in their programming abilities.
This lack of confidence can affect their motivation and willingness to engage with
more complex programming tasks. By addressing these misconceptions is crucial for
developing a solid foundation in programming. Correct instruction can help students
understand and rectify their errors, leading to more effective programming skills.

According to Ybañez, Stemler’s study serves as a reminder that programming

takes more than just presenting the basics. It involves finding the misconceptions that
students encounter while giving them tools to help them overcome those challenges.
Learning to program isn't always easy, but in the right direction and the willingness
to learn, it can be an enjoyable experience.
 Conclusion

Summary

BASIC, or Beginner's All-purpose Symbolic Instruction Code, was developed

in the 1960s by John G. Kemeny and Thomas E. Kurtz to make programming
accessible to students and beginners. Despite its initial success in education, BASIC
has faced challenges in adoption within schools and universities, resulting in
misconceptions and learning difficulties. A study by Stemler in 1989 aimed to explore
how instruction can reduce misconceptions about BASIC's syntax and semantics.

The study evaluated 33 high school students in an introductory BASIC

programming course, comparing traditional instruction with enhanced methods
designed to address misconceptions. Both groups received the same amount of
instruction time and used the same textbook, however the experimental group was
assigned additional tasks such as debugging and flowcharting. Analysis showed that
enhanced instruction led to better performance in programs involving selection and
iterative control structures, but not in sequential statements. The overall impact of the
enhanced instruction was limited, possibly due to the short duration of the instruction
and existing research suggesting that teaching methods alone may not significantly
affect performance.

Personal Reflection/Opinion

This section presents the researchers' viewpoints on the programming

language's effectiveness or relevance in the context of the case study.

According to Abutanmo, IT students often have misconceptions, believing the

field is not for them if they lack programming experience or feel out of place because
their classmates have programming knowledge. However, it's been shown that people
can learn programming without prior knowledge, and programming languages are
designed to be simplified so that students can understand them more easily. He might
stick around on this course; if this course does not fit him, he might shift to a new
course, but for now, he will do his best to finish this course with no problems. For him,
it depends on whether you are eager enough to learn about things. The difference
between BASIC programming and this generation of programming is way too far. If
BASIC is simplified so students can easily understand it, then this generation of
programming might too. There are a lot of videos you could watch to understand the
principles of programming for free. It doesn’t mean that if people have no idea about
programming, they are not qualified to take that IT course. If people want to learn
about something, it's all about making an effort for themselves.

According to Acodili, BASIC programming case study highlights the fact that
students may encounter difficulty with a language which is designed to be simple.
This reiterates the fact that just because a design is readable, it is not easy to design it.
Most impressive is the role of effective teaching in making clear the misconceptions
and improving the understanding of a topic. These findings of the study emphasize
the need to take care of students’ existing problems too while teaching the
programming language. This strengthens the notion that merely transferring
knowledge is not enough in an educational setup, teachers have to make intervention
in order to put an end to student’s misconceptions and get them to think genuinely.

According to Basadre, the case study "Effects of Instruction on the

Misconceptions About Programming in BASIC" looks at how better teaching methods
can help reduce common mistakes students have about the BASIC programming
language. Even though BASIC is simple, students still have trouble with things like
how the code is written (syntax) and how it works (semantics). The study compared
two groups: one that got regular teaching and another that did activities like fixing
errors, making flowcharts, and analyzing code. The results showed that the special
activities helped students better understand BASIC. This shows that hands-on,
problem-solving tasks are important in learning programming. The study highlights
that teaching needs to be more interactive to help students really understand
programming, even with newer programming languages.

According to Cahimtong, upon closer inspection of the case study on BASIC

programming, it is evident that learners might encounter difficulties with a language
that is supposed to be simple. This serves as a helpful reminder that readability is not
always correlated with design simplicity. She was impressed by how effective focused
teaching can be in dispelling misconceptions and improving comprehension. The
results of this study highlight the value of addressing students' particular obstacles in
addition to teaching programming languages. The statement reaffirms that providing
knowledge alone is not enough to ensure effective education; rather, teachers must
actively address students' misconceptions and assist them in gaining comprehension.

According to Carillo, while the BASIC programming language is not widely

used today, it has influenced other programming languages. During the late twentieth
century, some programmers' first programming language was BASIC. BASIC is one
of the first high-level programming languages designed to be simple to learn for
beginners, particularly non-computer science majors, and to run efficiently on a time-
sharing computer with multiple users. Despite its simplicity, the case study found that
some learners struggle with the BASIC programming language, such as print
statements, if statements, read statements, and variables. Conducting effective
teaching instruction in these areas will help to reduce student misconceptions.

According to Gabia, he has reflected that the BASIC (Beginners All Symbolic
Instruction Code) programming language did its part in the programming language
tech tree that taught young programming aspires on how to code. Despite it being a
low-level programming language, it still aimed for beginners as what the name is
based upon and to get a feel for what programming is and teach them about it. With
its updates and tweaks, it has grown to be a good language, but since it is old, it won’t
be able to compete with modern languages with stronger and better features.

According to Miasco, the BASIC programming language is useful in the field

of teaching programming; however, it is not advisable as its syntax is outdated in
modern development. Despite the fact that the language is outdated in modern
development, BASIC has had a lasting impact on programming and education and is
still in use due to its simple programming and being easy to learn. There are also new
programming languages that are considered as the modern BASIC programming
language, like PureBasic, which is based on BASIC and developed by Fantaisie
Software.

According to Rodriguez, when he first encountered BASIC, it was like opening

a door to a new world. BASIC was created by John G. Kemeny and Thomas E. Kurtz
in 1964. It was designed to be simple and accessible, which was a game-changer for
someone who was just starting out in the world of programming.
 According to Sanglay, the BASIC programming language was designed with a
simple and easy to understand syntax, which allowed users with minimal
programming experience to write and understand the code. BASIC was one of the first
languages to be included in personal computers, which greatly contributed to its
widespread use. It's clear that its significance has evolved greatly over time. When
BASIC was first introduced in the 1960s, it was revolutionary for its simplicity and
accessibility. Its straightforward syntax and clarified features made it an excellent
teaching tool and a stepping stone for many early programmers. BASIC was
instrumental and a foundation to programming skills. For many, it was their
introduction to the logic and problem-solving aspects of programming. However, as
technology advanced, BASIC's limitations became more apparent. BASIC struggled
with more complex applications and lacked modern programming features like
structured data types and advanced control structures. As a result, more powerful
programming languages such as Python, Java, and C++ have made BASIC obsolete in
the professional field. BASIC's legacy endures, like its variants the Visual Basic have
contributed significantly to software development, particularly in business
applications.

According to Ybañez, a group of students studying BASIC (Beginners all-

purpose Symbolic Instruction Code) had misconceptions about it being too simple and
no longer relevant. However, the study found that with the right kind of instruction,
those misconceptions can be cleared up. BASIC was once popular for teaching people
how to program due to its ease of learning. However, some judged it as not being
serious enough because of its simplicity. Like, "Oh, it's just BASIC; it's not like a real
programming language." The study demonstrates that this is incorrect because BASIC
is also a powerful language. The lesson learned is that "Do not judge a book by its
cover" or "BASIC" by its simplicity; even if it is not as advanced as modern languages,
it still has things to do and is used in a variety of ways, including automating tasks
and even creating apps.
 References

Abby. (2023, July 31). BASIC Programming Language: History, Origin, and More.
History-Computer. https://history-computer.com/technology/basic-
programming-language-guide/

Bellis, M. (2019, January 27). The History of the BASIC Programming Language.
ThoughtCo. https://www.thoughtco.com/history-basic-programming-
language-1991662

Contributor, T. (2019, May 30). BASIC (Beginner’s All-purpose Symbolic Instruction

Code). WhatIs. https://www.techtarget.com/whatis/definition/BASIC-
Beginners-All-purpose-Symbolic-Instruction-Code

Corbato, F. J., Merwin-Daggett, M., & Daley, R. C. (1962). An experimental time-

sharing system. In AFIPS Conference Proceedings, Vol. 21. Palo Alto, CA:
National Press.

Dalbey, J., & Linn, M. C. (1985). The demands and requirements of computer
programming: A literature review. Journal of Educational Computing
Research, 1 (3), 253-274.

Eck, D. J. (n.d.). A Comparative Analysis of BASIC, Python, and JavaScript for

Introductory Programming Courses. Retrieved from http://www.diva-
portal.org/smash/get/diva2:1355073/FULLTEXT01.pdf

Feldman, M. (2007, February 12). The Evolution of Programming Languages: From

BASIC to Python and JavaScript. arXiv.org. https://arxiv.org/pdf/2007.02699.

GeeksforGeeks. (2022, July 11). The Evolution of Programming Languages.

GeeksforGeeks. https://www.geeksforgeeks.org/the-evolution-of-
programming-languages/

History Tools. (2024, March 26). Introduction to the BASIC programming language.
https://www.historytools.org/introduction-to-basic

How BASIC inspired today’s important programming languages. (2019, September

27). The UK2 Blog. https://www.uk2.net/blog/how-basic-inspired-todays-
important-programming-languages/
Hunt, A., & Thomas, D. (1999). The Pragmatic Programmer: From Journeyman to
Master. Addison-Wesley Professional.
IEEE Spectrum. (2019). The 50-year history of BASIC, the programming language that
made computers personal. IEEE Spectrum. Retrieved from
https://spectrum.ieee.org/computing/software/the-50year-history-of-basic-
the-programming-language-that-made-computers-personal
Iverson, K. E. (1971). A comparison of ALGOL and BASIC. Communications of the
ACM, 14(6), 390-396.

Kemeny, J. G., & Kurtz, R. C. (1964). The programming language BASIC. Dartmouth
College.

Kemeny, J. G., & Kurtz, T. E. (1964). BASIC instruction manual. Hanover, NH:
Dartmouth College.

Kurtz, T. E. (1981). BASIC. In R. L. Wexelblat (Ed.), History of programming languages

(pp. 515-537). New York: Academic Press.

Mayer, R. E. (1979). A psychology of learning BASIC. Communications of the ACM,

22(11), 589–593. https://doi.org/10.1145/359168.359171

McCarthy, J., et al. (1963). A time-sharing debugging system for a small computer. In
AFIPS Conference Proceedings, Vol. 23, pp. 51-57. Washington, D.C.: Spartan
Books.

Microsoft. (n.d.). Visual Basic documentation. Retrieved from

https://docs.microsoft.com/en-us/dotnet/visual-basic/
Naur, P. (Ed.). (1960). Report on the algorithmic language ALGOL 60. CACM, 3(5),
299-314.

Pratt, M. J., & Zelkowitz, M. V. (2001). Programming languages: Design and

implementation (3rd ed.). Addison-Wesley.

Samelson, K., & Bauer, F. L. (1960). Sequential formula translation. CACM, 3(2), 76-83.

Senn, J. A., Gibson, V. R., & Hoopes, J. S. (1986, Winter/Spring). The impact of training
methods on the performance of programmers. AEDS Journal, 2(4), 234-247.
Sleeman, D., & Gong, B. (19S5, March). From clinical interviews to policy
recommendations: A case study in high school computer programming.
Stanford: Stanford University School of Education. (ERIC Document
Reproduction Service No. ED 257 415)

Stemler, L. (1989). Effects of instruction on the misconceptions about programming in

BASIC. Journal of Research on Computing in Education, 22(1), 26–34.
https://doi.org/10.1080/08886504.1989.10781899

Techopedia. (2016, December 23). Beginner’s All-Purpose Symbolic Instruction Code

(BASIC). Techopedia.
https://www.techopedia.com/definition/27138/beginners-all-purpose-
symbolic-instruction-code-basic

Wallace, D. C. (1987, March). Structured flowcharting versus structured pseudo-

coding in teaching problem-solving skills in software design: A critical
comparison. ProceedingJ of the 2nd Annual Datacon Educators Conference,
199-243.

Weiss, T. R. (2024, May 31). BASIC at 60: How this simpler language impacted
programming. The New Stack. https://thenewstack.io/basic-at-60-how-this-
simpler-language-impacted-programming/

Wexelblat, R. L. (Ed.). (1981). History of programming languages. New York:

Academic Press