DEV Community: ShellRean

Golang: Create Authentication JWT #2

ShellRean — Sun, 05 Dec 2021 15:58:47 +0000

Write DTO token

Create dto to transfer our token, create file token.go save it in entities/DTO

package dto

type TokenResponse struct {
    AccessToken     string      `json:"access_token"`
    RefreshToken    string      `json:"refresh_token"`
}

Create handler

create main_handler.go and save it in interface/http/handler and write code below.

package handler

import (
    "net/http"
    "github.com/gin-gonic/gin"
    "shellrean.com/auth/domain"
    "shellrean.com/auth/entities/DTO"
)

type UserHandler struct {
    userUsecase     domain.UserUsecase
}

func NewUserHandler(r *gin.Engine, m domain.UserUsecase) {
    handler := &UserHandler{
        userUsecase:    m,
    }

    r.POST("/auth", handler.Autheticate)
    r.POST("/refresh-token", handler.RefreshToken)
}

We declare 2 routes, /auth will handle for authentication and /refresh-token for give user refresh token, at the same file main_handler.go add handler Authenticate

func (h *UserHandler) Autheticate(c *gin.Context) {
    var u domain.User
    if err := c.ShouldBindJSON(&u); err != nil {
        c.JSON(
            http.StatusUnprocessableEntity,
            gin.H{"error": "Unprocessable Entity"},
        )
        return
    }

    res, err := h.userUsecase.Authentication(c, user)
    if err != nil {
        c.JSON(
            http.StatusInternalServerError,
            gin.H{"error": err}
        )
        return
    }

    c.JSON(http.StatusOK, gin.H{"data": res})
}

We also create handler for handle Refresh token request.

func (h *UserHandler) RefreshToken(c *gin.Context) {
    var u dto.TokenResponse
    if err := c.ShouldBindJSON(&u); err != nil {
        c.JSON(
            http.StatusUnprocessableEntity,
            gin.H{"error": "Unprocessable Entity"},
        )
        return
    }

    token := domain.Token {
        AccessToken: u.AccessToken,
        RefreshToken: u.RefreshToken,
    }

    err := h.userUsecase.RefreshToken(c, &token)
    if err != nil {
        c.JSON(
            http.StatusInternalServerError,
            gin.H{"error": err}
        )
        return
    }

    data := dto.TokenResponse{
        token.AccessToken,
        token.RefreshToken,
    }

    c.JSON(http.StatusOK, gin.H{"data": data})
}

Create usecase

package usecase

import (
    "context"
    "time"
    "fmt"

    "golang.org/x/crypto/bcrypt"

    "shellrean.com/auth/domain"
    "shellrean.com/auth/config"
    "shellrean.com/auth/entities/helper"
)

type userUsecase struct {
    userRepo        domain.UserRepository
    contextTimeout  time.Duration
}

func NewUserUsecase(d domain.UserRepository, timeout time.Duration) domain.UserUsecase {
    return &userUsecase {
        userRepo:       d,
        contextTimeout: timeout,
    }
}

func (u *userUsecase) Authentication(c context.Context, ur domain.User) (td domain.Token, err error) {
    ctx, cancel := context.WithTimeout(c, u.contextTimeout)
    defer cancel()

    user, err := u.userRepo.GetByEmail(ctx, ur.Email)
    if err != nil {
        return domain.Token{}, err
    }

    if user == (domain.User{}) {
        return domain.Token{}, fmt.Errorf("Error user not found")
    }

    err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(ur.Password))
    if err != nil {
        return domain.Token{}, fmt.Errorf("Invalid credential")
    }

    helper.GenerateTokenDetail(&td)

    err = helper.CreateAccessToken(u.cfg.JWTAccessKey, user, &td)
    if err != nil {
        return domain.Token{}, err
    }

    err = helper.CreateRefreshToken(u.cfg.JWTRefreshKey, user, &td)
    if err != nil {
        return domain.Token{}, err
    }

    return
}

func (u *userUsecase) RefreshToken(c context.Context, td *domain.Token) (err error) {
    ctx, cancel := context.WithTimeout(c, u.contextTimeout)
    defer cancel()

    token, errs := helper.VerifyToken(u.cfg.JWTRefreshKey, td.RefreshToken)
    if errs != nil {
        return fmt.Errorf("Invalid when verification")
    }
    err = helper.TokenValid(token)
    if err != nil {
        return fmt.Errorf("Session invalid")
    }

    data := helper.ExtractTokenMetadata(token)

    user := domain.User{
        ID: int64(data["user_id"].(float64)),
    }

    helper.GenerateTokenDetail(td)

    err = helper.CreateAccessToken(u.cfg.JWTAccessKey, user, td)
    if err != nil {
        return err
    }

    err = helper.CreateRefreshToken(u.cfg.JWTRefreshKey, user, td)
    if err != nil {
        return err
    }

    return
}

And the last, we create main.go store it int app/main.go

Golang basic: slice

ShellRean — Sun, 03 Jan 2021 15:26:18 +0000

Array is make you think is there any way to make size of array dynamic? and you ask to god, yeah there is a slice. Slice as same as array, a variable has more than 1 values.
Let's we write our code.

Declare Slice

Declare slice is simple, how do that?

package main

import "fmt"

func main() {
    var students []string
    // OR
    students := []string{}
}

You don't need to include number in [] it will make a dynamic size.

Assign data to slice

How to assign data to slice? the key is same as array, look at code below.

package main

import "fmt"

func main() {
    students := []string{"Linda","Lingling","Wang"}

    fmt.Println(students)
}

Access data slice

You can use [index] to access the value.

package main

import "fmt"

func main() {
    students := []string{"Linda","Lingling","Wang"}
    // Access single data
    fmt.Println(students[1])
}

At the code, we get 1 as index, so if we mapped the value
0 => Linda
1 => Lingling
2 => Wang
it will return "lingling". But I want to get "lingling" and "Wang" how to do that?

package main

import "fmt"

func main() {
    students := []string{"Linda","Lingling","Wang"}

    // Access multiple data
    fmt.Println(students[1:3])
}

you can use format slices[indexfrom:end] to access multiple data

Change single data slice

so how to change that data?

package main

import "fmt"

func main() {
    students := []string{"Linda","Lingling","Wang"}

    // Change data
    students[1] = "Longda"

    // Access data
    fmt.Println(students[1])
}

Add data at the end of slice

So now we want to add student, we can use append in order to add.

package main

import "fmt"

func main() {
    students := []string{"Linda","Lingling","Wang"}

    students = append(students, "Boru")

    fmt.Println(students)
}

so format of appendisappend(slice, value)`

Conclusion

We have knew about slice and how to write slice in golang, there is many ways to roman city. If you think the data is difficult to predict how size of array max, slice is the best choice for you, even the author of golang, suggest to use slice than array.

Golang: Create Authentication JWT #1

ShellRean — Fri, 01 Jan 2021 15:36:47 +0000

After all this time we learned Golang which is a simple application application, finally we want to make a complete application but we are stuck with the question, how do we authenticate in Golang? That was also my question when I decided to move from node-js to golang.

Folder structure introduction

In this tutorial we will use the folder structure that I usually use
├───app
├───domain
├───entities
│ └───helper
├───interface
│ └───http
└───services
└───user
├───repository
│ └───postgres
└───usecase
app: contains main.package which will be executed the first time the go program is run.
domain: contains the struct domain
entities/helper: contains helper functions
interface/http: contains the gin gonic routing handler
service: contains service
usecase: where to put usecase instead of the user.
repository: where to put the repository

now run go mod init shellrean.com/auth in the created folder.

Create a table in postgresql

For our DBMS, this time using PostgreSQL, create a table with the names of users with the following specifications:

id (int) auto increment
name (string)
email (string)
password (string)
created_at (timestamp)
updated_at (timestamp) Then create 1 dummy user, make it free to generate passwords from bcrypt using the online tool at Bcrypt-Generator ## Create domain files create user.go file and save it in the domain folder, we will create a domain struct and user interface in this file.

package domain

import (
    "time"
    "context"    
)

type User struct {
    ID          int64       `json:"id"`
    Name        string      `json:"name" validate:"required"`
    Email       string      `json:"email" validate:"required,email"`
    Password    string      `json:"password" validate:"required,min=6"`
    CreatedAt   time.Time   `json:"created_at"`
    UpdatedAt   time.Time   `json:"updated_at"`
}

type UserUsecase interface {
    Authentication(ctx context.Context, ur DTOUserLoginRequest) (DTOTokenResponse, error)
    RefreshToken(ctx context.Context, ur DTOTokenResponse) (DTOTokenResponse, error)
}
type UserRepository interface {
    GetByID(ctx context.Context, id int64) (User, error)
    GetByEmail(ctx context.Context, email string) (User, error)
}

create a domain.go file then save it in the same folder, we will make a domain struck for the token in this file

package domain

type TokenDetails struct {
    AccessToken     string
    RefreshToken            string
    AtExpires       int64
    RtExpires       int64
}

Create a file repository

create main_user.go file and save it in the services/user/repository/postgres folder, we will create a repository function for retrieving data from the database.

package postgres

import (
    "context"
    "database/sql"

    "shellrean.com/auth/domain"
)

type postgresUserRepository struct {
    Conn *sql.DB
}

func NewPostgresUserRepository(Conn *sql.DB) domain.UserRepository {
    return &postgresUserRepository{
        Conn,
    }
}

func (m *postgresUserRepository) GetByEmail(ctx context.Context, email string) (u domain.User, err error) {
    query := `SELECT id,name,email,password,created_at,updated_at
            FROM users WHERE email=$1`

    err = m.Conn.QueryRowContext(ctx, query,email).
            Scan(&u.ID,&t.Name,&t.Email,&t.Password,&t.CreatedAt,&t.UpdatedAt)
    if err != nil {
        return err
    }

    return
}

Create a helper file

create token.go file and save it in the entities /helper folder, we will create a helper function that will perform the operation with JWT

package helper

import (
    "strings"
    "time"

    "github.com/dgrijalva/jwt-go"

    "shellrean.com/auth/domain"
)

func GenerateTokenDetail(td *domain.TokenDetails) {
    td.AtExpires = time.Now().Add(time.Minute * 15).Unix()
    td.RtExpires = time.Now().Add(time.Hour * 24 * 7).Unix()
}

func CreateAccessToken(key string, user domain.User, td *domain.TokenDetails) (err error) {
    atClaims := jwt.MapClaims{}
    atClaims["authorized"] = true
    atClaims["user_id"] = user.ID
    atClaims["exp"] = td.AtExpires

    at := jwt.NewWithClaims(jwt.SigningMethodHS256, atClaims)
    td.AccessToken, err = at.SignedString([]byte(key))
    if err != nil {
        return domain.ErrSessDecode
    }
    return
}

func ExtractToken(bearer string) (res string) {
    str := strings.Split(bearer, " ")
    if len(str) == 2 {
        res = str[1]
        return
    }
    return
}

func VerifyToken(key string, tokenString string) (*jwt.Token, error) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, domain.ErrSessDecode
        }
        return []byte(key), nil
    })
    if err != nil {
        return nil, domain.ErrSessVerifation
    }
    return token, nil
}

func TokenValid(token *jwt.Token) error {
    if _, ok := token.Claims.(jwt.Claims); !ok || !token.Valid {
        return domain.ErrSessInvalid
    }
    return nil
}

func ExtractTokenMetadata(token *jwt.Token) map[string]interface{}{
    claims, ok := token.Claims.(jwt.MapClaims)
    if ok && token.Valid {
        return claims
    }
    return nil
}

At this point, we have created 2 domain files, 1 repository file and 1 helper file, we will continue in the next article.

Golang basic: how to use array and implement it

ShellRean — Sun, 27 Dec 2020 04:36:14 +0000

Train to busan, run from zombie in the train. you have 11 wagon and it is an array. Array is a data type but is have more than one values but have maximum space.

Imagine you're in a train looking for your seat suit to your ticket and then "Yiaaah" you get the it and sit on.
Yeah like the illustration, array is similar, have maximum seat and have order of seat. array order is start from 0 to ~~hero~~ maximum space.

{0,1,3,4,...,100,1001} is order of array, so if a seat that anyone person not there, the seat is still be there not disappear.

How to declare array

package main

import "fmt"

func main() {
    var values [10]int
    values = [10]int{0,1,2,3,4,5,6,7,8,9}
    fmt.Println(values)

    // Or
    values2 := [10]int{0,1,2,3,4,5,6,7,8,9}
    fmt.Println(values)
}

[10]int, 10 is space maximum of array and int is data type in the array.
but what will be happen if we assign value more than 10?

package main

import "fmt"

func main() {
    values := [10]int{0,1,2,3,4,5,6,7,8,9,10} 
    // array index 10 out of bounds [0:10]
    fmt.Println(values)
}

Yeah you get the answer.

Assign data to array

How we assign data to array? there is a simple way to do that, lets we write code below.

package main

import "fmt"

func main() {
    var values [20]int

    values[4] = 5
    values[19] = 10

    fmt.Println(values)
}

You can see in console the result is
[0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 10] it will just store in the index, so if you want to place it in index 5, it will be there.

Multidimensional Array

Yeah train have row and column but what if we want to convert it to an array? we can write it as.

package main

import "fmt"

func main() {
    seats := [4][4]string{
        {"A1","A2","A3","A4"},
        {"B1","B2","B3","B4"},
        {"C1","C2","C3","C4"},
        {"D1","D2","D3","D4"},
    }

    for i, item := range seats {
        for j, it := range item {
            fmt.Printf("[%d,%d]:%s ",i,j,it)
        }
        fmt.Println()
    }
}

Conclusion

Now you can write array type. array is not just int but you can write it as string, bool, or array inside array.

Question: can we change value of array?

Golang basic: looping

ShellRean — Sat, 26 Dec 2020 10:39:52 +0000

You wake up and look at the clock and woo it's late to go to work. its always happen to you and make it as daily activity.
it will repeat the same thing but you can change that until something happen, stop and never happen again.

Is a simple concept of looping doing something until you decide to stop you want to stop until a condition is happen.

Write simple code loop

Golang has only have a loop it is for loop lets we code

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        fmt.Printf("Loop in number %d\n", i)
    }
}

We can write loop from 0 (i := 0), and make a condition i<10, if the condition is not true looping will be stop. Increase the variable i i++ so the the loop will stop.

Loop iteration data type

Now the condition is what happen if we want to get value of slice? we can create like below.

package main

import "fmt"

func main() {
    fruits := []string{"banana","watermelon","apple","coconut"}

    for i := 0; i < len(fruits); i++ {
        fmt.Printf("Fruit index %d is %s\n", i, fruits[i])
    }
}

We create loop i until i have value less than 4. and we get fruit at index of i, but it is not a best practice, we know that we can use range instead.

package main

import "fmt"

func main() {
    fruits := []string{"banana","watermelon","apple","coconut"}

    for i, item := range fruits {
        fmt.Printf("Fruit index %d is %s\n", i, item)
    }
}

Nested loop

Imagine we want to create coordinate that have latitude and longitude. We can create is nested as below.

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        for j := 0; j < 20; j++ {
            fmt.Printf("%d%d ",i,j)
        }
        fmt.Println()
    }
}

Infinity loop

How if we don't know when we should stop the loop. we can use infinity loop, but the question is how to stop infinity loop? actually loop it will stop manually using key break like below.

package main

import "fmt"

func main() {
    for true {
        fmt.Printf("Infinity loop")
        break
    }
}

Conclusion

Now we know about loop so you can write "I will not do that again" 100 times without write it until 100 manually.

Golang basic: Condition

ShellRean — Fri, 11 Dec 2020 16:49:54 +0000

When you are in a crossroad and you choose to turn right and you see the pizza restaurant. that is condition and what your decision and that you get.

Let's we write how go write their code

Write Condition: if

Our decision is to turn right and we see the pizza restaurant.

package main

import "fmt"

func main() {

  turn := "right"

  if turn == "right" {
    fmt.Println("Pizza restuarant")
  }
}

we use if to make condition if the value is true then the block {...} will be execute.

turn == "right" will return bool type true or false

package main

import "fmt"

func main() {

  if true {
    fmt.Println("Always True")
  }
}

Write Condition: else

Okay it just turn right but in the other side we see school how we go there. we could use else

package main

import "fmt"

func main() {

  turn := "left"

  if turn == "right" {
    fmt.Println("Pizza restaurant")
  } else {
    fmt.Println("School")
  }
}

It will check is turn equal with "right" if not it will go to else and execute block else {...}

else have to write as } else { or you will get error compiler

package main

import "fmt"

func main() {

  turn := "right"

  // It will get error compiler
  if turn == "right" {
    fmt.Println("Pizza restaurant")
  } 
  else {
    fmt.Println("School")
  }
}

Write Condition: elseif

But wait no it is not other side, I want more specific what if I turn somewhere.

package main

import "fmt"

func main() {

  turn := "left"

  if turn == "right" {
    fmt.Println("Pizza restaurant")
  } else if(turn == "left") {
    fmt.Println("Gas station")
  } else {
    fmt.Println("School")
  }
}

There more operator logic you can use on if condition

Operator	Mean
==	equal
!=	not equal
!	not
&&	and
<	less than
>	greater than
<=	less than or equal
>=	greater than or equal

Is the data type just string value, NO. you can give condition with any data type

package main

import "fmt"

func main() {

  if 17 < 20 {
    fmt.Print("17 is less than 20")
  } else {
    fmt.Print("17 is greater than 20")
  }
}

Write condition: Switch

But is more complex imagine you look at street sign and what you can see? yeah the direction of the road.
you can convert if condition we have wrote before to switch condition

package main

import "fmt"

func main() {

  turn := "right"

  switch(turn) {
  case "right" :
    fmt.Println("Pizza restaurant")
  case "left" :
    fmt.Println("School")
  default: 
    fmt.Println("Gas station")
  }
}

switch is a function that can write condition with a variable the example use turn variable, and the condition actually use == equal.

case will check is value of turn variable is equal to "right". and if it not equal then will check the case "left".

if all conditions were not equal, so default will run.

don't forget to add : at the end of case or you will get error compiler.

Conclusion

We have created condition with two different functions and when we use if condition and when we use switch condition is up to you, but it look at the complexity and the logic in that condition.

if condition, you can give more logic !, !=, == , &&, || but in switch you cannot use them.

Question:
Write these line in if and switch conditions
if your age is 17 you have to get milk shake license
if not you can't get milk shake license

Golang basic: Variable and data type

ShellRean — Tue, 08 Dec 2020 14:32:35 +0000

variable is a container of value, what type value of you want to assign is data type. golang is static typing that mean you have to ensure what type actually you want to assign to the variable.

Data type Go

There is several data types

int
string
bool

int is data type numeric the value is number without floating point like -90,89,...,0,89,90.

string is data type text the value is text and phrase or word like "Steve", "Hello World", "I love learning golang".

bool is data type logic containt just 2 variant value true or false.

Declare variable

There is two way to create variable

package main

import "fmt"

func main() {
    var name string
    var age int
    var graduates bool

    name = "Linda"
    age = 24
    graduates = false

    fmt.Printf("%s and i %d years old", name, age)
    fmt.Println(graduates)

    // OR
    name1 := "Linda"
    fmt.Println(name1)
}

The first way, declare first variable name using key var and following string as data type so the format is look like.
var variable_name <data_type>

The second one is using := to declare variable and assign value, data type will follow the value. From the example we assign "Linda" so variable name1 will have string data type.

Symbol := just can be using once, you will get error if you using it at the same variable name. So if you want to change value of name1 just write name = "Linda changed"

package main

import "fmt"

func main() {
    name1 := "Linda" // Will set variable name1 as string 
    fmt.Println(name1)

    name1 = "Linda changed"
    fmt.Println(name1)
}

Go is static typing, int value can't assign to variable name1 cause name1 as string, it will show you compiler error.

package main

import "fmt"

func main() {
    name1 := "Linda"
    name1 = 1
    // Compiler error
    fmt.Println(name)
}

All variable that you have declared have to use, if there is a variable that never use, it will get out error compiler

package main

import "fmt"

func main(){
    name := "Steve"
    age := 17
    married := false

    fmt.Println(name)
    fmt.Println(age)
}

It will show you error because the variable married never been used. Not only variable the rule is same with package, if you import package for example fmt, you have use it or you can get error compiler.

Conclusion

We have knew how to create variable and data type so now you can specify what kind of data type you need.

Question:
Why we assign age as int why not string?

Golang basic: Input Output

ShellRean — Tue, 08 Dec 2020 00:33:30 +0000

There is 2 type of interface, GUI and the second one is CLI(Command Line Interface) it just show you text. The purpose of write code is to get an input and give output. each programming language has their way to do that. if you from c it gonna be easy cause the way is similar. let's code

Output Program

create first program it will be good if we start with hello world program it simple and pretty cool. let's we create file main.go open it in your love code editor.
write code below.

package main

import "fmt"

func main() {
    fmt.Println("Hello World")
}

First we declare main as package name it will tell the program what package is it. program will look for package main to run program first.

import key to import package to go's file you can't use fmt if you not import it first. there is many go packages that you can using it.

func main() is a function main. what code you write in this block it will be run first.

fmt.Println("Hello World")to use package that you have imported before(fmt) just write what package is, for example fmt.(dot) and following what function you need to call. this line will print out "Hello World" to your console.

to run our code, go to where the file was saved and open te terminal.

go run main.go

it will show you text

Hello World

Input Program

get input user from console is like a magic what your input, it will show to the console let's we edit the file main.go

package main

import "fmt"

func main() {
  var name string;

  fmt.Printf("Write your name : ")
  fmt.Scanf("%s", &name)

  fmt.Printf("Hello my name is %s", name)
}

var name string it will declare variable name as string. We will learn about data type and variable next.

There is new function we use its Scanf it will get user's input. %s it will tell the program that the data type of variable is string and &name is variable that where input use will be stored.
don't forget to add & before the variable name.

fmt.Printf as before we print program with Println but it is without formatting and Printf will format what you want to show to user.
"Hello my Name is %s" the %s will replaced by name so what you write in name it will change %s.

let's we run program.

go run main.go

we will get output

Write your name :

Input your name

Write your name: shellrean

The output will be

Hello my name is shellrean

Conclusion

We have write simple input and output program with go, we have use Println, Printf, Scanf function from fmt package to create our simple program. dont forget to change the code if you have and idea to improve the code.

challanger:
Write code that will show

I love learn go

First time using Map in Go

ShellRean — Fri, 04 Dec 2020 10:03:15 +0000

Every single person has their clean code, but not for team

Everything changes. I was changed my programming language from PHP to Go and I found many differences.

There are things that I interest, one of them is map

var student map[string]string

In PHP we know map as array associative

$student["name"] = "Brian"

Create Map

To create map is simple, in go just use key var
or ":=" it will create var and set type value as data type

// Just declare variable
var student map[string]string
var champion map[int]string

// OR 
student2 := map[string]string{}
champion2 := map[int]string{}

// map[datatype_key]datatype_value

the value can assign as map to, so you can write

var student map[string]map[string]string

in PHP is equal with

$student = [
    "key" => []
]

Assign data to map

To assign data to map just write like below

student := map[string]string{
    "name"    : "Shellrean",
    "address" : "Jakarta",
}

don't forget to add comma (,) at last map item or you cant get error compiler.

Accessing data map

You can use variable[key] to access data from map

fmt.Printf("%s", student["name"]) // Output: shellrean

Map is iterable type so you can make loop.

for key, value := range student {
  fmt.Printf("%s => %s\n", key, value)
}

One thing that you have to remember is map is unorderable so maybe property name at second or address at first in map order.

Deleting data from map

Delete map is simple use delete function

delete(student, "name")
// delete(map_name, key)

Yeah Go is beautiful language, I was used Java, C++, PHP, JavaScript, Dart. Each language have their benefit and have their strong use in. Go is Strong Typing but have interface{} data type for dynamic data type like use in dart language.

Don't stop to learn

After We Read some books

ShellRean — Fri, 04 Dec 2020 02:14:40 +0000

After follow tutorial from a book, you may feel and say "and then ?what" you are so confuse, and you try to read from another book for stack that you learn. and you will skip cause you have knew about the content, and you get the end of the book again, and you feel "and then?". yeah I feel that too you are not alone.

You try to create some apps and you get stuck what you should to do, when where I have to start from. because you have never try study case you just follow the tutorial, there is no experiment you do. if you want to follow tutorial you have to get stuck and error and try to fix it by yourself. Feel free to change something from that tutorial for example if there an array that have 5 item, try to add 3 so you will know what happen if the array is 8.

after you read the tutorial, make your free apps. don't think that you are news in the stack. you can crate anything in you mind. and try to implement that to your apps. you can use project from github for your reference. follow that project and change it if the project different from your idea and try to find another one.