This is Gregory from Dad University.

Some so excited to be on free code camp today to teach you how to become a Blockchain developer.

I'm gonna take you over the shoulder and teach you how to write Ethereum smart contracts with a solidity programming language for the block chain.

And you don't even have to know anything about solidity or Blockchain to follow along.

So I've compiled this multi part tutorial Siri's into one massive video for free code camp and you can follow along with the code examples step by step on my website.

There's an article that I'm gonna put a link to down the description below.

And finally, if you're serious about becoming a Blockchain developer needed or my free training on my website over a Daph university dot com forward slash boot camp and I also put a link to that description.

Below solidity is the main programming language for writing smart contracts on the ethereum block.

Jame, it's a contract or read a language which basically means that you know, smart contracts are the main way that you organize code and like stored data and write all of your programming logic and you know it's a high level language for implementing these smart contracts.

It looks a lot like Java script and, you know, python and C plus plus, as you see right here and it's used to run on the Ethereum virtual machine, which is basically, you know, the thing that runs the code on the ethereum Blockchain.

So solidity is statically typed a supposed to a dynamically type language and its support stuff like inheritance libraries and lots of other stuff.

So, enough of talking about solidity.

Let's actually jump in and start writing some solidity code.

This is a Web site that allows you to write solidity smart contracts in your browser and you know, it has a text editor here.

It allows you to compile them and deploy them and run them.

And that's exactly what I'm gonna use for this tutorial.

You won't have to down with anything in your computer.

You won't have to install anything.

You could just visit this website, um, to use remix, and we'll write the smart contracts that way.

So in order to do that, I'm gonna go over here to this browser folder.

Um, you can see the file browser over here.

This is basic smart contracts that come preloaded inside of this.

Ah, I d I'm just going to create a new one here.

I think I couldn't create a new file.

This will be a solidity file.

I will call it my contract, and we're gonna write a smart contract inside of here.

I'll do this by first declaring the version of solidity that we want to use you.

To do that like this was a Prague MMA solidity enemies a carrot to specify aversion greater than the woman want to use.

And I'm gonna say version zero dot for us for 24 And I'm gonna end each line like this with a semi colon, and next, I'm actually gonna declare the smart contract.

So before I do that, I'll explain a little bit more about what a smart contract is.

Um, you know, smart contract is code that gets executed on the block chain.

In this case is gonna be the ethereum Blockchain.

That's for using, you know, solidity for this Ethereum smart contract.

And this smart contract is kind of be kind of like a micro service out on the web.

It's gonna be accessible to everyone on the block chain.

They'll be able to, you know, see, this smart contract will be able to use it.

They'll be able to read and write data with it and actually execute any code that we write inside of here.

So it's going to be public.

And that's kind of why I called like a micro service.

It's more.

It's more than just a class, like in an eye, Victorian and system or something like that.

It's actually something that's publicly accessible.

So it's gonna look something like a class, though, because it's how we're gonna actually, you know, uh, keep all the code and side of here.

So she had to do that.

We'll call.

We'll start by saying Contract, say my contract and I'm opening with some curly races and it will notice that the editor closed this automatically for us, which is really nice.

And what I'm going to do first is just show you how to read and write a value for variable inside of here.

Now, like I said earlier, solidity is a statically type language, so we're gonna actually have to declare the type the debt a type of the variable you wanna store.

So in this case, we're just gonna store string and we'll declare string will say value.

Now, let me explain something about this value this value is gonna represent, you know, a variable that belongs to this entire smart contract.

So this isn't like a local variable.

It's actually a variable that this entire contract will know about.

And what that means with a smart contract is that data is actually gonna get stored on the block chain in storage.

So if we set this value were actually be riding data to the Blockchain.

That's different from a local variable that I might just know set instead of a function that would be, you know, local to that function scope on.

But you know, disappear instantly once that function is called.

Instead, this values actually could be stored on the Blockchain.

So let's create a way to us.

Just read this value so I can do this by writing a function and solidity like this.

We start with the function key word I say we call the function, get it's gonna get this value, and we'll say We'll just open the braces for now and write some more code here in a second season.

Warnings coming up.

But I'll fill this out more will say, just return about you.

Okay?

And that's a really basic way to do this.

I'm gonna add some more to this.

I'm gonna say this is also public, all right?

Which basically is setting the visibility.

This function that's that's called solidity is setting the visibility.

So that knows this function could be called by anyone who has access to the smart contract on the block chain, not just inside this contract.

So I'm also going to set a return value returns string.

All right, that makes our warning disappear down here.

And I just tell their function that we're always gonna return.

Ah, string data type.

And we know that's the same type as value because we declared it here.

Now, I'm also gonna look this warning down here which says this function state mutability could be restricted to basic.

What this is saying is in solidity.

Now, in this newest version, we're not actually changing this value.

We're not changing anything inside this function.

We want to add additional modifier here, which is says of you, all right.

And that makes that warning go away.

So now I'm gonna set a new function or write a new function that's called set Say function.

It's gonna louse to set this value set as a string.

It's a value, all right.

And I'm also going to, you know, set the visibility of this function when it call it public, which means that anyone will be able to set this value on the block chain.

And I'll say value equals this value that were passing him.

All right, let me explain that I'm using values and underscore here because I want to differentiate between this value that's getting passed in and the value that's referenced here.

Now, inside, if you're you know, this value without underscore is referencing this, you know, state variable that we set up earlier that's actually getting store to the block chain.

And this value slitting knows that it's just a local variable because I pass it in and I, you know, pretended it with an underscore like this and also noticed that I declare the data type of the function argument.

We need that inside solidity because it needs to know the type of the data that's getting passed in, All right.

And now we have a way to actually read this value and said it.

The next thing I'm going to show you is how to set this value.

Ah, whenever you we deploy the smart contract or whatever it's generated for the first time.

And I'm gonna do this with the constructor function.

So if you're familiar with other programming languages where you might write, you know, classes doesn't like that you might be familiar with a constructor function, which is basically a function that's called whenever this contract isn't Stan she hated or in this case is gonna be won over the contracts is created whenever the smart contract is deployed to the Blockchain.

And in the newer versions of solidity, we do that like this was a constructor.

And we just, you know, say it's public and we can, you know, write code inside of this constructor that gets called whenever this contract is created.

Um, well, say value.

We'll just set it as you know my value.

All right, there we go.

So that's a complete smart contract that, you know, set this value whatever is deployed, so it will have some sort of default value.

And then we'll have some functions that allow us to read that value from the block chain.

And then we'll have a function that allows us to create that value as well.

So now I can go to this tab over here and remix, and I can compile it.

We can, ah, slipped the compiler version.

And I'm gonna say this a year 04 to 5 will start to compile it and see what happens.

All right?

And now what I'm gonna do is actually run this mark contract.

You see some options over here.

I'm just going thio say JavaScript virtual machine, which basically what that's gonna do is give us a test Blockchain in the browser so we don't have to connect to a Blockchain of any kind.

We could just, you know, compile this and run it and deploy it inside our browser, which is pretty cool.

And it's gonna give us some, you know, free ethereum accounts over here.

I don't worry if you don't quite understand why all these values mean just yet.

That's okay.

I can explain those more.

Um, but for now, we're going to just keep my contract and we're gonna deploy it.

Alright, here we go.

It's deployed.

So now what I can do is click on this little down air here and we see the functions that are available to us in the smart contract.

We can seethe set function and the get function.

You know, these are the functions that we created over here.

The set function is gonna allow us to update it and they get functions allows to get it.

So I click get and we should probably see the value that we created inside the constructor.

We set it here, so let's get it.

Alright, there we go.

It's my value.

And we can see some activity in this log down here.

We can see that there was a call to my contract I get and now we'll set it.

So I'm gonna enter.

Ah, the quotations for the string and I'm gonna say new value.

All right, let's look set.

All right, then we can see that worked so you can see the transaction history over here.

Let's get the value.

All rights, new value.

There we go.

That's a complete smart contract that allows you to get instead of value on the block chain.

Now, let me explain what's going on here.

This is a list of transactions that are occurring on the ethereum Blockchain.

So the ethereum Blockchain is made up of, you know, bundles of records that are chained together into blocks that make up the block chain and the basic unit of all those blocks are these transactions so we can see transaction receipts?

Um, we can actually cook the downers here.

We could see all the details, those transaction receipts.

And I've got other videos in this channel that kind of talk about that in detail.

If you want to know more about that, just feel free to look for those.

All right, that's it, guys.

That's how you can write your first smart contract in the solidity programming language again, that's supposed to be just a high level overview of solidity and how to get started riding your first mark contracts and using the programming language itself and using the remix I t e in your browser to get started easily without having to download any tools or anything like that.

The first thing I want to do in this video is actually update the smart contract code that we wrote in the last video to support the newest version of the solidity programming language, which is 0.5 um dot one.

I believe you can actually see the compiler version overhears changed in the last video.

You know, we wrote this smart contract and there's, um, actually Cem copulation errors You can see over here on the right.

You have to update this code to support his version of the solidity programming language.

And I want to go.

I want to go ahead and do this.

I wanted to go ahead and support the new version of solidity so that when I make more videos in this series, we'll be up the day.

You'll have the newest version.

So let's see what we need to do.

We could read the air, it says, Um, basically, the data location must be memory, and that's actually the air in both cases.

So all we need to do in this case is actually just return.

Ah, memory here.

And then whenever we're passing in the value a string we actually need Thio put memory here as well.

All right, actually, that need to be before value.

My fault.

And now we there's go away.

So we will select the newest compiler version Will say, uh, do.

The latest complete version is you're not fired at one started, compile.

And hopefully the accomplishment work.

Yes, it worked.

So let's go to run and we'll deploy.

Yes, you've worked.

So get the value.

Yep, It worked.

Awesome.

Now let's move on to the next part of this tutorial where we're actually cover the content for this video.

Which is gonna be, you know, the basic data types and data structures and solidity and how you can use them when you develop your own smart contracts.

So I would change in values in here to kind of show you what that is.