In Lisp, programs are structured using lists, which are composed of atoms and other lists. The basic unit of Lisp program structure is the S-expression (Symbolic Expression), which can be either an atom or a list.

Atoms in Lisp can be symbols, numbers, or strings. Symbols are used to represent names and are typically used as function names, variable names, or to represent constants. Numbers and strings are self-explanatory and provide the means for representing numerical or textual data.

Lists, on the other hand, are enclosed within parentheses and can contain a combination of atoms and other lists. Lists can be nested within other lists, creating a hierarchical structure. The first element of a list is traditionally treated as the operator or function, and the remaining elements are its arguments.

Lisp follows a prefix notation, also known as Polish notation or prefix notation. In this notation, the operator is placed before its operands. For example, the arithmetic expression `(add 2 3)` in Lisp would be written as `(+ 2 3)`. Here, the operator `+` comes before its two operands, `2` and `3`.

Lisp programs are typically organized as a collection of function definitions. A function definition consists of the function name, a list of parameters, and the function body, which contains the expressions to be evaluated when the function is called. Here's an example of a simple Lisp program structure :

(defun factorial (n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

(defun main ()
  (let ((num 5))
    (format t "The factorial of ~d is ~d" num (factorial num))))​

In this example, we have two function definitions: `factorial` and `main`. The `factorial` function calculates the factorial of a number recursively, while the `main` function demonstrates the usage of the `factorial` function by calculating and printing the factorial of the number 5.

Lisp programs can be evaluated and executed interactively using a Lisp interpreter or compiler, where the expressions are read, evaluated, and the results are displayed. Lisp's interactive development environment, which includes features like a read-eval-print loop (REPL), facilitates an iterative and exploratory style of programming.