Lisp is world’s second high-level programming language and is still used to build software today. It was the first to implement many popular programming techniques like higher-order functions, recursion, REPL, garbage collection, and more. 

#programming #code #100SecondsOfCode

💬 Chat with Me on Discord

https://discord.gg/fireship

🔗 Resources

- Lisp Tutorial https://lisp-lang.org/
- Fortran in 100 Seconds https://youtu.be/NMWzgy8FsKs
- C in 100 Seconds https://youtu.be/U3aXWizDbQ4

🔥 Get More Content - Upgrade to PRO

Upgrade at https://fireship.io/pro
Use code YT25 for 25% off PRO access 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- What is Lisp?
- Should I learn Lisp?
- Lisp basics tutorial
- Who invented Lisp?
- Lisp vs Fortran
- Lisp vs C
2024-02-04T05:18:54.681Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
c6a1d952-7fd7-46cb-bcd7-306668a391b1
3ab7a181aecaae9ad734c1475fb9261bd5812e0ce966eba1b75ec051e3d0f323
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Lisp, a dynamic general purpose programming language famous for pioneering many of the programming techniques we take for granted today.
It was created in 1958 by John McCarthy at MIT, making it the 2nd high level language ever after Fortran the year before.
However, it was the first interpreted language that could be executed step by step without a compiler.
In addition, it's responsible for a variety of other language innovations, like recursion, dynamic typing, garbage collection, 1st class functions, and more.
Its name stands for list processor, and syntactically, it's known for its prolific use sub parenthesis, because at its core, almost everything is treated as a linked list data structure.
Each element in the list is called a cons or constructor, which contains and 2 pointers.
The car points to the actual data, while the CDR points to the next element in the list.
Developers write s expressions, which might start with a function or operator, followed by 1 or more arguments.
This gives rise to a powerful macros feature, where developers can extend the syntax of Lisp, and create domain specific languages.
It's like a programmable programming language.
Common Lisp is still in use today, but it's directly inspired many other languages like Scheme, Closure, Ruby, and JavaScript, just to name a few.
To get started, install common lisp on your machine, then create a file ending in dot lsp.
1st, create an s expression, which can represent an atom like a number or symbol, or a list of multiple values.
To print to the standard output, we can reference the format function, followed by t for true, then the string we want to print out, and it contains a ton of built in functions like print to simplify things.
Define a local variable with the let keyword, and will be lexically scoped to the context in which it's defined.
However, you can also define global variables with def parameter or def var, which are dynamically scoped and can be used anywhere.
All these variables can be modified.
However, you can also create immutable data with def constant.
Lisp is multi paradigm, but most well known as a functional language.
Use the def un keyword, which is definitely the way you pronounce it, to define a function.
It can take 1 or more parameters, and it's optionally followed by a string to define its purpose.
We can use the star operator to multiply pi by the input radius, and the last expression in the function body will automatically be used as the return value.
It was a first language to support higher order functions, where we might do something like create a list, then use another function called mapcar to loop over that list, and call the function we just to find on every single element inside of it.
It also includes a built in macro called loop for general purpose iteration.
What it doesn't have though is a while Loop.
Not a problem though, if you want to create 1, just write your own macro to extend the language.
Now run your code with the Lisp interpreter.
This has been Lisp in 100 seconds.
Hit the like button if you wanna More short videos like this.
Thanks for watching, and I will see you in the next one.

Speaker 0: Lisp, a dynamic general purpose programming language famous for pioneering many of the programming techniques we take for granted today. It was created in 1958 by John McCarthy at MIT, making it the 2nd high level language ever after Fortran the year before. However, it was the first interpreted language that could be executed step by step without a compiler. In addition, it's responsible for a variety of other language innovations, like recursion, dynamic typing, garbage collection, 1st class functions, and more. Its name stands for list processor, and syntactically, it's known for its prolific use sub parenthesis, because at its core, almost everything is treated as a linked list data structure.

Each element in the list is called a cons or constructor, which contains and 2 pointers. The car points to the actual data, while the CDR points to the next element in the list. Developers write s expressions, which might start with a function or operator, followed by 1 or more arguments. This gives rise to a powerful macros feature, where developers can extend the syntax of Lisp, and create domain specific languages. It's like a programmable programming language.

Common Lisp is still in use today, but it's directly inspired many other languages like Scheme, Closure, Ruby, and JavaScript, just to name a few. To get started, install common lisp on your machine, then create a file ending in dot lsp. 1st, create an s expression, which can represent an atom like a number or symbol, or a list of multiple values. To print to the standard output, we can reference the format function, followed by t for true, then the string we want to print out, and it contains a ton of built in functions like print to simplify things. Define a local variable with the let keyword, and will be lexically scoped to the context in which it's defined.

However, you can also define global variables with def parameter or def var, which are dynamically scoped and can be used anywhere. All these variables can be modified. However, you can also create immutable data with def constant. Lisp is multi paradigm, but most well known as a functional language. Use the def un keyword, which is definitely the way you pronounce it, to define a function.

It can take 1 or more parameters, and it's optionally followed by a string to define its purpose. We can use the star operator to multiply pi by the input radius, and the last expression in the function body will automatically be used as the return value. It was a first language to support higher order functions, where we might do something like create a list, then use another function called mapcar to loop over that list, and call the function we just to find on every single element inside of it. It also includes a built in macro called loop for general purpose iteration. What it doesn't have though is a while Loop.

Not a problem though, if you want to create 1, just write your own macro to extend the language. Now run your code with the Lisp interpreter. This has been Lisp in 100 seconds. Hit the like button if you wanna More short videos like this. Thanks for watching, and I will see you in the next one.
Lisp, a dynamic general purpose programming language famous for pioneering many of the programming techniques we take for granted today. It was created in 1958 by John McCarthy at MIT, making it the 2nd high level language ever after Fortran the year before.
However, it was the first interpreted language that could be executed step by step without a compiler. In addition, it's responsible for a variety of other language innovations, like recursion, dynamic typing, garbage collection, 1st class functions, and more. Its name stands for list processor, and syntactically, it's known for its prolific use sub parenthesis, because at its core, almost everything is treated as a linked list data structure.
languages
programming
Each element in the list is called a cons or constructor, which contains and 2 pointers. The car points to the actual data, while the CDR points to the next element in the list. Developers write s expressions, which might start with a function or operator, followed by 1 or more arguments. This gives rise to a powerful macros feature, where developers can extend the syntax of Lisp, and create domain specific languages. It's like a programmable programming language. Common Lisp is still in use today, but it's directly inspired many other languages like Scheme, Closure, Ruby, and JavaScript, just to name a few.
logical reasoning
logic
software development
To get started, install common lisp on your machine, then create a file ending in dot lsp. 1st, create an s expression, which can represent an atom like a number or symbol, or a list of multiple values.
To print to the standard output, we can reference the format function, followed by t for true, then the string we want to print out, and it contains a ton of built in functions like print to simplify things. Define a local variable with the let keyword, and will be lexically scoped to the context in which it's defined.
programming
However, you can also define global variables with def parameter or def var, which are dynamically scoped and can be used anywhere. All these variables can be modified. However, you can also create immutable data with def constant. Lisp is multi paradigm, but most well known as a functional language. Use the def un keyword, which is definitely the way you pronounce it, to define a function. It can take 1 or more parameters, and it's optionally followed by a string to define its purpose. We can use the star operator to multiply pi by the input radius, and the last expression in the function body will automatically be used as the return value. It was a first language to support higher order functions, where we might do something like create a list, then use another function called mapcar to loop over that list, and call the function we just to find on every single element inside of it. It also includes a built in macro called loop for general purpose iteration. What it doesn't have though is a while Loop. Not a problem though, if you want to create 1, just write your own macro to extend the language.
Now run your code with the Lisp interpreter. This has been Lisp in 100 seconds. Hit the like button if you wanna More short videos like this. Thanks for watching, and I will see you in the next one.
youtube
Lisp, a dynamic general purpose programming language famous for pioneering many of the programming techniques we take for granted today. It was created in 1958 by John McCarthy at MIT, making it the 2nd high level language ever after Fortran the year before. However, it was the first interpreted language that could be executed step by step without a compiler. In addition, it's responsible for a variety of other language innovations, like recursion, dynamic typing, garbage collection, 1st class functions, and more. Its name stands for list processor, and syntactically, it's known for its prolific use sub parenthesis, because at its core, almost everything is treated as a linked list data structure. Each element in the list is called a cons or constructor, which contains and 2 pointers. The car points to the actual data, while the CDR points to the next element in the list. Developers write s expressions, which might start with a function or operator, followed by 1 or more arguments. This gives rise to a powerful macros feature, where developers can extend the syntax of Lisp, and create domain specific languages. It's like a programmable programming language. Common Lisp is still in use today, but it's directly inspired many other languages like Scheme, Closure, Ruby, and JavaScript, just to name a few. To get started, install common lisp on your machine, then create a file ending in dot lsp. 1st, create an s expression, which can represent an atom like a number or symbol, or a list of multiple values. To print to the standard output, we can reference the format function, followed by t for true, then the string we want to print out, and it contains a ton of built in functions like print to simplify things. Define a local variable with the let keyword, and will be lexically scoped to the context in which it's defined. However, you can also define global variables with def parameter or def var, which are dynamically scoped and can be used anywhere. All these variables can be modified. However, you can also create immutable data with def constant. Lisp is multi paradigm, but most well known as a functional language. Use the def un keyword, which is definitely the way you pronounce it, to define a function. It can take 1 or more parameters, and it's optionally followed by a string to define its purpose. We can use the star operator to multiply pi by the input radius, and the last expression in the function body will automatically be used as the return value. It was a first language to support higher order functions, where we might do something like create a list, then use another function called mapcar to loop over that list, and call the function we just to find on every single element inside of it. It also includes a built in macro called loop for general purpose iteration. What it doesn't have though is a while Loop. Not a problem though, if you want to create 1, just write your own macro to extend the language. Now run your code with the Lisp interpreter. This has been Lisp in 100 seconds. Hit the like button if you wanna More short videos like this. Thanks for watching, and I will see you in the next one.
Lisp,
lisp
a
a
dynamic
dynamic
general
general
purpose
purpose
programming
programming
language
language
famous
famous
for
for
pioneering
pioneering
many
many
of
of
the
the
programming
programming
techniques
techniques
we
we
take
take
for
for
granted
granted
today.
today
It
it
was
was
created
created
in
in
1958
1958
by
by
John
john
McCarthy
mccarthy
at
at
MIT,
mit
making
making
it
it
the
the
2nd
2nd
high
high
level
level
language
language
ever
ever
after
after
Fortran
fortran
the
the
year
year
before.
before
However,
however
it
it
was
was
the
the
first
first
interpreted
interpreted
language
language
that
that
could
could
be
be
executed
executed
step
step
by
by
step
step
without
without
a
a
compiler.
compiler
In
in
addition,
addition
it's
it's
responsible
responsible
for
for
a
a
variety
variety
of
of
other
other
language
language
innovations,
innovations
like
like
recursion,
recursion
dynamic
dynamic
typing,
typing
garbage
garbage
collection,
collection
1st
1st
class
class
functions,
functions
and
and
more.
more
Its
its
name
name
stands
stands
for
for
list
list
processor,
processor
and
and
syntactically,
syntactically
it's
it's
known
known
for
for
its
its
prolific
prolific
use
use
sub
sub
parenthesis,
parenthesis
because
because
at
at
its
its
core,
core
almost
almost
everything
everything
is
is
treated
treated
as
as
a
a
linked
linked
list
list
data
data
structure.
structure
Each
each
element
element
in
in
the
the
list
list
is
is
called
called
a
a
cons
cons
or
or
constructor,
constructor
which
which
contains
contains
and
and
2
2
pointers.
pointers
The
the
car
car
points
points
to
to
the
the
actual
actual
data,
data
while
while
the
the
CDR
cdr
points
points
to
to
the
the
next
next
element
element
in
in
the
the
list.
list
Developers
developers
write
write
s
s
expressions,
expressions
which
which
might
might
start
start
with
with
a
a
function
function
or
or
operator,
operator
followed
followed
by
by
1
1
or
or
more
more
arguments.
arguments
This
this
gives
gives
rise
rise
to
to
a
a
powerful
powerful
macros
macros
feature,
feature
where
where
developers
developers
can
can
extend
extend
the
the
syntax
syntax
of
of
Lisp,
lisp
and
and
create
create
domain
domain
specific
specific
languages.
languages
It's
it's
like
like
a
a
programmable
programmable
programming
programming
language.
language
Common
common
Lisp
lisp
is
is
still
still
in
in
use
use
today,
today
but
but
it's
it's
directly
directly
inspired
inspired
many
many
other
other
languages
languages
like
like
Scheme,
scheme
Closure,
closure
Ruby,
ruby
and
and
JavaScript,
javascript
just
just
to
to
name
name
a
a
few.
few
To
to
get
get
started,
started
install
install
common
common
lisp
lisp
on
on
your
your
machine,
machine
then
then
create
create
a
a
file
file
ending
ending
in
in
dot
dot
lsp.
lsp
1st,
1st
create
create
an
an
s
s
expression,
expression
which
which
can
can
represent
represent
an
an
atom
atom
like
like
a
a
number
number
or
or
symbol,
symbol
or
or
a
a
list
list
of
of
multiple
multiple
values.
values
To
to
print
print
to
to
the
the
standard
standard
output,
output
we
we
can
can
reference
reference
the
the
format
format
function,
function
followed
followed
by
by
t
t
for
for
true,
true
then
then
the
the
string
string
we
we
want
want
to
to
print
print
out,
out
and
and
it
it
contains
contains
a
a
ton
ton
of
of
built
built
in
in
functions
functions
like
like
print
print
to
to
simplify
simplify
things.
things
Define
define
a
a
local
local
variable
variable
with
with
the
the
let
let
keyword,
keyword
and
and
will
will
be
be
lexically
lexically
scoped
scoped
to
to
the
the
context
context
in
in
which
which
it's
it's
defined.
defined
However,
however
you
you
can
can
also
also
define
define
global
global
variables
variables
with
with
def
def
parameter
parameter
or
or
def
def
var,
var
which
which
are
are
dynamically
dynamically
scoped
scoped
and
and
can
can
be
be
used
used
anywhere.
anywhere
All
all
these
these
variables
variables
can
can
be
be
modified.
modified
However,
however
you
you
can
can
also
also
create
create
immutable
immutable
data
data
with
with
def
def
constant.
constant
Lisp
lisp
is
is
multi
multi
paradigm,
paradigm
but
but
most
most
well
well
known
known
as
as
a
a
functional
functional
language.
language
Use
use
the
the
def
def
un
un
keyword,
keyword
which
which
is
is
definitely
definitely
the
the
way
way
you
you
pronounce
pronounce
it,
it
to
to
define
define
a
a
function.
function
It
it
can
can
take
take
1
1
or
or
more
more
parameters,
parameters
and
and
it's
it's
optionally
optionally
followed
followed
by
by
a
a
string
string
to
to
define
define
its
its
purpose.
purpose
We
we
can
can
use
use
the
the
star
star
operator
operator
to
to
multiply
multiply
pi
pi
by
by
the
the
input
input
radius,
radius
and
and
the
the
last
last
expression
expression
in
in
the
the
function
function
body
body
will
will
automatically
automatically
be
be
used
used
as
as
the
the
return
return
value.
value
It
it
was
was
a
a
first
first
language
language
to
to
support
support
higher
higher
order
order
functions,
functions
where
where
we
we
might
might
do
do
something
something
like
like
create
create
a
a
list,
list
then
then
use
use
another
another
function
function
called
called
mapcar
mapcar
to
to
loop
loop
over
over
that
that
list,
list
and
and
call
call
the
the
function
function
we
we
just
just
to
to
find
find
on
on
every
every
single
single
element
element
inside
inside
of
of
it.
it
It
it
also
also
includes
includes
a
a
built
built
in
in
macro
macro
called
called
loop
loop
for
for
general
general
purpose
purpose
iteration.
iteration
What
what
it
it
doesn't
doesn't
have
have
though
though
is
is
a
a
while
while
Loop.
loop
Not
not
a
a
problem
problem
though,
though
if
if
you
you
want
want
to
to
create
create
1,
1
just
just
write
write
your
your
own
own
macro
macro
to
to
extend
extend
the
the
language.
language
Now
now
run
run
your
your
code
code
with
with
the
the
Lisp
lisp
interpreter.
interpreter
This
this
has
has
been
been
Lisp
lisp
in
in
100
100
seconds.
seconds
Hit
hit
the
the
like
like
button
button
if
if
you
you
wanna
wanna
More
more
short
short
videos
videos
like
like
this.
this
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The Lisp programming language is a multi-premises programming language used in various programming styles. It is a powerful program language that allows developers to create domain-specific, multi-premises language. It is also a flexible language, allowing developers to use variables, inputs, and built in functions to create new programs. Lisp is also a multi-istic language, with its use of the word "function" to define parameters and return value to a variables.
Lisp in 100 Seconds
Lisp, a dynamic general purpose programming language famous for pioneering many of the programming techniques we take for granted today. It was created in 1958 by John McCarthy at MIT, making it the 2nd high level language ever after Fortran the year before. However, it was the first interpreted language that could be executed step by step without a compiler. In addition, it's responsible for a variety of other language innovations, like recursion, dynamic typing, garbage collection, 1st class functions, and more. Its name stands for list processor, and syntactically, it's known for its prolific use sub parenthesis, because at its core, almost everything is treated as a linked list data structure. Each element in the list is called a cons or constructor, which contains and 2 pointers. The car points to the actual data, while the CDR points to the next element in the list. Developers write s expressions, which might start with a function or operator, followed by 1 or more arguments. This gives rise to a powerful macros feature, where developers can extend the syntax of Lisp, and create domain specific languages. It's like a programmable programming language. Common Lisp is still in use today, but it's directly inspired many other languages like Scheme, Closure, Ruby, and JavaScript, just to name a few. To get started, install common lisp on your machine, then create a file ending in dot lsp. 1st, create an s expression, which can represent an atom like a number or symbol, or a list of multiple values. To print to the standard output, we can reference the format function, followed by t for true, then the string we want to print out, and it contains a ton of built in functions like print to simplify things. Define a local variable with the let keyword, and will be lexically scoped to the context in which it's defined. However, you can also define global variables with def parameter or def var, which are dynamically scoped and can be used anywhere. All these variables can be modified. However, you can also create immutable data with def constant. Lisp is multi paradigm, but most well known as a functional language. Use the def un keyword, which is definitely the way you pronounce it, to define a function. It can take 1 or more parameters, and it's optionally followed by a string to define its purpose. We can use the star operator to multiply pi by the input radius, and the last expression in the function body will automatically be used as the return value. It was a first language to support higher order functions, where we might do something like create a list, then use another function called mapcar to loop over that list, and call the function we just to find on every single element inside of it. It also includes a built in macro called loop for general purpose iteration. What it doesn't have though is a while Loop. Not a problem though, if you want to create 1, just write your own macro to extend the language. Now run your code with the Lisp interpreter. This has been Lisp in 100 seconds. Hit the like button if you wanna More short videos like this. Thanks for watching, and I will see you in the next one.
The Lisp programming language is a multi-premises programming language used in various programming styles. It is a powerful program language that allows developers to create domain-specific, multi-premises language. It is also a flexible language, allowing developers to use variables, inputs, and built in functions to create new programs. Lisp is also a multi-istic language, with its use of the word "function" to define parameters and return value to a variables.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Lisp in 100 Seconds 
        and a small summary : The Lisp programming language is a multi-premises programming language used in various programming styles. It is a powerful program language that allows developers to create domain-specific, multi-premises language. It is also a flexible language, allowing developers to use variables, inputs, and built in functions to create new programs. Lisp is also a multi-istic language, with its use of the word "function" to define parameters and return value to a variables.
        [/INST]
        
        Generate the video : Lisp, a dynamic general purpose programming language famous for pioneering many of the programming techniques we take for granted today. It was created in 1958 by John McCarthy at MIT, making it the 2nd high level language ever after Fortran the year before. However, it was the first interpreted language that could be executed step by step without a compiler. In addition, it's responsible for a variety of other language innovations, like recursion, dynamic typing, garbage collection, 1st class functions, and more. Its name stands for list processor, and syntactically, it's known for its prolific use sub parenthesis, because at its core, almost everything is treated as a linked list data structure. Each element in the list is called a cons or constructor, which contains and 2 pointers. The car points to the actual data, while the CDR points to the next element in the list. Developers write s expressions, which might start with a function or operator, followed by 1 or more arguments. This gives rise to a powerful macros feature, where developers can extend the syntax of Lisp, and create domain specific languages. It's like a programmable programming language. Common Lisp is still in use today, but it's directly inspired many other languages like Scheme, Closure, Ruby, and JavaScript, just to name a few. To get started, install common lisp on your machine, then create a file ending in dot lsp. 1st, create an s expression, which can represent an atom like a number or symbol, or a list of multiple values. To print to the standard output, we can reference the format function, followed by t for true, then the string we want to print out, and it contains a ton of built in functions like print to simplify things. Define a local variable with the let keyword, and will be lexically scoped to the context in which it's defined. However, you can also define global variables with def parameter or def var, which are dynamically scoped and can be used anywhere. All these variables can be modified. However, you can also create immutable data with def constant. Lisp is multi paradigm, but most well known as a functional language. Use the def un keyword, which is definitely the way you pronounce it, to define a function. It can take 1 or more parameters, and it's optionally followed by a string to define its purpose. We can use the star operator to multiply pi by the input radius, and the last expression in the function body will automatically be used as the return value. It was a first language to support higher order functions, where we might do something like create a list, then use another function called mapcar to loop over that list, and call the function we just to find on every single element inside of it. It also includes a built in macro called loop for general purpose iteration. What it doesn't have though is a while Loop. Not a problem though, if you want to create 1, just write your own macro to extend the language. Now run your code with the Lisp interpreter. This has been Lisp in 100 seconds. Hit the like button if you wanna More short videos like this. Thanks for watching, and I will see you in the next one.
        