Lisp (programming language)

From Uncyclopedia, the content-free encyclopedia
(Redirected from Lisp)
Jump to navigation Jump to search
Bloink1 solid.png
It is requested that an image or images be included in this article to improve its quality.
If possible, please add some pictures to make it into a full encyclopedia article and then remove this message. Do not remove this notice until it receives some pictures. Failure to comply will result in this notice being added again.

“The only thing you need for successful parentheses”

~ A brainwashed Lisp programmer on Lisp

“It haunts me every night. All I can see in my dreams is lines upon lines of parentheses. OH GOD, WHY?!?”

~ A rescued Lisp programmer on Lisp

Lithp is a programming language designed to drive all sane programmers completely out of their minds through the extreme overuse of parentheses involved in writing even the simplest of programs. Many have theorized that God himself created the language as a form of punishment for the most evil of computer programmers. In reality, it was created as a part of a government conspiracy to drive all programmers not under their control insane so that they would wind up in the looney bin. By doing this, they hoped to obtain complete control of the programming world. Fortunately, their ultimate objective was not reached; however, thousands of programmers now spend their lives in mental institutions due to this horrible, malicious programming language.

The name "Lisp" is derived from the speech impediment often developed by its users as a result of the permanent brain damage they suffer.

The Creation of Lisp[edit | edit source]

The original creator, a man by the name of Charles Manson, was himself already insane, and was commissioned by the CIA to create a language to spread his insanity to programmers everywhere. Once created, the CIA knew they had a weapon capable of destroying the entire world of free programming as we know it. They unleashed it upon the unsuspecting populace disguised as a harmless programming language. Over time, programmers across the country began to lose their minds within the halls of the evil parentheses. They were rounded up by the government and placed into looney bins. This time has become known to programmers everywhere as the Night of a Thousand Parentheses.

Basic Structure[edit | edit source]

The basic structure of a Lisp program is a series of opening and closing parentheses that can in some way be interpreted as commands, such as variable declaration and assignment, if statements and loop structures. The following program is a sample "Hello, world!" program written in Lisp:

((( (((( (( )))) )) )))

When compiled, the above code segment prints out the line "Hello, world!", then gives the programmer a severe case of explosive diarrhea.

Variables[edit | edit source]

Variables are the different ways of representing information within a computer. In Lisp, variables primarily serve the role of transferring bits of information into the programmer's psyche, instilling within them the very essence of the evil language.

The different types of variables in Lisp are demonstrated in the following table:

Type Explanation Samples
Integers Whole numbers, designed to imprint hidden messages contained in series of numbers into
the programmer's mind
7, 5, -1
Rationals Ratios of integers(otherwise known as fractions), designed to confuse the programmer
by not showing him the customary floating-point numbers that usually result from Integer division
3/4, 7/9, -5/6
Floating-Point Decimal numbers 5.12, 0.75, -7.7
Strings Readable text, designed to confuse the programmer by making him read actual text,
which is something he is not accustomed to
Hello, world!", "What is the air-speed velocity of an unladen swallow?", "75"

Why All the Parentheses?[edit | edit source]

Many of you may be wondering what purpose the vast amount of parentheses used in Lisp actually serve. On the surface, they are the method of enclosing an operation and its arguments; however, since every operation in the language must be so enclosed, one ends up with large segments of code that are nothing but parentheses. This confuses the programmer beyond all recognition, as it was intended to do. Its primary purpose is to give the programmer a feeling of being "enclosed" by the language of Lisp. This abstract concept is planted into the mind of the programmer, slowly driving them insane until they crack.

Possible Effects on Programmers[edit | edit source]

Lisp can be incredibly harmful to those seeking to learn and use it. The most common illnesses and conditions associated with it are parentheses eye, diarrhea and Communism. In severe cases, it is possible for the victim to develop extreme dementia and schizophrenia, as well as an ambulatory disorder which causes them to always walk in simple curved paths, unable to follow a straight line. It is believed that this last effect is a result of damage to the visual cortex in the occipital lobe of the brain which leaves the victim entirely unable to visually recognize or even to mentally visualize straight lines, the neurological damage having been caused by the programmer constantly fixing his or her visual focus on thousands of smoothly curved parentheses, to the exclusion of other shapes (especially square brackets). Or, the brain damage could be caused by the programmers banging their heads on the walls behind them after the sight of so many parentheses for so many long minutes has begin to drive them mad. Research is ongoing.

Over the years, many organizations, such as the Coalition for a Lisp Free World (CLFW), have attempted to spread awareness about the harmful effects of learning and using Lisp. They have worked to pass laws through Congress that limit the number of parentheses that may be used in one line of code. Currently, the limit is 25; this presents a problem for Lisp users everywhere. The most basic line of code in Lisp often contains upwards of 50 pairs of parentheses.

One difficulty in studying the ill effects of programming in LISP is that, like nuclear researchers, LISP-health researchers must limit their own direct exposures to displays of LISP (commonly known as LISP radiation) in order to avoid succumbing to LISP-induced illness themselves, which would not only make a crappy day for them but would invalidate their research by rendering them incompetent to rationally interpret their scientific observations and generally conduct their studies. They might even start writing all their notes and scientific papers in unintelligible LISP-like code, which would ironically complicate the problem rather than advance its solution, now wouldn't it?

Methods of Avoiding Lisp Usage[edit | edit source]

It is possible, however difficult, to keep oneself from being exposed to Lisp. The simplest way is to never go looking for Lisp; never Google "Lisp" or anything containing "Lisp", never look for Lisp books in the IT section of book stores, and never, ever, under any circumstance, attempt to program something in Lisp. The smallest amount of exposure to Lisp can have profound effects upon even the most resilient of programmers. If you ever come upon a line of code containing more than 5 pairs of parentheses, immediately exit out of whatever program you are running or close whatever book you are reading and spend several minutes looking at code from an actual programming language, such as C, C++, Java, Cobol or Visual BASIC.

See Also[edit | edit source]