Let's write a simple helloWorld smart contract with solidity. We will learn about:
- The pragma statement
- The `contract` keyword
- How to declare variables
- How to declare constructors?
- How to declare functions?
- and more ... !

The source code files are available on github:
https://github.com/jklepatch/eattheblocks/tree/master/episode2

Like this channel? Subscribe here: https://www.youtube.com/channel/UCZM8XQjNOyG2ElPpEUtNasA

Links:
- Official Website https://eattheblocks.com
- Author Website: https://www.julienklepatch.com

In a lot of programming languages, we have classes. In Solidity, we have contracts. Like classes, they can inherit from each other. Let's have a look at how it works.

Like this channel? Subscribe here:
https://www.youtube.com/channel/UCZM8XQjNOyG2ElPpEUtNasA

In this video tutorial we are going to:
- Write 2 contracts: a derived contract, and a base contract
- Make the derived contract inherit from the base contract
- Use the "is" keyword for contract inheritance
- Call a function of an inherited contract
- Access a variable of an inherited contract
- Use the Truffle framework

We will demonstrate that our contract work by using the Truffle console, deploying our contract to a local testnet and calling the functions of our smart contract.

Links:
- Source Code: https://github.com/jklepatch/eattheblocks/tree/master/episode6
- Official Website https://eattheblocks.com
- Author Website: https://www.julienklepatch.com
- Truffle: http://truffleframework.com

Let's learn about multiple inheritance in Solidity smart contracts. We will use the Truffle framework.

Like this channel? Subscribe here:
https://www.youtube.com/channel/UCZM8XQjNOyG2ElPpEUtNasA

In this video tutorial we are going to:
- Make a contract inherit from several other contracts
- Access variables of a parent contract directly inherited
- Access a variable of a parent contract, indirectly inherited
- Use Truffle

Links:
- Source Code: https://github.com/jklepatch/eattheblocks/tree/master/episode7
- Official Website https://eattheblocks.com
- Author Website: https://www.julienklepatch.com
- Truffle: http://truffleframework.com

Polymorphism is a feature of many programming languages which is closely related to inheritance. It allows a child class to redefine some inherited functions to specialize their behavior. Let's see how polymorphism work in Solidity with contracts.

Like this channel? Subscribe here:
https://www.youtube.com/channel/UCZM8XQjNOyG2ElPpEUtNasA

In this video tutorial we are going to study:
- Create 4 contracts with a chain of inheritance
- Define functions in each of those contracts
- Call inherited functions from the most derived contracts and see which functions will be resolved
- Use the Truffle framework
- Use the local testnet provided by Truffle for our interactions with smart contracts

BONUS: I am also going to give you the solution to the previous episode challenge about multiple inheritance. If you are curious, this is related to what we call the "Diamond Problem": https://en.wikipedia.org/wiki/Multiple_inheritance#The_diamond_problem

Links:
- Source Code: https://github.com/jklepatch/eattheblocks/tree/master/episode8
- Official Website https://eattheblocks.com
- Author Website: https://www.julienklepatch.com
- Truffle: http://truffleframework.com

In this tutorial we will learn how to update a smart contract from Solidity 0.4 to Solidity 0.5.

Solidity 0.5 was released last year in 2018 but a lot of the existing smart contracts and tutorials are still written for Solidity 0.4. It's important to be able to understand the difference between both versions and to update your old code the new version of Solidity.

In this video tutorial we will update the smart contract of the Todolist Dapp tutorial to Solidity 0.5, and learn the main new features and breaking changes of Solidity 0.5.

Solidity also comes with experimental features hidden behind the ABIEncoderV2 pragma statement. Few people are aware of this but this is a very powerful ways to use the bleeding edge of Solidity. These cool features allow to drastically simplify the code of your smart contract, and in this tutorial I am also going to teach you how to use this in your Solidity smart contracts.

►►►MORE TUTORIAL VIDEOS ON EatTheBlocks PRO◄◄◄
Subscribe to EatTheBlocks Pro to unlock access to more advanced video tutorials on Ethereum and smart contracts:
https://eattheblocks-pro.teachable.com/

►►►LEARN TO BUILD A DECENTRALIZED EXCHANGE (DEX)◄◄◄
Follow my video course on Manning to learn how to build Ethereum smart contracts, Dapps, and a DEX:
https://www.manning.com/livevideo/ethereum-dapps-in-motion

►►►SUBSCRIBE TO THE NEWSLETTER◄◄◄
Once a week, I will send you 10 links about Tips, Tutorials & News for Ethereum Dapp Developers:
https://eattheblocks.com

Other Links:
- Article: https://eattheblocks.com/eattheblocks-newsletter-19-trading-widget-for-0x-react-dapp-tutorial/
- Official Website https://eattheblocks.com
- Author Website: https://www.julienklepatch.com

Many Dapps need to clone the same smart contracts over and and over again... ex: loan smart contracts, token smart contracts to represent many different assets...

Instead of wasting a lot of gas to deploy the same code many times, it's possible to use a proxy smart contract to cheaply re-use the logic of a smart contract many times, but have separate storage.

In this video I am going to show you how we can use the ERC 1167 to cheaply clone a Solidity smart contract with a proxy. This is an advanced Solidity pattern and will probably a bit difficult if you are a total Solidity beginner. So make sure you have some basic knowledge about Solidity and smart contract before watching this video.

►►► GET SOURCE CODE OF EPISODE ON EatTheBlocks PRO◄◄◄
Create a free account on EatTheBlocks Pro to get the source code of this episode:
https://eattheblocks-pro.teachable.com


Other Links:
- Official Website https://eattheblocks.com
- Author Website: https://www.julienklepatch.com

Most Solidity smart contracts need to implement access control. In this tutorial, I will show you how to implement basic access control with pure Solidity, as well as more advanced role-based patterns like RBAC, using the OpenZeppelin library:

* Authentication vs Authorization
* Basic access control in Solidity
* Ownable pattern with OpenZeppelin
* Secondary pattern with OpenZeppelin
* RBAC (Role-Based Access Control) with OpenZeppelin

►►►SOURCE CODE AVAILABLE ON EatTheBlocks PRO◄◄◄
Click on "Enroll Now" on EatTheBlocks Pro to create a free account and get access to the source code of all tutorials (Solidity, Ethereum...):
https://eattheblocks-pro.teachable.com

Other Links:
- Blog: https://eattheblocks.com
- Author Website: https://www.julienklepatch.com
- Build an Ethereum ERC20 Dex (Decentralized Exchange) with my course on Manning: https://www.manning.com/livevideo/ethereum-dapps-in-motion

Are you preparing a job interview of a Solidity developer position? Or maybe that you want to review your knowledge of Solidity?

In this video I will give you 100 questions & answers on Solidity.

These questions will cover all difficulty level: easy, intermediate and difficult. Even if you already know a few things about Solidity, I guarantee you you will learn something new by watching this video!

►►►SOURCE CODE AVAILABLE ON EatTheBlocks PRO◄◄◄
Click on "Enroll Now" on EatTheBlocks Pro to create a free account and get access to the source code of all tutorials (Solidity, Ethereum...):
https://eattheblocks-pro.teachable.com

Other Links:
- Blog: https://eattheblocks.com
- Author Website: https://www.julienklepatch.com
- Build an Ethereum ERC20 Dex (Decentralized Exchange) with my course on Manning: https://www.manning.com/livevideo/ethereum-dapps-in-motion

Learn my TOP 5 Solidity tips with this free course: https://mailchi.mp/354073c8bd38/top-5-solidity-tips

Solidity is weird, and there are many things that will surprise you. Watch this video to learn about these Solidity Gotchas:
- Gotcha #1: Solidity versions
- Gotcha #2: Private variables
- Gotcha #3: Strings
- Gotcha #4: Memory
- Gotcha #5: Mappings
- Gotcha #6: Arrays
- Gotcha #7: Return types
- Gotcha #8: Number of variables (stackTooDeep error)
- Gotcha #9: Events
- Gotcha #10: Receiving Ether
- Gotcha #11: Locking Ether / ERC20 tokens
- Gotcha #12: Underflow / Overflow
- Gotcha #13: re-entrancy attack
- Gotcha #14: Gas spending
- Gotcha #15: Calling external APIs

Other Links:
- Forum: https://forum.eattheblocks.com
- Blog: https://eattheblocks.com
- Author Website: https://www.julienklepatch.com