IRC channel logs

2021-10-30.log

back to list of logs

<roptat>I wonder if we could have an editor that would guide with the syntax
<podiki[m]>sorry to repeat: what do we do when programs want to call ldconfig for libraries, we just disable that? (I see package defs that replace it with e.g. 'echo')
<nckx>Oh yeah, that.
<nckx>Sorry.
<nckx>Just nuke it from orbit.
<podiki[m]>👍️
***LispyLights is now known as Aurora_v_kosmose
<podiki[m]>although maybe I'll have to understand what this python is doing, using ldconfig to get each library path it needs (probably need to patch that whole thing to just look in the store dirs of inputs)
<florhizome[m]><roptat> "I wonder if we could have an..." <- Emacs guix could use some improvements
<florhizome[m]>(that's like an agreeing Statement)
<nckx>M-x guix-mode \o/
<florhizome[m]>I think my emacs Just froze BC im installing noto font in the bg
<nckx>podiki[m]: Sounds plausible. Even if the original didn't strictly need absolute file names, the Guix package might need them.
<podiki[m]>right
<florhizome[m]>i really really need to set up thinkfan for guix -.-
<rekado_>civodul: the CRAN importer has changed over the years and the packages we have were created with different versions of it.
<rekado_>when upgrading the importer suggests changes to inputs, but not to the description or synopsis (or license).
<rekado_>but in any case: CRAN descriptions are usually stylistically unacceptable for Guix, so there’s always some editing there.
<florhizome[m]>well.... ://
<florhizome[m]>still failing
<florhizome[m]> https://dpaste.com/HLG66DLEY
<florhizome[m]>that's it for today though for me ...
<florhizome[m]>gn8 guix
<jgart>nckx, I think that was a hypothetical bug. I don't think he ever tried it with python-lxml
<jgart>civodul, said that guix shell works as I hoped/described I wanted
<nckx>Oh.
<jgart>I'll test it to be sure/experience it soon :)
<nckx>So all this was based on conjecture?
<jgart>lol
<nckx>OK.
<jgart>not entirely
<jgart>I think Ryan ran into a bug regarding what was said but I don't have the context to reproduce it
<jgart>I'll get back to you if that comes about again
<nckx>florhizome[m]: Can you share your full package definition before you go?
<podiki[m]>how can you specify a patch in a package definition for a local file (e.g. not in a channel)? can set search-patches somehow?
<jgart>first question to answer would probably be how does `search-patches` find files?
<podiki[m]>i know it is specified per channel and guix; at least I can do a --with-patch i just never investigated how to do it properly
<jgart>podiki[m], It looks like it finds the files by looking at %PATCH-PATH
<jgart>that variable
<podiki[m]>ah
<jgart>podiki[m], https://paste.sr.ht/~jgart/76d23405bd7f1b921c4cf10251adb15bd690d02f
<jgart>that's what search-patches is doing
<jgart>it put's the paths in a list
<jgart>s/put's/puts
<podiki[m]>gotcha
<podiki[m]>so I could probably just let shadow it in a package definition for testing?
<jgart>so it sounds like it is tied to finding things in relation to guile's module path
<jgart>currently
<jgart>maybe there's a way to modify the arg or some other way to hack it to find patches relative to the current working directory
<jgart>haven't tried that
<podiki[m]>guix build --with-patch works though, so maybe that is easier for the one offs
<podiki[m]>(or see what it does exactly to figure it out)
<mahmooz>hi
<nckx>podiki[m]: Why use search-patches?
<nckx>Hi mahmooz.
<nckx>podiki[m], jgart: I think you're massively overthinking things. (patches (list "one.patch" "/another.patch"))
<podiki[m]>nckx: oh. maybe I never tried it as a list...? that would be dumb (on my part)
<nckx>Er, no comment ☺
<podiki[m]>haha no comment needed
<podiki[m]>indeed that works, with a handy warning of guix resolving the path relative to current directory
<podiki[m]>(but for a final package def I guess we want the search-patches)
<M6piz7wk[m]>is there a defvar in guile?... (full message at https://libera.ems.host/_matrix/media/r0/download/libera.chat/f2c111c08ad6d716c5c202fc37d016669aa09575)
<M6piz7wk[m]>oh there is whole manual to GNU Guile
<jgart>nckx, very cool. Thanks for sharing that
*M6piz7wk[m] feels really stupid for him to took this long to find the manual
<nckx>Why's everyone calling themselves stupid today. Be kind to yourselves, people.
<podiki[m]>(i've gotten spoiled with things like slime and seeing the definitions as I'm writing, and haven't fully setup my geiser/guix/scheme setup)
<mahmooz>has anyone managed to setup guix on vultr? does it work well?
<nckx>M6piz7wk[m]: If you haven't found it yet: define-once.
<jgart>saved me from shaving yak further
<drakonis>mahmooz: i've done it on linode and its fine
<drakonis>should be similar on vultr
<jgart>mahmooz, guix works great on capsul
<nckx>(Scheme has a preference for ‘clear naming’ — at least most of the time.)
<jgart>Guix System, that is
<nckx>call-with-current-continuation being an extreme example.
<mahmooz>whats capsul lol
<jgart>I upgrade it to the latest iso
<jgart>they're an interesting group
<jgart>capsul.org/
<jgart>or https://lists.gnu.org/archive/html/guix-devel/2021-10/msg00298.html
<jgart>I'll use one tomorrow for a guix packaging meetup
<mahmooz>they provide hosting services?
<jgart>all the code for their services are free/open source
<jgart>they're like vultr
<jgart>yea
<mahmooz>cool
<nckx>jgart: Interesting! (I feel like I've said that a lot today, which is good.)
<jgart>It'd be cool if they had one-click installs. Paste config.scm into form and submit type of deal.
<jgart>But overall they are a better user experience for Guix System than vultr
<mahmooz>is there anyway to get a flutter dev environment on guix
<M6piz7wk[m]>what's `set!` ? is the `!` indicating a macro?
<mahmooz>its the only reason i have to dualboot guix with nixos is that i dont have flutter on guix
<M6piz7wk[m]>flutter?
<M6piz7wk[m]>btw. you find guix better then NixOS?
<jgart>M6piz7wk[m], It just means that your mutating the variable
<nckx>M6piz7wk[m]: ‘!’ generally means stateful operation.
<M6piz7wk[m]>thanks
<nckx>…as jgart said.
<mahmooz>yes guix is better than nixos lol
<mahmooz>like way better
<mahmooz>but i have to use nixos because i cant get everything to work on guix
<mahmooz>i cant get startx/bluetooth/flutter/proper-spotify-client on guix
<M6piz7wk[m]>so `(set variable "value")` is not mutable -> i can't do `(set variable "different value")` without error?
<nckx>Well, set doesn't exist.
<mahmooz>nix language gives me anxiety
<M6piz7wk[m]>oh
<mahmooz>its so frustrating to use
<M6piz7wk[m]>mahmooz: me too thanks for giving me hope in life
<mahmooz>lol np
<M6piz7wk[m]>i will most likely never want to see JSON ever again after i am done with NixOS
<nckx>! is just a character in Scheme; you can name your variable Guix!is!neat! without issue. It's just a convention to indicate that something mutates state.
<mahmooz>maybe when i get enough free time one day ill become a guix contributor
<M6piz7wk[m]>nckx: ah i see.. i though it's a special functionality like in rustlang
<M6piz7wk[m]>So the identifier could be [a-bA-Z0-9!] ?
<M6piz7wk[m]>or are there more special chars?
<nckx>Very few magic characters in Scheme. ( ) ' ` , and sometimes . — I might be forgetting one or two but the set is very small.
<M6piz7wk[m]>i see O.o thanks
<nckx>And whitespace of course.
<M6piz7wk[m]>whitespace in the identifier?
<nckx>Is not allowed, I mean, and hence ‘special’, but then whitespace is not meaningful in any sane language :)
<singpolyma>I though scheme could also use [] in syntax, maybe that's just racket?
<jgart>singpolyma, nope guile too
<M6piz7wk[m]>nckx: thanks for saying that python is not sane lang i hate the syntax in that thing with those whitespaces
<singpolyma>#: also in guile is meaningful
<jgart>but it's not common practice
<nckx>M6piz7wk[m]: And ; for comments, and #; for (possibly Guile-specific) block comments; and # for escaping things, and \ for escaping things. So the list is growing but it's still extremely small compared to other languages.
<M6piz7wk[m]>ah oke O.o
<nckx>(define { 42) is fun.
<jgart>nckx, what can I use for subvector in guile?
<nckx>Can't do that in JavaScript!
<jgart>gambit and chicken have it
<nckx>I don't know either.
<jgart>There's an srfi that has something close to it
*M6piz7wk[m] is confused about the non-lexical vs. lexical scoping (elisp vs guile scheme)
*M6piz7wk[m] is reading 3.4.4 section in the manual
<jgart> https://srfi.schemers.org/srfi-133/srfi-133.html#vector-append-subvectors
<jgart>vector-append-subvectors
<jgart>M6piz7wk[m], lexical scoping is what most languages use
<nckx>Just a note that Guile discussion is always welcome here but there's also a #guile channel for the language proper, for those times where you really need to dial a guru.
<M6piz7wk[m]>jgart: first time hearing it in 14 years of my experience in CS O.o
<nckx>I find non-lexical scoping confusing as hell. Powerful, sometimes, but often just weird.
<jgart>bash is dynamically scoped
<nckx>bash *is* weird.
<M6piz7wk[m]>bash is non-lexical?
<jgart>probably the most popular dynamically scoped language still used today
<jgart>M6piz7wk[m], yup
<nckx>But good point, it didn't occur to me as the most popular example.
*nckx writes bash all the time.
<jgart> https://en.wikipedia.org/wiki/Bash_(Unix_shell)
<M6piz7wk[m]>nckx: http://ix.io/3D49 POSIX sh can also be weird when it's in my hands :p
<M6piz7wk[m]>Is POSIX sh lexical?
<jgart>probably not
<M6piz7wk[m]>is guile-scheme POSIX compliant?
<nckx>I'm intrigued by your comments, which tool are they for?
<M6piz7wk[m]>oh it's not apparently
<nckx>M6piz7wk[m]: That's not a question with an answer, there is no POSIX Scheme.
<M6piz7wk[m]>yep realized it after i said it
<nckx>So it's not ‘not’ either ☺
<nckx>Okie.
<singpolyma>In posix sh everything is global, so there's barely a scope to speak of
<jgart>nckx, https://paste.sr.ht/~jgart/51e62a6e507236e6e1c3e043eeabf412186f3ca3
<jgart>how comes?
<M6piz7wk[m]>what's the difference in between `set!` and `let` in guile? let is immutable and deduces the data type from input?
<jgart>let defines variables/expressions in a scope
<M6piz7wk[m]>scope as in the function?
<M6piz7wk[m]>since there is no main() invoked ?
<jgart>then you can use the variables/expressions in that scope
<jgart>those are all different things that you just mentioned
<M6piz7wk[m]>what's scope then?
<M6piz7wk[m]>oh within let scope?
<M6piz7wk[m]>like elisp?
<nckx>jgart: I don't get ‘Guile implementation’. Whose? How comes what? Guile is right: you give it a macro that takes 2 arguments, then you pass it 3.
<jgart>M6piz7wk[m], https://elm-lang.org/docs/syntax#let-expressions
<jgart>guile let is like elm let
<nckx>I don't know what Janet is so I can't read what it's supposed to do.
<jgart>I thought I wrote something that was variadic?
*M6piz7wk[m] never used elm lang, but he recognizes the nix syntax
<jgart>M6piz7wk[m], nix let is like guile let
<jgart>it's the same idea
<M6piz7wk[m]>oh elm is that cool javascript replacement i should take a look at it more often
<M6piz7wk[m]>ah i see
<jgart>the parens can sometimes confuse things at first
<jgart>but it's the same
<M6piz7wk[m]>i should stop referencing rustlang components with lisp when i know clisp and elisp heh
<nckx>jgart: Is that what &rest is supposed to be? Whence &?
<jgart>yup
<M6piz7wk[m]>*with guile
<jgart>& is #:rest
<M6piz7wk[m]>Can i do `(set! ...)` and have the value available in the sourced file as well?
*M6piz7wk[m] didn't yet figure out how to source files in guile like `. path/to/shell/file`
<jgart>M6piz7wk[m], can you show some code to contextualize what you're trying to do?
<jgart>like in a paste bin or something
<nckx>M6piz7wk[m]: You probably want 6.18.11 Local Inclusion
<jgart>oh
<jgart>M6piz7wk[m], you can use load
<jgart>(load "path/to/shell/file")
<M6piz7wk[m]> https://git.dotya.ml/OpenVolt/nyxtumops... (full message at https://libera.ems.host/_matrix/media/r0/download/libera.chat/a86f9750dfba2325deb7d0336754483a5a53b694)
<jgart>most schemes support that
<nckx>Well, yes and no. The manual puts it aptly: “If you are a C programmer, if 'load' in Scheme is like 'dlopen' in C, consider 'include' to be like the C preprocessor's '#include'.”
<M6piz7wk[m]>jgart: responding to ^
<nckx>. is the latter.
<M6piz7wk[m]>jgart: thanks
<nckx>But load is more idiomatic. Using ‘include’ in Scheme smells very much like ‘a shell programmer wrote this’.
<M6piz7wk[m]>but if i do:... (full message at https://libera.ems.host/_matrix/media/r0/download/libera.chat/f816200fc71f2e7bba9d00baf9dd0dd80e32de09)
<nckx>‘load’ won't do what you want if you want ‘.’.
<nckx>Why are you using set! over define?
<M6piz7wk[m]>because i don't understand the difference in between `set!` and `define` probably x.x
<M6piz7wk[m]>though `set!` is the general way to define variables
<M6piz7wk[m]>oh just mutable variables? define for immutable?
<jgart>M6piz7wk[m], you'll use define 95% of the time
<M6piz7wk[m]>oh ok
<M6piz7wk[m]>why though?
<nckx>No, define is. set! is used to modify variables, which is considered poor style by most programmers, but has its uses.
<jgart>Because set! is not functional
<nckx>M6piz7wk[m]: <but if I do> Yes, that works fine.
<M6piz7wk[m]>nckx: thanks
<jgart>It produces side-effects
<calnombl>is there a package for kernel userspaceapi/header manpages?
<nckx>M6piz7wk[m]: Because you can usually write programmes without changing any existing variables, and these programmes often end up better-designed.
<M6piz7wk[m]>i see
<nckx>calnombl: man-pages.
<M6piz7wk[m]>`(define)` is used for functions too?
*M6piz7wk[m] is looking at the 3.4.9 example
<nckx>M6piz7wk[m]: This is a matter of style, of course, and Scheme supports almost any style (it's sometimes called ‘multi-paradigm’ for this reason), but really, honestly, all styles aren't equal and functional is one of the better ones.
<M6piz7wk[m]>is there any standardization for the style that i can follow?
*M6piz7wk[m] prefers to follow standard since he's writting mission critical software
<nckx>M6piz7wk[m]: Yes. Functions are just a kind of value that you assign to a variable. Functions aren't magical things that live in a separate namespace, as is the case in elisp for example.
<M6piz7wk[m]>i see
<nckx>(Hence why elisp is a ‘lisp-2’ and Scheme a ‘lisp-1’, if you care about such background.)
<M6piz7wk[m]>oh
*nckx → away another while.
<M6piz7wk[m]>you can use guile in emacs?
<M6piz7wk[m]>like instead of elisp?
*M6piz7wk[m] is looking at 4.5
<M6piz7wk[m]>oh just editing guile in emacs
<calnombl>nckx: thanks! though is there anything that includes man9 as well?
<singpolyma>M6piz7wk[m]: there is a fork if emacs that uses the guile interpreter to run the elisp, which should then also support extending emacs with guile
<jgart>M6piz7wk[m], there was a pipe dream to use guile to compile elisp
<M6piz7wk[m]>i see O.o
<singpolyma>It is packaged for Guix but for some reason despite emacs being literally the inspiration for guile to exist, their merger is not of interest to the emacs PTB
<singpolyma>(guile is the name of both a scheme dialect and the compiler for that dialect, this compiler also supports emacs lisp, some of JavaScript, and there is a module to make it support python as well)
<jgart>singpolyma, I've been working on a project to run jupyter notebooks in guix containers. If you find the time I'd love for you to give a code review or to try it out: https://git.genenetwork.org/jgart/binderlite
<singpolyma>So with some effort it should be possible to configure guix in emacs lisp actually, but I haven't tried that direction yet
<jgart>the project is inspired by https://github.com/jupyterhub/binderhub
<jgart>but doesn't use docker at all
<singpolyma>jgart: I'm not sure if I'm the right person for that, I've never used jupyter or guix containers (or containers much at all)
<jgart>I was thinking more of the web app aspect of it
<jgart>networking and security
<jgart>I can pm you if you'd like to chat some time about it
<jgart>I could give you a demo
<jgart>Binderlite is currently a WIP and under rapid development and testing
<singpolyma>Ok
<jgart>But it currently is able to launch jupyter notebooks from git repositories and sources the manifest file in the repo
<jgart>I'm thinking about possibly supporting ipfs for storage/sharing of notebooks
<jgart>I've been able to run/test python, R, and guile notebooks so far with the above app in a guix container
<singpolyma>Sounds interesting
<jgart>I'll be pushing a commit soon that will add information to the user while they're waiting for the guix container to build before being redirected to it
<jgart>I took the idea from Drew's builds.sr.ht: https://builds.sr.ht/~sircmpwn/job/610711
<jgart>It uses ansi2html https://ansi2html.readthedocs.io/
<jgart>It's a lighter solution than using something like xtermjs
***bqv is now known as Guest5443
<M6piz7wk[m]>is `host-name` a defined thing that returns the system hostname?
<roptat>all the fields of an operating-system record are accessible with operating-system-<field-name>, so it's operating-system-host-name
*M6piz7wk[m] sent a scheme code block: https://libera.ems.host/_matrix/media/r0/download/libera.chat/0d6a7fdafd5f86129e4f45e5ea22a763dbfb1071
<M6piz7wk[m]>roptat: thanks
<M6piz7wk[m]>roptat: is the `operating-system-<field-name>` documented anywhere? i can't find it in the manual
<M6piz7wk[m]>oh found https://guix.gnu.org/en/manual/devel/
<jgart>M6piz7wk[m], I'd get comfortable with records in scheme by doing some exercises
<M6piz7wk[m]>yep that has it
<jgart>learn how to use records in scheme and then apply that knowledge to records that guix defines
<M6piz7wk[m]>i did the exercises in the guile manual
<M6piz7wk[m]>but i learn more by asking tbh x.x
<mahmooz>how come top's output on guix is different from other distros
<mahmooz>its all in red and its different its more like htop
<mahmooz>i like it but i wanna know why its different lol
<mahmooz>like its better im not complaining
<M6piz7wk[m]>mahmooz: branding?
<mahmooz>huh
<mahmooz>im talking about the monitoring tool top
<M6piz7wk[m]>i am using guile for like 20 min and about to switch on guix so just guessing it's different because of distro-branding as that seems to be the case everywhere else x.x
<mahmooz>what does branding have to do with it
<mahmooz>its a program
<M6piz7wk[m]>usually distros do branding for packaged software to represent the colors and branding of the distro O.o
<M6piz7wk[m]>e.g. Gentoo does configuration changes to XFCE4 to display gentoo wallpaper and stuff
<mahmooz>ye but its all different its not just the color
<M6piz7wk[m]>dunno then O.o
<mahmooz>its weird lol
<mahmooz>i mean its better but dunno why its different
<M6piz7wk[m]>is it even top? did you check --help ?
<M6piz7wk[m]>or --version
<M6piz7wk[m]>wait top doesn't have those right
<mahmooz>i need to reboot into guix to check whats up with it lol
<nckx>mahmooz: Most distributions customise top because they don't like the way it looks by default. Guix doesn't.
<potatoalienof13>top is red by default?
<nckx>Yes.
<M6piz7wk[m]>> <@6piz7wk:tchncs.de> ```scheme... (full message at https://libera.ems.host/_matrix/media/r0/download/libera.chat/d78d4ce0e7d6d3402cb79c978658dd003c8a32ad)
<mahmooz>oh lol
<mahmooz>ye that makes sense
<nckx>Old procps's versions weren't, then that changed, some distro[ user]s went nuts.
<nckx>potatoalienof13: https://i.stack.imgur.com/svmKZ.png
<potatoalienof13>gentoo doesnt seem to do any configuration, yet still has a white top?
<mahmooz>ye exactly and it shows all cores each in its own row
<jgart>Would guix/guile benefit from something like this? https://janetdocs.com/
<M6piz7wk[m]>potatoalienof13: gentoo does branding whenever possible last time i checked? see `branding` USE flag
<nckx>potatoalienof13: Yes they do: https://gitweb.gentoo.org/repo/gentoo.git/tree/sys-process/procps/procps-3.3.17-r1.ebuild#n69
<jgart>crowd sourced guile/guix examples
<nckx>Right there in the ebuild: ‘modern-top’ is off by default.
<jgart>maybe without the github oauth
<mahmooz>does guix do any branding?
<potatoalienof13>ah
<potatoalienof13>thought you were talking about a config file
<M6piz7wk[m]>mahmooz: if it doesn't already it will once i get my hands on it probably :p i like to brand my systems
<nckx>mahmooz: Very little, I can't think of any, but maybe some graphical packages (display managers, perhaps?) have a Guix background added. We add a GRUB background but that's not really branding in the sense that we don't modify the package, just add a line to grub.cfg.
<mahmooz>i see
<mahmooz>nckx youre part of the dev team?
<nckx>And we build xorg-server with "--with-os-vendor=Guix" ‘because it looks nice’ (quoth the comment), but it's also nice for bug reports, I guess 😛 Also not really branding if nobody ever sees it.
<mahmooz>lol
<nckx>mahmooz: I help maintain the distro but everyone who contributes is a ‘dev’. We have very little hierarchy.
*M6piz7wk[m] sent a scheme code block: https://libera.ems.host/_matrix/media/r0/download/libera.chat/019d1e88684edcc5cbcb882525d7fcc6eca79100
<mahmooz>cool
<M6piz7wk[m]>i guess i would have to set up a VM?
<nckx>M6piz7wk[m]: I would.
*M6piz7wk[m] goes to check if there is a docker image defined for guix
<nckx>guix system vm
<nckx>Oh, I don't know about that.
<M6piz7wk[m]>oh nothing official in terms of docker?
<jgart>nckx, has `guix system container ...` worked for you last time you tried?
<jgart>From what I remember it produces a guile script that then needs to be run as root
<nckx>jgart: That would be never.
<jgart>Oh ok. so it's currently broken?
<nckx>Sticking to the theme of things that exist but which I've never used: guix system docker-image is a thing, M6piz7wk[m], maybe it even works.
<nckx>jgart: I mean I've never tried it.
<jgart>ohh ok
<nckx>I'm not into containers or dockings.
<jgart>oh ok
<M6piz7wk[m]>nckx: what it does? Generates a dockerfile?
<mahmooz>apparently yes
<mahmooz> https://guix.gnu.org/manual/en/html_node/Invoking-guix-system.html
<M6piz7wk[m]>cool
<nckx>M6piz7wk[m]: I don't know what a that is, but Guix produces a file, which is for docker, so… probably! The dockerfile's called guix-docker-image.tar.gz.
<nckx>-a
<M6piz7wk[m]>Can you generate me one for bare minimal GUIX?
*M6piz7wk[m] is not sure if docker can do from scratch to ADD remote tarball
<nckx>M6piz7wk[m]: You can do so yourself: guix system docker-image bare-bones.tmpl, for example (from https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/system/examples)
<M6piz7wk[m]>i don't have GUIX running yet.. i want to develop a scheme that just switches me from nixos tbh
<jgart>M6piz7wk[m], have you used guix shell yet?
<nckx>I'm building that one.
<jgart> https://guix.gnu.org/en/blog/2021/from-guix-environment-to-guix-shell/
<M6piz7wk[m]>jgart: nope, dismissed it before bcs i didn't know it can do per-package configuration thinking parametrized packages are needed for it
<nckx>jgart: Thanks for hosting another meetup! (Which again I can't attend, but I love the idea.)
<mahmooz>i dont understand why guix doesnt have more users
<singpolyma>Well, most people have never heard of either nix or guix, and those that have heard of both often think of guix as "off brand nix"
<jgart>nckx, Thanks! Hope to see you at one in the future
<mahmooz>😕 their loss i guess
<mahmooz>guix is so far the best distro i've tried
<mahmooz>and i tried countless distros lol
<jgart>mahmooz, why is that?
<jgart>just curious
<M6piz7wk[m]>mahmooz: bcs of terrible marketing! I though it sucked this whole time while suffering on NixOS!
<libry>I have an X1 Carbon Gen 9, and have ordered a wifi USB for dodging iwlwifi firmware issues, is there anything else someone should be looking out for with really new hardware and guix?
<libry>also i found guix before i found Nix OS. I thought NixOS was the off-brand distro ;P
<mahmooz>well i wanted reproduciblity thats why i moved from arch to nixos to try it out i used to reinstall arch very very very often (for various reasons..) and it was exhausting going through the same commands every time to install arch and setup the AUR and all these tasks that took me hours to finally get a usable system
<mahmooz>so i found nixos to be great but the nix language was so confusing to me i didnt like it at all
<mahmooz>so i heard about guix and moved to it and found scheme to be much more sane than nix and way better
<jgart>libry, you'll probably be fine with the wifi dongle
<mahmooz>i prefer guix to nixos cuz i feel like guix is way tidier
<mahmooz>the docs are great and the commandline interface is too easy to learn
<jgart>but I don't have experience first hand using an X1, so take that with a grain salt
<libry>Thanks jgart! I'm excited to try it out on something other than an older Thinkpad.
<M6piz7wk[m]>Is it a sane setup to deploy an Alpine with Guix package manager for testing guile scheme?
<mahmooz>@jpart to answer your question
*M6piz7wk[m] is looking at https://github.com/bmpvieira/Dockerfiles/blob/master/guix/Dockerfile
<jgart>I wish guile docs were better
<jgart>That said, they're not bad
*M6piz7wk[m] likes the docs
<M6piz7wk[m]>mdbook might be a better integration for those though
<jgart>It'd be cool to have a guile-specific book instead of referring people to always check out SICP
<libry>Is the reference manual the best resource? I haven't seen much on the guile website..
<jgart>something like "How to design programs" but for guile
<M6piz7wk[m]>libry: i am using https://guix.gnu.org/en/manual/devel/en/guix.pdf https://www.gnu.org/software/guile/manual/guile.pdf atm
<jgart>The manual is not good for learning scheme
<jgart>If that's what you're thinking it might do
<jgart>or offer
<libry>Same M6piz7wk[m].
<libry>I will add that I think if you learn any implementation of scheme, even those such as Racket you'll be in a decent place to learn Guile.
<singpolyma>jgart: the manual seemed pretty thorough to me
<jgart>as a manual it is pretty featureful
<nckx>Big shade.
<nckx>jgart: You probably will, some day.
<libry>The documentation on Guile, and Guix are pretty stellar. I was surprised to learn that they are both 5+ years old.
<singpolyma>Guile is super old
<mahmooz>i hate that many low-effort linux distros get more traffic than guix
<libry>yeah I was completely unaware
<mahmooz>most distros are forked from arch/debian, they slap some preinstalled software on top of that and call it a distro
<nckx>Whatever this guix-docker-image.tar.gz is, it's taking its sweet time to build.
<singpolyma>mahmooz: well, most distros are more if the same, which people think they want. Guix is a whole new thing
<nckx>Oh, it's building inside a VM.
<jgart>I'd like guile to have something like this: https://janetdocs.com/
<nckx>‘Distro’ means Ubuntu with a different them and background people.
<nckx>*theme
<mahmooz>lol apparently 😂
<M6piz7wk[m]>So is alpine with guix a sane setup for testing?
<singpolyma>I try to never say distro anymore, better to just say "OS"
<singpolyma>M6piz7wk[m]: sure, but why not just guix system if that's your goal?
<singpolyma>I use guix in Debian, but I have different goals
<singpolyma>And I use guix system in CI
<M6piz7wk[m]>singpolyma: Because guix doesn't have official docker image defined and i can't do FROM scratch image that fetches tarball without getting it locally first
<M6piz7wk[m]>oh and because i want to do smooth migrating since both are reproducible to enable it
<jgart>singpolyma, do you mean you use guix system to run your CI?
<jgart>are you using laminar?
<jgart>s/using/running
<mahmooz>whats a CI
<nckx>M6piz7wk[m]: I forgot to ask earlier after mentioning ‘guix system vm’: why does it have to be Docker?
<libry>I nearly forgot the reason I came into this IRC room, is it normal behavior for the guided installer to not allow manual IP/Mask/GW/NameServ information?
<singpolyma>jgart: I'm using sr.ht CI and they have a guix system image
<libry>It seemed to try DHCP, did not connect, and then I was unable to do anything but reboot.
<jgart>singpolyma, oh ok
<drakonis>gonna install guix on my laptop
<jgart>yeah, I saw that they added that
<jgart>very cool
<M6piz7wk[m]>mahmooz: The thing that separates an average dev from competent dev :p
<M6piz7wk[m]>Continuous Integration -> Checks the commit for you prior to merge to the branch
<mahmooz>lol did u just call me a soydev
<singpolyma>jgart: was great timing for us, I was just using guix pack to get a new enough guix on Debian before that image landed
<mahmooz>seriously what is it tho 😂
*nckx .oO Mmm, soy.
<singpolyma>mahmooz: CI just means "build server"
<nckx>mahmooz: https://en.wikipedia.org/wiki/Continuous_integration#Compile_code_in_CI
<jgart>It'd be cool to create a distro of Guix System that uses wisp or https://github.com/lokke-org/lokke
<jgart>for the sake of experimenting/hacking
<nckx>mahmooz: Note how it's just a component of a wider methodology.
<nckx>jgart: I haven't tried, but I thought Guix (because Guile) files could be written in Wisp today?
<jgart>has anyone tried using clojurisms in their Guix System configs?
<libry>like?
<jgart>threading macros, etc... I mean
<mahmooz>if a build server is such a good practice why am i hearing about it for the first time lol
<jgart>nckx, haven't tested wisp with Guix System
<mahmooz>is there anything i should hear about thats supposed make me a better dev? 😂😂
<jgart>maybe I should try packaging something with wisp instead of guile to see if it works as intended
<mahmooz>anything else*
<nckx>mahmooz: Have you heard of something called Stack Overflow? If you have, you're done, you're a dev, congrats, go dev stuff.
<mahmooz>i am a dev already lol
<mahmooz>ofc i know stackoverflow
<nckx>Well, yeah, because I told you about it. Duh.
<mahmooz>im just hearing about a CI for the first time and still doing my research on it cuz i still dont get the point
<jgart>ha
<roptat>mh, does (specification->package "git:send-email") work for anyone? I am doing this wrong?
<mahmooz>ive been coding for 3 years and i only got 1 project done... mfw
<nckx>mahmooz: The point is that you find bugs sooner, and that all code in a large system is ‘integrated’ and tested together, frequently (ideally for each commit, so it's obvious what broke what and you don't waste more time hunting down bugs). To be useful it implies having a nice big test suite, because ‘it compiles’ is good but not enough.
<dissent>how to use the starship prompt? the commands given on the github page don't work
<mahmooz>i see..
<nckx>roptat: specification->package+output
<nckx>dissent: …?
<nckx>What is a starship prompt, how is it in Guix, etc.
<dissent> https://starship.rs/
<jgart>roptat, what nckx said worked for me
<dissent> https://guix.gnu.org/en/packages/rust-starship-module-config-derive-0.2.1/
<jgart>scheme@(guix-user)> (specification->package "git:send-email")
<jgart>guix repl: error: git:send-email: unknown package
<ajarara>roptat: https://issues.guix.gnu.org/51496 --with-source inputs fix! :)
<nckx>dissent: That is not the same package.
<nckx>It just has ‘starship’ in the name, probably because the starship authors maintain it for use in starship.
<roptat>nckx, thanks
<mahmooz>well its always good to learn something new i guess
<jgart>Is anyone interested in this package for guix? https://github.com/out-of-cheese-error/the-way
<mahmooz>i better get working on my 2nd project lol cya guys
<nckx>dissent: You (sorry, but you knew this was coming) are very welcome to contribute a proper starship package, if you feel up to the task. 😉
<nckx>Bye mahmooz. Good luck.
<dissent>Crap... I did know it was coming haha.
<dissent>Okay... how difficult would it be (on a scale from 1-10), how much time would it take, and will I find instructions in the documentation?
<jgart>dissent, on packaging?
<dissent>yeah
<jgart>You won't find instructions for packaging a rust package from start to finish
<jgart>but you'll find general instructions for packaging and everything you need to know for submitting a patch, testing, etc...
<nckx>dissent: I honestly don't know. Look at the output of ‘guix import crate --recursive starship’, which is what you'd start from.
<jgart>It's not comprehensive though. Ever package will present it's own problems to solve
<jgart>s/Ever/Every
<jgart>dissent, check out the source code for previously packaged rust programs
<jgart>that will help
<jgart>dissent, have you packaged anything before for guix?
<jgart>I'd start with a simpler package with less dependencies
<M6piz7wk[m]>Should i run GUIX as a non-root user for testing?
<M6piz7wk[m]>probably as root right?
<M6piz7wk[m]>-> PATH="PATH /root/.guix-profile/bin:$PATH" important?
<jgart>Maybe something written in c instead of rust
<dissent>I haven't packaged anything for any distro.
<nckx>It all depends on how ready-to-go the importer's output is, and that's impossible to tell beforehand (esp. because I avoid packaging Rust like the plague).
<nckx>M6piz7wk[m]: The ‘guix’ command should be run as the current user, not another. The daemon must always run as root.
<M6piz7wk[m]>noted
<jgart>The rust importer's output in my experience has never been ready-to-go. But I've only tried with large rust packages mostly and hence my dissapointment
<jgart>maybe a small lib would be closer to "ready-to-go"
<nckx>PATH="PATH /root/.guix-profile/bin:$PATH" dunno where you got that from but apart from the fact that "PATH …" is broken, it doesn't look right to me.
<M6piz7wk[m]>let me yolo it then
<jgart>dissent, I'd start with a small c program or a python library
<dissent>i'll do some googling.
<jgart>Or try first just updating a hash and version and testing
<nckx>Guix is meant to be updated using ‘guix pull’, which will create a per-user guix command in ~/.config/guix/current/bin/guix. If you set the above PATH, that new guix won't be used, but always root's instead.
<jgart>See previous commits of people upgrading just the hash and version
<jgart>start there
<jgart>test it
<nckx>The officially supported way to install Guix on a non-Guix-System is by running https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh M6piz7wk[m].
<jgart>take a patch and send to guix-patches@gnu.org
<jgart>that would be a quicker way to get started
<nckx>M6piz7wk[m]: If you already have, it should modify /etc/profile.something and (perhaps after logging out & in) PATH should be set correctly and you can just ‘guix pull’ and start guixing
<jgart>then you can build yourself up from there to packaging a whole program
<M6piz7wk[m]>nckx: thanks that should help a lot
<nckx>M6piz7wk[m]: It's certainly possible to install from source but it's making the learning curve needlessly hardcore.
<nckx>Because you'd have to know Guix before ever having used it. Not ideal!
<nckx>No.
<M6piz7wk[m]>nckx: I need it reproducible can you pin a commit on savannah?
<nckx>E.g. https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh?id=e4ed0b3969ddbe44347c468c96ccfa057b2dd256
<M6piz7wk[m]>e.g. on github https://github.com/sagiegurari/cargo-make/blob/c0baa09dd44bca41c5d488ea89fb105a189a7e23/README.md to get https://github.com/sagiegurari/cargo-make/raw/c0baa09dd44bca41c5d488ea89fb105a189a7e23/README.md
<jgart>Is it possible to explicitly associate packages with channels in a manifest currently?
<M6piz7wk[m]>nckx: perfect thanks
<nckx>(@ (my module name) variable) should work in Guix as elsewhere, jgart. As do e.g. #:select & #:hide when importing etc.
<dissent>so sounds like the difficulty is about an 8 and time spent is several hours.
<dissent>given my current lack of expertise.
<nckx>dissent: That's probably not way off.
<jgart>for that package, I'd say yes
<M6piz7wk[m]>/ # ./guix-install.sh
<M6piz7wk[m]>./guix-install.sh: exec: line 33: bash: not found
<M6piz7wk[m]>eh
<M6piz7wk[m]>oh no
<dissent>:) i'll look into it
<jgart>nckx, It'd be nice if there was some sugar to go with that
<nckx>Alpine is that hipster thing that hates GNU, right? Just an extra challenge. 😛
<nckx>It is just and right that it will soon run GNU.
<M6piz7wk[m]>is there a supported OS for the non-GUIX guix installation using the guix-install.sh
<nckx>‘Any sane Linux’.
<nckx>I'm sure Alpine can be made sane by e.g. installing bash somehow.
*M6piz7wk[m] is not aware of any sane GNU/Linux distro
<nckx>Hehe. Maybe glibc as well, I don't know if that's missing too.
<nckx>Guix is proudly GNU.
<M6piz7wk[m]>ah `apk add bash`
*nckx is proudly sleepy and → 😴💤, good night and good luck everybudz.
<apteryx>nckx: o/
<jgart>nckx, What is a reason you prefer glibc to musl?
<M6piz7wk[m]>gn thanks for info and help ^=^
<jgart>good night!
<jgart>`apk add musl-guix`
<M6piz7wk[m]>jgart: eh?
*jgart jgart dreams
<jgart>it's a joke
<M6piz7wk[m]>alpine doesn't have groupadd -w-
<jgart>guix implemented on top of musl
<M6piz7wk[m]>jgart: is that a thing on alpine?
<jgart>no
<M6piz7wk[m]>...
*M6piz7wk[m] just destroyed his almost-configured docker environment to try that
<jgart>guix can't run on musl
<jgart>either can guile
<M6piz7wk[m]>eh? why
<jgart>but janet can
<jgart>red pill: https://github.com/andrewchambers/hermes
<jgart>jk
<M6piz7wk[m]>o.o
*M6piz7wk[m] doesn't know what hermes is
<jgart> https://github.com/andrewchambers/p2pkgs
<jgart>hermes is yet another package manager
<jgart>inspired by nix and guix
<jgart>but it's not being worked on anymore
<jgart>author moved to p2pkgs which is written in shell and friends
<jgart>I think p2pkgs has some nice ideas
<jgart>They wanted mainstream success so they went with bash instead of lisp...
<roptat>mh, I just switched to guix home; I don't have a ~/.guix-profile anymore, is that expected?
<roptat>ah, I guess so
<apteryx>roptat: interesting
<apteryx>I'll be interested to know your experience, I haven't taken the plunge myself yet!
<roptat>just starting...
<roptat>I'm having some troubles now because I'm switching from my own home-manager
<roptat>getting in trouble with git: bash: /home/tyreunom/.guix-home/profile/bin/git: Trop de niveaux de liens symboliques
<roptat>oh
<roptat>what? `/home/tyreunom/.guix-home -> /home/tyreunom/.guix-home`
<roptat>I think I messed something up by calling the scripts manually from .guix-home
<dissent>pardon all the questions... moving to gnu guix and a lot of the stuff that was working on arch simply doesn't anymore.
<M6piz7wk[m]>How do i use the tarball? It has only `gnu var` directories
<M6piz7wk[m]>don't you have something with FHS and stuff too?
<roptat>M6piz7wk[m], the easiest way is to use the installer script instead of the tarball
<roptat>otherwise, you have to follow the manual: https://guix.gnu.org/manual/devel/en/html_node/Binary-Installation.html#Binary-Installation
<roptat>we don't follow the FHS
<roptat>(note the tarball is for the binary installation on a foreign distribution)
<M6piz7wk[m]>GNU project that doesn't follow FHS? O.o i got always screamed at for using wrong dir in #fsf
<dissent>users of ranger, when attempting to view view a txt file in PAGER or pressing 'r' to ask what to do it simply reads "Errno 2] No such file or directory: 'file'". Any idea how to fix? I thought xdg-utils was it but it won't.
<roptat>dissent, is "file" the name of the utility? maybe you need to install the package "file"
<M6piz7wk[m]>using the script then
<roptat>looks like I got to a usable state again relatively painlessly, nice :)
<roptat>I noticed two small contribs I could make, will send patches tomorrow ^^
*roptat goes to bed
<roptat>good night :)
<M6piz7wk[m]>gn thanks for helping ^=^
<apteryx>roptat: good night!
<dissent>optat, wow... face palm emoji.
*M6piz7wk[m] sent a code block: https://libera.ems.host/_matrix/media/r0/download/libera.chat/9418a6b498124f8005f09660b123e47aacead463
<M6piz7wk[m]>eh
<dissent>when you never have to do these things you don't know whats missing. it's definitely helping me understand what is under the hood so to speak.
*M6piz7wk[m] had to install `ca-certificates` on debian for it to work
<M6piz7wk[m]>... i can't do the guix-install.sh bcs it requires interactive shell -w-
*M6piz7wk[m] made a hotfix
<raghavgururajan>apteryx: Damn! That many conduits to qtbase.
<raghavgururajan>apteryx: I'll try moving it to separate output or separate package as gtk-with-gst-backend.
<M6piz7wk[m]>How annoying it is to go through the manual installation
<M6piz7wk[m]>how do i concatenate string in guile?
<M6piz7wk[m]>(load (string-concatenate ("domains" system-domain "default.scm")))
<M6piz7wk[m]>so that it puts the values together
<apteryx>raghavgururajan: OK!
<apteryx>sounds good
<Noisytoot>M6piz7wk[m], you should quote ("domains" system-domain "default.scm")
*M6piz7wk[m] is looking in guile manual 7.5.3.4 and is confused
<Noisytoot>'("domains" system-domain "default.scm")
<M6piz7wk[m]>Noisytoot: eh? it's quoted?
<M6piz7wk[m]>oh
<M6piz7wk[m]>i see
<Noisytoot>no, it's trying to call "domains", which won't work because it isn't a lambda
<M6piz7wk[m]>```
<M6piz7wk[m]>```
<M6piz7wk[m]>(load (string-concatenate '("domains" system-domain "default.scm")))
<M6piz7wk[m]>```
<M6piz7wk[m]>Same err with this
*nckx awakes… hrmz?
<M6piz7wk[m]>tried `\`(..)` too
<nckx>M6piz7wk[m]: My terminal dinged, it dinged for thee: https://tobias.gr/guix-docker-image.tar.gz (I have no idea if this is useful! or even if it's useful!!)
*nckx falls back asleep.
<M6piz7wk[m]>thanks!
<M6piz7wk[m]>oh i have missing parentecies above
<M6piz7wk[m]>works now
<apteryx>nckx: haha
<apteryx>meson 0.60 is riddled with regressions, it seems
*M6piz7wk[m] sent a scheme code block: https://libera.ems.host/_matrix/media/r0/download/libera.chat/a27d76aced061c140628e53b605eff35f344cb23
<M6piz7wk[m]>what am i doing wrong?
*M6piz7wk[m] tried to use `slot-unbound?` but that is not defined even when `slot-bound?` is
<M6piz7wk[m]>ah seems that (when (string=? (getenv "DOMAIN") "") works
*M6piz7wk[m] sent a scheme code block: https://libera.ems.host/_matrix/media/r0/download/libera.chat/ac3f29f7a173f418f1d6a511de6ecc6aef77f349
*M6piz7wk[m] is failing to figure out how to concate that
<jgart>This code will probably not run (string-append '("domains/" system-domain "/default.scm"))
<M6piz7wk[m]>yep.. how do i make it to work?
*M6piz7wk[m] continues to read 6.6.5.10
<jgart>string-append takes strings as arguments
<jgart>not a list
<M6piz7wk[m]>string-concatenate then?
<jgart>(string-append "domains/" system-domain "/default.scm")
<jgart>given that system-domain is also a variable that is a string
<M6piz7wk[m]>thanks!
<jgart>M6piz7wk[m], (string-append '("domains/" system-domain "/default.scm")) will still fail
<jgart>because system-domain is a boolean
<jgart>boolean value
<M6piz7wk[m]>eh?
<M6piz7wk[m]>but the `(load (string-append "domains/" system-domain "/default.scm"))` works?
<jgart>and you can't string-append a string and a boolean
<M6piz7wk[m]>but system-domain is variable expanding in string no?
<jgart>oh ok
<jgart>yes, when set
<M6piz7wk[m]>when set?
<jgart>otherwise it will return #f
<M6piz7wk[m]>o.o
<jgart>I see now in the when function what you did
<M6piz7wk[m]>but it expands correctly?
*M6piz7wk[m] tried with (display)
*M6piz7wk[m] is confused
<jgart>What is your code trying to do or how does it fit into the bigger picture of what you're doing with it?
<M6piz7wk[m]>Converting this https://git.dotya.ml/OpenVolt/nyxtumops into guile.. it's designed to manage 200+ systems at the same time from a public repository
<M6piz7wk[m]>it does that through separating the configuration by HOSTNAME and DOMAIN and then does distributed build and push-based deployment
<M6piz7wk[m]>(the public version is outdated.. i didn't yet publish the new one bcs i got aneurism from working with nixlang)
<M6piz7wk[m]>and based on hostname and domain it sources files with logic
<jgart>ha
<jgart>are you trying to switch it over to use guix?
<M6piz7wk[m]>yes
<jgart>it's a rust project?
<jgart>I just took a quick peek
<M6piz7wk[m]>it's using cargo-make just to manage the repo
<M6piz7wk[m]>it's snopyta.org-like network
<M6piz7wk[m]>just federated and more explosive
<jgart>what services do you provide?
<M6piz7wk[m]>in general everything i can
<M6piz7wk[m]>for myself i need a separete git handling since the project i am working on is monorepo with 2.2GB of pure source code and 120+ git repositories
<M6piz7wk[m]>but i also want to provide gitea
<jgart>M6piz7wk[m], have you heard of smithy?
<M6piz7wk[m]>the guy from my elementary school with which i played football?
<jgart>yea
<jgart>ha
<jgart> https://github.com/honza/smithy
<M6piz7wk[m]>wait he's alive?
<M6piz7wk[m]>oh
<jgart> https://git.eletrotupi.com/
<brendyn>For some reason (operating-system (inherit OS)) and (operating-system (inherit OS) (services (operating-system-services OS))) are different
<jgart> https://git.pokorny.ca/smithy
<jgart> https://git.pokorny.ca
<brendyn>the second one gives me an error more than one service of type shepherd-root
<M6piz7wk[m]>jgart: What exactly is it doing? just allowing me to define a lot of repositories to then publish them all?
<jgart>It's like cgit
<jgart>but written in go
<jgart>and nicer looking
<M6piz7wk[m]>Do you have that in rustlang by any chance? :P
<M6piz7wk[m]>Looks like solution to my problems though will check it thanks!
<jgart>haven't seen a forge yet in rust
<jgart>there's probably one out there
<jgart>somewhere
<jgart>brendyn, how did you check that they were different?
<M6piz7wk[m]>jgart: Btw. do you have OpenShift on clean energy infrastracture yet? (say that u work on openshift and took the opportunity to ask)
<M6piz7wk[m]>*saw
<jgart>I don't have openshift
<M6piz7wk[m]>ah nevermind then O.o
*M6piz7wk[m] wrote 200 lines of untested guile and goes to headbut coach since he can feel his brain not working
<jgart>what were you writing?
<M6piz7wk[m]>still the same system management
<jgart>ah ok
<M6piz7wk[m]>is guix optimized for phones?
<jgart>nope
<M6piz7wk[m]>it has binaries for armhf and aarch64 though?
<jgart>It was not a great experience on a phone last time I tried with mobian
<M6piz7wk[m]>Just knowing that it can work on those is enough for me to develop handling for it
<jgart>Everything took way to long to install (with substitutes enabled)
<jgart>Yup, it would be cool to start packaging sxmo suite
<M6piz7wk[m]>bcs it had to be compiled? -> distributed build?
<jgart>I was using substitutes
<jgart>binaries
<M6piz7wk[m]>Hm O.o
<M6piz7wk[m]>is Guix dependent on it's init system?
<M6piz7wk[m]>or can i change that anytime i want?
<jgart>you mean Guix System?
<M6piz7wk[m]>like is it the same like NixOS where i will suffer with systemd with no way to change it?
<jgart>Shepherd feels "baked in"/deeply integrated. It would definitely be a rabbit hole to go down to try to decouple it and put some other init in its place
<jgart>I might be wrong on that
<jgart>there might be some hacker out there that would love to do that and has all the time in the world
<M6piz7wk[m]>but none will prevent me from contributing code that makes it GNU Shepard independent right?
<M6piz7wk[m]>(thing that happens on NixOS)
<jgart>not sure what you mean. can you unpack that a bit
<M6piz7wk[m]>On NixOS i get threatened in various way for daring to submit anything that makes the derivation independent from systemd.. is that same here with the Init?
<jgart>I remember seeing a guix package for systemd somewhere
<jgart>how was the thing you submitted "independent from systemd"?
<jgart>can you give an example?
<jgart>do you mean like not using systemd's native chrooting features and using an app's own chrooting features?
<M6piz7wk[m]>Basically: https://github.com/NixOS/nixpkgs/issues/126797
<M6piz7wk[m]>NIxOS upstream blocking any kind of work on such feature
<jgart> https://github.com/NixOS/nixpkgs/pull/103991
<M6piz7wk[m]><jgart> "do you mean like not using..." <- +- i hate implementation dependent definitions
<jgart>MagicRB had a good point
<jgart>NixNG maintainer
<M6piz7wk[m]>Agree that it's more demanding on NixOS as it's too dependent on systemd for it's functionality
<M6piz7wk[m]>but distros like Gentoo and Devuan the maintanance overhead is almost non-existant
<M6piz7wk[m]>and i just don't want to be prevented on working on something alike tbh O.o
<jgart>What would you like to see instead of shepherd?
<jgart>runit?
<M6piz7wk[m]>In general anything that is not systemd is fine with me, but i would like to experiment with configuration for optimization so ruint, OpenRC, s6, etc..
<jgart>You could probably create a fork to experiment with that
<mahmooz>is it possible to run reconfigure on an external drive?
<M6piz7wk[m]>i would want to avoid doing fork.. rather define a method in guix that makes it to apply logic depending on chosen init
<M6piz7wk[m]>basically what devuan is doing to debian
<jgart>how would runit integrate with Guix System?
<M6piz7wk[m]>if shepard then do shepart things else if runit then do shepard things or fatal
<M6piz7wk[m]>ehh
<M6piz7wk[m]>*if shepard then do shepart things else if runit then do runit things or fatal
<M6piz7wk[m]>so that it can be an ongoing effort that can be submitted in the upstream
<M6piz7wk[m]>since doing forks is what killed NixNG and some users (like me) are more then happy to define e.g. runin compatibility for packages that they use
<jgart>I submitted an alternate cron: https://issues.guix.gnu.org/51113
<jgart>that is not mcron
<jgart> https://github.com/leahneukirchen/snooze
<jgart>but there are other crons like scron already packaged
<jgart>I'm not sure what the policy is on accepting init systems as packages
<jgart>M6piz7wk[m], https://github.com/NixOS/nixpkgs/blob/nixos-21.05/pkgs/tools/system/runit/default.nix#L55
<M6piz7wk[m]>ye i know there are packages for it, but it doesn't work well with nixos
<jgart>right
<M6piz7wk[m]>and NixOS doesn't seem to mind the package definition.. just touching other packages to make them work with it
<jgart>M6piz7wk[m], start by grepping for shepherd in guix/guix/
<jgart>and in guix/gnu/
<M6piz7wk[m]>ye :p like i don't mind the work.. i mind obstruction of work
<M6piz7wk[m]>which is what i was concerned about
*M6piz7wk[m] goes to sleep
<mahmooz>i just ended up with a broken guix system and with no choice but to reinstall it lol
<mahmooz>rolling back didnt help
<mahmooz>my pc turned off in the middle of a `guix system reconfigure` lol
<mahmooz>and guix wasnt booting up anymore
<mahmooz>does `guix system init` override the /home directory?
<rekado>no, guix system init does not touch /home
<rekado>can’t you select an old generation in Grub?
<mahmooz>i tried
<mahmooz>it refused to boot
<mahmooz>said something about errors in filesystem
<mahmooz>my pc literally turned off while a `guix system reconfigure` was building so..
<rekado>have you tried fsck on the filesystem?
<mahmooz>no..
<mahmooz>should i 😂
<rekado>if the computer turned off suddenly your file system may very well have been corrupted. So running fsck (either by plugging in the disk on another computer or prior to booting from it) seems like a reasonable course of action.
<mahmooz>ill try it
<mahmooz>brb
<mahmooz>fsck from util-linux 2.36.2
<mahmooz>e2fsck 1.46.2 (28-Feb-2021)
<mahmooz>guix: clean, 501931/17006592 files, 6012555/68010321 blocks
<mahmooz>ran it from another distro got this
<mahmooz>nope fsck didnt help same errors
<mahmooz>guix faills to start the services
<mahmooz>and never boots into the tty
<mahmooz>im using `guix system init` now
<mahmooz>`guix pull` is done
<mahmooz>```
<mahmooz>```[~]$ guix system init workspace/guix/config.scm /mnt
<mahmooz>guix system: error: failed to load 'workspace/guix/config.scm':
<mahmooz>ice-9/boot-9.scm:3300:6: In procedure resolve-interface:
<mahmooz>no code for module (<some-package> packages linux)``` any idea why im getting this?
<mahmooz>even tho i ran `guix pull`
<mahmooz>nvm i think $PATH wasnt setup right
<brendyn>jgart, I think i discovered the issue. I had used `operating-system-services' instead of `operating-system-user-services'. It seems these procedure names break the usual record accessor patterns
<shegeley>Hello there. I am a last year student of Math in Russian university currently. At the end of bachelor we have diploma project and I'm looking for a topic. Is there anything connected with guix/guile that could be one? (Assuming the standarts are quite liberal: so not only pure-math goes, some code will to).
<lilyp>I think there's some complexity theory stuff that you could at least implement in Guile (particularly anything to do with graphs) if you're into that.
<lilyp>Though typically university will want you to do one of two things: 1) take one of their suggested projects, 2) suggest one of your own and get a professor to sign it off.
<shegeley>Professor will sign.
<shegeley>I need to choose a topic ASAP.
<shegeley>Any good papers connected with guile/guix and math someone could reccomend?
<shegeley>I mean: I'm in good relationships with my curator. But the deadline for chosing topic is close.
<vldn>nice weekend 2 u all :)
<bost>Hi. Can somebody tell me how to find out from which package a binary comes from? E.g. how to see that `npm` comes from the `node` package?
<bost>`guix package --show=node | grep npm` shows nothing.
<florhizome[m]>Guix search?
<florhizome[m]>You mean gnu/packages/nvm
<florhizome[m]>*npm
<bost>florhizome[m]: I mean npm - the Node Package Manager.
<florhizome[m]>Oh npm is an output from node
<florhizome[m]>well idk :D
<jpoiret>i don't think there's a bult-in function to do that
<bost>florhizome[m]: Yeah, I guessed that it's the output. But I have no clue how to discover that. Hmm
<jpoiret>but maybe it would be possible to add an indexing job to the CI that has substitutes
<bost>jpoiret: If you remember I had a similar problem a day or two ago: I was searching for a package which contains pdflatex
<jpoiret>oh yes I remember. Most of the time it's pretty easy to find the package a binary belongs to though (texlive-bin is a bit harder i suppose)
<florhizome[m]>Though I maybe have a similar problem from a different perspective, a package (plank) wants to find „glib–compile–Schemas“
<florhizome[m]>i think that comes with glib or glibc, but putting that into inputs or native inputs hasn’t worked. I think I will need to try specifying „bin“ in the inputs...
<bost>jpoiret: It's pretty easy to find a package with a specific binary? Hmm. I personally, I'm struggling with it.
<jpoiret>most of the time, you can look up the name of the binary online and you'll have a pretty good idea of what the package should be
<florhizome[m]>It’s a general Linux problem though, even more since every distro names their packages differently
<bost>jpoiret: yeah but that's just a guess work.
<jpoiret>but I agree that it would be nice to have a command to do that, that leverages the CI's substitutes
<jpoiret>maybe a new option of `guix weather`?
<florhizome[m]>Wouldn’t it be easy to register what lands in /bin/ etc
<jpoiret>maybe simply just index every file
<bost>jpoiret: BTW why is that command called "weather"? Is that some kind of a pun?
<florhizome[m]>Maybe guix build could tell you ... these binarys have been installed and when you commit a package you include it in a new field like outputs or so
<jpoiret>i don't think so, just that it's akin to checking the weather i guess
<florhizome[m]>Then it’s available via guix search
<jpoiret>florhizome[m]: that would be way too annoying to manage by hand
<jpoiret>think of packages with many binaries
<florhizome[m]>If you just copy paste from guix output?
<florhizome[m]>The problem would be old packages
<florhizome[m]>Not much more work then getting the checksum and description etc
<jpoiret>I think that substitute servers having an index of their substituted files would be better, although I don't know what CPU/disk usage that would add
<jpoiret>yes but those are "necessary" for the package
<florhizome[m]>Well
<florhizome[m]>I would want it to be available in guix search. That means it would need to be in the package definition. I wouldn’t leave it up to maintainers to do that. Probably could be done automatically.
<florhizome[m]><singpolyma> "mahmooz: CI just means "build..." <- So if I would offload building locally in my network I would have a CI already ? :O
<sarg>hey guix, how to add a file-like object to an inherited package? Namely I have xf86-video-intel and I want the package to have also a xorg.conf.d entry
<sarg>or maybe there is another way to put some file into user's profile?
<florhizome[m]><nckx> "florhizome: Can you share your..." <- Doing garden work for mum today, but I’ll continue this evening. :)
<florhizome[m]>and maybe some other packages when it‘s done^^
<florhizome[m]>The desktop stuff I used on manjaro is not available so stuff to be done^^
<brendyn>sarg, are you sure you need to add such a file to the package its self?
<roptat>shegeley, I'm not sure it's really maths, but papers related to guix are listed here: https://guix.gnu.org/en/publications/ (those with a little hat before the name :))
<lilyp>florhizome[m]: in case you haven't figured out yet, glib-compile-schemas is in glib:bin, and yes, it's a native-input
***atw`` is now known as atw
<shegeley>roptat, yep, I saw that ones. more about reproducibility and proof-concept. I'd say some language (guile) stuff would also be good for a final project.
<roptat>shegeley, then you should ask on #guile :)
*M6piz7wk[m] sent a scheme code block: https://libera.ems.host/_matrix/media/r0/download/libera.chat/39d04f395376b20fb8f2528bcf96ea877182a392
<M6piz7wk[m]>(yes i just woke up and went straight to writting guile without even having breakfast or anything to drink, help me)
<M6piz7wk[m]>Btw. created https://issues.guix.gnu.org/51505 and https://issues.guix.gnu.org/51506 from issues i had yesterday with proposed solution
<M6piz7wk[m]>ehh i didn't provide patch for the 51506, but most likely will if such change is desired
<M6piz7wk[m]>> <@6piz7wk:tchncs.de> ```scheme... (full message at https://libera.ems.host/_matrix/media/r0/download/libera.chat/1105a916cf873a0021c009d2bd0754df0f2d3ea3)
<M6piz7wk[m]>ping
<KREYREN>M6piz7wk[m], pong
<M6piz7wk[m]>oh good
<nckx>Morning Guix.
<nckx>florhizome[m]: <So if I would offload building locally in my network I would have a CI already> No, that's just offloading. A CI system continuously builds (‘integrates’) software in some automated, proactive fashion.
<roptat>M6piz7wk[m], hi!
<roptat>I'm not sure what you're trying to achieve
<roptat>your operating-system records are incomplete, but I'll assume it's just an example you're giving, so the real thing is complete
<roptat>I think in your case I would use inheritance: polo.scm will include marco.scm. marco.scm needs to put the operating-system value in a variable, like (define-public marco-os (operating-system ...)), then polo.scm can load this module and inherit from it: (operating-system (inherit marco-os) (timezone "Europe/Paris"))
<M6piz7wk[m]>roptat: Yep example the idea is to be able to overwrite the value after it has been set
<M6piz7wk[m]>can't easily do the inherit since this may include 12+ files
<roptat>you can change a value after it's set
<roptat>can't*
<M6piz7wk[m]>oh so assuming complete (ope..
<M6piz7wk[m]>nevermind
<M6piz7wk[m]>so it would have to be a variable that expands?
<M6piz7wk[m]>or how should i do it assuming that this whole system works by overwriting values in (operating-system)
<M6piz7wk[m]>.. well projected to work that way since that is what it does in nixlang
<roptat>yes, you can have this in maco.scm: (define-public marco-timezone "Europe/Prague") and then in polo.scm you can choose whether you want (timezone "Europe/Paris") or (timezone marco-timezone)
<M6piz7wk[m]>thanks that seems usable
*M6piz7wk[m] goes to do experiments
<M6piz7wk[m]>How long does it take to process requests alike https://issues.guix.gnu.org/51505?
<roptat>depends if people are awake, think they can help...
<roptat>sometimes it can be very fast and sometimes it can last for years...
*M6piz7wk[m] goes to make Linux From Scratch script to get the guix libraries on then
<roptat>haha
<M6piz7wk[m]>wait can guix build itself?
<roptat>yes
<M6piz7wk[m]>how?
<M6piz7wk[m]>just defining `operating-system` ?
<roptat>no, guix is a package, not an operating system
<M6piz7wk[m]>i meant if it can build itself into an OS
<roptat>I don't understand
<roptat>you can build an os with guix using guix system
<roptat>and one of its default services is the guix daemon
<roptat>so the resulting os would have guix inside
<M6piz7wk[m]>ehh like can i make a `tools/minimal.scm` that can then guix build into a file hierarchy with GUIX that i can chroot into ?
<roptat>mh... maybe, but you'd be better off using, say, "guix system docker-image"
<M6piz7wk[m]>once the scheme file is defined that i can be a docker-image on demand right?
<roptat>yes
<M6piz7wk[m]>so how do i define it? just declaring `operating-system` ?
<roptat>you can build a VM, docker image, or install a system on bare metal from a file that defines an operating-system record
<M6piz7wk[m]>and like filling it with stuff
<M6piz7wk[m]>oh perfect
<roptat>I need to go, bbl
<M6piz7wk[m]>baiii
<davidl>Hello guix! I have some 4 easy python patches to review and apply in bug #51432 - anyone who feels up to it?
<dissent>hey guys where is the clear command located?
<dissent>or rather what packaged is it installed with
<jgart>ncurses
<jgart>I found that out here too some time ago
<jgart>might be a convenience to mention it in the manual since it is a bit arcane for new users to know that clear command is in ncurses package
<jgart>and most distros just provide that command out of the box
<dissent>hey thanks yeah. there needs to be a guix wiki for stuff like this. I'm really missing the ease provided by the arch wiki.
<singpolyma>dissent: you can submit edits to the manual or cookbook
<singpolyma>There is also a guix area on the libreplanet wiki IIRC, but probably better to submit to official docs
<dissent>the question that comes up for me is, is it better to bury this small detail in the large manual or dedicate something that could be more easily found?
<singpolyma>What would make it easier to find in a wiki than in the manual? These seem the same to me except the manual has no web editor of course
<nckx>The manual's not really a good fit (‘clear’ has nothing to do with Guix, after all, it's just one of the thousands of binaries Guix packages) but the cookbook sounds good. Until we have a proper package-not-found/guix package contents search, a ‘common binaries and their package’ might be a pragmatic workaronud.
<singpolyma>Package content search would be great. Basically just need to run `find` over store items produced in CI and put them somewhere I guess
<nckx>If $someone wants to maintain it, of course ☺ That's always the bottleneck. ‘Someone else should make a wiki’, not ‘here's a wiki I made’.
<nckx>singpolyma: Well, the somewhere *is* the hard part.
<dissent>Yeah not meaning to pass the buck. Just... my skills are rather limited. But perhaps I will start taking note of these little things so that they might evntually be integrated into something like a wiki.
<singpolyma>nckx: is it? There's already an unserachable package list on the website, could go wherever that is?
<nckx>I don't see how that's related.
<singpolyma>dissent: could make the notes on the libreplanet wiki at least if a cookbook submission is too much
<jgart>dissent, If you send a patch for the cookbook that might be a good place
<nckx>Building a list of packages is relatively easy: it's fixed as soon as the commit is fetched, but a list of contents is asynchronous. It gets populated slowly whilst the CI builds all changes.
<jgart>or if you send me the changes I can commit them for you an add your authorship
<jgart>I don't mind
<singpolyma>nckx: oh sure, so is the issue getting auth from CI to publish I guess?
<jgart>I'll submit the patch for you I mean
<jgart>just send it in a pastebin here
<nckx>singpolyma: I think distribution and versioning is harder than you imply, but I don't see the obvious solution either.
<dissent>jgart: okay I'll produce something
<jgart>great
<jgart>also share how you'd like to commit as with email in the paste
<jgart>If you'd like I can show to send patches yourself also eventually or come to the guix packaging meetup today and I can demonstrate after we package something
<singpolyma>nckx: I guess CI has to put the substitutes somewhere already, so maybe content listing could go next to that? Wouldn't need auth for a new location then
<nckx>What's the auth issue you see, singpolyma?
<nckx>I don't see it but then I wasn't thinking about auth(orisation?).
<singpolyma>If we wanted to put it on the website something has to have permission to get it from the CI job to there
<nckx>I don't think that's an issue, but if it were, I think this belongs on ci.guix anyway.
<nckx>You'd use the same substitute servers after all.
<nckx>Let's call the command ‘guix which’ for now: then it would query each substitute server in turn like we do for substitutes, I think.
<singpolyma>Sure, could even have it all work locally that way which would be neat
<nckx>I would *love* that. I'd love for this to be something that is delivered alongside Guix, somehow, so you always have accurate information for your particular commit, but that might be $too_hard :-/
<nckx>I'd love to be proven wrong though.
<nckx>Dinner's about to be served; TTYL, but interested in your thoughts :)
<singpolyma>Is the CI runner code etc in the guix repo or elsewhere? I'd love to understand more how the current parts work so I can think about this from an informed PoV
<jgart>singpolyma, I think it's in a different repo
<jgart>are you referring to cuirass?
<jgart> http://guix.gnu.org/cuirass/
<kozo[m]>singpolyma I'm not a very advanced user but setting up Cuirass 1.1 was great and it worked as described
<dissent>jgart: yes show me to how to send patches and I'd love to join the meetup.
<dissent>teach a man to fish.
<singpolyma>jgart: I don't know, but if that's what powers the main guix CI then probably. I will look at it
<florhizome[m]>yup I figured it out, though the magic that made it start work was including pkg–config in native inputs.
<florhizome[m]>I have now progressed to failing to build another dependency, “bamf”^^
<jgart>dissent, sure that'll be easy
<jgart>dissent, https://lists.gnu.org/archive/html/guix-devel/2021-10/msg00298.html
<jgart>singpolyma, yup that's it
<jgart>atleast that's the main program that does ci for guix
<jgart>singpolyma, then you'll want to see the cuirass service that's in the guix repo
<jgart>the shepherd service for it, I mean
<jgart>In gnu/services/cuirass.scm
<jgart>The guix package definition for it is in gnu/packages/ci.scm
<singpolyma>Thanks!
<pranavats>Hello. I'm trying to install guix on LVM on LUKS setup. And I'm unable to get it to boot to grub. I need some help figuring out what I'm missing.
<pranavats>I have 2 unencrypted partitions with mount points /boot and /boot/efi in the config. /boot contains Grub, and so needs to be unencrypted, and so does /boot/efi.
<pranavats>There's a single encrypted partition which is a physical volume for 3 logical volumes, /, /home, and swap partition.
<pranavats> https://disroot.org/upload/_Iml8h9nTZyOHBra/20211030_221333329_dc13.jpg
<pranavats>The above is the output of `lsblk -f` command.
<pranavats> https://disroot.org/upload/5ZKjl02UY1MOZKkf/20211030_221444924_71ab.jpg
<pranavats>And the above is part of my configuration of mapped-devices and file-systems from config.scm.
<pranavats>The physical volume and the volume group are both named "system".
<pranavats>I'm sorry. I mean, the decrypted luks partition is available at /dev/mapper/system and the volume group is named "system". So root partition is available at /dev/mapper/system-guixsd, and home partition at /dev/mapper/system-home.
<civodul>lilyp: do you think your comment at https://issues.guix.gnu.org/50873#40 should be a blocker for this series?
<civodul>i'm glad yoctocell followed up and would happily apply it all :-)
<civodul>(or let you take care of it, as you prefer)
<lilyp>I think it'd be easier to patch right now than going back and edit it later (including changes to the ui)
<jpoiret>pranavats: hi! is there any way we could get the file-systems and mapped-devices part of your config? is there any GRUB error? are they LUKS1 or LUKS2 devices?
<jpoiret>disregard the first question, i missed the image
<pranavats>jpoiret: It is LUKS1 (but I'd like to use LUKS2 if possible). There's no Grub error, it just doesn't boot. As if the partition isn't bootable, but I have set the boot,esp flag on EFI partition.
<jpoiret>as for the /boot vs /boot/efi, you don't need two partitions for those: personally, I have my EFI partition on /esp, and /esp/EFI/Guix/ bind mounted to /boot
<jpoiret>do you see the Welcome to GRUB prompt?
<pranavats>I don't see the prompt.
<pranavats>Would you like me to try that configuration. Is there anything else that you see amiss?
<jpoiret>what about the bootloader-configuration part of the system?
<pranavats>jpoiret: Where is grub.cfg stored in your system?
<jpoiret>as for LUKS2 support, I sent a patch an hour ago to add support, so we'll have to wait for a bit
<jpoiret>pranavats: it ends up at /EFI/Guix/grub/grub.cfg on my EFI partition
<pranavats>jpoiret: It's the usual grub-efi-bootloader config with /boot/efi as the target. Nothing special.
<jpoiret>or alternatively /boot/grub/grub.cfg
<pranavats>jpoiret: Do you mean /esp/EFI/Guix/grub/grub.cfg?
<jpoiret>yes, i'm just talking fs-wise
<pranavats>I see.
<jpoiret>when it's mounted at /esp/, that's also where it ends up
<jpoiret>did you mount everything before `guix system init`?
<jpoiret>you could try checking where the grub.cfg file ended up
<pranavats>jpoiret: yes, including swap, which isn't active in the image.
<jpoiret>grub-install does a lot of magic which is a bit annoying
<pranavats>I don't understand. For my install /boot/efi is the ESP and the only thing /boot/efi/EFI/Guix/ contains is grubx64.efi.
<jpoiret>yes, that's because grub installs its config and themes and whatnot to /boot
<pranavats>My grub.cfg is at /boot/grub/grub.cfg
<pranavats>That's why I kept /boot on a separate unencrypted partition, so it can find grub.cfg.
<pranavats>Can you share your config jpoiret?
<pranavats>Including the bootloader config.
<jpoiret>pranavats: https://paste.debian.net/1217393/
<jpoiret>although grub should be able to find its .cfg itself usually
<jpoiret>are you on EFI? if so, are you booting using the right boot option?
<pranavats>jpoiret: Is my file-systems config correct?
<pranavats>I don't use the subvol option, as you have used.
<pranavats>I have boot,esp flags set on the EFI partition.
<jpoiret>subvol is brtfs-only things, dw about them. Your file-systems look good to me
<jpoiret>those flags aren't really important EFI-wise
<jpoiret>do you know if you can enter your computer's UEFI Setup menu, where you can see eg boot order?
<pranavats>jpoiret: I have a menu to choose which disk to boot from, but not of boot order.
<jpoiret>only which disk to boot from? can you add new boot options? is this really an EFI system?
<jpoiret>if you can't add boot options from within the Setup menu, you could try using efibootmgr from a live image
<pranavats>jpoiret: It's a macbook. And I replaced the NVME SSD. I'm trying to install Guix on this new SSD.
<pranavats>I used to be able to run Guix just fine with the preinstalled NVME SSD.
<jpoiret>if you run efibootmgr from within the live image (from the efibootmgr package), do you see the boot option that is supposed to boot Guix's GRUB?
<pranavats>Let me try that.
<pranavats>But, I don't see that boot option in the boot menu. (Whereas I do see a boot option for the live installation disk).
<pranavats>Let me try efibootmgr
<pranavats>jpoiret: I don't know how to interpret the output of efibootmgr. I see entries for my old systems on the previous disk. Let me show you the output though.
<pranavats> https://disroot.org/upload/5NbAh3enw8QTCcqG/20211030_232221666_3ce3.jpg
<jpoiret>oh, sorry, you should do efibootmgr -v
<jpoiret>to see the full command line
<pranavats>jpoiret: No. I see a different UUID than any partitions on my disk.
<pranavats>This probably shows entries from my previous disk which isn't connected anymore. How can I update this configuration?
<jpoiret>you can use efibootmgr to manage them: `-b BOOTNUM -B` to delete one of them, and `-c -d /dev/nvme0n1p3 -l \EFI\Guix\grubx64.efi -L Guix` to add the right one (please double check the given options though)
<pranavats>Thank you. I'll look into how to use efibootmgr.
<jab>Hey guix people!
<civodul>o/
<civodul>lilyp: so i think i misunderstood your comment: was it just about the commit log mentioning "destination directory", or was it something deeper?
<civodul>now i'm guessing the latter, sorry the the silly question
*civodul rereads
<lilyp>It's about the variable "destination-directory" in both function arguments and elsewhere
<lilyp>I wrote it in response to the commit message because that's where the words were first used.
<pranavats>jpoiret: I'm unable to boot even after creating boot options using efibootmgr.
<civodul>lilyp: you're talking about the name of the formal argument, right?
<lilyp>yep
<civodul>ok
<jpoiret>pranavats: hmmm, did you check that they are in the right order?
<pranavats>jpoiret: Yes.
<jpoiret>weird... still no Welcome to GRUB?
<pranavats>Nope
<lilyp>now that I read it again, I don't think the name itself is ever "exposed" to the outside, so it'd probably be a simple sed
<lilyp>oh, right, there appears to be a (destination ...) block now
<pranavats>Apparently, there already existed a boot option from `guix system init` perhaps, that is identical to the options I created. So this doesn't seem to be the issue.
<jpoiret>so you simply get a black screen then?
<pranavats>jpoiret: I get a folder icon with a question mark. Which probably means no boot device found. It's a Macbook Air.
<civodul>lilyp: right, if it's just the formal parameter, aesthetic shouldn't block the whole series (i agree on the aesthetics you propose, but still :-))
<civodul>lilyp: you seemed to be hinting at something more fundamental though, which is to add a --skeleton=DIRECTORY option, no?
<lilyp>Again, I was under the impression that this would somehow be exposed to the CLI, which it is not
<pranavats>jpoiret: I think there might be something specific to my laptop that I need to do. Reset NVRAM that is.
<jpoiret>maybe, but i'm not sure it's what's preventing you to boot grub right now
<lilyp>I have no strong opinion on destination vs. prefix for the field name, but for the variable name we might want to s/-directory// as we apply it
<lilyp>Making the entire thing and using /etc/skel can be done in a separate patch if needed
<lilyp>s/the entire thing/the entire thing optional/
<roptat>how can I add aliases in my bashrc/profile with guix home?
<roptat>do I add them in a file-like object?
<pranavats>jpoiret: Yeah. It didn't work.
<lilyp>roptat: post the patchset we're discussing, you'd write it as a mixed-text-file I guess
<pranavats>jpoiret: I could try to install Guix without LUKS to see if luks really is the problem.
<jpoiret>maybe. but i really don't think so
<jpoiret>you should at least see a grub prompt
<roptat>ah plain-file is enough for my needs right now, looks like it worked
<roptat>I see the aliases in my bashrc
<roptat>I converted the openbox service from my old home-manager to guix home, it's great :)
<roptat>I configured the menu with software that are not present in my profile ; I can start my gui apps from the openbox menu, but they're not cluttering my shell, it's great :)
<roptat>the only downside to guix home is that it doesn't separate the user profile from itself, so I can't update my config separately from my packages, which was something I had to do a few times for lack of space during updates
<roptat>I'll figure something, probably by moving some of my big files to another disk
<civodul>lilyp: alright, all sounds good to me
<civodul>i can apply the patches, changing the variable name as i go
<lilyp>👍️
<lilyp>roptat: the insistence on the guix home profile is a pet peeve of mine as well – I do want to extend it so that any number of profiles (also possibly 0) can be managed using guix home
<minikN>Good evening. I've written a shepherd service that simply starts and stops a binary: https://paste.debian.net/1217401/ How can I add that service to my services in my system config?
<roptat>minikN, you can add this definition to your config.scm, and add something like this in your services field: (simple-service 'iptsd shepherd-root-service-type iptsd-shepherd-service)
<minikN>Thanks roptat. I'll try it now. However, is it also possible to somehow bake this into my package definition? So that when I install the package I automatically have a service for it running?
<roptat>no, that's not possible
<roptat>the other way around is possble though: you can have a service extend the package profile
<minikN>Meaning I'd set up the service and it would set up the package?
<roptat>yes
<roptat>note that you didn't define a guix service, but only a shepherd service
<roptat>that's why here you can use simple-service, but if you want to also extend the package profile, you'll need a guix service
<jgart>Hi, how can I test documentation?
<roptat>I have this syntax object: #<syntax:test.scm:1:0 ()>, and I'd like to extract the location. How can I do this?
<jgart>or, what's the quickest way to build the cookbook, for example
<jgart>If I just want to make a change and see the html
<roptat>jgart, "make doc/cookbook.html"
<minikN>Thanks roptat
<jgart>thanks!
<jpoiret>roptat: https://www.gnu.org/software/guile/manual/html_node/Source-Properties.html
<roptat>thanks, got it working
<minikN>roptat: I added your line to my config, but now I'm getting an error: https://paste.debian.net/1217405/
<jgart>make: *** No rule to make target 'doc/cookbook.html'. Stop.
<jgart>Hi roptat do you happen to know if the command should be something else?
<mahmooz>is there no way to check the stdout of a herd service? like with systemd we do the following `journalctl -u <service>`
<jgart>doc/cookbook.html rule does not exist
<jgart>atleast according to that error msg
<mahmooz>how am i supposed to run a webserver properly on a system if it doesnt have service logs 🤔
<mahmooz>i would never know why something went wrong whenever it does
*jgart searches the manual
<mahmooz>also anyone know what /var/log/messages is?
<mahmooz>what produces it?
<jgart>It looks like the manual does not describe how to build the docs
<jgart>unless I'm failing bad at grepping for it
<jgart>Or, it's something that you should just know from using texinfo?
*jgart knows very little texinfo and has mostly just used it for guix
<vivien>mahmooz, do you have nginx or apache?
<mahmooz>nginx
<mahmooz>i know nginx probably has logs of its own
<mahmooz>but what if a service wanted to run doesnt do its own logging but outputs to stdout instead idk i mean is there no equivalent to journalctl?
<vivien>No, there aren’t, unfortunately
*jgart reads texinfo manual
<vivien>However, if you have a program that does its own logging, and you want to create a service out of it, it’s not too difficult to run a bash script that invokes the daemon program with > bash redirections.
<vivien>Anyway, nginx logs under /var/log/nginx/{access,error}.log
<mahmooz>ye that makes sense
<mahmooz>thanks
<minikN>roptat: Actually cut that. Do you have an example on how to create a guix service that sets up a package and start/stops it?
<ss2>minikN: start reading through the available service definitions.
<ss2>That's what I did, and eventually successfully managed to write my own definition.
<ss2>Some are very simple and basically just have the bare minimum necessary to get running.
*jgart was able to compile the docs with texi2html
<florhizome[m]>What I haven’t grasped well is under which circumstances you would or would not default to the forkexec and the default kill process described in the manual
<minikN>ss2: That's what I've been doing. Can't seem to find an example that does what I want or I don't recognize it as such.
<mahmooz>exitim trying to run bluetooth but when i put `scan on` it just never finishes scanning
<minikN>ss2: https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/services/desktop.scm#n881 this looks good.
<ss2>florhizome[m]: I think I was in that situation too. If I don't get it wrong then you end up writing your own instruction if you wan't it to have behave differently. The ‘make-kill-instructor’ is just a default instruction.
<florhizome[m]><mahmooz> "but what if a service wanted..." <- Guix uses syslogd right, would one not just extend that?
<ss2>*want
<florhizome[m]>Well I just don’t really understand process forking and pids etc and so I’m kinda unsure but seems like a default
<mahmooz>how come bluetooth doesnt detect my headset lol
<mahmooz>but detects my phone
<mahmooz>wtf
<Jeremy[m]>Linux bluetooth support is kind of terrible
<mahmooz>it works fine on nix/arch
<mahmooz>on guix its acting up
<mahmooz>it detects my phone and connects to it and all
<mahmooz>but it doesnt see my headset lol
<Jeremy[m]>have you tried restarting bluetoothd
<mahmooz>ye multiple times
<florhizome[m]>f.e. why not just run “think fan”, but do this forking thing ^^
<Jeremy[m]>try deleting /var/lib/bluetooth
<mahmooz>wait should i stop bluetoothd beforehand?
<Jeremy[m]>that will reset bluetoothd including all devices and configurations
<Jeremy[m]>> wait should i stop bluetoothd beforehand?
<Jeremy[m]>yes
<mahmooz>oh the service is called bluetooth not bluetoothd lol
<mahmooz>huh same thing
<mahmooz>it sees the phone but no headset
<mahmooz>i can see the headset from my phone so i know its not the headset acting up
<florhizome[m]>how do I mention someone in matrix? Is it just @? wanted to post the package definition from yesterday evening since nsck had asked :)
<florhizome[m]>uhm irc (self report ^^)
<mahmooz>oh it found it omg
<mahmooz>its working lmao
<singpolyma>florhizome[m]: IRC mentions look like this
<mahmooz>ty jeremy
<mahmooz>oh wtf it fails to connect
<mahmooz>nvm it connected
<florhizome[m]>but how to write them :D
<mahmooz>bye guys
<florhizome[m]>bye
<singpolyma>florhizome[m]: by typing a name and then a colon
<florhizome[m]>singpolyma: hm ok
<florhizome[m]>that does not produce a link in element
<singpolyma>Most clients have tab completion or similar, not sure what matrix has
<nckx>IRC doesn't have links.
<singpolyma>It caused a mention in my client when you did that just now
<dstolfa>florhizome[m]: if they're on matrix, use @. if they're on irc, you probably want to just type the name and add a :, as both irssi and weechat ping with that
<florhizome[m]>aah
<nckx>The : isn't needed. Just write the name.
<nckx>Anywhere.
<ss2>I think mentioning the name alone is enough.
<nckx>How you doin', nckx? nckx: not bad. All works.
<dstolfa>huh. dstolfa
<dstolfa>i don't get notified for that
<dstolfa>on irssi
<florhizome[m]>yeah element also pings it with a column
<nckx>Time to upgrade to HexChat.
<dstolfa>nckx: you mean downgrade :)
<dstolfa>irssi lets me ssh!
<florhizome[m]>I think at the start of the line
<florhizome[m]>or just matrix
<nckx>dstolfa: See? HexChat doesn't. HexChat is the Unix philosophy writ large.
<singpolyma>dstolfa: you don't get notified by yourself
<singpolyma>The colon is conventional
<nckx>Hey dstolfa you gettin' pinged yet.
<dstolfa>nckx: no ping
<nckx>Whelp, we tried.
<singpolyma>dstolfa: really? I thought nick went on the irssi ping list by default. You can add other words to the list too
<nckx>/set hilight_nick_matches on
<nckx>/set hilight YOUR_NICK
<nckx>☝ says The Internet.
<nckx>Should fix the bug.
<dstolfa> https://pasteboard.co/gxisHAPaEZ7t.png (irssi defaults)
<florhizome[m]>what are the takes on guile’s Unix compliance :D
***jonsger1 is now known as jonsger
<lilyp>what does Unix compliance mean in this context?
<nckx>Is Guile a certified UNIX®? It's error messages are shit. I think we stand a good chance.
<florhizome[m]>The do one thing real good thingy
<nckx>Have you ever seen Unix do one thing well? Yeah.
<singpolyma>Guile and Guix are part of GNU, which we all know is Not Unix. Right in the name
<lilyp>I don't think programming languages are subject to that.
<nckx>Is C ‘unix’?
<lilyp>No, it does static and dynamic linking, that's two things.
<lilyp>Hence why Go and Rust are the only Unix programming languages.
<florhizome[m]>Probably scheme is actually well fitted for that
<florhizome[m]>And guile has a clear role
<nckx>But Scheme does do one thing well: everything.
<lilyp>buuuuuut they're also package managers and build chains, so there is actually no Unix programming language. It's back to assembly.
<lilyp>florhizome[m]: not so clear either
<jpoiret>just had a stroke of genius (or you could just call that Reading The Doc™). I'll add swap support to the hurd by using let-system inside the swap shepherd service to discriminate at eval time which api i should use for the system
<lilyp>you can use Guile to extend programs or to write your own
<lilyp>that's two things
<florhizome[m]>although the actually most used extension language for Unix is probably python
<florhizome[m]>or the most popular. Or I’m seeing python ghosts
<nckx>You misspelled shell?
<M6piz7wk[m]>What's the `(operating-system (timezone))` for UTC?
<nckx>(It's really not Python.)
*M6piz7wk[m] is on NIx and it doesn't have /usr/share/zoneinfo
<florhizome[m]>To me that’s not reeeeally extension
<florhizome[m]>but I don’t know any comps I
<nckx>M6piz7wk[m]: "UTC"…
<jpoiret>although now I have a problem: how do I refer to the system's chosen kernel package (since the 'swapon' binary will be in there) from inside the g-exp? surely there's something more elegant than just carrying it all the way down there
<lilyp>The most popular extension language is Javascript.
<M6piz7wk[m]>nckx: though it was it! thanks
<florhizome[m]>But not on a system level
<lilyp>Gnome folks would like to have a word with you :P
<jpoiret>side note: UTC's etymology is something incredibly stupid, in english it should be UCT, and in french TUC, so people thought naming it UTC would be a good compromise
<nckx>florhizome[m]: If you're defining ‘extension language’ in such a way that anything that's more common than Python doesn't count somehow, well, I can't argue with you, mainly because I can't.
<rekado>will the raw image for the pinebook pro that I can download from ci.guix.gnu.org work for the Honeycomb board?
<florhizome[m]>I thought they have vala :D
<rekado>I don’t know what’s the best way to install Guix System on these things.
<lilyp>Vala is for writing applications
<rekado>start with a default Ubuntu image and then use “guix system init /” perhaps?
<nckx>jpoiret: s/stupid/genius/ although opinions are pretty cheap on #guix right now 😉
<florhizome[m]>It seems like rusts little step cousin
<lilyp>lol no
<florhizome[m]>but idk
<lilyp>I'm pretty sure Vala predates Rust
<florhizome[m]>I think I am going too far
<florhizome[m]>Small in size
<lilyp>And it's sad to see it lose out thanks to the latter.
<lilyp>At least Vala has dynamic linking.
<florhizome[m]>Not in age
<jpoiret>if you factor in rust's bootstrap size then that's pretty easy
<nckx>Or dependency graph size.
<Jeremy[m]>Vala is C# for GNOME
<lilyp>Also Vala has actually sane syntax for most things.
<nckx>Jeremy[m]: That was Mono.
<florhizome[m]>I did not mean any computer metrics ._.
<lilyp>As sane a syntax you can get without becoming Lisp at least.
<florhizome[m]>Just a bigger thing know
<florhizome[m]>s/know/yknow/
<Jeremy[m]>Vala has a reference counting GC, Rust doesn't have a GC
<lilyp>nckx: No they're right, Vala is inspired by C#.
<nckx>I literally have no idea what Vala code looks like. Why did Mono get so. much. flak. compared to Vala then?
<singpolyma>Vala is fun but it's not really general purpose
<nckx>lilyp: JavaScript was inspired by Java. That went well.
<florhizome[m]>I would prefer gnome just using guile tbh so the bindings are readily available but I registered although a gnu project they don’t use gnu’s extension language :O
<singpolyma>It's basically heavy macros on C if you just want to use gobject and gtk for everything
<lilyp>JavaScript was also inspired by Scheme.
<nckx>They don't use much of GNU's anything.
<lilyp>I don't know how, but it's a fun thing to quote.
<nckx>lilyp: What is?
<singpolyma>Is GNOME actually a GNU project? Maybe technically
<florhizome[m]>Anything was probably at one time inspired by lisp or scheme
<Jeremy[m]>> Is GNOME actually a GNU project? Maybe technically
<Jeremy[m]>not technically, but in *spirit*
<singpolyma>But even emacs doesn't use GNU's extension language, so heh
<dstolfa>Jeremy[m]: sometimes not having a GC is a curse. source: i've implemented a GC for things in C numerous times :P
<Jeremy[m]>ok well historically, the FSF funded the development of GNOME and listed it as a GNU project, but nowadays the GNOME Foundation operates independently of the FSF, and the GNOME folks don't consider themselves to be part of GNU (even though GNU considers GNOME to be part of them ;D)
<lilyp>tbf the reference counting in GLib is really good tho
<singpolyma>Not having a *default* GC is great because you can always use one if you want it
<Jeremy[m]>> Jeremy: sometimes not having a GC is a curse. source: i've implemented a GC for things in C numerous times :P
<dstolfa>singpolyma: i didn't know you could turn on a GC in rust
<Jeremy[m]>Rust has optional reference counting
<nckx>I know that JS was supposed to be a Scheme, but I didn't know the mutilated mutt that replaced it was still meaningfully inspired by Scheme. Cool if true.
<florhizome[m]>And many people will say that GNOME is the real Linux desktop bc they are part of GNU
<Jeremy[m]>You just wrap everything in `Rc<>`
<singpolyma>dstolfa: there are a couple of rust gc libraries around
<singpolyma>Not as many as for C yet, but some :)
<Jeremy[m]>> And many people will say that GNOME is the real Linux desktop bc they are part of GNU
<Jeremy[m]>Note that the main GNU distro, Trisquel, ships MATE instead of GNOME 3.
<florhizome[m]>And guix ships xfce
<nckx>> Calling the main GNU distro Trisquel in #guix
<dstolfa>singpolyma: i never really used a gc library, i usually just implement a gc for the thing i need
<singpolyma>Jeremy[m]: pretty sure Guix is the *only* GNU distro
<Jeremy[m]>> > Calling the main GNU distro Trisquel in #guix
<Jeremy[m]>woops *blush*
*Jeremy[m] ducks
<nckx>
<nckx>,bef
<florhizome[m]>nsckx: haha my thoughts
<Jeremy[m]>RMS uses Trisquel though!
<singpolyma>Jeremy[m]: that doesn't seem relevant
<Jeremy[m]>maybe we should convince him to install Guix
<florhizome[m]>actually what is trisquel :D
<singpolyma>florhizome[m]: trisquel is Ubuntu
<nckx>A Debian fork/derivative, no offence intended.
<lilyp>RMS also uses credit cards when booking flight tickets, so clearly he is fallible :)
<nckx>Oh.
<florhizome[m]>You know he never installed Linux, you have to ask his guys
<M6piz7wk[m]>Why is GNU Guile using `.scm` (SCheMe) as extension? Is that a dialect of scheme?
<singpolyma>M6piz7wk[m]: yes, guile is a standards compliant scheme plus extensions
<jgart>M6piz7wk[m], yeah that is common for schemes
<lilyp>Many schemes use "scm" as prefix/suffix internally, Guile being one of them
<nckx>Yes. I'd say it's just ‘a Scheme’ and call e.g. Racket a ‘dialect’.
<M6piz7wk[m]>i see O.o
<florhizome[m]>And scheme is a lisp dialect?
<nckx>I don't know if that's absolutely technically correct but Guile is pretty compliant everywhere it matters.
<jgart>racket seems like it's just a dialect of scheme also
<singpolyma>You can write code portable to many schemes
<jgart>I would consider guile to also be a dialect of scheme
<jgart>as is gambit, chez, chicken
<jgart>etc...
<nckx>florhizome[m]: Scheme is an Esperanto of Lisp, but butter.
<singpolyma>nckx: pretty sure guile is at least r5rs compliant
<lilyp>same
<nckx>That was a typo but I like how it turns it into a flippin' Zen koan.
<florhizome[m]>I like Esperanto.
<lilyp>the manual would like to have a word with you
<nckx>singpolyma: It is.
<nckx>I think that's even how it self-identifies.
<singpolyma>IIRC it's *almost" r6rs compliant
<Jeremy[m]>> I like Esperanto.
<Jeremy[m]>saluton amiko!
<lilyp>oh, wait, incompatibilities only count for R6RS and R7RS
<nckx>Yes. And then things get weird with R7RS.
<M6piz7wk[m]>Racket uses .rkt though
<florhizome[m]>The eu should have that as main official language.
<florhizome[m]>and Linux should run in guile ;)
<singpolyma>M6piz7wk[m]: racket likes to think it is special
<M6piz7wk[m]>oh O.o
<singpolyma>Racket is leaving s expressions for default syntax IIRC
<nckx>I think Racket almost prides itself at not being wed to Scheme. In practice it is one but it likes to remind everyone it could leave at any time. At least that's my honest impression as a Guiler.
<singpolyma>Sounds right
<nckx>s/at/on/
<florhizome[m]>What would you use to write some GUI in guile though.
<florhizome[m]>Since gnome/gtk doesn’t even ship bindings by default.
<singpolyma>florhizome[m]: guile integrates well with C
<singpolyma>That's sort of it's main feature
<Jeremy[m]>Operacosistemo Giks es la plej bono.
<nckx>Dankon.
<lilyp>Writing bindings to something as big as GTK still isn't trivial, though.
<lilyp>In particular while keeping GC vs. reference counting in mind.
<M6piz7wk[m]>can i install guix on nixOS?
<lilyp>There's three attempts I know of, one of them ancient.
<lilyp>You can install Guix anywhere.
<lilyp>I'm sure Nix has a package
<jpoiret>lilyp: there's a whole cemetery out there of unmaintained GTK bindings
<M6piz7wk[m]>lilyp: https://search.nixos.org/packages?channel=21.05&from=0&size=50&sort=relevance&type=packages&query=guix nope
<florhizome[m]>would guile like ppl to stay with c for “backend” stuff, and not rust or go, or whatever?
<lilyp>Well, Guix people at least.
<M6piz7wk[m]>lilyp: won't it create a conflicts?
<lilyp>For Guile it doesn't matter, at least Rust has an "extern C"
<jgart>Hi, how do people pull patches from http://issues.guix.gnu.org/41293 for testing by others?
<lilyp>M6piz7wk[m]: Guix and Nix use different stores, so you'll just duplicate things
<florhizome[m]>what’s that?
<M6piz7wk[m]>ah oke
<jgart>Do you have a trick to automate it or make it less painful than just downloading them one by one
<jgart>I tried wget scraping them before
<M6piz7wk[m]>Can i cleanly remove guix once i install it on NixOS?
<jpoiret>lilyp: not duplicate, since the stores have different prefixes, their outputs will be different :)
<jgart>maybe I should finish that script
<jgart>M6piz7wk[m], yes
<M6piz7wk[m]>yay
<florhizome[m]>jgart: oh nice I kind of thought about building gala
<lilyp>jgart you can use /issue/NNNN/patch-set
<lilyp>if there's more than one, add /R
<jgart>lilyp, do you mean to wget that?
<lilyp>probably, it's a simple GET request and the API does magic in the background
<jgart>does the emacs debugs mode help with this at all?
<lilyp>dunno it's a mumi feature
<lilyp>so probably no
<M6piz7wk[m]>How is GUIX not FHS3.0 complaying? It is that it uses /gnu and otherwise FHS is respected or?
<Noisytoot>'Guix', not 'GUIX'
<M6piz7wk[m]>\>.<
<Noisytoot>M6piz7wk[m], Using /gnu means that FHS isn't respected
<jgart>or unrelated
<jgart>> racket likes to think it is special
<jgart>I agree
<Noisytoot>/home and /dev are used, but /lib, /usr, and /bin aren't
<M6piz7wk[m]>i see O.o
<jpoiret>FHS isn't respected mostly because it doesn't need to. But I'd say in this case that it's the FHS that doesn't respect Guix: ie programs have to be patched to be Guix-compliant
<Noisytoot>/etc is used, but lots of stuff there is generated from config.scm and a symlink to a file in /gnu/store
<M6piz7wk[m]>i meant mostly for when i am working outside of the store like being forced to put optional files in /usr
<Noisytoot>In / I have: bin boot dev etc gnu home media mnt opt proc root run sys tmp usr var, but some of those directories are just full of symlinks to files in /gnu/store
<jpoiret>when using guix on a foreign distro, Guix doesn't interact with the FHS at all
<M6piz7wk[m]>jpoiret: i meant for secrets and files that are changing on runtime since store is read-only and world readable?
<jgart>lilyp, could you give an example of the GET request with the syntax you mentioned above
<jpoiret>oh yes, true
<jgart>It would be much appreciated
<lilyp>/dev/stdin is not part of /gnu/store
<jpoiret>is 'parametrized' a guix or guile thing?
<jpoiret>parametrize *
<lilyp>jgart: Just one patch, but http://issues.guix.gnu.org/issue/47006/patch-set/5
<florhizome[m]>jgart: i think most of those patches are already available.
<florhizome[m]>and gala is not in there yet^^
<lilyp>parameterize is guile syntax
<jgart>Oh ok
*M6piz7wk[m] goes to relog to get guix on NixOS, if it breaks he will cry in a corner
<jgart>great that downloaded the patch set as one file called "5"
<jpoiret>lilyp: I can't find it anywhere in the guile manual
<jgart>florhizome[m], what do you mean that they are available?
<lilyp>info '(guile)Parameters'
<M6piz7wk[m]>... it would help if i installed guix outside of nix-shell
<jgart>like in a branch?
<M6piz7wk[m]>heh
<jpoiret>M6piz7wk[m]: don't forget to source the guix profile too
<M6piz7wk[m]>jpoiret: how?
<jgart>M6piz7wk[m], someone packaged guix for nix
<jgart>not sure if you've seen that yet
<jpoiret>well, in your bash_profile for example
<M6piz7wk[m]>i didn't link?
<jgart>It's not an accepted package in nixpkgs though
*M6piz7wk[m] C^ the installation
<jgart>M6piz7wk[m], https://github.com/Emiller88/guix
<M6piz7wk[m]>do i even want to use nix to handle guix
<jpoiret>lilyp: Oh, that's because it's spelled parameterized, my bad
<M6piz7wk[m]>ohh i do bcs i can have that in nix shell
<jgart>> Kinda more a code dump than for actual use
<singpolyma>Is there a nix package for Guix? Recursive installations!
<florhizome[m]>You can use nix on guix too
<jgart>mutual recursive installations...
<jgart>ha
<jpoiret>can you use guix on nix on guix though?
<M6piz7wk[m]>singpolyma: won't help since i need smooth migration from NixOS :p
<M6piz7wk[m]>and mainly i want to run the guix command to test the configuration since defining dockerfile is too much pain to do
<florhizome[m]>can nix do containers and system deployment like guix? Then you can do inceptioning
*M6piz7wk[m] doesn't know what inceptioning is in this context
<jgart>florhizome[m], have you worked on any pantheon desktop components?
<florhizome[m]>gala
<jgart>oh cool
<florhizome[m]>You need plank for that and for that you need sth called bamf
<jgart>are you planning to submit it
<florhizome[m]>No it does not work
<jgart>what's the issue you last ran into?
<jgart>more or less
<jgart>I think Ryan has packaged the pantheon terminal
<jgart> https://github.com/ryanprior/guix-packages/blob/master/proposed/pantheon.scm#L121
<jgart>Might still need some work
<florhizome[m]>well plank fails at bamf at least
<florhizome[m]>and bamf actually gets to install and then a lot of stuff happens
<florhizome[m]>my first automake package
<florhizome[m]>I can post what I have though
<jgart>what is bamf?
<jgart>Is that a dep of gala?
<jgart>sure, that would be cool
<florhizome[m]>No of plank
<jgart>oh ok