DEV Community: Red Nose Hacker

First steps toward Guix Home

Red Nose Hacker — Sat, 12 Nov 2022 14:20:55 +0000

In this article, I will show you, step by step, how one can simply install and configure software they use with Guix Home. For the demonstration, I will focus on a single package and a single service.

Disclaimer: I'm not an experienced Guix Home user. So don't take my words for granted. Read manuals, ask questions.

So far, to install a software, say Emacs, for my user, I could simply :
$ guix install emacs
Or, I could write a manifest and use it to populate my default user profile (or a custom one) :
$ guix package --manifest=$HOME/manifest.scm
Where manifest.scm contains the following :

(specifications->manifest (list "emacs"))

Then, the configuration for the new software had to be edited separately.
Here is a dummy ~/.config/emacs/init.el :

(setq initial-scratch-message nil)

Now, let's use Guix Home to start managing the whole !

The blank home

Guix Home ask you for two things : a list of packages and a list of home services.
So a blank Guix Home configuration file (which installs and configures nothing) would look like this :

(use-modules (gnu home))

(home-environment
 (packages (list))
 (services (list)))

You can save this expressions in a file named home-configuration.scm. So you now can invoke Guix Home to generate a home environment from this blank configuration :

$ guix home container home-configuration.scm

No worries, this won't affect your current environment.
Take a few seconds to see how empty this shell is and move on !

Oops, you need to leave the empty shell.

$ exit

Installing the software

To tell Guix Home to add a software package to the generated home environment, you have to edit home-configuration.scm and add its name to the package list :

(use-modules
 (gnu home)
 (gnu packages emacs))

(home-environment
 (packages
  (list emacs)))

You can now try it out.

$ guix home container home-configuration.scm

In this shell, you can run Emacs, proof that Emacs has been added to the generated home environment.

$ emacs -nw

Then you can quit the shell.

Install the software's configuration

From Guix Home perspective, things are packages or services. It's time to look for services. Especially one that can handle the process to configure Emacs. Simply put, a service capable of installing the init.el file on the right place : home-xdg-configuration-files-service-type.

Edit home-configuration.scm to be like :

(use-modules
 (gnu home)
 (gnu home services)
 (gnu packages emacs)
 (gnu services)
 (guix gexp))

(home-environment
 (packages
  (list emacs))
 (services
  (list (service home-xdg-configuration-files-service-type
         `(("emacs/init.el" ,(local-file "init.el")))))))

Then, create a init.el file, with your Emacs configuration, next to the home-configuration.scm :

(setq initial-scratch-message nil)

Try it with :

$ guix home container home-configuration.scm

Here you can see there is the init.el file at ~/.config/emacs/init.el !
So the Emacs in this environment will use this configuration file at startup… Ok, maybe not in the container, but trust me, it will when running (careful, it will have an effect to your current environment this time) :

$ guix home reconfigure home-configuration.scm

Warning : because there is no shell configuration in the home-configuration.scm (yet), you will need to manually configure your shell to make it benefits from the generated home environment.

Thank you very much for reading this article!

Don't hesitate to give me your opinion, suggest an idea for improvement, report an error, or ask a question ! I would be so glad to discuss about the topic covered here with you ! You can reach me here.

Don't miss out on the next ones ! Either via RSS or via e-mail !

And more importantly, share this blog and tell your friends why they should read this post!

Send an SMS with Guile and Twilio API

Red Nose Hacker — Mon, 13 Dec 2021 20:36:29 +0000

These last days, I tried to send an SMS with a Guile script.
TL;DR: I succeeded!

Since the code is just a simple HTTP POST request, the longest part should have been the creation of the Twilio account (with a Regulatory Bundle and a phone number).

But in the end, it took me about one evening[1] to set up a development environment with the right dependencies, and then two more evenings to figure out which HTTP headers were needed.

Anyway, here is the script:

;; send-happiness.scm

(use-modules (web client)
             (web http)
             (ice-9 receive)
             (ice-9 iconv)
             (gcrypt base64))

(define TWILIO_ACCOUNT_SID "your-account-sid")
(define TWILIO_ACCOUNT_TOKEN "your-account-token")
(define TWILIO_PHONE_NUMBER "your-twilio-phone-number")

(define TWILIO_CREDENTIALS
  (base64-encode
   (string->bytevector
    (simple-format #f "~A:~A" TWILIO_ACCOUNT_SID TWILIO_ACCOUNT_TOKEN) "utf-8"))

(define RECIPIENT_PHONE_NUMBER "a-phone-number")
(define TEXT_MESSAGE "Wish you so much happyness !")

(http-post
 (simple-format
  #f 
  "https://api.twilio.com/2010-04-01/Accounts/~A/Messages"
  TWILIO_ACCOUNT_SID)
 #:headers `((content-type . (application/x-www-form-urlencoded (charset . "utf-8"))
             (authorization . (basic . ,TWILIO_CREDENTIALS)))
 #:body (simple-format #f "Body=~A&To=~A&From=~A"
                       TEXT_MESSAGE
                       RECIPIENT_PHONE_NUMBER
                       TWILIO_PHONE_NUMBER))

And how to execute it :

$ guix shell guile gnutls guile-gcrypt -- guile send-happiness.scm

All phone numbers must start with the country indicator. For example +33 for a French number.

[1] the time unit of my Guile tinkering

Thank you very much for reading this article!

Don't hesitate to give me your opinion, suggest an idea for improvement, or ask a question! To do so : contact me.

Don't miss out on the next ones...

articles via Mastodon @jeko@write.as and RSS
screencasts via Peertube jeko@video.tedomum.net and RSS

And more importantly, share this blog and tell your friends it's the best blog in the history of Free Software! No kidding!

Code Kata with SRFI-64

Red Nose Hacker — Wed, 07 Oct 2020 16:34:31 +0000

I got into the habit of doing about 30 minutes of Code Kata every morning. I practice these Kata following the test-driven development (TDD) approach.

Guile distribution includes the SRFI-64 module: a unit testing framework. In this article, I explain how to use it and how to configure it in order to practice code kata.

Basic usage

The SRFI-64 module has a default configuration. Let me show you what it looks like here.

Below is a Guile program that creates a test suite with only one test (doomed to fail) :

(use-modules (srfi srfi-64))
(test-begin "demo")
(test "Hookup" #f #t)
(test-end "demo")

Explanation of the program :

line 1 : load the module named (srfi srfi-64).
line 2 : indicate the beginning of the test group demo.
line 3: define a test, named “Hookup”, with the procedure test-equal whose first parameter is the result expected by the test (here, #t ) and the second parameter is the tested expression (here, #t).
line 4: indicate the end of the demo test group.

It is relatively simple, there are few frills.

This is the result of the execution of this suite if you save it in a /tmp/tests.scm file and execute the :

$ guile --no-auto-compile test.scm 
%%%% Starting test demo (Writing full log to "demo.log")
/tmp/test.scm:3: FAIL Hookup
# of unexpected failures 1

The console displays only a summary of the result: line 3 shows an unexpected failure from the “Hookup” test. It's very brief but it gives a quick idea of the state of the program.

The complete detail is in the /tmp/demo.log file:

cat demo.log
%%%% Starting test demo
Group begin: demo
Test begin:
  test-name: "Hookup"
  source-file: "/tmp/test.scm".
  source-line: 3
  source-form: (test-equal "Hookup" #f #t)
Test end:
  result-kind: fail
  actual-value: #t
  expected-value: #f
Group end: demo
# of unexpected failures 1

This report gives me two pieces of information that I use a lot : actual-value and expected-value.

This default configuration, although ready to use, has the disadvantage of providing informations in two places : in the console (list of tests and their states) and in a file (test results). Not very practical...

Fortunately, the test framework is easily configurable. In the following article, I present you my configuration dedicated to code kata.

Configuration for Code Kata

The idea here is to configure the SRFI-64 module to display all the information I need directly in the console (and I don't need to report in a file). I want to see at a glance :

the list of executed tests ;
the status of each of these tests;
for failed tests, display the expected value and the value obtained.

According to the SRFI-64 reference, the objects that maintain the statistics on the test suite (total number of tests, number of successful, failed, passed, ...) are the test-runners.

Thanks to the section Writing a new test-runner and some examples gleaned from the web, you should be able to create the test-runner that suits you!

Here is the one I made for myself (based on the work of Mathieu Lirzin and Alex Sassmannshausen) :

;;;; kata-driver.scm - Guile test driver for code kata practice

(define script-version "2020-10-04") ;UTC

;;; Copyright © 2015, 2016 Mathieu Lirzin <mthl@gnu.org>
;;; Copyright © 2019 Alex Sassmannshausen <alex@pompo.co>
;;; Copyright © 2019 Jérémy Korwin-Zmijowski <jeremy@korwin-zmijowski.fr>
;;;
;;; This program is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; This program is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.

;;;; Commentary:
;;;
;;; This script provides a Guile test driver using the SRFI-64 Scheme API for
;;; test suites.  SRFI-64 is distributed with Guile since version 2.0.9.
;;;
;;; This script is a very cleaned up version of the Alex Sassmannshausen 's 
;;; version. The changes make it suitable for use in a code kata practice.
;;;
;;;; Code:

(define-module (runner-kata)
  #:export (test-runner-kata))

(use-modules (srfi srfi-64)
             (ice-9 pretty-print)
             (srfi srfi-26))

(define* (test-display field value  #:optional (port (current-output-port))
                       #:key pretty?)
  "Display 'FIELD: VALUE\n' on PORT."
  (if pretty?
      (begin
        (format port "~A:~%" field)
        (pretty-print value port #:per-line-prefix "+ "))
      (format port "~A: ~S~%" field value)))

(define* (result->string symbol)
  "Return SYMBOL as an upper case string.  Use colors when COLORIZE is #t."
  (let ((result (string-upcase (symbol->string symbol))))
    (string-append (case symbol
                     ((pass)       "")  ;green
                     ((xfail)      "")  ;light green
                     ((skip)       "")  ;blue
                     ((fail xpass) "")  ;red
                     ((error)      "")) ;magenta
                   result
                   "")))

(define* (test-runner-kata)

  (define (test-on-test-end-kata runner)
    (let* ((results (test-result-alist runner))
           (result? (cut assq <> results))
           (result  (cut assq-ref results <>)))
      (if (equal? 'fail (result 'result-kind))
      (begin
        (newline)
        (format #t "~a ~A~%"
            (result->string (result 'result-kind))
            (result 'test-name))
        (when (result? 'expected-value)
              (test-display "expected-value" (result 'expected-value)))
        (when (result? 'expected-error)
              (test-display "expected-error" (result 'expected-error) #:pretty? #t))
        (when (result? 'actual-value)
              (test-display "actual-value" (result 'actual-value)))
        (newline))
      (begin
        (format #t "~a ~A~%"
            (result->string (result 'result-kind))
            (result 'test-name))))))

  (let ((runner (test-runner-null)))
    (test-runner-on-test-end! runner test-on-test-end-kata)
    runner))

I created a git repository which contains a project template for a code kata. Just follow the README instructions and code !

Here is an example of feedback from your terminal while the watch.sh script is running :

FAIL Hookup
expected-value: #f
actual-value: #t

No more need to look at the content of the report (which is no longer generated) to find out what the problem is. So I can execute this script in a dedicated emacs buffer, every time I save, and act according to the test results.

Now it's up to you!

Choose a code kata exercise, work on it for about 30 minutes, share the link to your code and your tests in comments below!

Then, I give you my 2 cents for your next session!

Thank you so much for reading this article!

Don't hesitate to give me your opinion or ask a question !
To do so, please leave a comment below or contact me.

And most importantly, share the blog and tell your friends it's the best blog in the history of Free Software! No shit!

Learning Guile - Booleans

Red Nose Hacker — Sun, 13 Sep 2020 21:29:27 +0000

The two boolean values are: "true" and "false". Respectively #t or #true and #f or #false in Guile.

In a conditional test context, "true" means any expression other than #f or #false.

Here is a small test suite that illustrates all this:

(use-modules (srfi srfi-64))

(test-begin "test-suite")

(test-equal "Truth"
  #t
  #true)

(test-equal "Falsness"
  #f
  #false)

(test-equal "Numbers are true"
  #t
  (if 12547
      #t
      #f))

(test-equal "Strings are true"
  #t
  (if "I am not false"
      #t
      #f))

(test-equal "Lists - even empty - are true"
  #t
  (if '()
      #t
      #f))

(test-equal "Symbols are not false"
  #f
  (not 'i-am-not-false))

(test-end "test-suite")

Create a /tmp/bool.scm file with the code below. Run the tests and if everything goes well, you should see the following result:

$ guile bool.scm 
;;;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
;;; or pass the --no-auto-compile argument to disable.
;;;; compiling /tmp/bool.scm
compiled /home/jeko/.cache/guile/ccache/3.0-LE-8-4.3/tmp/bool.scm.go
%%%% Starting test-suite (Writing full log to "test-suite.log")
# of expected passes 6

If you feel like it, you can tweak this file to experiment!