Here are some of the most widely used and influential programming l...
### Sapir-Whorf hypothesis
The Sapir-Whorf hypothesis suggests tha...
### BASIC
In the early 1980s, BASIC was the dominant language on p...
In FORTRAN, especially in older versions of the language, you canno...
Early versions of BASIC, especially those used in microcomputers in...
### APL
APL (A Programming Language) is a high-level programming l...
SOFTWARE-PRACTICE
AND
EXPERIENCE,
VOL.
11,
733-740
(1981)
The Consequences
of
One’s First Programming
Language
RICHARD L. WEXELBLAT
Sperry
Univac,
Blue Bell,
PA
19424,
U.S.A.
SUMMARY
After seeing many programs written in one language, but with the style and structure of
another,
I
conducted an informal survey to determine whether this phenomenon was
widespread and to determine how much a programmer’s first programming language might
be responsible.
This paper discusses my observations, gives informal results
of
the survey and suggests the
need for a more formal study.
KEY
WORDS
Programming languages Teaching programming Education
BACKGROUND
What experienced programmer has not seen programs written in one language that
have the style of another language? Having experienced ‘FORTRAN with semicolons’
and ‘C with
a
BASIC flavour’ over the years, I began to wonder whether the
programmer’s first programming language had an effect on programming ability as
profound as the effect of one’s native language on one’s thought patterns.
Referring to what has been called the Sapir-Whorf Hypothesis, the logician W.
V.
0.
Quine has said ‘One frequently hears it urged that deep differences of language carry
with them ultimate differences in the way one thinks, or looks upon the world’.’ Dwight
Bolinger characterizes the hypothesis:
Since every language has a form and no two forms are the same, it follows that
no two cultures having different languages can have identical views
of
the
world. Instead
of
a perfectly flexible rubber mask that shapes itself to reality,
each language is somewhat like
a
Greek mask with its built-in scowl or grin.2
Over many years
of
programming, teaching programming, and debugging other
people’s programs, it has seemed to me that something akin to the Sapir-Whorf
Hypothesis applies to programmers-especially to those who have never been taught to
abstract the development of algorithms from the development of programs. Indeed, I
began to worry about the consequences of loosing on the computer centres and
computer science departments of the world a horde of programmers whose total
background is a rudimenatry BASIC learned in elementary or high school from a
teacher who has virtually no actual programming experience.
Kathy Hirsh-Pasek, who read an earlier version of this paper commented that I
I.
. .
should realize that the Whorfian hypothesis has both
a
strong version, “language
003 8-0644/81/07073 3-08$01
.OO
@
1981
by John Wiley
&
Sons, Ltd.
Received 14
August
1980
Revised
3
November 1980
734
R.
L.
WEXELBLAT
determines thought”, and a weak version, “language influences thought”: The strong
version which is depicted by this quote (i.e. Bolinger), is almost always contested. The
weaker version is virtually tautological’. My feeling is somewhere in between.
Of course, there are many fine teachers of programming at the pre-college level-and
my rude remarks also apply to some who teach programming outside of the high
schools and elementary schools. I see two interrelated problems: the teaching of the
programming language
and the teaching of
programmingper se.
Although there are some
who can ably and successfully teach the former, there are lamentably few who can teach
the latter. It is the effect of poor teaching and limited languages on the malleable minds
of youth that concerns me here.
If the language does even influence our way of thinking about programming then
it
is
quite important that we teach the concepts of programming before we teach the
language. Otherwise the biases will become ingrained.
In
1978
I published
a
request provocatively entitled ‘Youthful indiscretions, or is
BASIC bad for your health?’ in
a
series of journals, asking for information on
experiences that might confirm
or
deny my hypothesis. (The text of the letter is
appended below).
I
received almost
50
replies broken down roughly as:
30
addressing my points
12
not relevant
4
pointers to other sources
2
attacking me for raising the issue in the first place.
SUMMARY OF FINDINGS
There seems to have been no serious attempt at a controlled statistical study of the later
effects of the first programming language. Indeed, the problems of designing such an
experiment would require a major commitment of time and resources and a very large
population of students studied for years. I have come to this conclusion after thinking
about the enormous number of independent variables and their cross-correlations. For
any observed aspect of programming behaviour, there seem to be dozens of equally
valid alternative explanations. Without access to a large sample of students learning the
same language on the same operating system from the same teacher, etc., there seems
no way to isolate cause and effect from noise and artifact. Hirsh-Pasek adds that this is
why psychology and education are separate disciplines. ‘You can’t do pure research and
control variables in the classroom. Even if teacher, book and socioeconomic status are
controlled, individual and other differences wash out results’.
With the understanding that no universal truths are implied, here are some highly
subjective conclusions. There is no hard evidence to support or to deny any of these
opinions.
0
Programmers tend to favour their first language even to the extent of applying the
style or structures
of
this language when they program in other languages.
This tendency may be reduced by many other factors such as the length of time
the first language was used exclusively, the skill with which the second language
was taught, and the innate ability of the programmer.
ONE’S
FIRST
PROGRAMMING
LANGUAGE
73
5
0
Those who begin with an assembly language often have an unfortunate tendency
to prefer assembly language. Otherwise there seems to be no long-term effect on
the ability to assimilate new high level languages.
I believe this to be due to the very low level of most assembly languages. The
programmer is forced to abstract the conceptualization of the problem from the
coding of the solution.
0
The effects of poor teaching of programming methodology are probably as
important as the effects of
a
poor first language. Although (I repeat) there is no
significant quantitative evidence for this point of view, many programmers,
teachers, and managers of programmers have independently come to this
conclusion.
The usual result of linguistic myopia
(or
poor training) is the inability to abstrqct data
and control structures, the inability to separate the problem solving from the solution
implementation. In current jargon, the problem relates to the differentiation between
procedural
and
functional abstraction. A common manifestation is the tendency to
go
directly from problem statement to code without any intervening design steps. When
a
problem is too big to code directly, the programmer may try to cut off small chunks and
code them in the hope that ‘getting something running’ will eventually lead to a
solution. Such a
modus
operandi
is typical of the bottom-up design methodology that is,
I hope, discredited as an overall design strategy.
Programmers who think of code in concrete rather than abstract terms limit
themselves to the style of data and control structures of their ingrained programming
habits. A FORTRAN programmer who has successfully designed a payroll system
may not see any value in the ability to combine numeric and alphabetic information into
a single data structure. BASIC programmers often find no use
at
all
for subroutine
formal parameters and local variables.
The mind-set problem, works both ways: the PASCAL programmer who is forced to
use FORTRAN or BASIC may end up writing awful programs because of the difficulty
in switching from high-level to low-level constructs. APL converts seem to abhor
all
other languages.
TABULATION OF RESPONSES
My initial query was too loosely worded. After looking at the responses, I tried to
formulate a series
of
statements and then to tabulate (or in some cases deduce)
agreement or disagreement.
0.
The first language does indeed affect later programming ability.
Yes:
12,
no:
5
(Most of the yesses are from people observing other people; the
noes,
all
from people describing themselves.)
1.
Those who start with a limited language may find it hard to make full use of higher
level languages later on.
Yes:
7,
no:
7,
maybe:
2
Yes:
5
Yes:
9,
no:
1
2.
BASIC is a limited language.
3.
A small language is
a
good first language.
736
R.
L.
WEXELBLAT
4.
For beginners, the distinction between writing a program, translating it and
executing it is missing.
Yes:
2,
yes (but good):
3
Yes:
3
PASCAL:
5
PL/C (or similar):
5
Algol:
2
PL/I:
2
Assembler:
2
FORTRAN:
1
APL:
1
Structured pseudo-code:
2
COBOL:
7
FORTRAN:
3
PL/I:
3
Assembler:
2
BASIC:
2
Algol:
2
APL:
1
SNOBOL:
1
PASCAL:
2
LISP, Assembler, Algol, APL:
1
each
APL, BASIC, COBOL:
1
each
5.
The programming process is not learned when a limited language is used first.
6.
Good first languages are:
7.
Bad first languages are:
8.
Good later languages are:
9.
Bad later languages are:
Obviously, not all respondents addressed all of the above items. I was interested to
note that the majority
(5
of
7)
answering no to item
1
themselves began programming
in machine or assembly language.
Some of the respondents’ comments are interesting:
0
Prior experience with FORTRAN and PASCAL interfered with learning LISP.
0
Learning a ‘strange’first language (APL, SNOBOL, LISP) may limit later ability
0
Assembly language programmers are overly concerned with efficiency.
0
COBOL programmers have no insight into programming. (This, from someone
who professed to be a long-time COBOL programmer who had begun program-
ming in assembly language).
0
Managers who know only BASIC cannot understand the need for software
engineering.
0
An advantage to learning BASIC first
is
that you can avoid the need to worry about
data structures.
to program in a ‘classical’ language.
One respondent was a student about to take her first programming course. She was
concerned that learning BASIC would harm her ability to program. (I encouraged her
ONE’S
FIRST
PROGRAMMING
LANGUAGE
73
7
to take the BASIC course but to keep an open mind and to seek out other languages to
learn and use.)
Another respondent declared that he began programming with BASIC and was not
now limited in programming ability in any way. Therefore he is the counter-example
that disproves my hypothesis.
At the
1980
ACM Small Computer Conference, I spoke on this topic. Several in the
audience approached me afterwards with related experiences and anecdotes. All those
who took a programmer’s viewpoint commented that my hypothesis is true enough and
applies to many people-but not to the speakers themselves.
OTHER COMMENTS
Several respondents provided insight into related problems. I will quote from some of
these.
Sam Calvin sent me an interesting report at least part of which has been published in
the AEDS M~nitor.~
He feels that in a computer-illiterate society, the decisions that concern us all will be
made by a computer-literate few. This underscores the need for good training from the
start.
Ned Chapin who has been in the computer field for more than
25
years observes that
if a person has a ‘flexible turn of mind and learns easily’ then it does not matter what the
first language
is.
Starting with
a
low power language will slow the development but
have no long-term effect. For the majority of people, however, the view of the world
imparted by the first language will only slowly be broken. In his own Chapin
treats data structures in one chapter and algorithms in another, independent of any
particular language or formalization.
John Nicholls, whose book on programming languages I heartily recommend’
comments:
My observation is that, more important than one’s first programming language
is one’s first substantial (i.e.
6
months to write) program. At’one time I had
a
theory that many people after completing their first program spent much of
their remaining professional lives trying to repeat it, improve on it, or prove it
is the best. This comes from discussions with
a
number of very experienced
programmers and
I
have found it enlightening, while trying to understand the
seemingly irrational behaviour of
a
colleague, to try and understand their
early, formative experiences.
Alan Perlis, who successfully made the transition from Algol
to
APL, has stated:6
‘I’ve heard from
so
many people who program in Algol-or PASCAL now in
the universities-that they are not willing to learn APL because of the high
threshold investment in their time that it takes. They are not willing to spend
the time
to
think the way I think you have to learn to think if you’re going to
program in APL-to learn to think, so-to-speak, of arrays not as mathematical
objects but as carriers
. .
.
.’
738
R.
L.
WEXELBLAT
Since the most exciting (to me) breakthrough in computer accessibility is the advent
of the home or personal computer, the following comment by Don Tarbell is relevant:
‘Perhaps the single worst problem that the computer hobbyist faces right now is the
lack of a really good high-level language’.’ Although Tarbell recognizes the need for
improved handling of labels, names, I/O, and control structures, it is interesting and
significant that he does not mention any requirement for improved data structures.
INTERPOLATION
It should be obvious that the appeal of BASIC is its ready availability in low-cost
systems in an
interpretive
implementation. In an article on programming in the home of
the future, Bruce Anderson’ argues that programming will be a widespread activity.
For effective use of resources, users must become fluent programmers and that fluency
must come from source-level interaction with a real-time evaluator. He cites LISP,
POP-2 and Smalltalk, but of course, at least in the
U.S.,
BASIC is pandemic. In my
opinion, PASCAL is not the answer (what is the question?) but I welcome the spread of
low-cost PASCAL interpreters for minicomputers.
CONCLUSION
Although everything presented here is anecdotal evidence from which it would be
irresponsible to draw firm conclusions, I cannot help add that my concern about the
future generation of programmers remains. Who knows? Perhaps the advent of
automatic program generators and very high level specification languages will
so
change the way we talk to computers that
all
of this will become irrelevant.
I doubt this, though,
so
I again encourage those who have significant results or who
are in a position to design and conduct experiments to publish. And please, let us
involve trained statisticians in the design and evaluation of these experiments.
Phil Dorn, an old friend who has been involved in programming for years, accused
me of being
a
snob. He sees ‘no connection between what one was first taught and
ability to use the features of the newer (better?) programming languages’. Is BASIC a
programming language? ‘It certainly isn’t a programmers language, but that’s
a
different matter. BASIC is a reasonable tool for the casual or part-time computer user
and
MY
let’s leave it at that’. He adds that the teacher is more important than the language.
reply to Dorn sums up my feelings on the matter.
. .
.
No I (hope I) am not being a snob. I am expressing a concern based,on
limited experience and observation, and trying to confirm or deny an
hypothesis. All of us (old-timers) started with some form of assembler and
then graduated (or regressed
. .
.)
to higher level languages. The important
thing is that we started with
a
language that gave us the full power
of
the
machine and knowing what could be done, we continued to exploit fully
whatever language we happened to be condemned to use.
I’m not really worried about the professional computer scientist. My worry
is that the hordes of children now working in subsets of BASIC will never be
able to make full use of COBOL to write clear, understandable code. You see,
the children are not being taught to program, to express algorithms. They are
ONE’S
FIRST
PROGRAMMING
LANGUAGE
73
9
being taught to do quick and dirty (always dirty, never quick) run-it-once
programs
. . . .
Things will straighten out in time, I’m sure. It’s just that we are facing
a
generation
of
computational Flatlanders who will dominate the coding rooms
for a decade or
so.
These flatlanders will either be robots who code the same program over and over again
or, worse yet, be like the character in the recent movie ‘Being There’, who uses all of the
right terms but whose abstract understanding of them is void. If my inferences are
anywhere near correct, the first language does determine the mental set for the second
and other languages and we must concentrate on the teaching of programming as
a
concept and as a methodology not in Graduate School but from the start.
ACKNOWLEDGEMENTS
I would like to thank
all
those who replied to my query, especially the people whose
responses I quoted above. Thanks also to Kathy Hirsh-Pasek, Mike Schneider, Jeff
Schrager and Dennis Hamilton for comments and discussions based upon the first
version of the paper.
APPENDIX
(Text of original inquiry)
Youthful indiscretions, or is BASIC bad for your health?
There is at least one branch of Cultural Linguistics that teaches that the deep
differences in languages lead to differences in the way one looks upon the world.
(Sometimes referred to as the Sapir-Whorf hypothesis,
.
.
.
.)
I would be interested in hearing about experiences later in life of those who have first
learned a simple programming language (BASIC, LOGO, PILOT, etc.). In the world
of p-baked ideas
(0<
=
p<
=
1)
I have an idea that is about 0-48-baked (i.e. slightly
less than half-baked) and that hypothesis is that few programmers who begin their
programming life with a language
so
limited as BASIC ever significantly extend their
ability to make full use of the data and program structuring capabilities
of
higher level
languages learned later.
In any case,
I
solicit from programmers, managers of programmers, and teachers of
programming answers to the following questions:
What is the effect on later ablility to program of a person’s initial programming
language?
Is BASIC (or FORTRAN, COBOL, PLf I-you supply the name) a good or bad first
language? Why?
If the programmer’s first language is ‘different’ (e.g. SNOBOL, LISP, APL) from
the common languages (e.g. Algol, FORTRAN, COBOL) what effect does this have on
later programming ability?
If enough interesting or significant material appears, I hope to be able to put together
a report affirming or denying the hypothesis stated above. All contributions will be
acknowledged and
all
replying will recieve a copy of the conclusions.
740
R.
L.
WEXELBLAT
(Published
in
SIGPLAN Notices, Personal Computing,
Sof
tware-Practice and
Experience,
APL
Quote-Quad
and
others.)
REFERENCES
1.
W. V.
0.
Quine,
Word and Object,
Wiley, New York,
1960.
p.
77.
2.
D.
Bolinger,
Aspects
of
Language,
Harcourt, Brace, Jovanovich, New York,
1975,
p.
241.
3.
S.
Calvin and
D.
Robertson, ‘Computers in
a
large school system
1966-1980’,
AEDS
Monitor,
17
(+6),
4.
N. Chapin,
Computers, a Systems Approach,
Van Nostrand, New York,
1971.
5.
J. Nicholls,
The Structure and Design
of
Programming Languages,
Addison-Wesley, Reading,
MA.,
6.
A. Perlis, ‘Almost perfect artifacts improve only in small ways: APL is more French than English’, a talk
7.
D.
E. Tarbell, ‘The computer hobbyist-will he be
left
behind?’,
Proc.
IEEE
COMPCON.,
IEEE,
8.
B. Anderson, ‘Programming in the home of the future’,
Int.
J.
Man-Machine Studies,
12,
341-365.
22-23 (1978).
1975.
given at the APL
78
Conference in Los Altos, CA on
29
March
1978.
New York,
1977.
pp.
302-304.
### Sapir-Whorf hypothesis
The Sapir-Whorf hypothesis suggests that the structure of a language affects its speakers' worldview or cognition, and thus people's perceptions are relative to their spoken language. The theory states that the way people think is strongly affected by their native languages.
The hypothesis is named after the American linguist Edward Sapir and his student Benjamin Lee Whorf. Sapir and Whorf believed that language and thought are intertwined, and that different languages encode different categories and distinctions, leading speakers of different languages to think and behave differently.
There are two main versions of the hypothesis:
- The strong version suggests that language determines thought and cognitive categories.
- The weak version suggests that linguistic categories and usage influence thought and certain kinds of non-linguistic behavior.
The Sapir-Whorf hypothesis remains controversial and has sparked much debate in the fields of linguistics, cognitive science, and anthropology.
In FORTRAN, especially in older versions of the language, you cannot have an array or any other data structure that contains both strings and numerics.
Early versions of BASIC, especially those used in microcomputers in the 1970s and 1980s, often had limited or no support for subroutines and functions. When subroutines were supported, they often lacked formal parameters and local variables.
In these early BASICs, all variables were global by default, meaning they could be accessed and modified anywhere in the program. Many early BASICs also didn't support passing parameters to subroutines, forcing them to access and modify global variables instead. This made subroutines dependent on the global state of the program, reducing modularity and making them harder to understand.
### APL
APL (A Programming Language) is a high-level programming language developed in the 1960s by Kenneth Iverson while working at IBM. It was designed for mathematical and scientific computing, and it is known for its concise and expressive syntax, which relies heavily on special characters and symbols.
Some interesting aspects of APL include:
- Array-oriented programming: APL treats arrays as fundamental data types and provides a rich set of primitives for array manipulation.
- Implicit looping: Many operations in APL are performed element-wise on arrays, without the need for explicit looping constructs.
- One-liners: APL's concise syntax allows complex operations to be expressed in a single line of code.
- Dynamic typing: Variables in APL are dynamically typed, meaning their type can change during runtime.
APL was particularly popular in the 1970s and 1980s for its ability to efficiently manipulate large arrays and matrices.
Here is a program using APL which calculates the probability that in a group of ⍵ people, at least two of them share the same birthday, assuming an equal distribution of birthdays throughout the year:
```
birthdaysame←{⎕FR←1287 ⋄ 1-(!365)÷(365*⍵)×(!365-⍵)}
```
### BASIC
In the early 1980s, BASIC was the dominant language on personal computers like the Commodore PET, TRS-80, and Apple II, often serving as the first and sometimes only language learned by many new programmers. BASIC was considered a beginner-friendly but limited language, as it lacked many features and constructs of more advanced languages, such as strong typing and structured programming constructs.
There was a growing concern that the limitations of BASIC, if not supplemented with training in programming methodology, could lead to programmers developing habits that might hinder their ability to effectively adopt more sophisticated languages and programming paradigms later on. This was particularly relevant as structured programming was gaining recognition as an important paradigm.
The potential impact was especially worrying in the context of the personal computer revolution, which made programming accessible to a much broader audience, many of whom were learning BASIC as their first language.
*BASIC prompt in the Commodore 128*
Here are some of the most widely used and influential programming languages available in 1980, along with their primary areas of application:
- **COBOL**: Heavily used in business, finance, and administrative systems.
- **FORTRAN**: Dominant in scientific computing, engineering, and numerical analysis.
- **BASIC**: Popular for its accessibility to beginners, especially on microcomputers.
- **PL/I**: Heavily used in business, scientific computing, and system programming.
- **Pascal**: Gaining popularity for its structured programming features and use in education.
- **C**: Rising in prominence, particularly in Unix environments and systems programming.
- **Lisp**: The dominant language for artificial intelligence research.
- **Algol**: Influential in the development of programming language theory and design.
- **APL**: Used in scientific and numerical computing.
- **Smalltalk**: An influential object-oriented programming language used for educational and research purposes.