Solidity is the most popular blockchain language in the world designed to build DApplications (Smart Contracts). It powers Ethereum and there is an in-demand exponential growth of high-paying jobs all over the world which is changing the way we conduct business.
Learning Solidity can be likened to learning web development languages years ago – You are very much ahead of the game starting today -and that’s why you want to learn Solidity too. And you have come to the right place!
Why is this the right Solidity course for you?
This is the most complete Solidity focused course on Udemy. It’s an all-in-one topic by topic focused approach that will take you from the very fundamentals of Solidity and programming, all the way to building complex DApplications.
You will learn Solidity from the very beginning, step-by-step. I will guide you through smart contracts and fun code along with examples, an important theory about how Solidity works behind the scenes, and compiling and deploying your own smart contracts from simple storage systems to live interactions with injected web3 and Uniswap.
You will also learn how to problem solve like a developer, how to build smart applications from scratch, the proper conventions for your code, how to debug code, and many other real-world skills that you will need on your blockchain developer job.
And unlike other courses, this one actually contains beginner, intermediate, advanced, and even expert topics, so you don’t have to buy any other course in order to master Solidity from the ground up!
But… You don’t have to go into all these topics. This is a long course that focuses purely on Solidity, because, after all, it’s “The Complete Solidity Course”. It is designed to bring you a combination of courses all in one! But you can become a professional blockchain developer by watching only sections of the course. You can use this course as the lifetime reference guide for certain topics as you continue to build projects and learn more that you can always come back to anytime you wish to advance in a particular topic.
By the end of the course, you will have the knowledge and confidence that you need in order to ace your solidity blockchain job interviews and become a professional developer for smart contract and DApplications.
Why am I the right Solidity teacher for you?
My name is Clarian, I’ve worked as a head engineer for years and am fully passionate and dedicated to what I teach. Problem-solving and building complex design projects is my love and my life. I am someone who is passionate and committed to building quality projects from the ground up.
I have recently been spending my time building comprehensive training models with clear explanations to help others evolve and grow the blockchain space. This is the most clearly focused and in-depth solidity course that you will find on Udemy (and maybe the entire internet) that provides video code alongs, plenty of challenges, and exercises with solutions and discussions combined into one.
I know how students learn Solidity and what they need in order to master it. And with that knowledge, I designed the ideal course curriculum. It’s a focused approach on core fundamentals, multiple real world examples, advanced pattern techniques and hands on projects, that will take you from zero to professional and confident Solidity developer in a matter of weeks.
What do we learn exactly in this course?
- Build multiple complex Smart Contracts from scratch for your portfolio! In these projects, you will learn how to think and properly develop your ideas into written code including how to maximize your time by finding and reading documentation and best practices.
- Master the Solidity fundamentals: variables, if/else, operators, boolean logic, functions, arrays, modifiers, loops, strings, and more
- Learn Solidity from the beginning: Public & Private visibility (correctly securing data), struct and enums, special global and blockchain variables, suffixes, and addresses.
- How Solidity works behind the scenes: The Ethereum Virtual Machine (EVM) and assembly (low level language), events and logging blockchain emissions, send vs transfer methods, scoping and more.
- Deep dive into functions: modifier functions, cryptographic functions, fallback functions, and function overloading.
- Deep dive into object-oriented programming: constructor functions, contract and classes, interfaces, abstract contracts (virtual and override), inheritance, and hash tables from mapping to nested mapping (key for DApplication address tracking)
- Gain a clear understandings of advanced patterns: the withdrawal pattern, restricted access, error handling and more. We will use this knowledge to build an Auction DApplication as well as plug into the live mainnet and access the Ethereum Blockchain Data via real world DApplications.
- Learn the Solidity techniques that are used by professional in blockchain: test network deployment, IDE, debugging and compiling.
Check out the course curriculum for an even more detailed overview of the content 🙂
This is what’s also included in the package:
- Consistently updated content with video and downloadable code files you can reference whenever you want.
- Clear explanations which come with exercises, solutions, and discussions
- An online community of active developers and students is available for support and discussion.
- Free support in the course Q&A
- 30+ Exercises to practice your new skills (solutions included)
This course is for you if…
- … you want to gain a clear and advanced understanding of Solidity
- … you have been trying to learn Solidity but: 1) still don’t really understand Solidity, or 2) still don’t feel confident to code smart contracts
- … you are interested in working on a blockchain project in the future
- … you already know Solidity and are looking for a course to clearly go over advanced topics. This course includes expert topics!
- … you want to get started with programming: Solidity is an awesome and very interesting first language!
Does any of the above sound good to you? If so, then whenever you’re ready, start this new adventure today, and join me and thousands of other developers in the most focused Solidity course that you will ever need!
This solidity course is ideal for anyone searching for more info on the following: solidity – blockchain – Ethereum – blockchain developer – smart contract – Ethereum developer – solidity Ethereum – blockchain programming – Ethereum and solidity – Ethereum solidity. Plus, this course will be a great addition to anyone trying to build out their knowledge in the following areas:
Ethereum – smart Contracts – blockchain – Dapp – cryptocurrency
Introduction To Solidity (For Complete Beginner)
-
1What is a smart contract - Solidity
-
2Join our Online School (Developers and Mentors)
-
3Exercise: Meet the Community
-
4What is an IDE - Remix Ethereum
-
5Remix Ethereum - IDE Basics (How to use an IDE)
-
6How to Code Along with me throughout this Course
-
7Exercise - Get Familiar With the Remix Ethereum IDE
-
8What are comments in Solidity
-
9Why Comments are important!
Learn Solidity - Basics I
-
10Solidity For Beginners - Welcome to your new journey!
-
11Copy & Paste Your First Smart Contract :)
-
12Compile & Deploy Your First Smart Contract
-
13Exercise - Recongifure A Solidity Smart Contract
Exercise - Manipulate The Smart Contract Result: Change the function called getResult in our WelcomeToSolidity contract so that the output returns 15.
---------------------------------
IDE:: Tools provided by an IDE include a text editor, a project editor, a tool bar, and an output viewer.
IDEs can perform a variety of functions. Notable ones include write code, compile code, debug code, and monitor resources.
Solidity is a curly-bracket language.
It is influenced by C++, Python and JavaScript, and is designed to target the Ethereum Virtual Machine (EVM)
-
14Solution - Reconfigure A Solidity Smart Contract
-
15Introduction To Pragma Solidity (Compiling Versions)
-
16How to understand Pragma Solidity
-
17Exercise - Instantiate Solidity
Exercise - Instantiate Pragma Solidity:
1. Create a new solidity file called exercise-assignment
2. Instantiate the version solidity of 0.5.0
3. Bonus: increase the range of the version from 0.5.0 up to 0.6.3
________________
We are specifying the compiler version of solidity ranging and including from 0.7.0 up to and not including 0.9.0
>= means greater than or equal to...
< less than sign..
If we want to write solidity code we first create a new file and assign the type of data file with .sol
Pragma is generally the first line of code within any Solidity file.
Pragma is a directive that specifies the compiler version to be used for current Solidity file.
Solidity is a new language and is subject to continuous improvement on an on-going basis.
Solidity: Solidity is a contract-oriented, high-level language for implementing smart contracts. It was influenced by C++,
Python and JavaScript and is designed to target the Ethereum Virtual Machine (EVM).
-
18Solution - Instantiate Solidity
-
19First Assignment - Ask One Question
Learn Solidity - Basics II (Conditional logic, Scope & Visibility)
-
20General Introduction To Variables & Types
-
21Introduction To Booleans, Integers, & Strings
-
22Writing Solidity Variables
-
23Exercise - Write Solidity Variables
Exercise - Write Variables
1. Create a new variable called wallet as an integer
2. Create a boolean called spend
3. Create a string give it the name notifySpend
4. Initialize the wallet to 500
5. Set the value of spend to false
6. Add the string literal (the string value ) 'you have spent money' to notifySpend
----------
While writing program in any language, you need to use various variables to store various information.
Variables are nothing but reserved memory locations to store values.
This means that when you create a variable you reserve some space in memory.
Variables: Variables are used to store information to be referenced and manipulated in a computer program. Pseudo code example of storing information into variables
store-owner = 300 - integer
chocolate-bar = 10 - integer
totalValue = store-owner + chocolate-bar = 310
totalValue = 310 - integer
Types: Boolean - Keyword: bool - Value: true/false
Integer - Keyword - uint - Value - Signed and unsigned integers of varying sizes
String - Keyword - string - data values that are made up of ordered sequences of characters
-
24Solution - Write Solidity Variables
-
25What Are Functions - In Solidity
-
26How To Write Functions in Solidity
-
27Scope - Functions and Variables in Solidity
-
28Exercise - Write Your First Smart Contract - Calculator
Exercise - Write Your First Function (Calculator)
1. Create a function in the learnFunctions contract called multiplyCalculator
2. Add two parameters to the function a & b and set them as integers.
3. Grant the function public visibility as well as viewing capability for the IDE.
4. Return an integer for the function
5. Create a variable result that contains the logic to multiply a and b
6. Return the result
7. Compile and deploy your very first dApplication and test out the results!!
--------
FUNCTIONS:
A function is a group of reusable code which can be called anywhere in your program.
This eliminates the need of writing the same code again and again.
It helps programmers in writing modular codes. Functions allow a programmer
to divide a big program into a number of small and manageable functions.
Like any other advanced programming language, Solidity also supports all the features necessary to write modular code using functions. This section explains how to write your own functions in Solidity.
-
29Solution - Write Your First Smart Contract - Calculator
-
30Debug Assignment
-
31What is the Ethereum Virtual Machine (EVM)
Learn Solidity - Basics III
-
32Decision Making in Solidity
-
33How To Write If else statements in Solidity
-
34Exercise - Write an Airdrop If Statement in Solidity (Exercise with Solution)
Exercise in DeFi! :)
1. Create a stakingWallet variable as an integer and set it to the value of 10
2. Write a function called airDrop which has public visibility, is IDE viewable and returns an integer
3. create decision making logic so that if the wallet has a value of 10 then add to the wallet 10 more
4. add an else statement so that if the wallet does not equal the value of 10 to add only 1 more
5. return the value of the wallet
6. deploy the contract the test the results - try changing the value of the wallet to 6 and redeploying for varying results
-------------
While writing a program, there may be a situation when you need to adopt one out of a given set of paths.
In such cases, you need to use conditional statements that allow your program to make correct decisions and perform right actions. If statement: The if statement is the fundamental control statement that allows
Solidity to make decisions and execute statements conditionally.
If...else statement: The 'if...else' statement is the next form of control statement that allows
Solidity to execute statements in a more controlled way.
-
35Visibility - Public Private Internal External - in Solidity
-
36Scope & State in Solidity
-
37Exercise - Strengthen Your Understanding Of Scope and State
-
38Solution - Strengthen Your Understanding Of Scope and State
-
39Visibility - Public Private Interal External - in Solidity II
-
40Visibility - Public Private Internal External - in Solidity III
-
41Operators in Solidity
-
42Arithmetic Operators in Solidity
-
43The Remainder Operator in Solidity
-
44How to calculate the Modulo Remainder - Trick
-
45Exercise - Arithmetic Operator Practice
ARITHMETIC EXERCISES
1. a + b - b + a = ?
2. a * b * b - 1 = ?
3. b + b++ + a++ = ?
4. (b % a) + 3 = ?
-
46Solution - Arithmetic Operator Practice
-
47Comparison Opeartors in Solidity
-
48Exericse - Comparison Operators
-
49Solution - Comparison Opeartors
-
50Logical Operators in Solidity
-
51Exercise Logical Operators
-
52Solution - Logical Operators
-
53The Assignment Operator in Solidity
-
54Exercise - Final Solidity Operator Test
Exercise - Operations and Operators
1. Create a contract called final exercise (Final Exercise)
2. Initialize 3 state variables a, b, f
3. Assign each variable the following: a should equal 300, b should equal 12, and f should equal 47
4. Create a function called finalize that is public and viewable which returns a local variable d
6. Initialize d to 23
7. Return d in short handed assignment form to multiply itself by itself and then subtracted by b
8 bonus make the function conditional so that it will only return the multiplication if a is greater than or equal to a and b is less than f otherwise d should return 23
-----------------
An operator in a programming language is a symbol that tells the compiler or interpreter to perform specific mathematical, relational or logical operation and produce final result.
-
55Solution - Final Solidity Operator Test
-
56Assignment - Investigate Solidity And Make a Critical Assessment
Structures & Libraries in Solidity
-
57How to improve your skills with this course
-
58Review - Modulo & Fun Math in Solidity
-
59The For Loop in Solidity
-
60Exercise - How to loop in Solidity
Exercise - Looping Practice
1. Create a contract myLoopingPracticeContract and place all the following code within:
2. Create a list that ranges from 1 to 20 called longList
3. Create a list called numbersList of the following numbers: 1, 4, 34, 56
4. Create a function that loops through numbersList and returns a true value if the number that the user inputs exists in the list otherwise it should return false.
5. Create a function that loops trhough and returns how many even numbers there are in the long list
------------
Loops in Solidity allow you to iterate through data and take functional action depending on the data.
A "For" Loop is used to repeat a specific block of code a known number of times.
-
61Solution - How to loop in Solidity
-
62Strings in Solidity
-
63Memory Keyword in Solidity
-
64Bytes vs Strings in Solidity
-
65Bytes vs Strings in Solidity II
-
66Exercise - Writing Strings in Solidity
Exercises with Strings:
1. Create a string called favoriteColor
2. Set the favorite color of the string favoriteColor to blue
3. Create a function which returns the string literal of favoriteColor
4 . Create a function which changes the favoriteColor string literal from blue to your favorite color.
5 . Create a function which can return how many characters there are in the string favorite color
---------------------
Solidity supports String literal using both double quote (") and single quote ('). It provides string as a data type to declare a variable of type String.
Values that are made up of ordered sequences of characters, such as "hello world". A string can contain any sequence of characters, visible or invisible, and characters may be repeated.
-
67Solution - Writing Strings in Solidity
Learn Solidity Basics IV (Conversions and Special Variables)
-
68What are Constructors in Soliditiy
-
69Exercise - Build A Constructor in Soliditiy
Exercise for Constructors:
1. Create a contract called Base which stores full accessible (inside and outside) data upon deployment
2. Create a contract called Derived which derives the data from base and runs a function that always outputs the data to the integer 5.
-----------
Constructor is a special function using constructor keyword. It initializes state variables of a contract.
Following are key characteristics:
1. A contract can have only one constructor.
2. A constructor code is executed once when a contract is created and it is used to initialize contract state.
3. After a constructor code executed, the final code is deployed to blockchain.
This code include public functions and code reachable through public functions.
Constructor code or any internal method used only by constructor are not included in final code.
A constructor can be either public or internal.
A internal constructor marks the contract as abstract.
In case, no constructor is defined, a default constructor is present in the contract.
-
70Solution - Build A Constructor in Solidity
-
71Arrays in Solidity - Pop Push and Length Methods
-
72Arrays in Solidity - Delete
-
73Exercise - Compact Array
Exercise Arrays - Create a function that can fully remove an item from an array
1. Create an Empty array called changeArray
2. Create a function called removeElement which sets the index argument of the array to the last element in the array
3. Remove the last index from that function with the pop method
4. Create a function called test which pushes 1 2 3 4 into changeArray
5. Remove the element 2 from the array when the contract is called
------------------------
WHAT ARE ARRAYS? :)
Arrays in Solidity is a data structure, which stores a fixed-size sequential collection of elements of the same type.
An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.
-
74Solution - Compact Array
-
75What are Enums in Solidity
-
76Exercise - How To Write Enums
Exercise - Enums
1. Create an enum for the color of shirts called shirtColor and set it to the options of either RED or WHITE or BLUE
2. Create a data of shirtColor called defaultChoice which is a constant set to the color BLUE
3. Create a data of shirtColor called choice and don't initiate the value
4. Create a function called setWhite which changes the shirt color of shirtColor to white
5. Create a function getChoice which returns the current choice of shirtColor
6. Create a function getDefaultChoice which returns the default choice of shirtColor
--------------------------
Enums restrict a variable to have one of only a few predefined values. The values in this enumerated list are called enums. With the use of enums it is possible to reduce the number of bugs in your code.
-
77Solution - How To Write Enums
-
78What are Structs in Solidity
-
79Exercise - Structs in Solidity
Exercise: Structs
1. Create a new movie and set it up so that it updates to the movie in the setMovie function
2. Return the id of the new movie
3. Create a new var called comedy and set up comedy to the datatype Movie
4. Update the setMovie function with a comedy movie that contain name, director, and an id
5. Return the movie id of the comedy.
------------------------
Structs in Solidity are types that are used to represent a record.
-
80Solution - Structs in Solidity
-
81Mapping in Solidity
-
82Exercise - Set Keys and Values
-
83Mapping & Struct Assignment
Mapping Assignment:
1. Create a unique data type as a struct called Movie and give it the string properties: title and diretor.
2. Create a map called movie which takes a uint as a key and Movie as a value .
3. Create a function called addMovie which takes three inputs, movie id, title and director which assigns a value of an integer to a movie added back to the movie map. It should include a title and director name.
4. Deploy the contract and update the movie information to the movie map with our favorite movies!
---------------------
Mapping is a reference type as arrays and structs. Following is the syntax to declare a mapping type.
Mapping allows you to save data and add a key that you specifiy and then retrieve that info later.
Similar to struct or an array - it is a reference type in Solidity you can't iterate through a map - you need to store the keys in an array and you can't give size
-
84Solution - Mapping & Struct Assignment
-
85Nested Mapping in Solidity
-
86Pairing Addresses Assignment