Cusp, an Eclipse development environment for Lisp
Cusp is a development environment for the Common Lisp programming language. Using Lisp, you can develop all sorts of applications, including Web applications. Lisp is the second oldest programming language still used widely today (after Fortran) and is known as the first functional language. The creation of Lisp began in the late 1950s and was first implemented in 1958 by the MIT Artificial Intelligence (AI) Project. Its strength is in the processing of lists: AI and symbol mathematics. In fact, Lisp is short for "list processor," which was the need under which this programming language was created, as you'll see in the following paragraphs (see Resources for Lisp historical information).
You'll notice that Lisp is not at all like other general programming languages. For
example, in most general programming languages, you perform multiplication just as you
would on paper:
int times = 5 * 5;.
With Lisp, the following would produce 75:
(* 5 5 3). The
maximum in this list:
(MAX 9 8 7 6 20) returns 20.
Notice that the phrase "first functional language" here is apt, as everything is based
on functions. Each function can have a variable number of parameters. The processing of
these lists using recursion and Lisp functions like
cdr is the power of list processing using Lisp.
Given Lisp's age, you can find many development environments for it. However, also inherent to old programming languages, the tool support is mostly text-based and not intuitive for newcomers. Thus, one reason to try Cusp is that it has an intuitive GUI for newcomers to learn and develop Lisp in, rather than a text-based "try-to-remember-all-of-these-commands" type of interface. It also has the advantage of the superb project management features inherent in the Eclipse GUI framework.
Before going on, you'll need to download the latest Eclipse classic bundle from Eclipse.org. Then you'll learn how to install and set up Cusp.
You should now have a zipped-up archive of the Eclipse classic bundle. Un-archive it and run eclipse.exe.
To get the latest version of Cusp: click Help > Software Updates > Find and Install. Click the Search
for new features to install option. Now click the New Remote Site button.
Type the name as
update site and the URL as
http://www.sergeykolos.com/cusp/update, and click OK (see Figure 1).
Figure 1. Entering remote site information for Cusp
Click the checkbox next to the new remote site you added and click Finish (see Figure 2).
Figure 2. Selecting the Cusp Eclipse Update Site
You'll be brought to another window where you need to expand the Cusp Eclipse Update Site and select Cusp, as shown below.
Figure 3. Selecting features to install
Click Next. Then read and accept the license agreement by clicking I accept the terms in the license agreement and click Next. Make sure all the libraries are selected, as shown below, and click Next again.
Figure 4. Selecting optional features
The last page gives you an installation summary of the features you're about to install. Click Finish. The plug-in and its components will download and install. After the download, you'll get a warning saying that you're about to install an unsigned feature. Click Install all. At the end of the installation, you'll be asked to restart Eclipse; click Yes.
You've installed the Eclipse Cusp plug-in. Next, you'll set up a Lisp project.
Setting up a Lisp project
Before Lisp development can begin, you need to set up a new Lisp project. You can do so by going to File > New > Project. Expand the Lisp folder, click Lisp Project, and click Next. Choose a name for the new project, my_new_lisp_project, as shown below, then click Finish.
Figure 5. Naming your new Lisp project
After clicking Finish, your new project gets created and the Lisp perspective opens, as shown below.
Figure 6. The Lisp perspective
Behold the Lisp perspective. The Lisp Navigator window shows your open project, along with its associated files. The Outline window shows an outline of the currently open file. The top-right window, showing main.lisp, is the Lisp development window. The bottom-right window, REPL, is the command-line Lisp interpreter, where you can run Lisp commands.
In the event you close Eclipse and reopen it, you'll need to load your projects .asd file, as shown below.
Figure 7. Loading your ASD file
Note that you need to right click the my_new_lisp_project.asd file under the my_new_lisp_project folder and select Load asd. What this essentially does is compile your Lisp project in the REPL window, allowing you to enter Lisp commands that can use your new code.
Next, you'll try out some Lisp development using Cusp.
Lisp development using Cusp
First, you'll define a simple custom function and test it, as well. Open the main.lisp
file and, using the
defun (define function) command,
and add the following:
... (defun first_howdy_function () "howdy ho")
Save the file. To export the function from within the package, type the following code in defpackage.lisp:
... ;; Exported symbols go here first_howdy_function ))
The function can be used from outside the package. To test your new function, type the
following in the lower window of REPL:
Note that for the scope you're in, this is the same as entering
(my_new_lisp_project::first_howdy_function). This is what you would
have to type if you didn't export the function in defpackage.lisp.
Click Send and check out the output. The output from entering either of the above commands is as follows:
COMMON-LISP-USER> (my_new_lisp_project:first_howdy_function) "howdy ho"
There you have it: your first Lisp Howdy function.
echo function with an input to it:
... (defun first_echo_function (echoval) echoval)
As with the last function, export it in defpackage.lisp. You'll test this
first_echo_function by typing the following in the lower portion of
the REPL window:
"y h" "o")). Note that the
'("howd" "y h" "o") portion
is the syntax for defining a list. First, the single quote must precede the
parentheses, then the list elements are defined within the parentheses. The output is
COMMON-LISP-USER> (my_new_lisp_project:first_echo_function '("howd" "y h" "o")) ("howd" "y h" "o")
You'll create a method to process each list element individually, which is the true power of Lisp. Define it as follows:
(defmethod concat2 ((str1 string) (str2 string)) (concatenate 'string str1 str2))
Note that the above method actually defines a type string.
Up to now, you've been using Lisp as a largely typeless language. Though the double
quotes implicitly types data as strings, the above method
explicitly types both the input and output to the
function as strings. This method also uses the built-in concatenate function to combine
two strings and return them as a single string.
concat2, export it, then type
(my_new_lisp_project:concat2 "howd" "y ho"). Its output is as
Listing 7. The output of concatenating two strings
COMMON-LISP-USER> (my_new_lisp_project:concat2 "howd" "y ho") "howdy ho"
There you have it. The strings
"y ho" become
"howdy ho." Now you'll
create a more generalized concatenation function using the two functions Lisp is famous
Listing 1. Concatenating three elements in a list
(defun concat3 (args_list) (concat2 (car args_list) (concat2 (car (cdr args_list)) (car (cdr (cdr args_list))))))
Note that this function still uses the
concat2 function, but
takes as its input a parameter list. Take note of how each section of the concatenation
is retrieved from
car takes the first element
from the list. The
cdr returns the list minus the first
element. You can see how you'd get the first element by just calling the
car function on the list. Obtaining the second element requires
cdr on the list, then the
car on the new list. The third element is taken by calling the
cdr on the list twice and calling
car on the final list.
The output of the above function after exporting it is as follows:
COMMON-LISP-USER> (my_new_lisp_project:concat3 '("howd" "y h" "o")) "howdy ho"
And there you go. The three strings were concatenated correctly to produce
"howdy ho." Next, you'll create a recursive function.
Recursion using Lisp
The last function you're going to create is going to take some recursion, where the true power of list processing using Lisp lies. Iteration is possible (looping through each item one by one), but unlike general languages like the Java language, recursion is by far the easiest way to process lists in Lisp. You'll know exactly what recursion is by the end of this section.
Begin by creating a recursive
Listing 2. Recursive concatenation (unlimited parameters)
1 (defun concat_recursive (args_list) 2 (if (equal (cdr args_list) nil) 3 (car args_list) 4 (concat2 (car args_list) 5 (concat_recursive (cdr args_list)))))
Recursion can be a difficult concept to tackle, so lets walk through this one:
- Assume an arbitrary argument list is passed to the above function.
- If there is only one element in the list (the
(cdr args_list)portion on line 2 returns nil), return the single element (the
(car args_list)on line 3).
- If there is more than one element in the list (meaning the
(cdr args_list)portion on line 2 did not return nil), return the result of concatenating (using
concat2) the first element of the list (see line 4) and the result of recursively calling
concat_recursiveusing the result of
(cdr args_list)as parameters (see line 5).
When passing the following list as a parameter,
'("ho" "wd" "y" "
h" "o"), the following is a walk-through of the output:
- The first time line 2 is reached, the
ifstatement is false, and
concat2is called with
(concat_recursive '("wd" "y" " h" "o")).
- The second time line 2 is reached, the
ifstatement is again false, and
concat2is called with
(concat_recursive '("y" " h" "o")).
- The third time line 2 is reached, the
ifstatement is again false, and
concat2is called with
(concat_recursive '(" h" "o")).
- The fourth time line 2 is reached, the
ifstatement is again false, and
concat2is called with
- The fifth time is the magical time when the recursion ends. This is because this time,
ifstatement on line 2 is now true, and
"o"is simply returned. The recursion unwinds as follows:
- Fourth time:
"o"are concatenated and returned.
- Third time:
" ho"are concatenated and returned.
- Second time:
"y ho"are concatenated and returned.
- First time:
"wdy ho"are concatenated and returned as the final result.
- Fourth time:
And there you have it — "howdy ho" ultimately gets returned, as shown below:
COMMON-LISP-USER> (my_new_lisp_project:concat_recursive '("ho" "wd" "y" " h" "o")) "howdy ho"
You have added recursion to your Cusp development arsenal. Try out the debugger next.
Debugging using Cusp
Think of input conditions that will cause
to fail, so that the debugger might come in handy. One is that you could send a number
mixed in with the strings to see what happens. Remember that the concatenation using
concat2 requires two strings, so a number will cause this
function to break within the recursion.
Type the following command:
'("ho" "wd" "y" 55 " h" "o")). Note the number 55 without being enclosed in double quotes is not a string and will
cause the debugger to appear, as shown below.
Figure 8. Triggering the debugger
Notice the main error triggering the debugger is that
concat2 cannot be called on the list:
ho"). Also notice that the
" h" and
"o" were already concatenated before the error got triggered.
In the debugger window, you can also see the
==Backtrace==, shown in Figure 8. Each
of the lines underneath it (0-19, in this case) give a detailed trace from
when you click Send to the occurring fault. Here, you can also see and follow the
recursion leading up to the numeric 55 that triggered the fault.
What now? You have three options in the above case to exit the debugger, and to modify and validate your input to the function: You can abort the command and return to the regular REPL window; you can close the connection (via testing, it's found you'll need to reboot Eclipse to restart the Lisp processor if you choose this option); or you can simply abort the debugger and return to the regular REPL window. The best option to exit the debugger is always to abort the command and return to the regular REPL window.
There you have it. You've implemented a recursive function in Lisp.
You completed this Lisp development using the Cusp Eclipse plug-in successfully. You should now know why Lisp is so powerful. Through simple recursive statements, you can power process lists of symbols and data easily. Cusp complements the capabilities of Lisp with the help of the built-in Cusp debugger, a solid GUI with project management capabilities, an interactive Lisp editor, and the command-line interface to the Lisp processor where you can enter commands and test your code. Be sure to review the Resources for more information.
|Cusp article sample code||os-eclipse-lispcusp.code.zip||28KB|
- Learn more about Cusp, a Lisp Plug-in for Eclipse.
- Read the "History of Lisp," as written 12 Feb 1979 by John McCarthy of the Artificial Intelligence Laboratory at Stanford University.
- Learn to use HyperSpec and LispDoc from within Cusp in the document titled "Programming In Lisp With Cusp," which was written by Sergey Kolos.
- Learn more about Common Lisp at Wikipedia.
- Read Paul Graham's essays on Lisp to understand its history and uses.
- The basics of the Eclipse plug-in architecture and how to create one are described in "Developing Eclipse plug-ins."
- For more information about plug-in development, see Eclipse.org.
- Creating Eclipse plug-ins is well described in a book titled Eclipse: Building Commercial-Quality plug-ins, by Eric Clayberg and Dan Rubel.
- Browse a complete list of plug-ins for Eclipse.
- Documentation, articles, and downloads of Eclipse are available from the Eclipse Project.
- Check out the "Recommended Eclipse reading list."
- Browse all the Eclipse content on developerWorks.
- New to Eclipse? Read the developerWorks article "Get started with Eclipse Platform" to learn its origin and architecture, and how to extend Eclipse with plug-ins.
- Expand your Eclipse skills by checking out IBM developerWorks' Eclipse project resources.
- To listen to interesting interviews and discussions for software developers, check out developerWorks podcasts.
- For an introduction to the Eclipse platform, see "Getting started with the Eclipse Platform."
- Stay current with developerWorks' Technical events and webcasts.
- Watch and learn about IBM and open source technologies and product functions with the no-cost developerWorks On demand demos.
- Check out upcoming conferences, trade shows, webcasts, and other Events around the world that are of interest to IBM open source developers.
- Visit the developerWorks Open source zone for extensive how-to information, tools, and project updates to help you develop with open source technologies and use them with IBM's products.
Get products and technologies
- Visit the Cusp Eclipse Update Site to download Cusp.
- Download Eclipse at Eclipse.org.
- Check out the latest Eclipse technology downloads at IBM alphaWorks.
- Download Eclipse Platform and other projects from the Eclipse Foundation.
- Download IBM product evaluation versions, and get your hands on application development tools and middleware products from DB2®, Lotus®, Rational®, Tivoli®, and WebSphere®.
- Innovate your next open source development project with IBM trial software, available for download or on DVD.
- The Eclipse Platform newsgroups should be your first stop to discuss questions regarding Eclipse. (Selecting this will launch your default Usenet news reader application and open eclipse.platform.)
- The Eclipse newsgroups has many resources for people interested in using and extending Eclipse.
- Participate in developerWorks blogs and get involved in the developerWorks community.
Dig deeper into Open source on developerWorks
Get samples, articles, product docs, and community resources to help build, deploy, and manage your cloud apps.
Experiment with new directions in software development.
Software development in the cloud. Register today to create a project.
Evaluate IBM software and solutions, and transform challenges into opportunities.