ugly-lisp-code compendium

It has been some time since I’ve posted on this blog. This blog is going into hiatus for now!

A more current blog is in the works. This blog will explore ideas in many languages and systems.

Hopefully you will be able to use these ideas below to learn something or even take them to the next level.

Feel free to leave me some comments. Thank You!

Exploring an extension to a basic unit testing framework. The extension encapsulates the idea of unit-tests wrapped by a test-fixture.

• Dog-fooding a Domain Specific Language (DSL); creating an extension to lisp-unit
• Update to test-fixture

Exploring a lightweight object-oriented type in Common Lisp.

• An Object in Lisp. Part 1
• An Object in Lisp. Part 2
• An Object in Lisp. Part 2 Addendum
• An Object in Lisp. Part 3
• An Object in Lisp. Part 4
• An Object in Lisp. Part 5
• An Object in Lisp. Part 6

Exploration of an event driven system in Common Lisp.

• Event Driven Architecture Programming in Lisp Part 1
• Event Driven Architecture Programming in Lisp Part 2

An efficient methodology for me when working with lightweight objects.

• Object Programming in Lisp Observation #1

Tools and explorations that were used for the above projects.

• object.zip
• lisp-unit-with-fixture
• coverage-runner
• presenter-first
• mock

Read it Later – Make your browsing a breeze

This is a must have. Creating a list of the links to review later instead of opening tabs.

Read It Later

Abstraction of an encapsulted property in Lisp

Abstraction (computer science): is a mechanism and practice to reduce and factor out details so that one can focus on a few concepts at a time.

If you read Lisp Trick #1, hopefully, you saw a pretty good abstraction. What it was doing was abstracting out the setting and getting a value from a variable. As a bonus, because of the way &key parameter keyword can be used, we were able to differentiate whether you were getting the value or setting the variable. Another bonus is that the variable we are getting and setting is encapsulated.

Usually an abstraction is created with the use of macros. Now I’ve made an even larger abstraction of the setter/getter abstraction.

Lisp Content

I’ve now added content to this blog.

Some of the content consist of:

1. Blogs I read concerning Lisp.
2. Helpful errata.
3. Download of Lisp that I program in.
4. Some of my personal Lisp projects.

Status of Lisp as I See It

Dependency Management: Seems to be brittle.

Project Management: Weak also.

Mocking Framework: None. I found this: ‘el-expectations.el’ and ‘el-mock.el’

Unit Testing: I am presently using lisp-unit. I have found that this tool is pretty good. Sofar I’ve been able to change it’s output pretty easy. I changed the format of the output and then wrapped the macro in (time). I really like this tool.

4 ways to do functions in lisp

With lisp you can not only pass variables into functions but also pass functions into other functions.

1. This function has no abstraction whatsoever.

(defun does-everything ()
(< 1 2))

2. The predicate function is passed into the function. The number values are constants.

(defun does-constants (fn)

(funcall fn 1 2))

3. The number values are passed into the function.

(defun does-function (x y)

(< x y))

4.Everything is abstracted out, the predicate function and number values are abstracted out.

(defun does-nothing (fn x y)

(funcall fn x y))

The functions could be further refined to take advantage of the abstractions, but for a basic knowledge these are the basic functions.