Joe Bew - Apprendi un nuovo linguaggio sfruttando il TDD e il Clean Code - Codemotion Milan 2017

Ho imparato qualcosa di Elixir
Il Test-Driven Development e il Clean Code come supporto per apprendere
un nuovo linguaggio di programmazione
CODEMOTION MILAN - SPECIAL EDITION
10 – 11 NOVEMBER 2017

Ho imparato qualcosa di Elixir
Il Test-Driven Development e il Clean Code come supporto per apprendere un
nuovo linguaggio di programmazione

Warming up
Developers
Development
Industry
https://www.pexels.com/photo/amphitheater-ancient-arch-architecture-397431/

Developers
Scientists
Engineers
Self taught
https://static.pexels.com/photos/259335/pexels-photo-259335.jpeg

We are good at writing code!
https://static.pexels.com/photos/225769/pexels-photo-225769.jpeg

Software Development
“Costruiamo” software allo stesso modo di come si costruiscono ponti
https://www.pexels.com/photo/architecture-area-bay-bridge-356968/

tutti i sistemi costruiti
con lo stesso processo di sviluppo
condividono la stessa caratteristica

We did it and it works!
https://www.pexels.com/photo/architecture-building-clouds-contemporary-388419/

Faremo manutenzione …
(prima o poi)
● Fix a bug
● Add new features
● Other Changes:
Because changes happens
https://static.pexels.com/photos/1599/building-vehicle-motorbike-motorcycle.jpg

Potremo percepire
qualcosa di strano
https://static.pexels.com/photos/560/feet-legs-animal-farm.jpg

Abitudini
Il processo di sviluppo
Pratiche e disciplina

I want to tell you a little secret

I am
an impostor
https://www.pexels.com/photo/black-and-white-man-person-cigarette-543/

I am not the best
computer programmer
in the world

Discipline
Practices
Discipline
Practices

CHAPTER ONE:
il nostro primo test
alla ricerca della comfort zone

defmodule HelloWorldTest do
use ExUnit.Case, async: true
test "should return a greeting" do
assert "hello world" == HelloWorld.greet()
end
end

HelloWorldTest
* test should return a greeting (1.1ms)
Finished in 0.03 seconds
1 test, 1 failure
Randomized with seed 689156

defmodule HelloWorld do
def greet() do
"hello world"
end
end

.
1 test, 0 failures

HelloWorldTest
* test should return a greeting (1.3ms)
1 test, 0 failures

CHAPTER TWO:
test the documentation
seguire la documentazione scrivendo prima i test

defmodule GreetingTest do
pid = spawn(Greeting, :loop, [])
send pid, {self(), :greet}
assert_receive "hello world"
end
end

defmodule Greeting do
def loop do
receive do
{from_pid, :greet} ->
send from_pid, "hello world"
loop()
end
end
end

defmodule GreetingTest do
pid = Greeting.start
response = Greeting.greet(pid)
assert "hello world" == response
end
end

def start do
spawn(fn -> loop() end)
end
def greet(pid) do
send pid, {self(), :greet}
receive do
reply -> reply
end
end
...

test "should return a greeting in spanish" do
pid = Greeting.start(:spanish)
response = Greeting.greet(pid)
assert "hola mundo" == response
end

def start(language nil) do
spawn(fn -> loop(language) end)
end
defp loop(language) do
receive do
{from_pid, :greet} ->
send from_pid, greet_message_for(language)
loop(language)
end
end
defp greet_message_for(:spanish), do: "hola mundo"
defp greet_message_for(_), do: "hello world"
end

CHAPTER THREE:
the bank account
proviamo a scrivere una piccola applicazione

The Bank Account Application
TODO
- Posso creare un nuovo account
- Posso eliminare un account
- Posso controllare il saldo corrente
per ciascun account
- Posso depositare un importo
- Posso prelevare un importo
DOING

test "should create a new account" do
bank_pid = Bank.start()
created_response = Bank.create_account(bank_pid, "non_existing_account")
assert {:ok, :account_created} == created_response
end

defmodule Bank do
def start() do
nil
end
def create_account(_pid, _name) do
{:ok, :account_created}
end
end

test "should return an error when the account exists" do
Bank.create_account(bank_pid, "non_existing_account")
response = Bank.create_account(bank_pid, "non_existing_account")
assert {:error, :account_already_exists} == response
end

defmodule Bank do
def start() do
spawn(fn -> loop(%{}) end)
end
def create_account(pid, name) do
send pid, {self(), {:create, name}}
receive do
reply -> reply
end
end
...
...
defp loop(accounts) do
receive do
{from_pid, {:create, name}} ->
{updated_accounts, message} = _create_account(name, accounts)
send from_pid, message
loop(updated_accounts)
end
end
defp _create_account(name, accounts) do
case Map.has_key?(accounts, account) do
true -> {accounts, {:error, :account_already_exists}}
_ -> {Map.put(accounts, name, nil), {:ok, :account_created}}
end
end
end

test "should delete an existing account" do
not_exists_response = Bank.delete_account(bank_pid, "an_account")
Bank.create_account(bank_pid, "an_account")
deleted_response = Bank.delete_account(bank_pid, "an_account")
assert {:error, :account_not_exists} == not_exists_response
assert {:ok, :account_deleted} == deleted_response
end

defp loop(accounts) do
receive do
{from_pid, message} ->
{updated_accounts, reply} = handle_message(message, accounts)
send from_pid, reply
loop(updated_accounts)
end
end
defp handle_message({:create, name}, accounts)
case Map.has_key?(accounts, name) do
_ -> {Map.put(accounts, name, nil), {:ok, :account_created}}
end
end
defp handle_message({:delete, name}, accounts)
true -> {Map.delete(accounts, name), {:ok, :account_deleted}}
_ -> {accounts, {:error, :account_not_exists}}
end
end

test "should return the current balance of an existing account" do
Bank.create_account(bank_pid, "an_account")
response = Bank.check_balance(bank_pid, "an_account")
assert {:ok, 0} == response
end

def check_balance(pid, name) do
send pid, {self(), {:check_balance, name}}
receive do
reply -> reply
end
end
defp handle_message({:check_balance, name}, accounts)
false -> {accounts, {:error, :account_not_exists}}
_ -> {accounts, {:ok, Map.get(accounts, name)}}
end
end

BankTest
* test when account exists we are able to deposit positive amounts (0.04ms)
* test when account exists we are not able to withdraw if the amount is greater than current balance (0.01ms)
* test when account exists we are able to delete an account (0.01ms)
* test when account does not exists we are able to create a new account (0.00ms)
* test when account exists we are not able to deposit negative amounts (0.01ms)
* test when account exists we are not able to withdraw a negative amount (0.01ms)
* test when account does not exists we are not able to check current balance (0.00ms)
* test when account does not exists we are not able to deposit (0.00ms)
* test when account exists we are able to withdraw if the amount is lower or equal than current balance (0.01ms)
* test when account does not exists we are not able to delete an account (0.00ms)
* test when account exists we are able to check the current balance (0.01ms)
* test when account exists we are not able to create an account with the same name (0.00ms)
* test when account exists we are able to perform actions on different accounts (0.02ms)
* test when account does not exists we are not able to withdraw (0.00ms)
14 tests, 0 failures

Se provassimo a estrarre un processo per ogni account?
Questo è refactoring.

defp handle_message({:create, name}, accounts)
_ ->
bank_account = BankAccount.start()
{Map.put(accounts, name, bank_account), {:ok, :account_created}}
end
end

E poi tante altre cose ...
Images from http://learnyousomeerlang.com
defmodule Bank do
use Application
def start(_type, _args) do
Bank.Supervisor.start_link([])
end
end
defmodule Bank.Supervisor do
use Supervisor
def start_link(opts) do
Supervisor.start_link(__MODULE__, :ok, opts)
end
def init(:ok) do
children = [
Bank,
AccountSupervisor
]
Supervisor.init(children, strategy: :one_for_one)
end
end

The Bank Account Application
TODO
- Posso creare un nuovo account
- Posso eliminare un account
- Posso controllare il saldo corrente
per ciascun account
- Posso depositare un importo
- Posso prelevare un importo
DOING
- Voglio esporre una API HTTP

CHAPTER FOUR (the last one):
a RESTful API
esporre l’applicazione appena creata in RESTful

defmodule Http.HelloWorldTest do
use Plug.Test
@opts Http.HelloWorld.init([])
conn =
conn(:get, "/greet")
|> Http.HelloWorld.call(@opts)
assert 200 == conn.status
assert "hello world" == conn.resp_body
end
end

defmodule Http.HelloWorld do
use Plug.Router
plug :match
plug :dispatch
get "/greet" do
send_resp(conn, 200, "hello world")
end
end

defmodule Http.RouterTest do
use Plug.Test
import Mock
@router Http.Router
@opts @router.init([])
test "should return 201 when a new account is created" do
with_mock Bank.Admin, [create_account: fn("joe") -> {:ok, :account_created} end] do
conn = do_request(:post, "/accounts/joe")
assert "/accounts/joe" == conn.resp_body
end
end
defp do_request(verb, endpoint, payload) do
conn(verb, endpoint, payload)
|> @router.call(@opts)
end
end

defmodule Http.Router do
use Plug.Router
plug :match
plug :dispatch
post "/accounts/:account_name" do
{:ok, :account_created} = Bank.Admin.create_account(account_name)
send_resp(conn, 201, "/accounts/" <> account_name)
end
end

defmodule Http.RouterTest do
use Plug.Test
import Mox
@router Http.Router
@opts @router.init([])
test "returns 201 when a new account is created" do
expect(Bank.AdminMock, :create_account, fn("joe") -> {:ok, :account_created} end)
conn = do_request(:post, "/accounts/joe")
assert "/accounts/joe" == conn.resp_body
verify! Bank.AdminMock
end
defp do_request(verb, endpoint, payload) do
conn(verb, endpoint, payload)
|> @router.call(@opts)
end
end

defmodule Http.Router do
use Plug.Router
plug :match
plug :dispatch
@bank_admin Application.get_env(:bank, :bank_admin)
post "/accounts/:account_name" do
{:ok, :account_created} = @bank_admin.create_account(account_name)
send_resp(conn, 201, "/accounts/" <> account_name)
end
end

defmodule Bank.Supervisor do
use Supervisor
def start_link(opts) do
Supervisor.start_link(__MODULE__, :ok, opts)
end
def init(:ok) do
children = [
Bank,
AccountSupervisor,
Plug.Adapters.Cowboy.child_spec(:http, Http.Router, [], [port: 4000])
]
Supervisor.init(children, strategy: :one_for_one)
end
end

# checkout the project
git clone https://github.com/joebew42/elixir_bank_account.git
cd elixir_bank_account/
mix test
iex -S mix
# create an account
curl -v -H "auth: joe" -X "POST" http://localhost:4000/accounts/joe
# deposit an amount
curl -v -H "auth: joe" -X "PUT" http://localhost:4000/accounts/joe/deposit/100
# check current balance
curl -v -H "auth: joe" -X "GET" http://localhost:4000/accounts/joe
{ "current_balance": 1100 }
# delete an account
curl -v -H "auth: joe" -X "DELETE" http://localhost:4000/accounts/joe

rhythm > process > learning > working software
Un attimo ...

Software Development
is a learning process

“Itis bettertobeawarriorinagarden
thantobeagardenerinawar”

the little warrior recipe:
look for continuous improvement
through deliberate practice

We have to be proud
about the way we work
and not of what we have
built
(it’s not about the tool)

twitch.tv/joebew42xpeppers.com/carriere
github.com/joebew42/study-path
HIRE
ME!

“Learn to build working software
by playing our preferred videogame …
… Writing code!” - @joebew42

This presentation is released under
Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)
https://creativecommons.org/licenses/by-nc-sa/3.0/

Joe Bew - Apprendi un nuovo linguaggio sfruttando il TDD e il Clean Code - Codemotion Milan 2017

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Joe Bew - Apprendi un nuovo linguaggio sfruttando il TDD e il Clean Code - Codemotion Milan 2017

Semelhante a Joe Bew - Apprendi un nuovo linguaggio sfruttando il TDD e il Clean Code - Codemotion Milan 2017 (20)

Mais de Codemotion

Mais de Codemotion (20)

Último

Último (20)

Joe Bew - Apprendi un nuovo linguaggio sfruttando il TDD e il Clean Code - Codemotion Milan 2017