Introduction to Smart Contracts and Remix IDE Usage

Remix is an essential tool for learning and developing Solidity smart contracts efficiently.

### Getting Started with Smart Contracts in Remix IDE
* 🖥 Smart contracts are being developed in a local environment, but Remix remains a valuable tool for **quick checks and learning Solidity fundamentals**.
* 📁 The file explorer in Remix allows users to **manage their files and write smart contract code**, with an option to **delete existing folders for a cleaner workspace**.
* 🛠 Users can select specific Solidity compiler versions, such as **0.8.18**, to ensure compatibility, while understanding that using a version below **0.8.7** will prompt the system to select an **appropriate compiler version automatically**.
* ✍ To create a smart contract, the keyword **"contract"** is used, and the structure is similar to **classes in object-oriented programming languages** like Java or Python.
* 📄 It's essential to include the **SPDX license identifier** for legal clarity, although it's not required by the compiler, and users are encouraged to write **comments in their code** for future reference.
* 🔍 The Remix IDE provides various features, including a **Solidity compiler** and the ability to **deploy contracts**, making it an effective environment for **smart contract development**.
* 💾 Remember to save your work frequently, as compiling transforms **human-readable code into machine-readable byte code**, which is crucial for **executing contracts on the blockchain**.
* ⚙ Users should familiarize themselves with different Solidity versions since each version may introduce **new features or changes**, and tools like Slither recommend specific versions for **stability**.

welcome to the remix IDE or the integrated development environment. This is where we're going to learn to write a lot of our code in the beginning. If you want, you can go ahead and accept to help out remix here. And if you've never been to the remix website before, it'll give you a tutorial walkthrough of some of the features that remix has to offer. For example, it has a solidity compiler. Solidity is the programming language that we're going to be using in this course to code our smart contracts. Where and we need to compile them when we've written the solidity. We'll learn about that in a little bit. We have a tab here where we can actually deploy our contracts to a blockchain. And we have all these different folders and scripts since we can actually write JavaScript and TypeScript in remix as well. But don't worry about those too much for now because I'm going to be explaining everything that we're going to do. Remix is an incredibly powerful tool because it has a lot of features that allow us to really see and visualize what our

smart contracts do eventually. We're going to move off of Remix to a local development environment. However, Remix as a tool is still used by some of the top auditors and smart contract developers in the space when they want to quickly check something out. Additionally, it's fantastic for learning the fundamentals of Solidity. The left-hand side is where we're actually going to start interacting with Remix. If we bring our mouse up to the top, this little file explorer is where we're going to have all of our files and where we're going to write our Solidity or our smart contract code. If you want, you can leave all these folders in here, but I'm actually going to go ahead and delete everything so that there's less for me to work with or deal with. So I'm just going to go ahead and right-click and delete everything in here just so I can start completely from scratch again. If you want to leave all of these in here, feel free to do so. It doesn't matter. I just think it's cluttering up my mental

space a little bit. Now we have a blank remix project, and the first thing that we're going to want to do is create our first file to start writing and deploying our Solidity smart contract. We're going to go ahead and click the create new file right here and type in simple storage dot Sol. Dot Sol tells our compiler that this is going to be a Solidity contract, a Solidity file, and we're going to be writing Solidity inside of this file, which again, Solidity is the most popular smart contract programming language. And you'll see we actually get popped up a simplestorage.soul on the right-hand side, which we can type in and actually write our Solidity code. Now, right below the file explorer button is a little search icon, which allows us to search for different code in all of our contracts. So, for example, if I type in hello in here and I copy that, paste that into the search bar, hit enter, we can see that it found this line hello in our simplestorage.soul. Let's go ahead and delete that right below that search icon.

is this Solidity compiler, and you'll see a bunch of different stuff pop up, which tells us about our compiler configuration. We can see even more advanced configuration if we hit the drop-down. We're not going to hit that for now. Let's go ahead and double-click this Solid Compiler over here so we can just see the SimpleStorage.sol. I'm also going to click this Hide Terminal button so that we just see our SimpleStorage.sol. Now, the first thing that we want to do in all of our Solidity smart contracts is write the Solidity version that we're going to be working with. Solidity is a constantly changing language, and we want to be very specific about what version we're going to be using to write our smart contract, as each version does different things. So, write your version. You're going to do pragma solidity, and then type your version. For most of this course, we're going to be using 0.8.19, as that's the most current edition of Solidity. However, getting used to working with different versions of

solidity is really good for you, as you're going to be working with different versions of solidity no matter where you go. Certain versions of solidity are considered more stable than other versions. Right now, there's a popular tool called Slither, which recommends using 0.8.18. So, if you want to default to 0.8.18 for this course, feel free to do so. We're going to be using a couple of different versions as we code. So, this line says we're stating our version. Now, these two slashes here stand for what's called a comment in solidity, and this allows you to write anything after the two slashes. And when we compile or run our code, it will just ignore what's in here. So, we could type blah blah blah, whatever we want, cats are cool, and it doesn't matter. You can write anything in here. I highly recommend to, as we're going along, you should write comments in your own code as well for you to refer to later on. And additionally, feel free to copy all the

code that you write and paste it locally so that just in case your browser cache refreshes or something, you won't lose all the work you've done. So, before you lock off for the day, copy-paste this into a text file so that you can have it for later. But a good comment for here might be, This is the version now. Writing our version like this in Solidity tells the Solidity compiler that we're only allowed to use 0.8.18 when compiling this. However, maybe a new version comes out, and we're okay to use anything newer than this version. To tell the compiler that, we add this little hat, this little carrot, which says, This contract only works with 0.8.18 or anything greater than that. This means 0.8.19 would work. When 0.8.20 comes out, that one would work. However, 0.8.17 would not work if we were working with 0.8.18 or above. If we don't have the carrot, this tells the compiler that

only 0.8.18 will work with this code. If we want to use slotted versions within a range, we could do something like this. We could say we want our version to be greater than or equal to 0.8.18 but less than 0.9.0. This would tell the compiler that any version between these two is a valid version. For example, 0.9.1 would not work, neither would 0.9.0, because these are not strictly less than 0.9.0, right? So now we know how to do compiler versions. Now the next thing every smart contract needs to start with is something called the SPDX license identifier. Now this actually isn't required by the compiler. It'll actually throw a warning if we compile, and it won't error. It's fine if you don't have this; however, it's highly recommended. This is a way to make licensing and sharing code and IP of your contracts a lot easier from a legal perspective. I have a link to more about how licenses work in the GitHub repo.

associated with this section of the course. MIT is known as one of the most permissive licenses. Basically, it means anybody can use this code and pretty much do whatever they want with it. I wouldn't worry too much about the licenses right now, but let's actually go back to 0.8.19, and on the left-hand side, let's scroll down to this compiler button and open this back up. Even right now, now that we don't even have any code, we can actually go ahead and compile this contract. Now, you might see a red squiggly, and you might see a warning here, but don't worry about that for now. To choose our compiler version, we scroll up to this section, and we can choose the compiler version that we want to work with. Most of the time, though, if you just hit compile simple storage.soul, or you hit this big compile button, it'll automatically choose the version for you. For example, if I scroll down, when I hit compile, it'll automatically flip up to 0.8.19, and we were able to go ahead. We

were able to successfully compile this code. Now it says no contract compiled yet because we haven't put a contract in here yet. We just put the version of Solidity that we're working with. Compiling our code means taking our human-readable code and transforming it into computer-readable code, which is essentially a bunch of zeros and ones, or it's byte code. Computer code is very specific instructions for the computer to use, or in our case, the blockchain to use for our contract. We'll learn later about machine-level code, opcodes, and EVM codes in a much later section of this course. Additionally, you can hit command S or control S, which will also save and compile. You'll see I kind of have a trigger finger, and I will, out of habit, hit command S all the time because, as somebody who codes a lot, I need to make sure I save all the time. Otherwise, things might not work as intended, as you saw. If we use a different version of Solidity and we hit the compile button, it'll automatically flip back. But for example, let's say I I

wanted to use 0.8.7. Anything greater than that, and we're on compiler 0.8.19. And we hit compile. It won't change. However, if I use something less than 0.8.7, and we hit compile, it'll change because it wants to automatically select a solidity version that is appropriate for the version that you chose. Again, I want to use 0.8.18, and I'm going to hit compile, and we're good to go. Now we're going to go ahead and start writing our contract. And to get the full-screen view again, we just go ahead and click the salinity compiler so that we can just see our code here. To start writing our contract, we're going to use a keyword in solidity called contract. This tells solidity that the next piece of code is going to be the name for our contract that we're going to create. You can think of a contract very similar to a class if you're familiar with JavaScript or Python or Java or really any object-oriented programming. And we're going to

go ahead and give our contract a name here. We're going to call ours simple storage, and then we add this little open and closed curly braces or curly brackets. Everything inside of these curly brackets is going to be considered part of this contract simple storage. Now, if we hit enter, we go back to the compiler and hit compile, we can see once again this little green check mark pop up. This means our compilation has been successful. If we were to remove, for example, this curly brace and hit compile, we would see we would get this error compilation failed with one error, and if we scroll to the bottom, it'll tell us where the error actually is, and we'll get a little red pop-up saying what line the error is actually on. We'll learn about debugging these errors in a little bit, but let's add the curly brace back. Go ahead, back to the compiler, hit compile, and we're good to go.

Lesson 2 Part 2 | Welcome to Remix - Solidity & Foundry Full Course

Book a smart contract audit here 👇
https://www.cyfrin.io/


Cyfrin Audits

Using Remix for Smart Contract Development

Remix is a popular tool for smart contract developers and auditors, ideal for learning Solidity fundamentals.

The file explorer in Remix is used to manage and write smart contract code, with the option to delete unnecessary folders for a cleaner workspace.

The Solidity compiler version can be set, and the contract keyword is used to define a new contract, similar to classes in object-oriented programming.

Creating and Compiling a Solidity Smart Contract

We start by creating a new file named simple storage.

sol extension indicates it's a Solidity file, and we can write our code in it.

Compiling the code transforms it from human-readable to computer-readable format, and we can save and compile using command S or control S.

The Solidity compiler configuration can be viewed by double-clicking on it, with the option for advanced settings in a drop-down menu.

It's important to specify the Solidity version at the beginning of the smart contract, with 0.

Using comments in the code is encouraged for better understanding and future reference.

Slotted versions can be specified to be greater than or equal to 0.

The SPDX license identifier is recommended for smart contracts, making licensing and sharing code easier.

The Remix IDE offers features like Solidity compilation and contract deployment, making it a powerful tool for writing and visualizing code.

Creating and Compiling a Simple Storage Contract

The contract is named "simple storage" and is defined within curly braces.

Successful compilation is indicated by a green check mark, while removing a curly brace results in a compilation error.

The compiler version can be chosen or automatically selected, and the contract can be compiled even without any code.