Racket is a great way to learn a language from the Scheme and Lisp families.
From our partners:
I am a big advocate of learning multiple programming languages. That’s mostly because I tend to get bored with the languages I use the most. It also teaches me new and interesting ways to approach programming.
Writing the same program in multiple languages is a good way to learn their differences and similarities. Previously, I wrote articles showing the same sample data plotting program written in C & C++, JavaScript with Node.js, and Python and Octave.
This article is part of another series about writing a “guess the number” game in different programming languages. In this game, the computer picks a number between one and 100 and asks you to guess it. The program loops until you make a correct guess.
Learning a new language
Venturing into a new language always feels awkward—I feel like I am losing time since it would be much quicker to use the tools I know and use all the time. Luckily, at the start, I am also very enthusiastic about learning something new, and this helps me overcome the initial pain. And once I learn a new perspective or a solution that I would never have thought of, things become interesting! Learning new languages also helps me backport new techniques to my old and tested tools.
When I start learning a new language, I usually look for a tutorial that introduces me to its syntax. Once I have a feeling for the syntax, I start working on a program I am familiar with and look for examples that will adapt to my needs.
What is Racket?
Racket is a programming language in the Scheme family, which is a dialect of Lisp. Lisp is also a family of languages, which can make it hard to decide which “dialect” to start with when you want to learn Lisp. All of the implementations have various degrees of compatibility, and this plethora of options might turn away newbies. I think that is a pity because these languages are really fun and stimulating!
Starting with Racket makes sense because it is very mature and versatile, and the community is very active. Since Racket is a Lisp-like language, a major characteristic is that it uses the prefix notation and a lot of parentheses. Functions and operators are applied to a list of operands by prefixing them:
(function-name operand operand …)
(+ 2 3)
↳ Returns 5
(list 1 2 3 5)
↳ Returns a list containing 1, 2, 3, and 5
(define x 1)
↳ Defines a variable called x with value of 1
(define (f x y) (* x x))
↳ Defines a function called f with two parameters called x and y that returns their product.
This is basically all there is to know about Racket syntax; the rest is learning the functions from the documentation, which is very thorough. There are other aspects of the syntax, like keyword arguments and quoting, but you do not need them for this example.
Mastering Racket might be difficult, and its syntax might look weird (especially if you are used to languages like Python), but I find it very fun to use. A big bonus is Racket’s programming environment, DrRacket, which is very supportive, especially when you are getting started with the language.
The major Linux distributions offer packaged versions of Racket, so installation should be easy.
Guess the number game in Racket
Here is a version of the “guess the number” program written in Racket:
#lang racket
(define (inquire-user number)
(display “Insert a number: “)
(define guess (string->number (read-line)))
(cond [(> number guess) (displayln “Too low”) (inquire-user number)]
[(< number guess) (displayln “Too high”) (inquire-user number)]
[else (displayln “Correct!”)]))
(displayln “Guess a number between 1 and 100”)
(inquire-user (random 1 101))
Save this listing to a file called guess.rkt
and run it:
<span class="co4">$ </span>racket guess.rkt
Here is some example output:
Insert a number: 90
Too high
Insert a number: 50
Too high
Insert a number: 20
Too high
Insert a number: 10
Too low
Insert a number: 12
Too low
Insert a number: 13
Too low
Insert a number: 14
Too low
Insert a number: 15
Correct!
Understanding the program
I’ll go through the program line by line. The first line declares the language the listing is written into: #lang racket
. This might seem strange, but Racket is very good at writing interpreters for new domain-specific languages. Do not panic, though! You can use Racket as it is because it is very rich in tools.
Now for the next line. (define ...)
is used to declare new variables or functions. Here, it defines a new function called inquire-user
that accepts the parameter number
. The number
parameter is the random number that the user will have to guess. The rest of the code inside the parentheses of the define
procedure is the body of the inquire-user
function. Notice that the function name contains a dash; this is Racket’s idiomatic style for writing a long variable name.
This function recursively calls itself to repeat the question until the user guesses the right number. Note that I am not using loops; I feel that Racket programmers do not like loops and only use recursive functions. This approach is idiomatic to Racket, but if you prefer, loops are an option.
The first step of the inquire-user
function asks the user to insert a number by writing that string to the console. Then it defines a variable called guess
that contains whatever the user entered. The read-line
function returns the user input as a string. The string is then converted to a number with the string->number
function. After the variable definition, the cond
function accepts a series of conditions. If a condition is satisfied, it executes the code inside that condition. These conditions, (> number guess)
and (< number guess)
, are followed by two functions: a displayln
that gives clues to the user and a inquire-user
call. The function calls itself again when the user does not guess the right number. The else
clause executes when the two conditions are not met, i.e., the user enters the correct number. The program’s guts are this inquire-user
function.
However, the function still needs to be called! First, the program asks the user to guess a number between 1 and 100, and then it calls the inquire-user
function with a random number. The random number is generated with the random
function. You need to inform the function that you want to generate a number between 1 and 100, but the random
function generates integer numbers up to max-1
, so I used 101.
Try Racket
Learning new languages is fun! I am a big advocate of programming languages polyglotism because it brings new, interesting approaches and insights to programming. Racket is a great opportunity to start learning how to program with a Lisp-like language. I suggest you give it a try.
For enquiries, product placements, sponsorships, and collaborations, connect with us at [email protected]. We'd love to hear from you!
Our humans need coffee too! Your support is highly appreciated, thank you!