DEV Community: Luis Ángel Méndez Gort

Scope progression

Luis Ángel Méndez Gort — Fri, 18 Oct 2024 10:29:05 +0000

In imperative programming, we usually have code that looks the following way:

func addOneToSlice(xs []int) []int {
  rs := make([]int, len(xs))
  for i, value := range xs {
    rs[i] = value + 1
  }
  return rs
}

However, notice the following about the for loop:

Each iteration has a specific purpose, which is to add one to the current element.
However, each iteration has no constraint on which element it can operate.
Operating with xs[i+2] and rs[i+3] wouldn't fundamentally alter the structure of the code we have, while making the end result incorrect.

Compare how the same task would be done in F#:

let rec addOneToList =
  function
  | [] -> []
  | x :: xs -> x + 1 :: addOneToList xs

Now consider the following:

We have a list as a function argument.
A list in functional languages is a linked list.
The efficient and standard operations on linked lists are:
- Separating the head x from its tail xs
- Doing something to the head x
- Comparing the list passed as a parameter with the empty list []

Given these restrictions, adding 1 to any element y not at the head of the list would significantly alter the structure of our function.

Now compare how the computation progresses in both styles:

In the functional style, we create a new scope with new values, which involves making a recursive call in the example above.
In the imperative style, we mutate an existing value without changing the scope.

In functional style, marrying both scope with computational progress has the following consequences:

We avoid mutation.
The execution flow is explicit.
The structure we are dealing with becomes clear.

New wallpapers every day

Luis Ángel Méndez Gort — Thu, 17 Oct 2024 13:59:17 +0000

There a lot of good wallpapers for free in the Internet, however I have found that the applications to get them automatically in Linux are quite disappointing. Because of that I made the following script.

#r "nuget: FsHttp"
#r "nuget: Fli"

open FsHttp
open Fli

let API_KEY = "<YOUR_UNSPLASH_API_KEY>"

type Urls = { full: string }

type UnsplashBody = { id: string; urls: Urls }
let wallpaper = "/YOUR/WALLPAPERS/wallpaper.jpeg"

let random () =
    http {
        GET "https://api.unsplash.com/photos/random?orientation=landscape&query=landscape"
        Authorization $"Client-ID {API_KEY}"
        header "Accept-Version" "v1"
    }
    |> Request.send
    |> Response.deserializeJson<UnsplashBody>
    |> _.urls.full

http {
    GET(random ())
    Authorization $"Client-ID {API_KEY}"
    header "Accept-Version" "v1"
}
|> Request.send
|> Response.toBytes
|> fun bs -> System.IO.File.WriteAllBytes(wallpaper, bs)


cli {
    Exec "<COMMAND>"
    Arguments [ "<TO>"; "<SET>"; wallpaper ]
}
|> fun o -> printfn $"%A{o}"

You can run it with dotnet fsi wallpaper.fsx assuming you saved the above code in wallpaper.fsx

To improve the experience you could use it in a cron job.

F# 🤝 GTK4

Luis Ángel Méndez Gort — Thu, 17 Oct 2024 08:09:32 +0000

#r "nuget: GirCore.Gtk-4.0,0.5.0"

open System
open Gtk

let label () =
  let label = new Label()
  label.SetText "hello"
  label

let button (label: Label) =
  let button = new Button()
  button.SetLabel "click me"
  let mutable counter = 0

  let clickHnd (_: Button) (_: EventArgs) =
    label.SetText $"hello {counter}"
    counter <- counter + 1

  button.add_OnClicked (new GObject.SignalHandler<Button>(clickHnd))
  button

let box () =
  let box = new Box()
  box.SetOrientation Orientation.Vertical
  box.SetHomogeneous true

  let l = label ()
  box.Append l
  button l |> box.Append
  box

let onActivateApp (sender: Gio.Application) (_: EventArgs) =
  let window = ApplicationWindow.New(sender :?> Application)
  window.Title <- "Gtk4 Window"
  window.SetDefaultSize(300, 300)
  window.SetChild(box ())
  window.Show()

let application = Application.New("org.gir.core", Gio.ApplicationFlags.FlagsNone)
application.add_OnActivate (new GObject.SignalHandler<Gio.Application>(onActivateApp))
application.RunWithSynchronizationContext(null)

The above code does the following:

creates a 300px × 300px window with GTK4
the window title is "Gtk4 Window"
it has a button and a label controls
when clicking the button the label text changes to show the value of a counter that increases with each click

Notice the code is an F# script, which means it doesn't need a main function and can run by putting the code in an .fsx file and then running it with dotnet fsi your_file.fsx

Running an Algorand node in Fly.io

Luis Ángel Méndez Gort — Tue, 15 Oct 2024 12:10:35 +0000

Step by step guide

We need a directory with the following structure and contents:

algo_node
   + fly.toml
   + run.sh

The file fly.toml looks the following way

app = 'algorand-node'
primary_region = 'cdg'

[experimental]
  cmd = ['/bin/bash', '/run.sh']

[build]
  image = 'algorand/algod:latest'

[[mounts]]
  source = 'node_vol'
  destination = '/algod/data'
  auto_extend_size_threshold = 80
  auto_extend_size_increment = '1GB'
  auto_extend_size_limit = '500GB'

[http_service]
  internal_port = 8080
  force_https = true
  auto_stop_machines = 'off'
  auto_start_machines = true
  min_machines_running = 1
  processes = ['app']

[[files]]
  guest_path = '/run.sh'
  local_path = 'run.sh'

[[vm]]
  size = 'performance-8x'
  memory = '16gb'
  cpu_kind = 'performance'
  cpus = 8

The above configuration relies on the run.sh script, which has this content

cp /node/run/genesis/mainnet/genesis.json /algod/data
/node/bin/algod -l 127.0.0.1:8080

Now is time to launch our application with the command

fly launch

Now you can answer Yes to the following question:

An existing fly.toml file was found for app algorand-node
? Would you like to copy its configuration to the new app?

and No to the following

? Do you want to tweak these settings before proceeding? (y/N)

You should see an output like:

✓ Configuration is valid
==> Building image
Searching for image 'algorand/algod:latest' remotely...
image found: img_8y6w4zd58kx7v7rn

Watch your deployment at https://fly.io/apps/algorand-node/monitoring

Provisioning ips for algorand-node
  Dedicated ipv6: 2a09:8280:1::4a:fa1b:0
  Shared ipv4: 66.241.124.189
  Add a dedicated ipv4 with: fly ips allocate-v4

Creating a 1 GB volume named 'node_vol' for process group 'app'. Use 'fly vol extend' to increase its size

To check if everything went well open a shell to the deployment with

fly ssh console

Once there execute

/node/bin/goal node status -w 1000

This will show you an output like

Last committed block: 25644
Time since last block: 0.0s
Sync Time: 126.7s
Last consensus protocol: https://github.com/algorandfoundation/specs/tree/5615adc36bad610c7f165fa2967f4ecfa75125f0
Next consensus protocol: https://github.com/algorandfoundation/specs/tree/5615adc36bad610c7f165fa2967f4ecfa75125f0
Round for next consensus protocol: 25645
Next consensus protocol supported: true
Last Catchpoint: 
Genesis ID: mainnet-v1.0
Genesis hash: wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=

This shows the node is up and synchronizing with the network

If you don't want to continue running the node, execute

fly app destroy algorand-node

The node synchronization progress can be tracked by comparing Last committed block: 25644 with the last block at Pera Explorer. Calculating 25644 / 43466969 we can see the synchronization progress so far is 0.05%.

Explanation

The run.sh script is needed because we need the genesis.json file in /algod/data. Once the node is running it will create there other files important for its operation, including blockchain data.
Since /algod/data contains blockchain data we need a volume, i.e. permanent and potentially large storage. The volume is specified above in the [[mounts]] section in fly.toml.
The beefy machine we have specified under [[vm]] makes possible to synchronize faster with the network. So far I've running my node for 4 days and it has checked 38423066/43466716 blocks, which is around the 88%. The accumulated cost is $35.
The settings auto_stop_machines = 'off' and min_machines_running = 1 are needed because Fly.io will try to stop the machine if there's no incoming traffic to the configured HTTP port.