
Programming is not algebra - krogsgard
http://andy.wordpress.com/2012/05/30/programming-is-not-algebra/
======
tikhonj
It's funny--I've just spent several days realizing exactly the opposite.
Namely, programming _is_ algebra. Not high school algebra, granted, but
abstract algebra. I've seen patterns from abstract algebra come up several
times in programs I've worked on recently, but I didn't know enough about the
subject to take advantage of them. Abstract algebra has definitely moved up on
my list of subjects to learn soon!

Abstract mathematics aside, this article is a perfect case for using Scheme as
an introductory language. Scheme does not have false cognates in its syntax--
it practically doesn't have syntax at all! C-style assignment syntax _is_
needlessly confusing; the only reason people still use and teach it is because
they're acclimated to it.

Scheme has some other big advantages as well. It's _exceptionally_ simple, so
there is much less incidental complexity to trip up the student. Additionally,
it has far less magic than other languages. Assignment is built into the
language, but the syntax isn't: changing a variable looks much like calling a
normal function. The same is true for OOP. I found this a big advantage--it's
much easier to see that OOP is not the one true way, and that there is no one
true OOP way, when things like classes and inheritance are not built into the
language. Scheme shows OOP for what it really is: a design pattern that can be
useful in certain cases. Compared to a dogmatic language like Java, this is a
breath of fresh air!

Scheme is also very multi-paradigm. It supports functional programming far
better than any mainstream languages but also supports imperative and OO
programming well as well. You can even reuse the same syntax for
nondeterministic or logic programming. The best bit is that it supports all
these paradigms in very similar ways--it lets them stand on their own merits
rather than pushing you towards or away from any of them.

The most important idea in computer science is abstraction, and Scheme is
extremely well-suited for teaching students about it. Beyond this, Scheme is
also just a fairly pleasant language to use for normal tasks.

~~~
perfunctory
> this article is a perfect case for using Scheme as an introductory language

People keep saying that. That Scheme is a perfect introductory language. I
doubt though that there is _any_ evidence to suggest that students who start
with Scheme end up being better programmers.

I love functional programming, but I don't see any correlation between one's
first programming language and their programming abilities.

~~~
endgame
> I don't see any correlation between one's first programming language and
> their programming abilities.

I don't see tikhonj saying that at all. I read it as an assertion that scheme
is a superior language for bootstrapping people into the programmer mindset.

~~~
perfunctory
> that scheme is a superior language for bootstrapping people into the
> programmer mindset.

And I am saying that there is no evidence to support that assertion.

~~~
brudgers
One might say that a Lisp dialect overcomes the difficulty suggested by the
author because:

1\. Code looks less like algebra than many other languages. 2\. The algebraic
symbols Lisp dialects use tend to carry their algebraic meanings, e.g. "(" and
"*". 3\. Fewer side effects make the language read more similarly to algebra,
in so far as it is centered around determine values.

That's not to say that Lisp dialects are the best starting point for learning
programming. Only that they appear to address the issue of syntax raised in
the article.

------
currywurst
This is the first time I'm hearing a beginner looking at a program as
algebraic equations! I wonder how people with such backgrounds will take to
Haskell. I think their intuitions will get them a long way ...

~~~
tikhonj
I've certainly seen plenty of beginners get confused by the idea of mutable
state and assignments. The unfortunate syntax that _looks_ like an equation
but isn't doesn't help. When I was teaching Java to some younger students in
high school, I had consistent problems explaining the idea of variables. Then
again, I'm not the best of teachers :P.

Seeing someone like that start with Haskell would be pretty cool. There, at
the very least, the equations are actually just that.

~~~
EvilTerran
The Oxford undergraduate CS course starts people on Haskell before touching
any other languages, and the prospectus actively discourages people from
picking up a language as "prep work" (although, of course, most applicants are
avid programming tinkerers already).

My impression was that those with very little practice programming found
Haskell no harder to pick up, if not a bit easier, than those who'd played
with imperative languages beforehand -- everyone had a good grasp of high-
school algebra (being most of the entrance exam), and that seemed to help more
than any programming skills.

~~~
tikhonj
As you can guess from my other post, the intro CS class at my school
(Berkeley) was based around Scheme and SICP.

I noticed the something similar: people with no previous experience found
Scheme much easier to pick up than Java. (Java was, unfortunately, the
language in the second CS class.) In fact, as odd as it may seem to people
well acquainted with C-like languages, people even had problems with the
syntax. Some students just didn't know where to put the curly braces in if
statements, for example.

I think starting from Haskell or ML would be similar to starting from Scheme.
While I actually like Haskell more for programming, I think Scheme has some
slight advantages for _learning_ : there's no syntax, it's very simple and it
supports a ton of different paradigms. I would personally like to cover a
whole bunch of different paradigms in Scheme before specializing with
languages like Haskell or Prolog.

~~~
EvilTerran
Regarding advantages for learning, via introducing concepts incrementally,
Haskell has its own strengths over Scheme as well as vice-versa. You can start
on both with "the interactive interpreter is a calculator!", and introduce the
non-numeric data types -- but then, in Haskell, you can bring in the various
monads to introduce other paradigms.

For instance: once the students have a handle on pure code, show them State
for, well, state; Maybe/Either for exception handling; Writer for output;
lists for prolog-esque non-determinism; ST for a richer model of mutable
state; and finally IO for side-effects.

Also, I guess I like "getting them while they're young" when it comes to
static typing -- it encourages a certain rigour of thought that I feel serves
me well even in dynamically typed langauges.

------
dinkumthinkum
I think your three steps are basically Scientology's "Education Tech." :) But
seriously, it's sort of common sense. I think the key is does the subject
engage you enough to want to do all that work? If not then either the
presentation should change or maybe you're not into it or not ready to be into
it.

Nevertheless, what's really wrong with starting with basic assembler, like on
MIPS or something. You don't have any of these kinds of expressions like "a =
b + c" to confuse people!

Knuth is without parallel but I think for the beginner that example you cited
might be too abstract for many newcomers, they may have trouble seeing that
associated with how the "blinky light box" really works. :) But sure, using
any language which uses different semantics for settings variables than simply
algebraic looking statements would probably solve that problem.

~~~
skeltoac
OP here. You correctly spotted Hubbard's "Study Tech", a modern formalization
of common-sense learning habits. It is a good system independent of the rest
of his work. I omitted the credit because many readers would hasten to
generalize (i.e. commit an association fallacy[1]) and dismiss the system as
inherently crazy.

[1] <http://en.wikipedia.org/wiki/Association_fallacy>

~~~
dinkumthinkum
Ah yes, Study Tech, I had a total brain freeze on that one. :)

------
colanderman
_?- A = 10, B = 20, A = B.

false._

Her intuition checks out in my REPL.

Seriously though, I'm surprised no-one has mentioned Prolog yet. It's the
closest popular language to honest-to-goodness mathematics, to the point that
some Prologs can solve linear equations that are written exactly as a system
of equations.

~~~
sbmassey
I was going to say the same thing.

'cut', of course, destroys the purely algebraic nature of the thing, and
forces you to understand the whole search-tree and backtracking part of the
language, but the basics work.

------
krollew
Maybe you should suggest some language that don't create such problems? There
are many languages that use mathematical symbols similar way to maths.
Functional languages should be better, since there variable values are not
reassigned too often. There are also languages that use another operators for
value assignemnt, like := in Pascal and <\- in GNU R.

------
dasil003
> _Um… 10 and 20… but then how can a be equal to b? Programming is not for
> me._

Jumping to this response really bothers me. If you can put your finger on the
exact contradiction shouldn't that allow you to seek an explanation rather
than throwing your arms up and assuming it's not for you?

~~~
scotty79
It's kind of natural response when you encounter something that doesn't match
what you already know. When I approach new subject I almost always go through
that stage. "This is just silly." "This is crap." "I hate this." "Not for me."
But that dissonance between the fact that I see something as stupid and the
fact I also see people doing this makes me want very hard to understand why
people are doing this. Often it leads me to better understanding of the
subject, sometimes to better understanding of the people.

------
Dn_Ab
Programming can be algebraic or a basic application of logic depending on how
imperative you lean but algebraic thinking does help code.

The best way to teach someone who knows algebra but is new to programming how
to not excessively repeat themselves and to use functions is to tell them to
factor out the commonalities. This analogy to factoring in algebra really
helps someone who understands the concept but hasn't grokked its application
to programming yet.

------
dons
_Imperative_ programming is not algebra.

(Well, it still is, but its an algebra of state).

------
jorgeleo
Short version:

Some programming languages use the same symbols and notation to mean something
different that algebra. Chances are you will get confused if you come from an
algebraic background. I Reached to this conclusion based on a single data
point: a friend of mine.

Problems like this was what Niklaus Wirth was trying to solve when creating
Pascal. The assignment symbol in pascal is :=

Or maybe she would have been better begging with assembly (if I remember my
6502 correctly):

    
    
        .macro a $300
        .macro b $302
    
        LDA a
        STA b
    

The assignment clearly looks different than algebra.

------
rytis
_Instead of a program, she saw three statements of equality and assumed they
were a system of simultaneous equations._

Er, BASIC line numbers kind of made it easier to get my head around the
concept.

------
ThePherocity
Programming is algebra in some instances, it's calculus in others. When you
want to display something to the screen it's geometry and trigonometry and if
you're you're doing 3d work its' linear algebra.

------
keymone
drop the "not" from your title and people will think that you're incredibly
smart before even reading the article.

