jgrasser has quit [(Remote host closed the connection)]
copumpkin has quit [(Quit: My MacBook Pro has gone to sleep. ZZZzzz…)]
jgrasser has joined #nixos
eacameron has quit [(Remote host closed the connection)]
mkoenig has quit [(Ping timeout: 255 seconds)]
mkoenig has joined #nixos
jgrasser has quit [(Quit: No Ping reply in 180 seconds.)]
bennofs has quit [(Ping timeout: 245 seconds)]
eacameron has joined #nixos
mzarella has quit [(Ping timeout: 255 seconds)]
thc202 has quit [(Ping timeout: 240 seconds)]
t7 has quit [(Remote host closed the connection)]
mudri has quit [(Quit: WeeChat 1.6)]
athan has quit [(Quit: Lost terminal)]
obadz has quit [(Ping timeout: 240 seconds)]
obadz has joined #nixos
mzarella has joined #nixos
<NixOS_GitHub>
[nixpkgs] ttuegel closed pull request #22404: jsoncpp: update and drop old version (master...jsoncpp) https://git.io/vDGp9
[0x4A6F]_ has quit [(Ping timeout: 260 seconds)]
mkoenig has quit [(Remote host closed the connection)]
mkoenig has joined #nixos
derjohn_mob has quit [(Ping timeout: 258 seconds)]
<benley>
Is there some special trick to making xdg Desktop Entry *.desktop files actually work when installed by a nix derivation?
<benley>
I've got what I am pretty sure are valid *.desktop files landing in ~/.nix-profile/share/applications/ and they are just not showing up in the kde apps menu no matter what I try
<benley>
but the other items in that applications directory _do_ show up as they should
<benley>
I had already tried running kbuildsycoca5, but I also needed to rm ~/.cache/ksycoa5_en_*
<benley>
(and then run kbuildsycoca5 again)
xwvvvvwx has quit [(Ping timeout: 264 seconds)]
<NixOS_GitHub>
[nixpkgs] benley opened pull request #22453: vim: Create xdg apps/icons dirs so .desktop items get installed (master...vim-desktop) https://git.io/vDcK0
<taktoa>
anyone know what happened to goPackages?
takifugu[m] has joined #nixos
takifugu[m] has left #nixos []
nhooyr has joined #nixos
systemfault has quit [(Quit: Bye!)]
fiddlerwoaroof has quit [(Read error: Connection reset by peer)]
<mog>
im trying to use wine on nixos, the program im running makes use of libgl. it crashes instantly. "libGL error: unable to load driver: i965_dri.so"
<mog>
cant seem to find libgl
mbrgm has quit [(Ping timeout: 240 seconds)]
mbrgm has joined #nixos
<Unode>
hi all. I've been going through the manual trying to figure out the syntax without luck so far. I'm trying to figure out how to set (for instance) mediaSupport = true in a package that defines http://dpaste.com/2VTV7V1
<Unode>
could someone point me in the right direction? Thanks
dramforever has joined #nixos
<NixOS_GitHub>
[nixpkgs] taku0 opened pull request #22455: nixos-generate-config.pl, all-hardware.nix: Add support for Hyper-V (master...hyper-v_installation) https://git.io/vDc6M
<paperd>
Is there someplace to request packages for inclusion?
ertes has joined #nixos
<nhooyr>
paperd: make an issue on nixpkgs or just package it yourself and make a PR on nixpkgs
ertes has quit [(Client Quit)]
MP2E has quit [(Quit: one more reboot)]
ertes has joined #nixos
MP2E has joined #nixos
<paperd>
thanks
osxi has joined #nixos
<osxi>
I'm trying to override emacs to emacs25 for exwm. I found how to use `packageOverrides` in nixpkgs.config but I don't see how to do that for window managers
<osxi>
Is there a simple way to override emacs in configuration.nix?
mizu_no_oto has quit [(Quit: Computer has gone to sleep.)]
<paperd>
is exwm even packaged?
<osxi>
Yep
ebzzry has quit [(Ping timeout: 258 seconds)]
<osxi>
setting `services.emacs.package = pkgs.emacs25` does it actually
phant0mas has quit [(Remote host closed the connection)]
mudri has quit [(Ping timeout: 240 seconds)]
volhovm has quit [(Ping timeout: 276 seconds)]
<NixOS_GitHub>
[nixpkgs] vcunat pushed 1 new commit to staging: https://git.io/vDCea
<NixOS_GitHub>
nixpkgs/staging 6d2c381 Vladimír Čunát: libssh: bugfix 0.7.3 -> 0.7.4
mkoenig has quit [(Ping timeout: 240 seconds)]
mkoenig has joined #nixos
<Jackneill>
are there active plans to make nixos grandma/general citizen friendly?
<Jackneill>
like GUI frontend for nix? like ubuntu has for apt
vagrant- has quit [(Ping timeout: 276 seconds)]
jgertm has quit [(Ping timeout: 255 seconds)]
nh2_ has quit [(Ping timeout: 258 seconds)]
sigmundv has joined #nixos
vagrant- has joined #nixos
dvim has joined #nixos
<hodapp>
okay, I just copied "nix-env --set-flag priority 5 binutils" right out of the nix-env manpage and it fails
<hodapp>
"error: selector ‘binutils’ matches no derivations"
<Acou_Bass>
Jackneill: im not a nix dev or anything, but id imagine the answer is something like 'if you feel like making one go ahead, but we arent interested' :P (though i think itd be cool to see a packagekit backend for it)
<Jackneill>
packagekit?
<Acou_Bass>
yeah packagekit is sort of a thing that sits on top of your distros package manager and provides a unified frontend... gnome-software is packagekit-based, as is KDE Apper
<Acou_Bass>
so gnome-software will run on any distro that has a packagekit backend for its package manager
<Jackneill>
i see
kier has joined #nixos
xwvvvvwx has joined #nixos
<Acou_Bass>
so... if you made a packagekit module for the nix package manager you could run gnome-softweare or KDE apper or whatever other packagekit GUIs exist
<Jackneill>
i see, thanks
<MichaelRaskin>
I think there is some work in progress about PackageKit backend
<MichaelRaskin>
# TODO: set enableNixBackend to true, as soon as it builds
<MichaelRaskin>
(that's from PackageKit expression in NixPkgs)
<hodapp>
what can tell me why something is hanging around in /nix/store when I can't see any packages in 'nix-env -q' that should require it, and I've run nix-collect-garbage?
<hodapp>
my concern is that a stupid build is finding an incorrect version of a library
<Acou_Bass>
id be quite interested to see a GUI for the nixos configuration too (i guess it could be used both on the installer CD and for doing rebuild switches when you wanna change stuff)
<Acou_Bass>
though i suppose having ALL the options would be a nightmare
<MichaelRaskin>
Well, the tree can be folded and have search
<Acou_Bass>
theres the 'options' search on the website, but doesnt really explain fully how to use those options, whereas a GUI would have to 'know' how to use them
<MichaelRaskin>
Well, you need to allow raw-nix-overrides anyway
<MichaelRaskin>
Allowing arbitrary strings for type string and arbitrary integers for type int may be suboptimal but still a step forward
<MichaelRaskin>
For type package you could ask the PackageKit
ThatDocsLady has joined #nixos
ThatDocsLady has quit [(Ping timeout: 260 seconds)]
alibabzo has joined #nixos
<hodapp>
this build is making my brain hurt.... it is an OpenCV wrapper library, yet the build never seems to find its way to an actual OpenCV library (and never complains about it, nor logs anything), and the final product when examined with 'ldd' never links to anything even remotely related to OpenCV
<xwvvvvwx>
Hi :)
<hodapp>
so I'm trying to figure out if it's somehow building with OpenCV 3.1.0 (which is someplace on my system) despite me running in nix-shell --pure with a shell.nix that is using only OpenCV 3.2
<xwvvvvwx>
So I would like to include the catch unit testing library into a c++ project I am working on
<xwvvvvwx>
I add it to the buildInputs in default.nix
<xwvvvvwx>
and then I don't quite know what do to next
<xwvvvvwx>
how do I tell cmake where to find the headers?
<xwvvvvwx>
or do I just build with nix-build?
dramforever has quit [(Read error: Connection reset by peer)]
mkoenig has quit [(Ping timeout: 260 seconds)]
rmeis has joined #nixos
mkoenig has joined #nixos
faffolter has quit [(Ping timeout: 240 seconds)]
faffolter has joined #nixos
faffolter has quit [(Changing host)]
faffolter has joined #nixos
rmeis has quit [(Ping timeout: 260 seconds)]
dramforever has joined #nixos
taktoa has quit [(Ping timeout: 248 seconds)]
phant0mas has joined #nixos
faffolter has quit [(Ping timeout: 240 seconds)]
gsora has quit [(Quit: uh-oh!)]
taktoa has joined #nixos
gsora_ has joined #nixos
<NixOS_GitHub>
[nixpkgs] vcunat pushed 2 new commits to master: https://git.io/vDCTm
<NixOS_GitHub>
[nixpkgs] vcunat pushed 4 new commits to staging: https://git.io/vDCTa
<NixOS_GitHub>
nixpkgs/staging 35dffbd Vladimír Čunát: mesa: maintenance 13.0.3 -> 13.0.4
<NixOS_GitHub>
nixpkgs/staging 5ced6c7 Vladimír Čunát: libdrm: 2.4.74 -> 2.4.75
<NixOS_GitHub>
nixpkgs/staging 768d445 Vladimír Čunát: gdk-pixbuf: maintenance 2.36.3 -> 2.36.4
<Acou_Bass>
does anyone have an example nixpkg for a program using some python packages + PyGObject? im hoping to make a package but not 100% sure how to start with this particular program XD
<Acou_Bass>
their instructions for 'normal' distros is just 'python2 setuptools build' and 'python2 setuptools install'
<Acou_Bass>
so not sure how to replicate that in nix
bennofs has joined #nixos
VisualizeR has joined #nixos
sigmundv has quit [(Ping timeout: 240 seconds)]
Shou has joined #nixos
simendsjo has quit [(Remote host closed the connection)]
<ablubla>
Hi. I am new to nix (using it on arch) and I want to customize the st build by provding a config. Here is my config.nix: https://paste.xinu.at/icuMi5/nixos However st is not built with my variables. How can I debug this?
nckx has quit [(Remote host closed the connection)]
mkoenig has quit [(Read error: Connection reset by peer)]
<yorick>
ablubla: you can override that with pkgs.st.override {conf = ./strc;}
<mbrgm>
is someone familiar with nix cross compilation (u-boot would be a start)? I tried to gain some knowledge on this topic, but the documentation is pretty sparse and I'm not too familiar with all of the implementation details. are there some projects using the cross compilation options, so I could take a look at how it works?
<taktoa>
mbrgm: wait until clever wakes up, he knows a lot about nix cross-compilation
<mbrgm>
taktoa: which timezone is he in?
<taktoa>
he "sleeps when you least expect it" :) but atlantic standard time
<taktoa>
you'll know when he's awake (he is on here a lot)
<taktoa>
mbrgm
gui_ has joined #nixos
<gui_>
Hey guys. I'm creating a docker image with dockerTools.buildImage. When I add clang in the contents the image is almost 1Gb. How can I trim that ?
nh2_ has quit [(Ping timeout: 264 seconds)]
sigmundv has joined #nixos
<mbrgm>
taktoa: ty
<taktoa>
np
mkoenig has quit [(Read error: Connection reset by peer)]
nh2_ has joined #nixos
gui__ has joined #nixos
gui_ has quit [(Ping timeout: 260 seconds)]
mkoenig has joined #nixos
layus has joined #nixos
mlieberman85 has joined #nixos
<ertes>
a friend of mine is trying to install nix on gentoo, but is getting errors about shared libraries (libX11.so) during nix installation… background: she has tried to install it before, but deleted everything again (/nix, ~/.nix-defexpr, ~/.nix-profile)
<drakonis>
when's nix's turn to cannibalize other distros :V?
<simpson>
drakonis: What do you mean?
<drakonis>
i mean that when is nix going to have a surge in users
<drakonis>
a bigger surge akin to the other "make/tweak your own distro"
<drakonis>
distros
<taktoa>
I think it's already starting
<simpson>
Don't worry about it.
<drakonis>
i want to get more packages :v
<drakonis>
even more, even faster :v
<simpson>
drakonis: Which packages do you want? Have you considered packaging them yourself?
<drakonis>
i have
<drakonis>
but the current way to do testing is a little messy
<simpson>
How so?
mudri has joined #nixos
joneshf-laptop has joined #nixos
<drakonis>
no, maybe its me
<tnks>
okay, I think the `haskdogs` project may be fine... just tried it from a nix-shell.
nh2_ has joined #nixos
JagaJaga has quit [(Ping timeout: 240 seconds)]
jensens has joined #nixos
estewei has joined #nixos
<ablubla>
drakonis: I don't think nix will cannibalize other distros. While I really like nix and I am using nixos as a hypervisor for about 6 month now, I love to use alpine on my VMs. And my laptop is still running arch linux, though I may want to change that in favor of a distribution where openrc is a first class citizen. In nix I see the chance to get what bsd
<ablubla>
folks are getting with the ports tree: A base system to build upon (arch) with plenty of packages (nix). My software selection is portable, while I can use the base system to get the best out of the hardware it is running on.
Itkovian has joined #nixos
<taktoa>
ablubla: well, I don't see any reason why nixos would get any _less_ out of the hardware it is running on
<taktoa>
oh, you're referring to systemd
agjacome has joined #nixos
mudri has quit [(Ping timeout: 240 seconds)]
<taktoa>
while nixos does use systemd, it isn't *that* tied into the system. I would put the cost of getting nixos to work on arbitrary init systems at a few tens of thousands of dollars worth of developer time
<simpson>
taktoa: That is a nice dream but it will take engineer-years, not engineer-weeks, to do this.
<ablubla>
taktoa: nixos has a lot of maintenance (besides me favoring openrc over systemd). I need to keep track of old profiles, collect garbage etc. I am fine with automating cleanups for things like firefox or my wm, but not for my kernel and bootloader.
<taktoa>
(by "getting nixos to work" I'm including all the work to port nixos modules to something less systemd-specific)
m-i has quit [(Remote host closed the connection)]
<simpson>
taktoa: I grok that. I think that you're misunderestimating the amount of work required.
m-i has joined #nixos
gui__ has quit [(Ping timeout: 260 seconds)]
<NixOS_GitHub>
[nixpkgs] pSub pushed 1 new commit to master: https://git.io/vDCsn
<NixOS_GitHub>
nixpkgs/master 8012ead Joachim F: Merge pull request #22447 from rnhmjoj/fish...
<simpson>
ablubla: I guess? GC can and should be automatic; when you run a Java program, do you complain that you have to pause it every minute and manually run the GC?
edvorg has quit [(Ping timeout: 240 seconds)]
<taktoa>
and the tool only has to support the systemd features used in 95% of nixos modules (i.e.: very few of them); the rest can probably be manually coerced into a form suitable for openrc
Itkovian_ has joined #nixos
Itkovian has quit [(Ping timeout: 248 seconds)]
<simpson>
taktoa: Why is OpenRC the Right Direction, and not some other init system?
<taktoa>
anyway I think that's mostly a waste of time because the init system is *far* from the bottleneck on system performance on desktops laptops and servers
<taktoa>
simpson: ^
<taktoa>
I don't think openrc is good
<taktoa>
I like systemd
<drakonis>
simpson, that's ablubla you want to ask
<simpson>
drakonis: I am being slightly facetious; I'm a longtime Gentoo user.
<drakonis>
heh
<drakonis>
i see
<taktoa>
lol
<MichaelRaskin>
My experience with not having an init system at all is better than with systemd
<simpson>
MichaelRaskin: I agree, and as soon as it's ready, we'll have a boot-to-Monte system.
<simpson>
No init, just Monte.
<taktoa>
what's monte
<MichaelRaskin>
Well, in my case it is worse than that: just a bootscript and daemon-launcher scripts from NixOS
<taktoa>
also kdbus (err, libbus1) will fix most of the performance issues of systemd on embedded systems
<MichaelRaskin>
Still better than systemd (I sometimes launch a second X session)
JagaJaga has joined #nixos
<taktoa>
simpson: "a dynamic language inspired by Python and E" does not give me much confidence in the quality of this software, but I will take a look ;^)
<drakonis>
it suggests you to use nix instead of docker :v
<simpson>
taktoa: Please, tell me what you think is low-quality about Monte.
<taktoa>
I haven't looked into it, but I will. Just stating my prior probability distribution based on the first sentence of readthedocs.
<simpson>
Monte is E with several syntactic improvements from Python. You should judge it based on E.
<taktoa>
the only E I had previously heard of was a formal verification tool; looking it up now it seems to be a secure object-capability language. Capability-oriented security seems like a good idea to me, while objects (like those of Java) are not, but "object" is such an overloaded term that it's entirely possible that they mean something completely different
nh2_1 has quit [(Ping timeout: 255 seconds)]
<taktoa>
like, it wouldn't surprise me if E objects were more like Erlang-style processes
<simpson>
By "object" in "object-based capability" *and* "object-based language" we mean the same concept: A value which has a uniform calling interface and encapsulates a bundle of state and behavior.
vagrant- has quit [(Ping timeout: 276 seconds)]
<simpson>
E and Monte contribute *perfect encapsulation* to objects; you cannot violate the closure of an object in these languages without some sort of primitive unsafe power (e.g. a memory debugger).
<alibabzo>
Hi all, I was wondering if anyone has a working mopidy setup with mopidy-youtube
<simpson>
taktoa: BTW it is super-cool that you've heard of object-capability theory; it's sadly still on the fringe for most security folks.
<alibabzo>
At the moment the log seems to spew all sorts of stuff about gstreamer and not being able to find an Opus decoder, which seems to suggest it can't find a dependency.
<taktoa>
well I'm the kind of security person who is going to work at a haskell/nixos security startup, so I wouldn't be too surprised :)
<taktoa>
simpson: anyway, does the aforementioned encapsulation come at an unneeded runtime cost? i.e.: could the same thing be achieved with static analysis or a type system?
cutuchiqueno has joined #nixos
<cutuchiqueno>
I am looking for a way to get the log of the last `nixos-rebuild switch` but could not find anything in manual or manpages of nixos-rebuild, nix-store or nix-env or in /var/log
<simpson>
taktoa: It is a zero-cost feature; the design of objects mandates it.
<taktoa>
or to the research in substructural type systems (e.g.: Rust, Pony, Frank Pfenning's paper on Polarized Substructural Type Systems)?
<taktoa>
session types are a pretty popular approach to this problem domain lately
stepcut has quit [()]
<simpson>
taktoa: Pony's type-driven approach is pretty hot right now. Monte takes the safety of the memory model for granted, and focuses more on being an object calculus.
<simpson>
taktoa: Monte has something that this avenue of static research usually omits: Monte, like E, can generate runtime proofs of correctness. You can assemble object designs and audit their correctness live, on the fly.
<taktoa>
I see. I would call that a runtime cost, but in some ways it's probably an advantage
<simpson>
We can, and do, statically discharge auditors in the runtime. (I'm actually elbow-deep in that code right now.)
<simpson>
It's only a runtime cost if you build an object that can't possibly have been shown statically correct; e.g. you dynamically chose which auditors to apply.
<taktoa>
ah, so then it's similar to the approach of a lot of dependently-typed languages these days (whenever it's impossible to claim some property of a runtime value, i.e.: because it's user input, a runtime check is inserted to account for it)
<taktoa>
*statically claim
<simpson>
Sure. Or Ada; it's an old idea and we're not trying to be novel.
<taktoa>
yeah
stepcut has joined #nixos
<NixOS_GitHub>
[nixpkgs] peti closed pull request #22427: haskellPackages.callCabal2nix: provide fallback name (master...fix-callCabal2nix) https://git.io/vDn9L
<taktoa>
simpson: well, it seems like a good effort on the margin (i.e.: it's definitely a better tool than most things in use today), though I would probably not use it myself unless it turns out to have an overwhelmingly good ecosystem or toolchain
drakonis has quit [(Remote host closed the connection)]
<simpson>
taktoa: Yeah, we know; that's why we're spending so much time on tooling.
<simpson>
And honestly I don't care whether people use Monte. I care whether people listen to our ideas and consider adopting capability-safe systems.
<simpson>
Like, if nobody uses Monte, but people hear me talking and then they adopt Capn Proto, then that's a win.
<taktoa>
well I'm definitely on board with that
MP2E has joined #nixos
<simpson>
Or Tahoe-LAFS or Capsicum or even just baby steps like tame()/pledge(). Every step towards cap-safe environments is a step away from vulnerable ways of life.
drakonis has joined #nixos
mkoenig_ has joined #nixos
<simpson>
Or Tahoe-LAFS or Capsicum or even just baby steps like tame()/pledge(). Every step towards cap-safe environments is a step away from vulnerable ways of life.
<simpson>
Dammit SSH.
<taktoa>
simpson: tame() --- you just reminded me that I recently had a bunch of thoughts about making it easy to drop privileges in Haskell (i.e.: a custom monad that encodes what privileges you use at the type level and then drops everything but those at the earliest possible point)
<taktoa>
I think an approach like that could be pretty popular if type inference makes it easy
<taktoa>
*if the type errors are not hard to read
mkoenig has quit [(Ping timeout: 245 seconds)]
<taktoa>
I think it would be an "indexed state monad" (or maybe a "parameterized state monad"?)
<simpson>
taktoa: So, the Expression Problem has ended up biting here; I *think* (but haven't proved) that there's no way to bring k distinct unsafe capabilities across an unsafe call barrier (e.g. a program entrypoint) without at least O(k) annotations in code.
<taktoa>
I mean, it really depends on how fine-grained your privilege system is. If "accessing /bin/foo" is a privilege, then you need dependent types (or at least a lot of type-level computation), but if "accessing the filesystem" is the privilege, you can probably do it in System Fc.
Itkovian has joined #nixos
<taktoa>
the "monad" looks like `pure :: a → m ε a`and `join :: (m x (m y a)) → m (x ⊕ y) a`
<taktoa>
where ε and ⊕ form a monoid over some kind of unordered type-level set structure
<simpson>
Yeah, the cool thing about Monte is that *no* type system means that we can make *arbitrarily-rich* type systems. We have two hooks (guard and auditor) where you can provide Turing-complete tests of object behavior.
Itkovian_ has quit [(Ping timeout: 258 seconds)]
<taktoa>
but those happen at runtime, no? so they're basically just assertions
<simpson>
I like to joke that Monte is dependently typed because this signature is legal: def nonZeroSubtract(x :(Int >= 0), y :(Int <= x)) :(Int >= 0) { return x - y }
<taktoa>
otherwise Monte really is dependently typed
<taktoa>
or maybe just refinement-typed; do you use an SMT solver to discharge proof obligations?
nh2_ has joined #nixos
<simpson>
Well, that's the thing. It's implementation-dependent whether an optimizer can make it a static proof.
<taktoa>
okay, suppose we're talking about Monte-the-implementation rather than Monte-the-language
<simpson>
So it's dependently-typed in practice; our JIT generally can see through these sorts of integer arrangements. But the code will still run fine on a non-optimizing interpreter.
<simpson>
So in theory, no type system. Boring, right?
<taktoa>
yes :^)
Itkovian has quit [(Ping timeout: 240 seconds)]
Itkovian has joined #nixos
<taktoa>
simpson: I mean, the real issue with that is that the errors are not guaranteed to happen statically, they could happen at runtime
<taktoa>
and runtime errors drop you into a world of hurt vis a vis testing, coverage, etc.
<schoppenhauer>
I see no apparent reason. this travis CI thingy does not fail because of my package.
<simpson>
taktoa: Our position is that runtime errors are *inevitable* and thus systems should have some sort of way to deal with them.
<taktoa>
simpson: of course, but that claim is very different from "we should not make any guarantees about what classes of errors are statically checkable"
<taktoa>
(which is what a type system is)
Itkovian_ has joined #nixos
<simpson>
taktoa: A type system merely needs to be syntactic and capable of rejecting programs that don't have a desired property. Static scopes, for example, form a simple type system that nonetheless some languages, like Python and Ruby, don't have.
<schoppenhauer>
it would be nice to know what the problem is.
<Ralith>
hurray for object-capability stuff
<Ralith>
less hurray for no type system
<simpson>
Ralith: Suggestions welcome. We couldn't find a way to add simple gradual typing without running into well-trodden terribleness.
<taktoa>
simpson: every programming language can be implemented in terms of rewriting logic, which is completely syntax-directed (IIRC), so I don't see why making a distinction between syntax and semantics is germane here
<NixOS_GitHub>
[nixpkgs] 7c6f434c closed pull request #22146: gbsplay: init at version 2016-12-17 (master...gbsplay) https://git.io/vMpDl
<Ralith>
simpson: I haven't really studied gradual typing intensively, but I wrote half of a capnp serializer in typed racket and their gradual typing was pleasant
<simpson>
taktoa: Just quoting Benjamin Pierce: "A type system is a syntactic method for enforcing levels of abstraction in programs."
<taktoa>
simpson: I'm not disagreeing, I'm claiming that "syntacticness" is epiphenomenal here
<simpson>
Ralith: We have to tackle the hard problems immediately, like subtype variance, since List[Int] is a legal guard.
<taktoa>
why would you have subtyping
Itkovian has quit [(Ping timeout: 240 seconds)]
moet has joined #nixos
<moet>
hello nixos
<taktoa>
(well, subtyping in the constrained polymorphism sense is fine, but otherwise it sucks)
<simpson>
taktoa: Because we inherited E's guards. The guard `List` can be specialized to `List[Int]` or `List[List[Char]]` or etc. and presumably people would want a gradual type checker to support that.
<moet>
if i go to the nixos website and launch an AMI on AWS, how do i then login? (i didn't use nixops in the launching process!)
<simpson>
Without running into the problems that the Dart and Java folks have found.
<simpson>
moet: I suspect that you have to roll the keys into there somehow.
<simpson>
moet: I don't know the EC2 command line tools at all, but perhaps https://nixos.org/wiki/NixOS_on_Amazon_EC2 has some useful hints? It appears to have SSH-key-related commands.
<Ralith>
simpson: I'm sure you've thought about your problems more than I have, I just only really value type systems for the static guarantees they give me, and it sounds like this one doesn't give any.
jensens has quit [(Ping timeout: 255 seconds)]
<taktoa>
simpson: Here's what I would suggest: give the end user a mode where, if the Monte compiler has to insert a runtime check for some property, it instead gives an error "We couldn't prove this!". Then, add a mode that uses an SMT solver to try to prove those really tough things.
<simpson>
Ralith: Really, we still have an error for stuff like m`def x :Int := "totally not an int"`. It's just that the error is presented by a linter and not by the compiler.
<Ralith>
comparing it to dependent typing seems misleading; dependently typed languages don't insert dynamic checks wherever static checks can't work, they simply fail to typecheck if you haven't statically proven correctness, and sometimes that requires you to write runtime code
<simpson>
Ralith: I gave Ada as an example of a language with a powerful type system which *does* do runtime checks for things it can't statically enforce. I don't know whether Ada meets the bar of dependent types.
<Ralith>
I don't know Ada but I strongly doubt it does, considering how old it is
<taktoa>
Ralith: yeah, I was referring to the thing in dependent types where you say "trust me, type system" and then the runtime inserts a dynamic check Just In Case™.
<taktoa>
*the compiler, not the runtime
<Ralith>
taktoa: you mean unsafe coercions or something?
<taktoa>
yeah exactly
<simpson>
taktoa: I'm not sure what use an SMT solver would have. We don't have an upper bound on complexity; it's legal to craft `def x :IsPrime := 5` or `def y :RefutesTheRiemannHypothesis` if you're sufficiently wild.
<Ralith>
simpson: "there exists an external tool which can catch the most trivial of mistakes" isn't super reassuring :P
<taktoa>
simpson: in cases where the SMT solver does not terminate in time, give a different error
<taktoa>
SMT solvers are *really* good at proving these kinds of theorems
<simpson>
taktoa: This sounds like an interesting addition to the language, but it sounds incredibly complex. I'm going to have to think about this.
<simpson>
Ralith: It's my opinion that The Filesystem and The Network present possibilities for behavior which *no* static type system can adequately prepare for. So I try my best to not worry about it.
<Ralith>
simpson: on the contrary, "the filesystem screwed up" and "the network screwed up" are both well-defined and isolated error classes :P
<taktoa>
I'm actually working on something in this milieu for a graduate project for one of my classes
agjacome has quit [(Quit: leaving)]
<taktoa>
implementing row polymorphism through refinement types
<simpson>
Ralith: No, I mean that the type erasure of The Filesystem presents an ultimate barrier to statically capturing what a file can self-express. Part of the type of the file can be embedded within the file itself.
<simpson>
(And that's not including what The Network can do with adaptive queries!)
<Ralith>
I'm not really sure what your point is
<Ralith>
knowing that some function f can never encounter errors arising from accessing the filesystem or doing some sort of deserialization or whatever is useful
<simpson>
I know, I've been trying to find a way to express this point for a while.
<Ralith>
a type system at its best is documentation that's guaranteed to be accurate, and there's no world in which that's not a good thing
<taktoa>
type systems also really improve expressiveness of the language
<simpson>
So, what I mean is that GHC can type-check your program, but it can't type-check your program *plus* the layout of a file.
<taktoa>
of course, but !perfect is not the same as bad or worthless
t7 has quit [(Remote host closed the connection)]
mlieberman85 has quit [(Quit: My MacBook has gone to sleep. ZZZzzz…)]
<simpson>
I don't believe that I have said "bad" or "worthless" or anything about static type systems in that vein. We just don't have one.
<taktoa>
yes, sorry
mlieberman85 has joined #nixos
mlieberman85 has quit [(Client Quit)]
<simpson>
It's cool. This is why I'm not in #haskell; my opinion is that Haskell is Just Another Programming Language, and that's not very compatible with their worldview.
mlieberman85 has joined #nixos
mlieberman85 has quit [(Client Quit)]
<taktoa>
I mean, if haskell didn't exist I'd be using ML or something. I have no love for Haskell itself other than the fact that it implements a bunch of features I like.
mlieberman85 has joined #nixos
<Ralith>
I think the point is rather that we think a static type system is overwhelmingly useful and are having trouble understanding how your points detract from that sufficiently to justify omitting one
mlieberman85 has quit [(Client Quit)]
<simpson>
It's probably the nicest language for writing compilers in, that's for sure.
mlieberman85 has joined #nixos
mlieberman85 has quit [(Client Quit)]
<Ralith>
unless of course the answer is "we want to explore these other ideas and it's not yet clear how to reconcile them with a static type system"
<peti>
simpson: A language that's purely functional and lazily evaluated is not quite "just another language". I wouldn't know many other language that chose this path.
<Ralith>
I get "sure, I suppose that's nice for writing compilers" any time I try to explain ADTs to any pure C(++) programmer :P
mlieberman85 has joined #nixos
<simpson>
Ralith: In summary, (1) nobody knows how it should work in the tough cases, (2) it's hard to enforce across the network, (3) it breaks the uniform calling interface, (4) we come from a tradition of not using static types for values.
mlieberman85 has quit [(Client Quit)]
mlieberman85 has joined #nixos
<Ralith>
simpson: at a guess, is your language trying to treat the network as transparent?
mlieberman85 has quit [(Client Quit)]
<simpson>
peti: "Purely functional" doesn't mean anything, or it means things which Haskell doesn't have. (Also I'm sure that there's at least one esolang which vacuously meets those criteria.)
moet has quit [(Ping timeout: 240 seconds)]
endformationage has quit [(Quit: WeeChat 1.6)]
<simpson>
Ralith: We do, yes. m`f.x()` happens immediately on a near object. m`f<-x()` sends a message to an object, crossing thread/process/machine/datacenter boundaries as necessary.
c0bw3b has left #nixos []
* Ralith
thinks he vaguely recalls seeing that syntax somewhere before
<taktoa>
simpson: "purely functional" = typeful separation of pure and effectful functions + closures
systemfault has joined #nixos
<taktoa>
well, it can also be by-construction rather than typeful
<taktoa>
e.g.: (a fragment of) Nix is pure just because it doesn't have any primops that do IO
<simpson>
taktoa: That is an interesting and novel definition to me; I'll have to think about that.
<Ralith>
taktoa: not just separation; even IO doesn't do anything, it just describes things for the runtime to do
<Ralith>
that's the only definition I've ever seen
<taktoa>
Ralith: yeah, that's a better way of putting it
<taktoa>
Ralith: but, as Conal Elliott pointed out, by that definition, the C preprocessor is a purely functional language
<simpson>
taktoa: Unfortunately, you've let Monte be purely functional, since Monte's I/O is always "between turns", which means that it *never* races with object mutation.
<Ralith>
taktoa: of course; it takes more than being purely functional to be useful
hotfuzz_ has joined #nixos
<taktoa>
^
<Ralith>
simpson: if it actually does I/O, it's not pure
<peti>
simpson: Actually, the term "purely functional" has a very precise definition. If you believe that it doesn't mean anything, then it seems more like you don't know what you're talking about.
<simpson>
Ralith: No Monte code can perform I/O. I/O is a side effect performed by the VM. (Are you gonna penalize the GHC runtime for doing I/O too?)
<simpson>
taktoa: Pretty easy with the new compiler interface; straightforward but lots of typing with the current compiler interface.
<Ralith>
simpson: so, the obvious (to me) way to handle unreliable network/fs/whatever in the case where you're trying to make that somewhat convenient is just have operations that statically might traverse an unreliable medium possibly yield a decoding error instead of what they otherwise might.
hotfuzz has quit [(Ping timeout: 276 seconds)]
<simpson>
taktoa: You'd implement an abstract AST interpreter, which is our favored compiler construction.
<taktoa>
simpson: well, `nix-build '<nixpkgs>' -A dotnetPackages.Boogie` is a thing now. happy hacking :)
<simpson>
Ralith: You can obviously get as good as Haskell's async library, where you keep the pending promise for the response wrapped up in a type-safe monad.
<Ralith>
simpson: I don't know monte enough to judge whether that's an accurate characterization
<Ralith>
"the runtime does it" is not a cheap copout, it's a fundamental semantics distinction
<simpson>
Ralith: We have something similar; Monte m`def rv :Vow[Int] := f<-()` will assert at runtime that the return value is eventually an Int.
<Ralith>
in Haskell, you can have [putStrLn "hello", putStrLn "world"] and pass it around and manipulate it and have neither of those strings actually be printed
<simpson>
Ralith: Okay, lemme try a birds-eye. Monte has *vats*. A vat is like a thread, but without shared memory or I/O. Vats take *turns*, where they run some Monte code by delivering messages. All I/O happens *outside* of vats.
moet has joined #nixos
<Ralith>
and that has nothing to do with lazy evaluation
<moet>
ah, my nixos crashed again :(
<Ralith>
delivering messages sounds like IO to me
<moet>
simpson: thanks for your response! i thought the wiki isn't up to date?
mkoenig_ has quit [(Remote host closed the connection)]
<taktoa>
Ralith: not if it's deterministic ala `par`
<simpson>
moet: It isn't, but it was the best thing I could find with a few search engine queries. I don't know anything about those AMIs, sorry.
<moet>
simpson: ah, no worrys :) thanks! i'll see what the wiki says.
<Ralith>
taktoa: if it can terminate in filesystem/network ops it's probably not deterministic :P
<simpson>
peti: Sorry, I didn't mean to ignore you; what *is* the definition? I feel like it's always something about mutability or purity, but just like with "OOP", I feel like it's largely used to refer to things that it doesn't mean.
<simpson>
Ralith: Delivering messages in an object-based language is pretty pure if the object can't do I/O. The analog in GHC would be calling "objects" (GHC's term, not mine!).
<simpson>
Set up some registers and jump to an address. Same thing.
<Ralith>
simpson: sure, and a fragment of a C program is pretty pure if none of the functions you call do IO
reinzelmann has joined #nixos
<simpson>
Ralith: Right. So, by *definition*, it's impossible for a Monte object to do I/O; you have to go find an object that does I/O and it always seems to do it with a delay instead of giving you immediate results.
<taktoa>
the real difference between Haskell/Nix and most languages is not being "pure", it's that the community *cares* about impurities
<simpson>
taktoa: That is very insightful!
<taktoa>
(and the language makes it easy to write pure code)
markus1199 has joined #nixos
<Ralith>
simpson: again, not sure what your point is; you might as well say it's impossible for C code to do I/O (and it's important to emphasize that purity isn't just about I/O, but side effects in general)
<taktoa>
^ and *that's* the feature that makes it easy to write pure code
<simpson>
peti: Oh, okay. That's fair.
<peti>
simpson: In short: "An expression is said to be referentially transparent if it can be replaced with its corresponding value without changing the program's behavior. As a result, evaluating a referentially transparent function gives the same value for same arguments. Such functions are called pure functions."
goibhniu has quit [(Quit: Leaving.)]
<simpson>
peti: In a correctly-implemented Monte vat, the act of taking a turn on a vat is referentially transparent; it should be possible to *replay* turns on a vat from checkpoints without any observable changes in behavior.
<simpson>
Proving this for the object calculus seems trickier and hasn't been done AFAIK.
<peti>
simpson: Not sure what this has to do with Haskell ... ?
<simpson>
peti: Sorry, by "that's fair", I meant that yes, you are correct that Haskell has referential transparency and thus would be "purely functional", and that I can fully agree with you.
<peti>
simpson: Oh, okay. That's good news. :-)
goibhniu has joined #nixos
georges-duperon has joined #nixos
wangoe has quit [(Quit: WeeChat 1.5)]
Itkovian_ has quit [(Read error: Connection reset by peer)]
<peti>
The consequence is that Haskell has rigurously defined formal semantics, which allow you to reason in rigorous mathematics about program behavior. That's quite a unique property for a general-purpose programming language, IMHO.
<Heffalump>
I don't think Haskell does have any formal semantics, actually
<taktoa>
I like to tell people that I could probably evaluate any arbitrarily large closed chunk of Haskell code with only pencil and paper
<peti>
Heffalump: Of course it does.
<taktoa>
Heffalump: well it has a semantics in terms of ω-cpos, but there is no formal executable semantics out there
<Heffalump>
well, not one that someone has written down
<peti>
Heffalump: Of course they have. What are you talking about?
<Heffalump>
peti: do you have a reference? I thought ML was well known for having a formal semantics but that Haskell doesn't have one.
<simpson>
taktoa: Whiteboard warriors unite! o/
<c74d>
Does NixOS package the "words" file (`/usr[/share]/dict/words` on other distros)?
<taktoa>
peti: I think he is contrasting the Haskell Report against, for example, the SML Language Definition, which not only has a formal semantics, but an executable implementation of that formal semantics
<peti>
taktoa: Sorry, but I don't thing I understand the difference?
<taktoa>
and that executable implementation is proven correct (wrt some axioms), so it really is a formal object
<taktoa>
the Haskell Report leaves a lot more wiggle room than the SML Language Definition
moet has quit [(Ping timeout: 256 seconds)]
<simpson>
taktoa: Do you happen to have a recommendation for formal semantics frameworks? I tried K a while ago, but it was more than a little weird, especially in the parser, and I didn't get very far.
<taktoa>
simpson: I worked on K
<peti>
taktoa: Oh, okay. Sure, that is true. Nobody prooved that GHC actually follows the report.
<taktoa>
simpson: it's a tire fire
<peti>
taktoa: that's not the same thing as saying "the language doesn't have format semantics" though.
<Heffalump>
I wouldn't call the Haskell report a formal semantics at all, it's just an English language description.
<taktoa>
peti: yeah it all comes down to what you mean by "formal"
<Heffalump>
that's much more of an informal semantics
<peti>
Heffalump: Have you read it?
<Heffalump>
not line by line, but I'm fairly familiar with it
<peti>
Heffalump: Can you point me to any concrete statement in the report which you perceive as "informal"?
<taktoa>
simpson: the only tool other than K that I've heard of in that area is Stratego/XT (IIRC), but they both seem to have some big problems. I haven't used Stratego/XT, though.
m-i has quit [(Remote host closed the connection)]
m-i has joined #nixos
<simpson>
taktoa: I looked into their stuff briefly but was very confused. You'd think that something as foundational as this would be simple, right?
<jophish>
The typing section of the haskell report can be very vague :)
<taktoa>
unfortunately for some reason all the people who work on it seem to be funded by companies that use Java
faffolter has joined #nixos
faffolter has quit [(Changing host)]
faffolter has joined #nixos
<taktoa>
K is implemented in Java, which is terrible
<taktoa>
like, me and the guy I was working with on K probably could have rewritten the whole thing in Haskell over the course of our summer working on it
<MichaelRaskin>
simpson: foundational, simple? Well, even formal arithmetics is already not simple
jensens has joined #nixos
<taktoa>
instead, we couldn't even achieve what we set out to do (refactor the experimental OCaml backend to work for SML)
<simpson>
MichaelRaskin: I mean that I can write out ZF or TNT or JSON or Smalltalk-80 or Lisp on a relatively small amount of space. I feel like that should imply that the corresponding code is relatively small too.
<MichaelRaskin>
I want to dare you to write full formal ZFC. I would have a use for result, too.
<taktoa>
MichaelRaskin: that's just because ZFC sucks. natural deduction is much better
<MichaelRaskin>
Note that there are tricks about handling the schemas
<simpson>
I don't have them all memorized. But there's only what, six rules?
<MichaelRaskin>
More like ten, and some of them are schemas
<MichaelRaskin>
Which is the real annoying problem
<Heffalump>
peti: well, it's more that there's not very much that is formal in there. Admittedly a lot of stuff is defined by translation to other things, but most of the text (apart from the formal semantics of 'case') is just an English description. Pretty much all of chapter 4 is a good example of that.
<simpson>
MichaelRaskin: I gladly defer to you; I guess that I'm just used to thinking of this problem as only as hard as the number of clauses that have to be handled.
<taktoa>
simpson: to clarify, most of my issues with K are in the implementation. the actual language is actually decent, other than some syntactic weirdness and the fact that it has subtyping (K inherited an obsession with order-sorted algebras from Maude)
<MichaelRaskin>
The problem is that formal handling explodes the number of clauses
goibhniu has quit [(Ping timeout: 248 seconds)]
<peti>
Heffalump: Okay. I suppose we have different understanding of the term "formal".
<MichaelRaskin>
taktoa: well, you can switch to higher order and become unable to reason about the things that create the most annoying problems with ZFC. Which is actually fine for programs that can be expressed as primitively recursive (most of real programs), but creates interesting risks when doing maths
<simpson>
I believe it. I've always taken it for granted that Peano/TNT do what they're supposed to do, and I haven't worked much with ZF.
<MichaelRaskin>
Well, Peano as a first-order theory has infinite number of axioms
<taktoa>
MichaelRaskin: I think I know what you are alluding to, and yeah there are some real open problems in that area; HoTT / cubical type theory are quite promising
<MichaelRaskin>
I have read the first half of The HoTT Book, and I have a bad feeling
alx741_ has joined #nixos
<MichaelRaskin>
With ZFC the problems are known and once you work around the annoyances, you have some breathing room until the real problems
<taktoa>
MichaelRaskin: I'd be interested to hear more, but I have to go afk for about 15 minutes
alx741 has quit [(Ping timeout: 245 seconds)]
<MichaelRaskin>
Ah OK
goibhniu has joined #nixos
<jophish>
NIX_BUILD_HOOK is being passed four arguments "x86_64-darwin 0 0 0" What's the fourth argument
<jophish>
I thought it was current-system, build timeout and max silent time
<jophish>
the source for build-remote.cc and build-remote.pl seem to expect three arguments
<NixOS_GitHub>
[nixpkgs] peti opened pull request #22469: callCabal2nix: take "name" parameter as a function argument (master...fix-callCabal2nix) https://git.io/vDClS
pi3r has joined #nixos
<taktoa>
MichaelRaskin: I'm back
<hodapp>
MichaelRaskin: YOU SHOULD HAVE USED UNIVALENT FOUNDATIONS
* hodapp
hides
<MichaelRaskin>
hodapp: have you _looked_ at them?
<hodapp>
yes
<hodapp>
ish
<hodapp>
what's cubical type theory?
<taktoa>
hodapp: computable implementation of HoTT
<hodapp>
interesting
<jophish>
peti: how complicated are you willing to make callCabal2nix. We have quite a sophisticated version in use at work
<simpson>
Not to be confused with cubical time theory~
<hodapp>
or cubicle type theory
<taktoa>
lol
<hodapp>
which smells a lot like Java's type system
<schoppenhauer>
why are foundations of mathematics discussed here?
<jophish>
although, perhaps a little overcomplicated (It's grown quite "organically") there may be some useful bits in
<schoppenhauer>
(not that it was bad, it is just … unusual)
<hodapp>
lately I've mostly been looking at Lean Theorem Prover and haven't progressed much in reading the HoTT text
<MichaelRaskin>
You don't create a language without side effects and expect its channel to be free of foundational discussions
<simpson>
schoppenhauer: It happens. I noticed that your PR got merged, BTW.
<hodapp>
MichaelRaskin: would you say that it's a...... side effect?
<simpson>
hodapp: Ooh, yes, I know this one! It's called Conway's Law.
<taktoa>
schoppenhauer: the demographics of nixos users overlap hilariously with those of formal methods grad students (and professors)
<hodapp>
simpson: bah?
<MichaelRaskin>
I think it is fully reprodcuible, so you can as well include it in the referentially transparent part
<simpson>
It's not a "side" effect, but yeah, the shape of a community informs the shape of its discussions.
<taktoa>
the number of formal methods tools packaged on nixos is amusing
<Ralith>
schoppenhauer: this is what happens when you spam social news sites with "NixOS, the functional linux!" for years on end
m-i has quit [(Remote host closed the connection)]
<Ralith>
(and actually have credible backup for the claim)
m-i has joined #nixos
<MichaelRaskin>
Hey, both me and peti have come here before spamming social news site was going on for years!
<MichaelRaskin>
It was just a trickle back then
<jophish>
Does anyone know what happened to "print build trace"?
<taktoa>
I forget how I first learned about NixOS (other than that it was definitely through Haskell), but I think it was around 2012 or 2013.
<schoppenhauer>
Ralith: I never really found that this was a good motto. It tries to be side-effect-free, but that is only one thing people associate with "functional".
<clever>
and i got into nixos because i was trying to fix a bug taktoa had in teamspeak, lol
<Ralith>
yeah it always seemed a little weird to me too
<Ralith>
made me curious enough to look, though
<simpson>
Yeah, I'm the odd one out; I'm here because Monte uses Nix as its package manager.
<taktoa>
yeah it was like "huh I can't click links in teamspeak" *4 hours of stracing later* "let me just install your operating system to fix this bug"
<clever>
:D
<taktoa>
the main adoption barrier for me with NixOS is that I was worried that not enough stuff was packaged
<taktoa>
I was very wrong :)
<drakonis>
package even more :v
<drakonis>
Nix has the greatest advantage
<jophish>
Ah, apparently it was added to support hydra, but hydra doesn't use it
<taktoa>
nix is the embodiment of "easy things are easy, hard things are possible"
<drakonis>
packing for it is far easier than packaging rpm and deb files
<drakonis>
it does however still need more DEs packaged :V
<hodapp>
the main adoption barrier for me with NixOS is that I was fucking lazy
<drakonis>
same i guess.
<drakonis>
but here i am
rmeis has joined #nixos
<taktoa>
I remember reading the nixos website and thinking "this is exactly how operating systems should be" but then it took a few years before I took the plunge
<hodapp>
one interesting effect is that there seems to be a lot less of me hacking things together so they just work, and more me trying to turn those same efforts into something people can reuse
<taktoa>
yeah it's so easy to depend on something in Nix that it really imrpoves code reuse
<taktoa>
okay I gotta go
<drakonis>
i only wish budgie was already packaged
<Ralith>
the main adoption motivator for me was that I am super lazy
<Ralith>
and keeping an Arch Linux system working is not for lazy people
<MichaelRaskin>
Well, when I have seen NixOS described first, I understood that this is a better implementation of what I was trying to do with A/BLFS
<MichaelRaskin>
So I switched quickly
<hodapp>
right now, I'm trying to take this clusterfuck known as EmguCV and put a bow on it so it's a NixOS package... or something
<drakonis>
running arch is painful when you want work done
<taktoa>
MichaelRaskin: yeah it wasn't long after I had done LFS
<Ralith>
on Nix, if something breaks I can just put the problem off indefinitely by rolling back
<hodapp>
drakonis: I switched from Arch too
<peti>
jophish: I don't care about the complexity of the function as long as the complexity gives you some power in return. :-)
<gchristensen>
hi #nixos
<hodapp>
the one thing I have not been able to get work on NixOS yet is Turtl
<drakonis>
hi gchristensen
<MichaelRaskin>
I have done LFS three times and by the third time I had something interesting
<clever>
Ralith: ive done that with my nixos router, its now over a year out of date!
<drakonis>
package everything.
<Ralith>
the whole testing things in a VM gimmick is pretty neat too
<taktoa>
my path was Ubuntu -> (briefly) LFS -> Arch -> NixOS
<MichaelRaskin>
But limits on upfront investment meant it was still too bad
<MichaelRaskin>
So short?
<clever>
MichaelRaskin: i also ran LFS on my router at one time, but had to retire it when the modem got too fast for the cpu/nic
<MichaelRaskin>
I think mine was something like Mandrake (before it was Mandriva) -> ASPLinux (a properly localized spinoff of RedHat before Fedora) -> A/BLFS -> Simply MEPIS that quickly turned into Debian sid -> NixOS
<hodapp>
my path: Caldera OpenLinux -> Grey Cat Linux / BasicLinux -> Red Hat Linux -> Slackware -> Debian -> Ubuntu -> Debian -> Ubuntu -> Debian -> Ubuntu -> ???? -> Arch Linux & Fedora -> NixOS
<hodapp>
yeah, I said Caldera OpenLinux
<hodapp>
get off my lawn
jensens has quit [(Ping timeout: 240 seconds)]
<NixOS_GitHub>
[nixpkgs] k0001 opened pull request #22471: Export haskellSrc2nix, hackage2nix. Prefer local builds. Name arg optional. (master...hs2nix) https://git.io/vDC8F
<drakonis>
i don't see arch's appeal
<clever>
my path was redhat9 -> ubuntu -> gentoo -> LFS (on some systems) -> nixos
<hodapp>
drakonis: it is a nice system in some regards but for me it just broke too. damn. much.
<Ralith>
my path was incident on FreeBSD, so the amount of manual packaging required for Nix didn't even register
<MichaelRaskin>
I tried Arch once, and same for Gentoo. Didn't stay long on either
<drakonis>
i'd rather have things get configured than fiddling with config files trying to get it to work the first time
<clever>
i still have 1 gentoo machine still active
<drakonis>
time is money they said
<drakonis>
use arch they said
<drakonis>
although arch's only advantage is maybe AUR?
<drakonis>
the real standout being the packages on AUR and not being bleeding edge
rmeis has quit [(Ping timeout: 252 seconds)]
<MichaelRaskin>
Some people say cutting edge. But we know that as soon as you try to use cutting edge, it turns out to be a bleeding edge
<drakonis>
ha!
<drakonis>
rather
<drakonis>
being bleeding edge ho ho
<drakonis>
there's lots of arcane packages in there
<hodapp>
I had a lot of random stuff break on Arch too because of minor transgressions of standards (ad-hoc or otherwise)
<jophish>
also, thanks for adding callCabal2nix in the first place!
<jophish>
(There are certainly improvements to be made, for example there's probably no reason to not filter src in this function)
<hodapp>
wow, soon I'll have enough stuff working to put EmguCV into dotnet-modules, but I feel sort of bad about adding a derivation that will insist on downloading 3.2 GB of crap in order to do its build
<hodapp>
because it requires custom OpenCV, VTK, and so on
<jophish>
aside from convenience for the caller
<drakonis>
a question, how do you fix the git repo for nixpkgs becoming too large
<drakonis>
how would you
mudri has quit [(Ping timeout: 240 seconds)]
<mbrgm>
is someone familiar with nix cross compilation (u-boot would be a start)? I tried to gain some knowledge on this topic, but the documentation is pretty sparse and I'm not too familiar with all of the implementation details. are there some projects using the cross compilation options, so I could take a look at how it works?
<mbrgm>
clever: ty! I'll take a look at it when I have some spare time, but I think I'll have some questions to you after that ;)
<gchristensen>
drakonis: no idea :P
<clever>
mbrgm: the wiki mentions that u-boot is one of the things that was being used to test cross-compiles
obadz has quit [(Quit: WeeChat 1.5)]
jensens has joined #nixos
<drakonis>
you make it sound like a hardware failure
<gchristensen>
it does seem to be that, yeah
<clever>
gchristensen: ive unseated the GPU before when plugging in a monitor, and the system just locked up solid
obadz has joined #nixos
<hodapp>
yeah, it depends on a lot of things what will happen
<gchristensen>
yikes
<gchristensen>
I've had that problem with a wiggly thunderbolt cable, since the pcie devices just disappear
<gchristensen>
domenkozar: ping? how are you feeling about the new xps?
<clever>
gchristensen: ive seen some pretty crazy thunderbolt hacks
<clever>
gchristensen: one demo, involved cutting apart a thunderbolt->hdmi adapter, and just running the thunderbolt wire right thru it, so the user thinks its just hdmi, but its really thunderbolt
<clever>
gchristensen: that line then ran to a box with an external pcie card, that did dma attacks against the host
<clever>
and because you see the shell of an hdmi adapter on the wire, you think its just hdmi, and it cant dma you
<LnL>
lol
<NixOS_GitHub>
[nixpkgs] obadz pushed 4 new commits to release-16.09: https://git.io/vDCBU
<NixOS_GitHub>
nixpkgs/release-16.09 a5087e6 Peter Hoeg: virtualbox: 5.1.8 -> 5.1.10...
petar has quit [(Remote host closed the connection)]
<jophish>
drakonis: was that the call for maintainers/contributers one?
<peti>
jophish: Wow, that looks slightly more sophisticated than what we have now. :-) I'll need a day or two to think about that snippet, but this looks interesting.
<drakonis>
yeah
petar has joined #nixos
<hodapp>
alright, how do I refer to the package for GTK+? "gnome.gtk" is just giving me "error: undefined variable ‘gnome’"
<jophish>
peti: sure, I hope some of it can be helpful. Thanks :)
<clever>
LnL: in this defcon talk, they left the tunderbolt device on the table, wired up to the projector system, and got the memory dump from a different presenter
<drakonis>
lol
<gchristensen>
clever: just adds to the terror that is usb-c (having thunderbolt embedded inside)
<drakonis>
the switch has usb-c
<clever>
gchristensen: yeah, and i believe firewire had similar problems
<drakonis>
nintendo switch
<clever>
gchristensen: the IOMMU is the only way to fight these kinds of things
<hodapp>
since I can use the name "gtk+" in a Nix file...
<drakonis>
shit's spooky
<hodapp>
but seemingly can't use what nix-env -qaP is telling me either.
<clever>
with a properly configured IOMMU, you can force the usb controller to obey its own set of paging tables and virtual memory
<clever>
so it cant get full access to all ram
<hodapp>
oh, names changed
<jophish>
hodapp: often it's useful to look at all-packages.nix from nixpkgs
<drakonis>
does nix-collect-garbage also clean up previous generations?
<clever>
drakonis: only if you tell it to with one of the extra arguments
<gchristensen>
hot dog, opensuse's build system has over 1,000 nodes
<drakonis>
nice
<clever>
drakonis: check its man page
<drakonis>
get on with opensuse
<drakonis>
they got guix in their basic repos
<drakonis>
get nix in there
<hodapp>
uggggh, it's a lot easier to make sure a library is built properly when the build doesn't do some completely custom build of it
<clever>
drakonis: and if you tell it to delete generations and dont give it root, it cant delete generations of system or root's profile
<drakonis>
and see if they can share some of those repos
<drakonis>
nodes*
<hodapp>
since I can't just pkgs.opencv3.override { enableContrib = true; enableGtk3 = true; }
JagaJaga has quit [(Quit: WeeChat 1.6)]
petar has quit [(Remote host closed the connection)]
petar has joined #nixos
Itkovian has joined #nixos
mudri has joined #nixos
<NixOS_GitHub>
[nixpkgs] grahamc pushed 1 new commit to release-16.09: https://git.io/vDCR5
<NixOS_GitHub>
nixpkgs/release-16.09 36ffe58 Graham Christensen: tigervnc: patch for CVE-2017-5581...
<NixOS_GitHub>
[nixpkgs] PierreR opened pull request #22474: Asciidoctor: add pygments.rb (highlighter) to Gemfile (master...asciidoctor-patch) https://git.io/vDCRx
viric has quit [(Ping timeout: 240 seconds)]
m-i has quit [(Remote host closed the connection)]
reinzelmann has quit [(Quit: Leaving)]
m-i has joined #nixos
<gchristensen>
<3 to fpletz for fixing those libgd2 and libarchive issues days ago :)
<fpletz>
unfortunately my laptop is broken now and I'm still in belgium :/
m-i has quit [(Remote host closed the connection)]
m-i has joined #nixos
<fpletz>
<3 weechat android app %)
Itkovian has quit [(Quit: My MacBook has gone to sleep. ZZZzzz…)]
<gchristensen>
ouch! :) mine is about fallen apart. I need to pick its replacement and get on with it.
<LnL>
fpletz: that sucks :(
Itkovian has joined #nixos
cutuchiqueno has quit [(Quit: WeeChat 1.7)]
<globin>
fpletz: o.O?
<yorick>
maybe hydra failures should generate github issues
<yorick>
(aka the asterisk build is still failing because someone put a svn export in the ./configure)
<simpson>
Sometimes I wish that it were easier to TOFU the hashes for prefetched content.
<yorick>
yeah, that really needs to be there
<yorick>
I keep copying in dummy hashes and then fixing them using the error message
<globin>
yorick: I'll be making a new mega issue for 17.03 to reduce failures to zero in a few days
<LnL>
when is the branching going to happen?
<yorick>
feb 29th?
<globin>
yorick: for most of the stuff nix-prefetch-url -A whatever.src
<globin>
Feb 27th
<jophish>
gchristensen: I'm trying to replicate your "travis-nix-build" script. I've got a build hook which prints the required derivation to a file, however when I use 'nix-store --realize $drv' it waits forever trying to get a build slot
<mitchty>
well i hacked around it by doing this but its not all that ideal export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$(nix-env -qaP --out-path munge | awk '{print $3}')/pkgconfig:~/.nix-profile/lib/pkgconfig
estewei has quit [(Quit: Quit)]
mlieberman85 has joined #nixos
<mitchty>
i couldn't find much in anyones config.nix that dealt with PKG_CONFIG_PATH
nekroze has joined #nixos
<NixOS_GitHub>
[nixpkgs] bjornfor pushed 2 new commits to release-16.09: https://git.io/vDCzs
<NixOS_GitHub>
nixpkgs/release-16.09 8352dee Domen Kožar: hydra: 2016-04-15 -> 2016-12-09...
<nekroze>
How could I make an option set for a custom module that is an array of key value pairs? something like `services.thin.extraVariables = { "COLOR" = blue; };` but I don't want to predefine COLOR as an option, just the extraVariables option.
hiratara has joined #nixos
<mitchty>
gah, nevermind i just noticed i put the pkgconfig dir in the wrong spot
<mitchty>
derp
ablubla has quit [(Ping timeout: 255 seconds)]
ablubla has joined #nixos
grenade has quit [(Ping timeout: 255 seconds)]
copumpkin has joined #nixos
grenade has joined #nixos
smola_ has quit [(Ping timeout: 252 seconds)]
adelbertc has quit [(Ping timeout: 252 seconds)]
JagaJaga has joined #nixos
<NixOS_GitHub>
[nixpkgs] Ericson2314 pushed 2 new commits to master: https://git.io/vDCgU
<NixOS_GitHub>
nixpkgs/master 5eaea6c John Ericson: cross stdenv: let build package's build deps resolve to native packages...
<NixOS_GitHub>
nixpkgs/master f6ef6b5 John Ericson: Merge pull request #22387 from Ericson2314/cross-3-platforms...
Judson has joined #nixos
adelbertc has joined #nixos
smola_ has joined #nixos
<Judson>
Not completely blocked, but if manveru's around, I'm wondering about how they hack on Bundix?
carter has quit [(Ping timeout: 252 seconds)]
<copumpkin>
what about it?
<copumpkin>
actually modifying the tool, or making packages with it?
carter has joined #nixos
derjohn_mob has joined #nixos
Itkovian has quit [(Quit: My MacBook has gone to sleep. ZZZzzz…)]
<Judson>
Modifying the tool
<Judson>
There's no tests (which I can understand), but the default.nix in there isn't working for me in nix-shell without modification, and 'bin/bundix' there complains about the bundler lib files missing.
<Judson>
I think some of this is just Nix-noobery on my part, coupled with an opiniated setup of my own.
<LnL>
Judson: you might have to use bundler exec
ebzzry has joined #nixos
<Judson>
(e.g. I'm using direnv's use_nix to load the default.nix...)
<Judson>
Bundix (wisely) doesn't have a Gemfile - or depend on anything outside the stdlib (in theory, but bundler is a gem...)
<nekroze>
How could I make an option set for a custom module that is an array of key value pairs? something like `services.thin.extraVariables = { "COLOR" = "blue"; };` but I don't want to predefine COLOR as an option, just the extraVariables option.
<Judson>
So `bundle exec bin/bundix` errors with "Could not locate Gemfile", as expected.
<LnL>
oh, don't know then I've only used it too generate expressions
<gchristensen>
nekroze: how do you want to use these variables?
<Judson>
Isn't it common that default.nix in a project is intended as the default.nix in nixpkgs? Or is that a bad asumption?
<Judson>
Because one of the changes I had to make was to add meta.version
<nekroze>
gchristensen: I want to map over the extraVariables and do some string bashing on them to turn them into say environment variable lines like "export COLOUR='blue'"
<Judson>
(which was otherwise inheritied somehow?)
<gchristensen>
ho hum ... I was going to write security notes while on this flight, but I can't use a browser.
jmiven has quit [(Quit: co'o)]
<NixOS_GitHub>
[nixpkgs] benley opened pull request #22476: redshift-plasma-applet: init at 1.0.17 (master...redshift-kde) https://git.io/vDC2P
stepcut has quit [(Remote host closed the connection)]
copumpkin has quit [(Quit: My MacBook Pro has gone to sleep. ZZZzzz…)]
JagaJaga has quit [(Ping timeout: 255 seconds)]
<manveru>
Judson: hey
<Judson>
Hey, manveru
<manveru>
lemme take a look
jmiven has joined #nixos
<manveru>
ah, yeah
<manveru>
i can make you a shell.nix that should work
Jackneill has quit [(Remote host closed the connection)]
<Judson>
I think I did already :)
<manveru>
ok :)
<Judson>
(buildInput = [bundler])
<manveru>
you just need bundler and ruby in buildInputs
<Judson>
Oh, ruby would be good to, huh? :)
<manveru>
i guess you have it systemwide already, but if you want it to work in pure, yes
<manveru>
also nix-prefetch-scripts
<manveru>
or at least nix-prefetch-git
<Judson>
In terms of it actually working beyond "bundix -h"
<Judson>
Any advice on testing it at all?
<Judson>
Maybe checking out problem gems into a subdir and bundixing them?
<manveru>
i think just making a Gemfile and making sure bundix output is always the same for the same Gemfile.lock
<Judson>
I mean, what do you do?
<manveru>
i use it in production... so if something's broken i usually notice
<schoppenhauer>
hi. anyone here using expresscard and nixos? I once added boot.kernelParams = [ "pciehp.pciehp_force=1" ]; to hardware-configuration.nix and kernelExtraConfig = "HOTPLUG_PCI_PCIE y", but it still does not work
<manveru>
having tests would be great though, just haven't had much time to invest in it
<Judson>
Okay... my Nix is still pretty weak. How do you use it in production? I notice that the current nixpkgs is still 2.0.8
<Judson>
Okay. If I refactor pretty heavily, you'll not be offended then?
<manveru>
no worries
<manveru>
i use an older version because the new one doesn't work on nixos
<manveru>
the new prefetch is broken if you can't write to /nix/var with your user
<manveru>
it's way faster in single user nix though
<Judson>
Got it.
<Judson>
(-i and -m look like the business though...)
<schoppenhauer>
I will try boot.initrd.luks.mitigateDMAAttacks = false; now
georges-duperon has quit [(Ping timeout: 252 seconds)]
<manveru>
Judson: the -m shouldn't be needed really... it's just annoying as hell if you have bundix in buildInputs after your gems, and a gem of yours (esp rails) depends on bundler, then your `bundle lock` will be broken
<manveru>
so make sure you put it before, since it'll be before on the PATH as well
<Judson>
Cool.
<manveru>
sorry, gotta go, have to get up in 6 hours :(
rmeis has joined #nixos
rmeis has quit [(Ping timeout: 240 seconds)]
jensens has quit [(Ping timeout: 255 seconds)]
copumpkin has joined #nixos
setgid has joined #nixos
<setgid>
hi, why are there clang-wrapper and gcc-wrapper packages? what does the wrapper do?