Solidity is a programming language for writing smart contracts. Learn how to build your first smart contract on the Ethereum blockchain to get started with web3 decentralized applications. Own this video as an NFT https://bit.ly/3i6z1BB

#web3 #ethereum #100SecondsOfCode

🔗 Resources

Own this video https://bit.ly/3i6z1BB
Solidity Docs https://docs.soliditylang.org/en/v0.8.7/
Vending Machine https://nakamotoinstitute.org/the-idea-of-smart-contracts/

🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

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

🔖 Topics Covered

- Solidity programming tutorial
- Using web3.js for dapps
- Learning to code web3
- History of smart contracts
- Blockchain development
2024-02-04T05:44:41.586Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
d58af2c4-1dbf-4fd5-ad94-cb2c4ff7789e
3abe895c06393df75286f178bd15f134c1eb3b700da7101ed13f745d7915a71d
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Solidity, a statically typed compiled programming language for implementing smart contracts.
The concept of a smart contract has been around since 1994 when Nick Sabo described it as a digital vending machine.
It's just code and data that govern the behavior of accounts on Blockchain.
For example, Bob might agree to pay Alice for a service, so they deploy a smart contract to the Blockchain that's its own independent account.
The contract act is not controlled by humans, but rather its own internal code.
So it can't be manipulated, and no lawyers are needed for interpretation.
Regis, egregious for busters.
When the services are rendered to Bob, the contract will execute and transfer funds to Alice.
There are many other potential use cases like web 3 decentralized apps, decentralized financial products or DeFi, or to trade digital assets in the form of non fungible tokens.
In fact, you could be the proud owner of this very YouTube video as an NFT.
Solidity is a high level language for writing smart contracts with a syntax that resembles many curly brace languages, like c plus plus or TypeScript.
It's statically typed and supports object oriented patterns like inheritance.
It came to life in 2014 and is most commonly associated with Ethereum, but it supports multiple blockchain platforms.
To code a smart contract, create a file ending in dotsol.
Use the pragma keyword at the top to tell the compiler which version of solidity to use, then use the contract keyword to define the details of the smart contract.
It's roughly equivalent to a class in other programming languages.
Inside the braces, we can define state or variables where the value might change throughout the life cycle of the contract.
The language also has special data types like address to hold a 20 byte Ethereum address.
The struct keyword allows you to create more complex data types, usually to represent the different entities in the contract.
Use the function keyword to define executable blocks of code, which might be called upon at some point to modify the state of the contract.
You can also define a constructor that's only called once when the contract is first created.
When the constructor is finished executing, your code will be deployed on the blockchain.
After the contract has been defined, you then compile it so you can use it programmatically with the API of your choice, is like web 3 dotjs to instantiate and manage your smart contracts in JavaScript.
This has been Solidity in 100 seconds.
Hit the like and subscribe if you wanna see more short videos like this, and let me know if you want to see a full tutorial on this topic.
Thanks for watching, and I will see you in the next one.

Speaker 0: Solidity, a statically typed compiled programming language for implementing smart contracts. The concept of a smart contract has been around since 1994 when Nick Sabo described it as a digital vending machine. It's just code and data that govern the behavior of accounts on Blockchain. For example, Bob might agree to pay Alice for a service, so they deploy a smart contract to the Blockchain that's its own independent account. The contract act is not controlled by humans, but rather its own internal code.

So it can't be manipulated, and no lawyers are needed for interpretation. Regis, egregious for busters. When the services are rendered to Bob, the contract will execute and transfer funds to Alice. There are many other potential use cases like web 3 decentralized apps, decentralized financial products or DeFi, or to trade digital assets in the form of non fungible tokens. In fact, you could be the proud owner of this very YouTube video as an NFT.

Solidity is a high level language for writing smart contracts with a syntax that resembles many curly brace languages, like c plus plus or TypeScript. It's statically typed and supports object oriented patterns like inheritance. It came to life in 2014 and is most commonly associated with Ethereum, but it supports multiple blockchain platforms. To code a smart contract, create a file ending in dotsol. Use the pragma keyword at the top to tell the compiler which version of solidity to use, then use the contract keyword to define the details of the smart contract.

It's roughly equivalent to a class in other programming languages. Inside the braces, we can define state or variables where the value might change throughout the life cycle of the contract. The language also has special data types like address to hold a 20 byte Ethereum address. The struct keyword allows you to create more complex data types, usually to represent the different entities in the contract. Use the function keyword to define executable blocks of code, which might be called upon at some point to modify the state of the contract.

You can also define a constructor that's only called once when the contract is first created. When the constructor is finished executing, your code will be deployed on the blockchain. After the contract has been defined, you then compile it so you can use it programmatically with the API of your choice, is like web 3 dotjs to instantiate and manage your smart contracts in JavaScript. This has been Solidity in 100 seconds. Hit the like and subscribe if you wanna see more short videos like this, and let me know if you want to see a full tutorial on this topic.

Thanks for watching, and I will see you in the next one.
Solidity, a statically typed compiled programming language for implementing smart contracts. The concept of a smart contract has been around since 1994 when Nick Sabo described it as a digital vending machine. It's just code and data that govern the behavior of accounts on Blockchain. For example, Bob might agree to pay Alice for a service, so they deploy a smart contract to the Blockchain that's its own independent account. The contract act is not controlled by humans, but rather its own internal code. So it can't be manipulated, and no lawyers are needed for interpretation. Regis, egregious for busters. When the services are rendered to Bob, the contract will execute and transfer funds to Alice. There are many other potential use cases like web 3 decentralized apps, decentralized financial products or DeFi, or to trade digital assets in the form of non fungible tokens. In fact, you could be the proud owner of this very YouTube video as an NFT. Solidity is a high level language for writing smart contracts with a syntax that resembles many curly brace languages, like c plus plus or TypeScript. It's statically typed and supports object oriented patterns like inheritance. It came to life in 2014 and is most commonly associated with Ethereum, but it supports multiple blockchain platforms. To code a smart contract, create a file ending in dotsol. Use the pragma keyword at the top to tell the compiler which version of solidity to use, then use the contract keyword to define the details of the smart contract.
cryptocurrency
litigation
logic
youtube
intellectual property
commerce
billing
ethics
copyright licenses
copyright
It's roughly equivalent to a class in other programming languages. Inside the braces, we can define state or variables where the value might change throughout the life cycle of the contract. The language also has special data types like address to hold a 20 byte Ethereum address. The struct keyword allows you to create more complex data types, usually to represent the different entities in the contract.
languages
programming
Use the function keyword to define executable blocks of code, which might be called upon at some point to modify the state of the contract. You can also define a constructor that's only called once when the contract is first created. When the constructor is finished executing, your code will be deployed on the blockchain. After the contract has been defined, you then compile it so you can use it programmatically with the API of your choice, is like web 3 dotjs to instantiate and manage your smart contracts in JavaScript. This has been Solidity in 100 seconds. Hit the like and subscribe if you wanna see more short videos like this, and let me know if you want to see a full tutorial on this topic. Thanks for watching, and I will see you in the next one.
youtube
programming
software development
streaming
Solidity, a statically typed compiled programming language for implementing smart contracts. The concept of a smart contract has been around since 1994 when Nick Sabo described it as a digital vending machine. It's just code and data that govern the behavior of accounts on Blockchain. For example, Bob might agree to pay Alice for a service, so they deploy a smart contract to the Blockchain that's its own independent account. The contract act is not controlled by humans, but rather its own internal code. So it can't be manipulated, and no lawyers are needed for interpretation. Regis, egregious for busters. When the services are rendered to Bob, the contract will execute and transfer funds to Alice. There are many other potential use cases like web 3 decentralized apps, decentralized financial products or DeFi, or to trade digital assets in the form of non fungible tokens. In fact, you could be the proud owner of this very YouTube video as an NFT. Solidity is a high level language for writing smart contracts with a syntax that resembles many curly brace languages, like c plus plus or TypeScript. It's statically typed and supports object oriented patterns like inheritance. It came to life in 2014 and is most commonly associated with Ethereum, but it supports multiple blockchain platforms. To code a smart contract, create a file ending in dotsol. Use the pragma keyword at the top to tell the compiler which version of solidity to use, then use the contract keyword to define the details of the smart contract. It's roughly equivalent to a class in other programming languages. Inside the braces, we can define state or variables where the value might change throughout the life cycle of the contract. The language also has special data types like address to hold a 20 byte Ethereum address. The struct keyword allows you to create more complex data types, usually to represent the different entities in the contract. Use the function keyword to define executable blocks of code, which might be called upon at some point to modify the state of the contract. You can also define a constructor that's only called once when the contract is first created. When the constructor is finished executing, your code will be deployed on the blockchain. After the contract has been defined, you then compile it so you can use it programmatically with the API of your choice, is like web 3 dotjs to instantiate and manage your smart contracts in JavaScript. This has been Solidity in 100 seconds. Hit the like and subscribe if you wanna see more short videos like this, and let me know if you want to see a full tutorial on this topic. Thanks for watching, and I will see you in the next one.
Solidity,
solidity
a
a
statically
statically
typed
typed
compiled
compiled
programming
programming
language
language
for
for
implementing
implementing
smart
smart
contracts.
contracts
The
the
concept
concept
of
of
a
a
smart
smart
contract
contract
has
has
been
been
around
around
since
since
1994
1994
when
when
Nick
nick
Sabo
sabo
described
described
it
it
as
as
a
a
digital
digital
vending
vending
machine.
machine
It's
it's
just
just
code
code
and
and
data
data
that
that
govern
govern
the
the
behavior
behavior
of
of
accounts
accounts
on
on
Blockchain.
blockchain
For
for
example,
example
Bob
bob
might
might
agree
agree
to
to
pay
pay
Alice
alice
for
for
a
a
service,
service
so
so
they
they
deploy
deploy
a
a
smart
smart
contract
contract
to
to
the
the
Blockchain
blockchain
that's
that's
its
its
own
own
independent
independent
account.
account
The
the
contract
contract
act
act
is
is
not
not
controlled
controlled
by
by
humans,
humans
but
but
rather
rather
its
its
own
own
internal
internal
code.
code
So
so
it
it
can't
can't
be
be
manipulated,
manipulated
and
and
no
no
lawyers
lawyers
are
are
needed
needed
for
for
interpretation.
interpretation
Regis,
regis
egregious
egregious
for
for
busters.
busters
When
when
the
the
services
services
are
are
rendered
rendered
to
to
Bob,
bob
the
the
contract
contract
will
will
execute
execute
and
and
transfer
transfer
funds
funds
to
to
Alice.
alice
There
there
are
are
many
many
other
other
potential
potential
use
use
cases
cases
like
like
web
web
3
3
decentralized
decentralized
apps,
apps
decentralized
decentralized
financial
financial
products
products
or
or
DeFi,
defi
or
or
to
to
trade
trade
digital
digital
assets
assets
in
in
the
the
form
form
of
of
non
non
fungible
fungible
tokens.
tokens
In
in
fact,
fact
you
you
could
could
be
be
the
the
proud
proud
owner
owner
of
of
this
this
very
very
YouTube
youtube
video
video
as
as
an
an
NFT.
nft
Solidity
solidity
is
is
a
a
high
high
level
level
language
language
for
for
writing
writing
smart
smart
contracts
contracts
with
with
a
a
syntax
syntax
that
that
resembles
resembles
many
many
curly
curly
brace
brace
languages,
languages
like
like
c
c
plus
plus
plus
plus
or
or
TypeScript.
typescript
It's
it's
statically
statically
typed
typed
and
and
supports
supports
object
object
oriented
oriented
patterns
patterns
like
like
inheritance.
inheritance
It
it
came
came
to
to
life
life
in
in
2014
2014
and
and
is
is
most
most
commonly
commonly
associated
associated
with
with
Ethereum,
ethereum
but
but
it
it
supports
supports
multiple
multiple
blockchain
blockchain
platforms.
platforms
To
to
code
code
a
a
smart
smart
contract,
contract
create
create
a
a
file
file
ending
ending
in
in
dotsol.
dotsol
Use
use
the
the
pragma
pragma
keyword
keyword
at
at
the
the
top
top
to
to
tell
tell
the
the
compiler
compiler
which
which
version
version
of
of
solidity
solidity
to
to
use,
use
then
then
use
use
the
the
contract
contract
keyword
keyword
to
to
define
define
the
the
details
details
of
of
the
the
smart
smart
contract.
contract
It's
it's
roughly
roughly
equivalent
equivalent
to
to
a
a
class
class
in
in
other
other
programming
programming
languages.
languages
Inside
inside
the
the
braces,
braces
we
we
can
can
define
define
state
state
or
or
variables
variables
where
where
the
the
value
value
might
might
change
change
throughout
throughout
the
the
life
life
cycle
cycle
of
of
the
the
contract.
contract
The
the
language
language
also
also
has
has
special
special
data
data
types
types
like
like
address
address
to
to
hold
hold
a
a
20
20
byte
byte
Ethereum
ethereum
address.
address
The
the
struct
struct
keyword
keyword
allows
allows
you
you
to
to
create
create
more
more
complex
complex
data
data
types,
types
usually
usually
to
to
represent
represent
the
the
different
different
entities
entities
in
in
the
the
contract.
contract
Use
use
the
the
function
function
keyword
keyword
to
to
define
define
executable
executable
blocks
blocks
of
of
code,
code
which
which
might
might
be
be
called
called
upon
upon
at
at
some
some
point
point
to
to
modify
modify
the
the
state
state
of
of
the
the
contract.
contract
You
you
can
can
also
also
define
define
a
a
constructor
constructor
that's
that's
only
only
called
called
once
once
when
when
the
the
contract
contract
is
is
first
first
created.
created
When
when
the
the
constructor
constructor
is
is
finished
finished
executing,
executing
your
your
code
code
will
will
be
be
deployed
deployed
on
on
the
the
blockchain.
blockchain
After
after
the
the
contract
contract
has
has
been
been
defined,
defined
you
you
then
then
compile
compile
it
it
so
so
you
you
can
can
use
use
it
it
programmatically
programmatically
with
with
the
the
API
api
of
of
your
your
choice,
choice
is
is
like
like
web
web
3
3
dotjs
dotjs
to
to
instantiate
instantiate
and
and
manage
manage
your
your
smart
smart
contracts
contracts
in
in
JavaScript.
javascript
This
this
has
has
been
been
Solidity
solidity
in
in
100
100
seconds.
seconds
Hit
hit
the
the
like
like
and
and
subscribe
subscribe
if
if
you
you
wanna
wanna
see
see
more
more
short
short
videos
videos
like
like
this,
this
and
and
let
let
me
me
know
know
if
if
you
you
want
want
to
to
see
see
a
a
full
full
tutorial
tutorial
on
on
this
this
topic.
topic
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
In this video, Sol bills a high level language for writing smart contracts with statically typed syntax. The language supports multiple blockchain platforms and allows for the creation of custom objects and variables. The language also supports multiple variables and forms a structure called a blockchain. The video is a YouTube tutorial and encourages viewers to subscribe and leave comments if they want to see more short videos.
Solidity in 100 Seconds
Solidity, a statically typed compiled programming language for implementing smart contracts. The concept of a smart contract has been around since 1994 when Nick Sabo described it as a digital vending machine. It's just code and data that govern the behavior of accounts on Blockchain. For example, Bob might agree to pay Alice for a service, so they deploy a smart contract to the Blockchain that's its own independent account. The contract act is not controlled by humans, but rather its own internal code. So it can't be manipulated, and no lawyers are needed for interpretation. Regis, egregious for busters. When the services are rendered to Bob, the contract will execute and transfer funds to Alice. There are many other potential use cases like web 3 decentralized apps, decentralized financial products or DeFi, or to trade digital assets in the form of non fungible tokens. In fact, you could be the proud owner of this very YouTube video as an NFT. Solidity is a high level language for writing smart contracts with a syntax that resembles many curly brace languages, like c plus plus or TypeScript. It's statically typed and supports object oriented patterns like inheritance. It came to life in 2014 and is most commonly associated with Ethereum, but it supports multiple blockchain platforms. To code a smart contract, create a file ending in dotsol. Use the pragma keyword at the top to tell the compiler which version of solidity to use, then use the contract keyword to define the details of the smart contract. It's roughly equivalent to a class in other programming languages. Inside the braces, we can define state or variables where the value might change throughout the life cycle of the contract. The language also has special data types like address to hold a 20 byte Ethereum address. The struct keyword allows you to create more complex data types, usually to represent the different entities in the contract. Use the function keyword to define executable blocks of code, which might be called upon at some point to modify the state of the contract. You can also define a constructor that's only called once when the contract is first created. When the constructor is finished executing, your code will be deployed on the blockchain. After the contract has been defined, you then compile it so you can use it programmatically with the API of your choice, is like web 3 dotjs to instantiate and manage your smart contracts in JavaScript. This has been Solidity in 100 seconds. Hit the like and subscribe if you wanna see more short videos like this, and let me know if you want to see a full tutorial on this topic. Thanks for watching, and I will see you in the next one.
In this video, Sol bills a high level language for writing smart contracts with statically typed syntax. The language supports multiple blockchain platforms and allows for the creation of custom objects and variables. The language also supports multiple variables and forms a structure called a blockchain. The video is a YouTube tutorial and encourages viewers to subscribe and leave comments if they want to see more short videos.

        [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 : Solidity in 100 Seconds 
        and a small summary : In this video, Sol bills a high level language for writing smart contracts with statically typed syntax. The language supports multiple blockchain platforms and allows for the creation of custom objects and variables. The language also supports multiple variables and forms a structure called a blockchain. The video is a YouTube tutorial and encourages viewers to subscribe and leave comments if they want to see more short videos.
        [/INST]
        
        Generate the video : Solidity, a statically typed compiled programming language for implementing smart contracts. The concept of a smart contract has been around since 1994 when Nick Sabo described it as a digital vending machine. It's just code and data that govern the behavior of accounts on Blockchain. For example, Bob might agree to pay Alice for a service, so they deploy a smart contract to the Blockchain that's its own independent account. The contract act is not controlled by humans, but rather its own internal code. So it can't be manipulated, and no lawyers are needed for interpretation. Regis, egregious for busters. When the services are rendered to Bob, the contract will execute and transfer funds to Alice. There are many other potential use cases like web 3 decentralized apps, decentralized financial products or DeFi, or to trade digital assets in the form of non fungible tokens. In fact, you could be the proud owner of this very YouTube video as an NFT. Solidity is a high level language for writing smart contracts with a syntax that resembles many curly brace languages, like c plus plus or TypeScript. It's statically typed and supports object oriented patterns like inheritance. It came to life in 2014 and is most commonly associated with Ethereum, but it supports multiple blockchain platforms. To code a smart contract, create a file ending in dotsol. Use the pragma keyword at the top to tell the compiler which version of solidity to use, then use the contract keyword to define the details of the smart contract. It's roughly equivalent to a class in other programming languages. Inside the braces, we can define state or variables where the value might change throughout the life cycle of the contract. The language also has special data types like address to hold a 20 byte Ethereum address. The struct keyword allows you to create more complex data types, usually to represent the different entities in the contract. Use the function keyword to define executable blocks of code, which might be called upon at some point to modify the state of the contract. You can also define a constructor that's only called once when the contract is first created. When the constructor is finished executing, your code will be deployed on the blockchain. After the contract has been defined, you then compile it so you can use it programmatically with the API of your choice, is like web 3 dotjs to instantiate and manage your smart contracts in JavaScript. This has been Solidity in 100 seconds. Hit the like and subscribe if you wanna see more short videos like this, and let me know if you want to see a full tutorial on this topic. Thanks for watching, and I will see you in the next one.
        