Hello Guix,

Table of Contents
_________________

1. Introduction
2. How to create a fork?
.. 1. guix time-machine
.. 2. Any other limitations?
3. How to keep the fork up to date?
.. 1. Authentication
4. Conclusion


1 Introduction
==============

  I would like to start my own fork of the upstream Guix, in order to be
  able to use some patches I require.  I went through the documentation,
  but I am unclear on few details, so I hope someone will be kind enough
  to help me.


2 How to create a fork?
=======================

  While documentation does describe most of this, I want to make sure I
  did figure out all the step (and their ordering).

  1. Create a git repository (git.example.org/guix)
  2. Add my signing key (with fingerprint F) into a file name.key on the
     keyring branch, producing commit with hash H1.  Push it.
  3. Add my signing key (with fingerprint F) into the
     .guix-authorizations file, commit the changes, producing commit
     with hash H2.  Push it.
  4. Create a channel description file:

     ,----
     | (list (channel
     |        (name 'guix)
     |        (url "https://git.example.org/guix")
     |        ;; Enable signature verification:
     |        (introduction
     | 	(make-channel-introduction
     | 	 "H2"
     | 	 (openpgp-fingerprint
     | 	  "F")))))
     `----

     The %default-channels is missing.

     Q: Can %default-channels contain multiple channels?  Should I
     rather replace 'guix in that variable?

  5. Guix pull using the file from 4.
  6. Reconfigure the system/home.

  From this point on I should be running my own fork, from commits in my
  git repository, with things like authentication properly working,
  correct?  Did I miss any required steps?


2.1 guix time-machine
~~~~~~~~~~~~~~~~~~~~~

  How does the time-machine interact with this setup?  Since any time
  travel would likely interact with commits before the channel
  introduction, will it even work?  If now, is there a way around it?


2.2 Any other limitations?
~~~~~~~~~~~~~~~~~~~~~~~~~~

  Will I encounter any other limitations with this setup?  Are there
  things that will just not work?  Or will this behave exactly like
  upstream Guix (- the patches)?  I guess I am curious if I should
  expect any foot guns (and where).


3 How to keep the fork up to date?
==================================

  The other question is how to keep my "fork" up to date.  I am inclined
  to just use git merge, and periodically merge changes from the
  upstream.  Are there any downsides to that?  If it is relevant, I
  expect the flow to be unidirectional, from Guix to my fork.


3.1 Authentication
~~~~~~~~~~~~~~~~~~

  I need to also keep the keyring branch synchronized, correct?

  Will authentication work properly with merge-based workflow?  Will the
  commits being merged have their signatures checked?  Or will it check
  just the merge commits?


4 Conclusion
============

  Did I miss anything?  Does anyone have any tips before I give this a
  try?


Thanks,
W.

-- 
There are only two hard things in Computer Science:
cache invalidation, naming things and off-by-one errors.