[MUSIC] At this point in our study of Racket, you probably notice that there
are a lot of parentheses. So, in this segment, I want to talk about
why that's actually a good thing in many ways.
And then, in the next segment, I want to teach you how to really think about
parentheses carefully and debug when you make mistakes with your parentheses.
So, ignoring a few bells and whistles, a few corners of the language that we
haven't encountered and won't really focus on,
Racket has an amazingly simple syntax. The way we write programs does not have a
lot of complicated rules. In fact, I can pretty much put them all
on this slide. That's amazing.
So, let's go through what the rules of writing Racket programs are.
So, anything you write in a language, what racket people would call a term is
either some primitive atom, atom as in the word for indivisible, coming from the
Greek, right? So, true and false, I haven't shown these to you yet, but you
write them #t and #f, a number, a string, 4.0, variable names,
these are all atoms. There are also certain atoms that are
special forms. Define is a special form,
lambda, if.
Here, I'm just talking about the words, okay? And when we study macros in the
next section we'll be able to define our own special forms,
that's essentailly what macros are but we'll get there.
So, we have atoms, a very small set of them are special forms and then we have
sequences which is just putting some sequence of terms in parentheses.
So, term is a recursive definition, each of these terms could itself be a sequence
or be an atom or a special form. So, the semantics comes straight from
this syntax as follows, if t1 is a special form, well then, we have
different semantics for each special form, if has a meaning, lambda has a
meaning, define has a meaning, and so on. Otherwise, if t1 is not a special form,
it's not one of these special words, then this is a function call and that's
really it. So, let's do a couple of examples.
If I have + 3 car of xs, this is a sequence with three terms + 3 and car of
xs. Plus, it turns out is not a special form,
so this is a function call just like we expect.
Here, I have a lambda, so I also have a sequence of 3 terms, and I'm missing a
parenthesis here. I'll fix that after I record.
So, I have lambda, then this sequence with the x, then an if, and I should
close this with one more round parenthesis,
okay? Since lambda is a special form, that effects the meaning of the rest of
this. So, this next thing is not a function
call, it's the list of parameters and the thing after that is the function body
which is treated as something that we would evaluate as an expression.
That's really all there is to Racket syntax and it's because of all those
parenthesis that it's so simple. One minor note, as long as we're talking
about syntax, you can also use the square bracket anywhere you use the round
bracket. It's really just a matter of style where
you use square, where you use round, never affects the meaning of everything.
We won't be picky about this, but I will show you a few places where square
brackets are the convention. DrRacket is actually kind of nice on this
one if you're writing a bunch of close parentheses.
don't worry about which kind you're closing.
If you, on your keyboard, hit the round parenthesis, but there's a matching open
square bracket, DrRacket will just change it to a closing square bracket for you.
It's just a convenient keyboard DrRacket thing, okay?
So, why are all these parentheses good? There's a few reasons, but the one I want
to emphasize is that converting the program text into a tree that represents
the program is completely trivial. So, let's go straight to the example you
see here, kind of in the middle of the slide.
Here's one of the version of the cube function we wrote a couple of segments
ago. And when you write it, it's just lines of
text, right? It's just, you know, rows and,
and, and columns of, of characters, right? Parenthesis, define, cube, and so
on. Anything that wants to reason about your
program for compiling it, running it, indenting it automatically for you when
you hit Tab, really wants to think about your program
in terms of this tree. You have defined with two children, cube
and lambda. Lambda with 2 children, the argument and
then the body. This body is just a function call with
star in the first position and then 3 children that, in this case, all happen
to be x. The process of going from the code on the
left to the tree on the right, is incredibly easy when all those
parenthesis are there. This is called parsing in programming
languages speak, taking the string of a program and converting it to the right
tree. And when you have all these parentheses,
it's easy enough that there's never any confusion on the programmers part with
how these things are organized. We simply don't have issues like we do in
other languages of things if you have x plus y times z, is that the tree with
plus at the top or the subtree with the multiplication or is the multiplication
at the top with the plus as a subtree? In other languages, we have to come up with
rules for this. In school, you had to learn the mathematical convention that
multiplication binds more tightly than addition.
But in a syntax like Rackets, just use extra parentheses,
put everything in prefix notation, put the times before its argument,
and there's never a bunch of special rules.
Okay. So, it turns out that people tend to not like this.
I don't mind it. Well, some people do but a lot of people
don't like all these parenthesis. So, let me defend the parenthesis for one
slide. First of all, I never hear anyone
complain about HTML. If you go to a webpage and you look at
the source for that webpage, it takes exactly the same approach.
Instead of things like open parenthesis foo, where foo is some kind of special
form, it actually does something even longer.
It writes foo in angle brackets. It's one character longer.
And then, instead of the closed parenthesis, it's much longer.
It writes a slash and it repeats whatever opened the corresponding thing.
And in HTML, you're not allowed to leave off the closed things.
We don't have a bunch of rules where you get to write plus in the middle, but
other things have to go at the beginning. And yet, no one seems to complain about
this. I agree, at first, it's a little harder
to read. It's nice to have an environment that
colors things and indents things for you. But we have all that for Racket and we
have all that for HTML. And yet, all that, going all the way back
to LISP and Scheme and all these languages that, like Racket, use
parentheses for everything, people seem to have what I would even
call an irrational dislike of them. Now, I can have an irrational like and
you can have an irrational dislike because it's just syntax.
This course is not about teaching you which syntax is good or which syntax is
bad. So, we're allowed to have different
opinions. I can like parentheses and you can
dislike parentheses and that's okay. What I think is inappropriate to do is to
dismiss the entire language of Racket just because you don't like parenthesis.
It has a number of interesting constructs, prospectives, semantics that
we want to study. And even if you don't like parenthesis I
ask you to look past them. The analogy I have on this slide is, it
would be like if someone was a historian and wanted to learn about European
History. So, they wanted to learn all about the
different countries, how they came to be, the wars, the social changes and all
that. But there is one particular country where
they didn't like that people's accent. They found that accent hard to understand
and they wished that people didn't talk like that.
And as a result, they never studied that country's history.
I would argue that that would make you a poor historian.
And dismissing all of Racket just because you happen to not like looking at a bunch
of parentheses on your screen, would make you a bit of a poor computer scientist,
okay? And just to finish up, now that I've been a little vigorous and, and
attacking of people's dislikes or preferences, there is a fun cartoon I'm
linked to here that talks about this age-old issue of there being lots of
parentheses in languages like Racket.
