Introduction
What is Flow?
Flow is a blockchain similar to others you may have heard of such as Ethereum or Solana. One of the key distinguishers for Flow is how they solved scalability while maintaining decentralization and security.
If you want to dive into a more in depth comparison of Flow and Ethereum check out this article: https://pixelplex.io/blog/flow-vs-ethereum-comparison-best-platforms-for-nft/
What is Cadence?
Cadence is a Resource-Oriented programming language designed for developing smart contracts. Cadence is a great programming language to get started in Web3 because it prevents developers from accidentally writing code that could cause data or financial loss. It is also fast, lower cost compared to other Proof Of Work Blockchains, and secure.
You can learn more about Flow and Cadence through their Getting Started page.
Part I - Installing Flow CLI
Installing the Flow CLI will depend on the operating system of your device. Follow the documentation from Flow to install the latest version.
After installing, in your CLI/terminal, use the command flow version
to verify you have the correction version installed.
To start working with Flow in a REPL, in the CLI/Terminal type the command flow cadence
which will open something that looks like this:
Welcome to Cadence v0.18.0!
Type '.help' for assistance.
1>
This is the REPL environment in which we will start in.
Of course, we can't break tradition. Let's start learning Cadence with none other than "Hello, World."
In your CLI/terminal type the following and press enter.
log("Hello, World")
This should echo the statement back in your CLI/Terminal.
Now we can move onto learning comments, types, variables, and functions.
Part II - Comments
Cadence has your standard options for formatting comments plus a few more.
-
Single line comments
// comment
-
Multi-line Comments
/* multi line comment */
-
Documentation Comments - Single Line
/// documentation single line comment
-
Documentation Comments - Multi-line
/** documentation multi-line comment **/
Part III - Types + Variable Declaration
Like most programming languages, Cadence has primitive types. Primitive types are basic data types that serve as a building block in most languages.
In Cadence, you can declare primitive type variables explicitly let name: String = "Samina"
or implicitly let name = "Samina"
Note: before we get into types, when declaring variables in Cadence there is a difference between let
and var
. Unlike in JavaScript, let
is an immutable or not changeable variable declaration. In contrast, var
is mutable or changeable.
let age = 21
age = age + 1
For example, the statement above would result in an error. Use var
instead of let
when you are planning on changing the variables.
-
Integers are used to represent whole numbers. An integer can take on many forms including decimal, binary, octal, and hex. You can also use underscores to make it visually easier to comprehend bigger numbers (ex. 100,000,000 ->
100_000_000
).
let numOne = 627 //decimal var numTwo = 0b1010 //binary (decimal equivalent 10) let numThree = 0o13 //octal (decimal equivalent 11) var numFour = 0xFF //hex (decimal equivalent 255)
You can use specific versions of
Int
such asInt8
(range: -128 to 127) orInt16
(range:
-32,768 to 32,767) if you want to be specific or save storage space. You can also use unsigned
integers:UInt
. -
Fixed- Point Numbers are used to represent fractional numbers. In Cadence, these are
Fix64
orUFix64
for the unsigned version.
let numOne: Fix64 = 7.25 var numTwo: UFix64 = 126.02
-
Strings are a collection of unicode characters that are immutable. I like to think of them as a collection of characters or a word. Note: strings are always enclosed in quotes.
let name = "Steve" let favoriteGame: String = "Minecraft"
-
Addresses allows you to store addresses or pointers. This is used quite frequently in Cadence to reference accounts and will be super useful when we dive into Smart Contracts and Transactions.
let accountAddress: Address = 0x123456789
-
Booleans allows you to store the binary values
true
orfalse
. These types can be used to indicate an on or off state or work with conditionals (if-else) to help control your program.
var lightsOn = false let isAfraid = true
Cadence also has several composite data types. Composite types are usually built from the aforementioned primitive types.
-
Arrays are a mutable collection of types.
let months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
-
Dictionaries are a mutable collection of key-value pairs.
let sides = {"triangle": 3, "square": 4 , "pentagon": 5 , "hexagon": 6} sides["square"] //outputs 4
-
Structures or structs are a value type. You can compare them to objects in JavaScript. Their primary purpose is to store information.
pub struct avenger { pub let name: String pub let ability: String pub let weapon: String pub let weight: Fix64 //pounds pub let height: Fix64 //inches init(name: String, ability: String, weapon: String, weight: Fix64, height: Fix64) { self.name = name self.ability = ability self.weapon = weapon self.weight = weight self.height = height } }
The keyword
pub
stands for public- which is an [access modifier](https://en.wikipedia.org/wiki/Access_modifiers#:~:text=Access%20modifiers%20(or%20access%20specifiers,facilitate%20the%20encapsulation%20of%20components.). We use the keywordstruct
to declare the structure and follow it with the name to reference the struct:avenger
. Inside of the struct, after we declare our fields, we must useinit()
to initialize the fields.In order to initialize an instance of a struct we would do the following:
let CaptainAmerica = avenger(name: "Steve Rogers", ability: "Super Strength", weapon: "Shield", weight: 240, height: 74)
-
Resources are similar to structs except they are linear types. Resources are moved around and not copied (in contrast to structs) and they can only exist once.
What does that mean?
Good question. Well, it is a vital part of Resource-oriented programming
languages, prevalent in Web3. Resources are special and can be used in Cadence to
represent something unique such as an NFT, Collection, etc.For resources I am going to use the following example provided in the Fast Floward Bootcamp:
pub resource Wallet { pub var dollars: UInt init(dollars: UInt) { self.dollars = dollars } }
In order to initialize the Wallet we created, we would use the following
let myWallet <- create Wallet(dollars: 10) destroy myWallet
Notice how it uses an arrow
<-
instead of=
and the keywordcreate
to initialize the Wallet. The arrow signifies where the resource is moving and thecreate
indicates the creation of that resource.Because resources don't allow [garbage collection](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science), we must delete the resource manually by using the keyword
destroy
followed by the name of the resource.Something interesting to note is that resources are used in Cadence for assets like NFTs because they cannot be destroyed (unless destroyed by the owner). This is an important structure to have because you don't ever want to lose these, oftentimes, valuable assets.
Part IIII - Functions
Are you still there? Bare with me, this is the last technical section.
Functions!
If you have worked with functions in other programming languages, this should be fairly similar in nature.
In contrast to the REPL we worked with earlier, for this section we can work with a .cdc
or Cadence file.
To begin, create your file in the CLI/terminal:
flow cadence demo.cdc
You can open this using your favorite command line editor or use an IDE such as VS Code. If you decide to use VS Code, be sure to install the Cadence extension to assist you with syntax highlighting.
In a .cdc
file we will declare an entry-point by using the main()
function.
pub fun main() {
log("Hello, World")
}
To run this program type
flow cadence
in the root of your directory. We should once again see it echo "Hello World"
Notice the keyword pub
(short for public)- this is an access modifier meaning that the public has access to the value. Following that is fun
which is an abbreviation for function. The rest of it should look similar to functions you have created before.
Now let's take it a step further and add another function. This example was also provided by the Fast Floward Bootcamp
pub fun hello(to name: String) {
log("Hello, ".concat(name))
}
pub fun main() {
hello(to: "Steve Rogers")
}
We should see the following when we run this program:
Hello, Steve Rogers
With that, we can conclude the main material from Day 1.
Fast Floward BootCamp
For further learning, the Fast Floward Bootcamp provides a great example to reinforce all these concepts, and provides Quests to practice your learning.
I want to thank the team at Decentology for providing all this material to learn Flow and Cadence. Their team has gone above and beyond providing an inclusive, welcoming environment, and supporting incoming developers to Web3.
If you are interested in registering for the Fast Floward Bootcamp, register through this link: https://www.decentology.com/blog/fast-floward-developer-bootcamp-for-flow
Top comments (0)