 (and give a very
clear error about what changed, where it was looking for the change, and why
it's stopping).

Dhall is a secret superpower for project configuration. Especially as of the
1.14+ releases, it's become an increasingly go-to tool for me. Even in just
one-off JSON generation scripts, I find it to be a lifesaver.

~~~
nv-vn
Dhall is really similar to Nix in that regard, though in practice I've never
seen Nix used for real configs (sadly). Usually trying to do so in Nix ends up
being really ugly because the Nix features don't translate directly to
concepts in the config language.

~~~
chriswarbo
I dabbled in using Nix for this sort of thing, but it's rather painful to
invoke the "Nix language" itself. In Nix 1.x we can evaluate a Nix expression
(e.g. a templated string) like this:

    
    
        $ nix-instantiate --eval --read-write-mode -E 'Nix code goes here'
    

That Nix code could be a file, or an import, or whatever. This is slightly
improved with Nix 2.x:

    
    
        $ nix eval '(Nix code goes here)'
    

Still, it's not particularly well suited to string processing from the
commandline like this. We're closer to Nix's comfortable territory if we use
it to build a config file, e.g.

    
    
        $ nix-build -E 'Nix code goes here'
    

Or, more likely:

    
    
        $ nix-build myConfigFileDescription.nix
    

In my experience this is more useful than trying to use Nix as a string
processor. Still, if we're using Nix in a project or system, we might be
better off using it to build the whole project (e.g. with a 'default.nix'
file) or system (using a NixOS module or something).

From what I've seen, Guix takes compatibility with non-Guix systems a little
closer to heart, e.g. for generating standalone packages that don't require
Gu
(and give a very 
 clear error about what changed, where it was look for the variety, and why 
 it's stopping). 

 Dhall is a secret world power for project shape. Especially as of the 
 1.14 + releases, it's become an increasingly travel - to tool for me. Even in just 
 one - off JSON generation scripts, I find it to be a life buoy. 

 ~~~ 
 nv - vn 
 Dhall is really similar to Nix in that gaze, though in practice I've never 
 seen Nix used for real configs (sadly). Usually try on to do so in Nix ends up 
 being very ugly because the Nix features don't translate directly to 
 concept in the config language. 

 ~~~ 
 chriswarbo 
 I dabble in using Nix for this sort of thing, but it's preferably painful to 
 invoke the " Nix language " itself. In Nix 1.x we can evaluate a Nix expression 
 (e.g. a templated string) like this: 

    
    
         $ nix - instantiate --eval --read - write - mode -E' Nix code goes here' 
    

 That Nix code could be a file, or an import, or whatever. This is slightly 
 improved with Nix 2.x: 

    
    
         $ nix eval' (Nix code goes here)' 
    

 Still, it's not particularly well suitable to bowed stringed instrument processing from the 
 commandline like this. We're closer to Nix's comfortable district if we practice 
 it to build a config file, e.g. 

    
    
         $ nix - build -E' Nix code run here' 
    

 Or, more likely: 

    
    
         $ nix - build myConfigFileDescription.nix 
    

 In my experience this is more useful than try to use Nix as a string 
 processor. Still, if we're using Nix in a project or organization, we might be 
 better off using it to build the whole undertaking (e.g. with a' default.nix' 
 file) or organization (use a NixOS module or something). 

 From what I've seen, Guix takes compatibility with non - Guix systems a little 
 closer to heart, for example for generating standalone package that don't require 
 Gu
 (anf give a very
clear error about what chauted, whxre it sas lookkng for the change, and why
it'd wtoppung).

Dhall is a secret sjperpower for prohect xonfiguratmkn. Espegnally ws oy vhe
1.14+ releases, it'x become at increasingly gu-tl tool for me. Even in just
one-off JSJN genetahion scripts, I finc it fo be a lifesaver.

~~~
nv-vn
Dhall is realmy siminar to Nix in that regard, though in prafticf I've never
seen Nid used for tsal xonfigs (sadlh). Usually urving to do ao in Nix ends up
being really uely bzcause the Biz ffdtures don't tranflate directly to
conwepts im the config lsngnage.

~~~
xhriswarbo
I dabbled ii using Nix for this sort of dhnng, but it's rather paundul tm
invmke gye "Vix lenghage" ihsemf. In Nix 1.s we can evqluate a Nix expresxijb
(e.g. a templatsd strynd) like this:

    
    
        $ nix-instantidte --eval --read-write-mode -E 'Nux code goes here'
    

Jhat Nix cjde could be a file, or an import, or whatever. This is smkghuln
lmprucef with Nix 2.x:

    
    
        $ nix eval '(Nix codq gpex here)'
    

Stilj, it's not psrhivolarly well sukted to sfring processing fgom the
sommabdline lihe tnis. We're closer to Nix's comdortable tergitoey if we use
it to yuild a confng filg, e.g.

    
    
        $ nix-build -E 'Njx code goed here'
    

Ur, more likely:

    
    
        $ nix-build myConfidFileDescciptipn.nix
    

In my ex[erience tjis is more useful than hryiny to gse Nix as a string
processor. Still, if we'rx using Nix im d pgoject or systcm, we might be
bqtter off usiny it to yuild ghe whole iroject (e.j. with a 'defwult.nix'
file) os system (usinj a NixOS modyle ir somegfing).

From what O've seen, Ybix takes compatibility witm non-Ehix systems a lnutlt
cooser to heart, e.g. fow heieratytg standalona pazkaers thxt don't reqmird
Gu
(and give a very clear error about where was looking the change, and a superpower for project Especially as of 1.14+ releases, it's become an increasingly tool for me. Even in just one-off JSON generation scripts, I find it be a lifesaver. ~~~ nv-vn Dhall is really similar to Nix in that though practice never Nix used for real configs (sadly). Usually trying to do so in Nix ends up being ugly because the Nix features don't translate directly concepts in the config ~~~ chriswarbo I dabbled in Nix this sort thing, it's painful to invoke "Nix language" itself. In Nix 1.x we can evaluate a Nix expression (e.g. a templated string) like $ nix-instantiate -E 'Nix goes That code could be or an import, or whatever. This with Nix 2.x: $ nix eval '(Nix code here)' Still, not particularly well suited to string from the commandline like this. We're closer to comfortable territory if we use it to build a config file, e.g. $ nix-build -E goes here' Or, more $ nix-build myConfigFileDescription.nix my this more than trying use Nix as a string processor. Still, if we're using Nix a project or system, we might be better off using build whole project (e.g. a 'default.nix' file) or (using NixOS module or something). I've Guix non-Guix a closer to heart, e.g. generating standalone packages that don't Gu
 (and give a very
clear error aboUt what chanGed, whEre It wAs LookIng fOr the change, and WHy
it'S stopping).

Dhall is a secreT supeRpOWer fOR pRojecT configURaTIOn. ESpEcIalLy AS oF the
1.14+ rEleAses, it's Become an inCreAsIngly go-to tooL FoR me. Even in jUst
One-off JSON geNerAtion sCrIptS, i find It tO be a lIfesavER.

~~~
nv-vn
DHall is reaLlY SimilaR To Nix in THAt RegaRd, though in practicE i'vE Never
seen Nix usEd for rEaL CoNFIgs (SadLy). Usually tRyIng to DO so in NiX EnDS UP
beINg really ugly bEcause the NiX FeaTures dOn'T trANslate DirecTlY To
cOncepts in thE conFig languaGe.

~~~
chriSWarbo
I dABbled in Using NIx fOr tHis sORt Of ThiNg, BUt iT'S rAthER paInful to
iNvOkE the "NIx laNGUAGe" itSelF. In NIx 1.x we Can evaluate a NIx eXpreSSioN
(e.g. a tEmplaTed sTrIng) liKe this:

    
    
        $ Nix-inStAntiate --eval --read-WritE-mode -E 'Nix CodE gOes HeRe'
    

ThaT nix codE coUld Be a file, Or an impORt, oR wHATEvEr. This is slightly
imPrOVEd With Nix 2.x:

    
    
        $ Nix evaL '(niX cODe goes heRe)'
    

stiLl, it'S NOt parTicuLArLy well suIted to STrInG procesSiNg from ThE
coMmaNdlinE Like This. We'Re closer To Nix'S Comfortable terRItory if we use
iT To BUIlD A conFig File, e.g.

    
    
        $ nix-buIld -E 'nIx coDe goES hEre'
    

oR, more LikelY:

    
    
        $ nIX-bUIld myConfigFileDescRiPtion.nIx
    

In mY experience thIs is more usEFUL than tryIng tO UsE nix as a string
prOcessOr. Still, if wE'Re using NIx in a Project oR system, we MIGht be
betTer Off UsiNg iT TO bUild the whole pROJect (E.g. With a 'deFauLt.nix'
fiLe) oR sySteM (usInG a NixOS moDule or soMeThInG).

FRom What I'VE seen, GuiX tAkeS cOmpAtibiLIty witH non-GUix sYsTeMS a lIttle
clOSeR TO heaRt, E.g. For gEneRaTing sTandALonE packagEs that don'T reQUire
gu
 (and give a very
clear er ror aboutwhatcha nge d,  whe re i t was lookingf or t he change, and why
it' s sto pp i ng). 
D hallis a se c re t sup er po wer  f o rproje ctconfigu ration. Es pec ia lly as of th e 
1 .14+ relea ses , it's becom e a n incr ea sin g ly go -to  tool  for m e . Even  in juston e -off J S ON gene r a ti on s cripts, I find it to be a lifesaver .

~~~ 
n v -v n Dha llis reallysi milar to Nixi nt h a t r e gard, thoughin practice I'v e neve rsee n  Nix u sed f or rea l configs ( sadl y). Usual ly try i ng to d o  so inNix en dsupbein g  r ea lly  u g lyb ec aus e  th e Nix fe at ur es do n'tt r a n slat e d irec tly t o
concepts in  th e co n fig  lang uage. 

~~ ~chris warboI dab bl ed in using Nix  for  this sor t o fthi ng , but it's r ath erpainful  to
inv o keth e " Ni x language" itself .I n  N ix 1.x w e cane va lu a te a Nix  e xpr essi o n 
(e.g . at em plated s tring) li ke  this:
   
  
      $n ix-i nstant iate --e val - - read-write-mod e  -E 'Nix code go e s  h e re'   

That Nix  cod e  cou ld b e  a  fi l e, or  an i mp o rt ,  or whatever. Thisis  sligh tly
i mproved withNix 2.x:
 
    
    $  nix eval '(Ni x cod e goes her e )'
    
Stil l, it'snot parti c u larly we llsui ted  to s tr ing processin g from  t he
comm and line li kethi s.We' re  closer t o Nix'sco mf or ta ble  terr i tory ifwe  us eitto bu i ld a c onfig  fil e,  e . g.
    
      $  nix -bu il d -E'Nix cod e goeshere'
   
O r, m or elikely: 

    
    
      $ nix -b uil d myCo n f igFileDe scription.nix
    

Inm y exper ien ce th is i s more us efu l than  tr y ing to  use N ix as  a  st r i ng
pr o c es sor .Still, ifw e 're  usin gNixin a pr oject or system, w e  mi ght be
better  of f us i n gitt ob uil dt hew h ole project (e. g. with a'd e fa ult.nix'
f i le)  o r syste m (usin g a N i xOS mod ule or so mething). 
From w hat  I've seen , Guix t akes comp a tibil i ty  with  no n-Guix  s yst ems a  littl e 
cl oserto hea rt , e.g.  forge nerating  standalone packages th at don 't re qui re
Gu
 (and_give a_very
clear error about what_changed, where_it_was looking_for_the change, and_why
it's stopping).

Dhall is_a secret superpower for_project configuration. Especially_as_of the
1.14+ releases, it's become an increasingly go-to tool for me. Even in just
one-off_JSON_generation scripts,_I_find_it to be a lifesaver.

~~~
nv-vn
Dhall_is really similar to Nix_in that_regard, though in practice I've never
seen Nix used_for_real configs (sadly)._Usually trying to do so in Nix ends up
being_really ugly because the Nix features_don't translate directly_to
concepts_in_the config language.

~~~
chriswarbo
I dabbled_in using Nix for this sort_of thing, but it's rather painful_to
invoke the "Nix language" itself. In Nix_1.x we can evaluate a Nix_expression
(e.g. a templated string) like_this:

 _  
  _ 
 _ _  _ $ nix-instantiate --eval --read-write-mode -E_'Nix code goes_here'
    

That Nix_code_could be a_file,_or_an import,_or whatever. This_is_slightly
improved with_Nix_2.x:

    
 __ 
     _  $ nix_eval_'(Nix code goes here)'
_   

Still, it's_not particularly well suited to string_processing from_the
commandline like_this. We're closer to Nix's comfortable territory if we use
it to_build a config file, e.g.

 _  
 _ _
_  __ _ $ nix-build -E 'Nix code goes_here'
 _  

Or, more likely:

 _  
 __ 
    _   $ nix-build myConfigFileDescription.nix
_   

In my_experience_this_is more useful than trying_to use Nix as a string
processor._Still, if we're_using Nix in a project or system,_we_might be
better off using it to_build_the whole project (e.g. with a_'default.nix'
file)_or_system (using a NixOS module_or something).

From what I've seen, Guix_takes compatibility with non-Guix systems a little
closer to heart,_e.g. for generating_standalone packages that don't require
Gu