How to Start Lisp Programming?

When it comes to Lisp programs, learning the ins and outs of this language takes some practice. If you are looking for a way to learn a new computer language that allows you to express your intentions easily, Common Lisp may be the best choice out there. Not only is this a highly desirable tool to use for other reasons, including functionality, but it can also help you get more done faster. Many programmers find that it can actually be a simple method to create code that is far easier than many other languages.

Why learn Lisp? It’s not easy to convince those who already know a computer language or are learning one to embrace something new. Even if you can see the potential in the time savings, why bother if you already are doing well enough with what you are using? When you take a look at a Lisp programming language example, you will see that it’s quite interesting.

There may not be an immediate payoff for learning Lisp as there can be with other languages like learning Java, C, or C++. If you own, of course, a Lisp Machine, then there’s definitely a benefit right away! Lisp code has numerous quirks and interesting aspects to it, but its worth getting to know it and how well it can work for you.

Lisp Programming Tutorial: What Is Lisp?

Let’s start at the beginning. Lisp is an older computer language written in 1958! That makes it the second oldest such language. Since that initial iteration, numerous versions have become available. This includes:

• Common Lisp
• Emacs Lisp (Elisp)
• Clojure
• Racket
• Scheme
• Fennel
• GNU Guile

Lisp is a favorite to many because of how its syntax and data share the same structure. In short, Lisp code is made up of a list of lists. The product’s name is LISt Processing, though most don’t know it by anything else but Lisp.

There are some factors that detract from the desirability to use Lisp. For example, if you are one of the many people that do not like all of the parentheses for scoping Lisp requires, you may find this to be a tedious process.

Lisp is not just a computer language of the past. Through the use of Clojure and Guile, you gain one of the most effective tools for future computer programming uses as well. If you’re working on big codebases used within a specific industry, there’s likely some level of Lisp code built into it at some point. In other words, it’s worth learning.

The Most Common Elements of Lisp Programs

As you work through this Lisp tutorial, there will be a few important bits of information you need to have to ensure you’re ready to take on the challenge of learning Lisp programs. Here is a short list of features you will find in Common Lisp (remember, there are other versions with differences to learn, too!)

• Lisp is machine-independent.
• Lisp uses iterative design. It has easy extensibility.
• One of the nice features of it is the high level of debugging it offers.
• Lisp lets you update programs dynamically, which can speed up the application time.
• Lisp has a convenient macro system.
• Lisp provides numerous data types. Some examples of these include like, objects, lists, structures, adjustable arrays, vectors, hash-tables, and symbols, which are the most commonly used components.
• There is a complete I/O library available for Lisp.
• You can see, right from using this Lisp programming tutorial, that it is an advanced, object-oriented programming tool.

Lisp is a common language. It can be extended for specific implementation without much difficulty. Also, note that any programs written within Common Lisp are not dependent on machine-specific characteristics.

You will find that this expression-based computer language also offers extensive control structures.

Wondering who uses Lisp? If you are not sure you want to learn it, consider some of the most successful applications built in Lisp that you have probably heard of and used:

• G2
• Emacs
• Igor Engraver
• Yahoo Store
• AutoCAD

Those are some pretty heavy hitters, and if you may use any of these types of applications in the future, it’s worth learning the ins and outs of Lisp.

Examples of Lisp Programs: Local Environment and Starting the Process

To get started, you will need to set up an environment for programming with Lisp. To do this, you need two types of software:

• Text editor
• The Lisp Executer

The text editor is where you will input or type your code. There are numerous options you can choose to use, but the most common for this include:

• OS Edit command
• Windows Notepad
• Brief
• Epsilon
• Vim or vi
• Emacs

What you choose depends on the operating system you are using. For example, those using Linux or UNIX, you will likely use vim or vi. For those who are using Windows, Notepad is the default solution.

Any of the files that you create within the text editor are your source files. These will contain the program source code. Most of the time, source files for your Lisp programs will be named using the “.lisp” extension.

The Lisp Executer is the second component you need to get started. The source code created in the source file is what you, a human, will read for your program. However, for your computer to do the work, you need to execute it. This will turn that code into machine language so that the computer can then execute the program or run the program the way you want it to based on the instructions you have provided to it.

The programming language is used to execute your source code into the final executable program.

Lisp Programming Online Installation

The first step in the process is, of course, to get your hands on the program. There are various incarnations of Lisp, and while any of them will work, there are a few that can be beneficial to focus on as a starter. This includes the popular open-source versions:

•  SBCL
•  GNU Lisp
•  GNU Common Lisp (GCL)

You can install any of these with your distribution’s package manager.

As you look through the Lisp programming examples and details here, it is important to know one thing. For this Lisp programming tutorial, we are using the clisp command. However, you can apply the same principles to any Lisp. All you have to do is run Lisp code such as a gcl or sbcl instead of using the clisp we use here.

You can get the most up-to-date clisp for Windows by going to this link.

To provide a bit of help to get you started with clisp, during the installation process, it will add to your PATH variable when you select the option (RECOMMENDED). That is generally what you need to do. This allows you to open a new Command Prompt window and, from there, type clisp into the prompt. This will instantly bring up your compiler so you can get to work on it.

Lisp Programming Language Example: List Processing

To get started, let’s talk about the basic unit that is within Lisp course code: the expression. It is written as a list.

Here is a Lisp programming language example of this with the operator (+) and two integers (1 and 2).

(+ 1 2)

Another Lisp expression is to use a symbol (+) that evaluates to a function (addiction) as well as two arguments (1 and 2). If you wish to run this expression, you can do so in REPL (read-eval-print loop), an interactive Common Lisp environment. For those who have used Python as a computer language, you may have used IDLE. REPL is much like that.

So, let’s say you wish to launch REPL. To do so, launch Common Lisp:

$ clisp

[1]>

When you see the REPL prompt, type the following expressions:

[1]> (+ 1 2)

3

[2]> (- 1 2)

-1

[3]> (- 2 1)

1

[4]> (+ 2 3 4)

9

You can choose to use other Lisp programs, but for simplicity’s sake, while learning, stick to Common Lisp.

Lisp Programming Tutorial: Functions

With this basic structure under your belt, it is time to consider the next step in this Lisp programming tutorial: learning about functions. You can use Lisp functions in useful methods.

For example, the print function will take any argument and display it on your terminal. If you use the pprint function (which refers to pretty prints), it will pretty print it.

You will find other variations of the print function out there. In REPL, pprint is:

[1]> (pprint “hello world”)

“hello world”

[2]>

Use defun to create your own function. To do so, a defun function will require a name for the function and then the specific parameters you wish the function to accept.

Lisp Programming Examples: Variables

In order to create variables in the Lisp programs, you can use setf:

[1]> (setf foo “hello world”)

“hello world”

[2]> (pprint foo)

“hello world”

[3]>

Then, you can also nest expressions in a pipeline. One example of this is to pretty print the contents of the variable after you invoke the string-upcase function. This will convert the characters to upper case letters. Here’s how to do that:

[3]> (pprint (string-upcase foo))

“HELLO WORLD”

[4]>

One of the key factors about Lisp programs is that they are dynamically typed. That means that you do not have to declare variables when setting them. Instead, the computer program will treat integers by default. Here are examples:

[1]> (setf foo 2)

[2]> (setf bar 3)

[3]> (+ foo bar)

5

Here are other examples of Lisp programs. In this situation, the programmer intends for the integer to be interpreted as a string. To do that, the programmer can quote it as follows:

[4]> (setf foo “2”)

“2”

[5]> (setf bar “3”)

“3”

[6]> (+ foo bar)

*** – +: “2” is not a number

The following restarts are available:

USE-VALUE      :R1  Input a value to be used instead.

ABORT          :R2  Abort main loop

Break 1 [7]>

Take a look at this particular REPL session. When you do, you’ll notice that both foo and bar are set to quoted numbers. In this situation, Lisp programs will interpret them as strings.

You cannot use math operators in strings, though. REPL goes into debugger mode at that point. If you want to get out of debugger, you can use Ctrl+D to do so.

Another step you may wish to try out is the use of introspection on objects. If you want to try this out, use the typep function. This allows you to test out a specific data type. In this example, the tokens T and NIL represent True and False.

[4]> (typep foo ‘string)

NIL

[5]> (typep foo ‘integer)

T

To prevent Lisp from evaluating keywords as variables, you can use the following. Use a single quote (‘) before the string and integer. This prevents Lisp from improperly evaluating those keywords. It looks like this:

[6]> (typep foo string)

*** – SYSTEM::READ-EVAL-PRINT: variable STRING has no value

[…]

It protects the terms. Normally, this is done with the quote function:

[7]> (typep foo (quote string))

NIL

[5]> (typep foo (quote integer))

T

Lisp Programming Language Example: Lists

As we noted, Lisp is all about lists, and therefore, you can create a list on Lisp using the following:

[1]> (setf foo (list “hello” “world”))

(“hello” “world”)

You can also use the nth function to index lists:

[2]> (nth 0 foo)

“hello”

[3]> (pprint (string-capitalize (nth 1 foo)))

“World”

Lisp Programming Tutorial: Scripting

Use Lisp either as a compiled or an interpreted scripting language. The easiest of the two is to use it as an interpreted scripting language. You will find it offers some similarities to shell scripting.

To provide you with an example of this in Lisp programs, consider this dice roller script that was written in GNU Common Lisp:

#!/usr/bin/clisp

(defun roller (num)

(pprint (random (parse-integer (nth 0 num))))

)

(setf userput *args*)

(setf *random-state* (make-random-state t))

(roller userput)

When you look at this code, the initial line will tell the terminal what executable to use to run your script. We create the roller function using defun. It uses the random function to print a pseudo-random number up to the zeroth item of the num list. We have not yet created the num list. However, the function does not get executed until it’s called.

Next, look at the second line. Here, it assigns any argument provided to the script at launch time to the variable userput. Userput is a list. It becomes num after passing to the roller function.

The next important line is the penultimate line. This begins a random seed. It provides the tool info to generate a random number.

The end lines of the code involve the custom roller function. In this example, the userput list is the sole argument created by you.

Taking these examples of Lisp programs, go ahead and save this file as dice.lisp. Then, market it executable like this:

$ chmod +x dice.lisp.

If you want to see the results, run it by providing a maximum number from which it can select a random number

Examples of Lisp Programs: Get in Some Skill

Now, this is not an AutoCAD Lisp programming tutorial (you have a bit of learning to do before you can reach that level of effectiveness!) However, when it comes to learning Lisp programming online, let’s start with the basics.

Lisp expressions are symbolic expressions, though you may also hear them referred to as s-expressions. There are three valid objects, atoms, lists, and strings. Any symbolic expression is a valid program.

You will run Lisp programs in either an interpreter or compiled code. Let’s focus on the first. In the interpreter, it will check the source code through a repeated loop. This is called the read-evaluate-print-loop (REPL) as noted previously.

Let’s try a simple program.

Your goal is to write an s-expression that will determine the sum of these three numbers: 3, 5, and 7.

To create this in Lisp programs, you will need to type the following into the interpreter prompt:

(+ 3 5 7)

When you do this, it will return the result:

15

That’s simple enough. Now, if we use compiled code, that changes the game a bit. To try this out, create a Lisp source code file. Name it myprog.lisp. Once you do that, type in the following:

(write + 3 5 7))

Once you do that, hit the execute button. This will lead to the result of:

15

Examples of Lisp Programs: Here’s Why You Want to Use It, Too

Lisp has certainly been pushed to the side by many computer language lovers for multiple reasons. There is no doubt it has a specific influence on all functional languages used today. Take a closer look at some of the ways that Lisp is used today.

Check out these Lisp programming examples:

Grammarly

You may be using it to make sure that your grammar skills are on point. However, this online tool processes texts in English. It uses artificial intelligence to analyze that text and then, from the results, makes recommendations on how the user can improve them. What you probably did not know was that all of Grammarly’s backend including all of its text processing mechanism, is built on Common Lisp. Grammarly’s tech team broke down how and why they use it, providing clarity on the benefits it offers.

Apache Storm

Another example is the real time processing tool called Apache Storm. It has gotten a lot of attention recently for the large amount of data it can handle. It’s an excellent example of how Lisp can be very effective today. The tool is based on the use of Clojure and Java. Twitter purchased it at one point. One of the key reasons why it is used is that it can be used alongside Java.

AutoCAD

Remember that AutoCAD Lisp programming tutorial we mentioned? It’s a hot topic out there when it comes to the conversation of Lisp. That’s because AutoCAD is one of the most commonly used Lisp programs today. It is a computer-aided design system. To work, it uses AutoLISP dialect as the internal application development language for the tool. Over time, other versions have developed, but Lisp is still heavily supported

The Benefits of Lisp Programming

There is quite a bit more to learn than this basic Lisp programming tutorial can provide (remember, this is an old language, and dozens of versions now exist with some really exciting features). However, if you’re still unsure if you should put the time into using Lisp, consider a few of the reasons why some developers love it and consistently use it over other products.

It’s the OG

Let’s be frank. Many of today’s computer languages are based on, at least in part, on Lisp. Considering that, you will certainly heard a lot of developers talking about it being their favorite choice and, often refer to it as the most powerful language. It has plenty to offer – first class functions, macros, and much more that we did not touch on.

Reliable and stable

While there are lots of other reasons to use Lisp, one to keep in mind is perhaps the most important. It’s stable. It’s super reliable. You can write quality code that lasts for a long time.

Some of the most important reasons for this include that it offers standardized language with specifications, and these are well understood, including through cross-platforms. It is also designed and founded on the solid computer science principles most people used back in the day. It is efficient and offers plenty of stability overall.

Let Rayobyte Help You With Your Next Project

Is Lisp programming right for you? Even if you’re not sure it is the best choice for the way you operate today, the good news is that Rayobyte offers the solutions you need.

We’re the leading source on proxy use cases, and for that reason, we encourage you to give us a call so we can help you with your proxy needs.

The information contained within this article, including information posted by official staff, guest-submitted material, message board postings, or other third-party material is presented solely for the purposes of education and furtherance of the knowledge of the reader. All trademarks used in this publication are hereby acknowledged as the property of their respective owners.