Google Summer of Code project concepts

Google Summer of Code project concepts

[Chris Dale]

[-- Attachment #1: Type: text/plain, Size: 1227 bytes --]

Hello Guix community!

I just learned about Guix from the GNU Google Summer of Code project page,
and I'm very interested in the idea of a fully functional package manager.
That one of the project ideas was bundling the distribution with a window
manager sparked in me the idea to bundle it with a fully-functional window
manager. I originally envisioned xmonad as the wm of choice, due to my
interest in Haskell, and emailed Ludo to this effect. He told me it might
be more beneficial to use a natively Guile Scheme wm, which he observed are
few, not very mature, and generally stagnant already. Upon looking around
further, I came across stumpwm, implemented in 100% Common Lisp, so I
propose a compromise: adapt and package stumpwm for use with Guile Scheme
and Guix, and then use the resulting environment to have  a free software
distribution configurable primarily in Guile Scheme.

I chose stumpwm because I prefer tiling managers to conventional ones,
though I would respect if the view of the crowd was that conventional wms
would be more useful to have for the distro - there are Common Lisp (and
even Guile, sort of) alternatives in the conventional realm.

Thank you in advance for all of your input!

[Chris] Dale

[-- Attachment #2: Type: text/html, Size: 1407 bytes --]

Re: Google Summer of Code project concepts

[Brandon Invergo]

Hi Chris,

> I just learned about Guix from the GNU Google Summer of Code project page, and I'm very interested in
> the idea of a fully functional package manager. That one of the project ideas was bundling the
> distribution with a window manager sparked in me the idea to bundle it with a fully-functional window
> manager. I originally envisioned xmonad as the wm of choice, due to my interest in Haskell, and
> emailed Ludo to this effect. He told me it might be more beneficial to use a natively Guile Scheme
> wm, which he observed are few, not very mature, and generally stagnant already. Upon looking around
> further, I came across stumpwm, implemented in 100% Common Lisp, so I propose a compromise: adapt and
> package stumpwm for use with Guile Scheme and Guix, and then use the resulting environment to have  a
> free software distribution configurable primarily in Guile Scheme.

Check out nwm:
https://github.com/nizmic/nwm

It's written in XCB and uses Guile. I don't know how complete it is
yet, though. I haven't had much time to play around with it but it seems
to be generally working. It has a REPL and it uses Scheme functions to
manage window placement. I think it would be a better choice. Stumpwm is
huge and I'm pretty sure it has a lot of dependencies on Common Lisp features.

-brandon

ps - sorry if you got this message twice

Re: Google Summer of Code project concepts

[Nikita Karetnikov]

[-- Attachment #1: Type: text/plain, Size: 1707 bytes --]

> I originally envisioned xmonad as the wm of choice, due to my interest
> in Haskell, and emailed Ludo to this effect.

I haven't tried xmonad myself, but I hope to try it when we have GHC on
mips64el (actually, we haven't packaged GHC for i686 and x86 too).

> I chose stumpwm because I prefer tiling managers to conventional ones,
> though I would respect if the view of the crowd was that conventional
> wms would be more useful to have for the distro - there are Common Lisp
> (and even Guile, sort of) alternatives in the conventional realm.

I also use a tiling WM and I'm OK with the idea.  And I think that it
should be easier to adapt a tiling WM than a non-tiling one.  Maybe it's
not even possible to package something like GNOME right now, but I'm not
sure about that.  (I guess that you should ask Andreas about the state
of X-related things.)

On the other hand, I'm pretty sure that most people use non-tiling WMs
and maybe we should think about them first.  But I don't really think
that it's a right time for that.  Because the distro isn't bootable yet
and there aren't too many packages.

> Upon looking around further, I came across stumpwm, implemented in 100%
> Common Lisp, so I propose a compromise: adapt and package stumpwm for
> use with Guile Scheme and Guix, and then use the resulting environment
> to have a free software distribution configurable primarily in Guile
> Scheme.

But what do you mean by "adapt for Guix"?  What would you like to
implement?  The only thing that comes to mind is to have shortcuts for
commands like 'guix package'.

It sounds like the proposed project has more to do with Guile than Guix.
But I haven't heard the details yet.  Please elaborate.

[-- Attachment #2: Type: application/pgp-signature, Size: 835 bytes --]

Re: Google Summer of Code project concepts

[Chris Dale]

[-- Attachment #1: Type: text/plain, Size: 1400 bytes --]

> (I guess that you should ask Andreas about the state
> of X-related things.)
>

Will do!


> On the other hand, I'm pretty sure that most people use non-tiling WMs
> and maybe we should think about them first.  But I don't really think
> that it's a right time for that.  Because the distro isn't bootable yet
> and there aren't too many packages.


I'm definitely interested in getting the distro bootable in general. What
are the remaining roadblocks for this issue? What remaining tools need to
be added? And the question for me: are there good, purely-functional
implementations of these tools we can look at?


> But what do you mean by "adapt for Guix"?  What would you like to
> implement?  The only thing that comes to mind is to have shortcuts for
> commands like 'guix package'.
>

That's a fair question. I suppose I don't much know -- the Summer of Code
ideas site listed "package window manager" as one of the projects, so I
assumed there was a lot to be done. Maybe that's more about packaging the
dependencies of the larger projects.


> It sounds like the proposed project has more to do with Guile than Guix.
> But I haven't heard the details yet.  Please elaborate.
>

The project would be about extending the Guix distribution with more Guile
projects - it would not, admittedly, involving much work on the actual Guix
package manager, though I'm not against doing work on that.

[-- Attachment #2: Type: text/html, Size: 2213 bytes --]

Re: Google Summer of Code project concepts

[Chris Dale]

[-- Attachment #1: Type: text/plain, Size: 984 bytes --]

On Tue, Apr 9, 2013 at 1:33 AM, Brandon Invergo <brandon@invergo.net> wrote:
>
> Check out nwm:
> https://github.com/nizmic/nwm
>
> It's written in XCB and uses Guile. I don't know how complete it is
> yet, though. I haven't had much time to play around with it but it seems
> to be generally working. It has a REPL and it uses Scheme functions to
> manage window placement. I think it would be a better choice. Stumpwm is
> huge and I'm pretty sure it has a lot of dependencies on Common Lisp
> features.
>
> -brandon
>

I'm definitely interested in playing around with it. It might make an
interesting project in itself to see how close to completion we could bring
the project, though justifying a close marriage to Guix in that respect
might be difficult. I'm interested in the idea of entire distribution where
the tools at the user level are entirely (or primarily) configurable in a
functional language, and Guix the distribution seems like a good starting
point.

Cheers
Dale

[-- Attachment #2: Type: text/html, Size: 1528 bytes --]

Re: Google Summer of Code project concepts

[Nikita Karetnikov]

[-- Attachment #1: Type: text/plain, Size: 1074 bytes --]

> That's a fair question. I suppose I don't much know -- the Summer of
> Code ideas site listed "package window manager" as one of the
> projects, so I assumed there was a lot to be done. Maybe that's more
> about packaging the dependencies of the larger projects.

I've just checked the page.  Yes, I feel that it's about packaging the
dependencies.  So if you like tiling WMs, you can package one (by the
way, there is a patch [1] that adds dwm to 'core-updates').  Then you
can package things like PDF viewers and other graphical tools.  For
example, you can create a list of tools which are shipped with GNOME.
This will reduce the amount of work when we decide to package a
non-tiling WM.

So, here is a to-do list that summarizes the above:

1. Choose a WM.

2. For instance, find which packages are shipped with GNOME.

3. Use 'guix import' and 'guix package -A' to identify the missing
   packages.  It will help to determine what should be done first.

But first, let's hear what others think.

[1] https://lists.gnu.org/archive/html/bug-guix/2013-03/msg00167.html

[-- Attachment #2: Type: application/pgp-signature, Size: 835 bytes --]

Re: Google Summer of Code project concepts

[Ludovic Courtès]

Hello!

Chris Dale <adventureonthehighseas@gmail.com> skribis:

> I'm definitely interested in getting the distro bootable in general. What
> are the remaining roadblocks for this issue? What remaining tools need to
> be added? And the question for me: are there good, purely-functional
> implementations of these tools we can look at?

The goal would be provide mechanisms to describe the system’s global
configuration, and the instantiate it, similar to what NixOS does.  So
users would describe the set of services do be started, and the usual
bits of configuration such as user accounts, timezone, locale, and
networking settings.

This is mostly missing.  I did a “boot-to-Guile” QEMU image some time
ago that was built entirely using Guix.  That could serve as a starting
point.

Then I would like to use dmd as the init system:

  https://gitorious.org/guix/dmd

The project needs love, testing, and everything, so that’s another area
where you could help.

>> It sounds like the proposed project has more to do with Guile than Guix.
>> But I haven't heard the details yet.  Please elaborate.
>>
>
> The project would be about extending the Guix distribution with more Guile
> projects - it would not, admittedly, involving much work on the actual Guix
> package manager, though I'm not against doing work on that.

I believe Guile could be a tool allowing us to provide an unprecedented
level of integration and flexibility: Guile for packages, Guile in the
initrd, Guile in the init system, why not Guile for network-related
setup tasks, and perhaps Guile in the WM.  The good thing is that each
of these aspects can be tackled mostly independently of the others.

Let your imagination work, and let us know any ideas you want to
discuss!  :-)

Thanks,
Ludo’.

Re: Google Summer of Code project concepts

[Ludovic Courtès]

Brandon Invergo <brandon@gnu.org> skribis:

> Check out nwm:
> https://github.com/nizmic/nwm

Indeed, that looks like something we want to have.

Ludo’.

Re: Google Summer of Code project concepts

[Chris Dale]

[-- Attachment #1: Type: text/plain, Size: 2939 bytes --]

Repairing this project seems like a really interesting way to go:
http://www.gnu.org/software/guile/manual/html_node/The-Scheme-shell-_0028scsh_0029.html

Not just configurable in Guile, but interactable in it all the time! The
link on the page appears to be out-of-date: a fairly active version of
guile-scsh lives here: http://gitorious.org/guile-scsh, though from the
contributors to that project it seems like at least some of the mailing
list is already pretty aware of it! Even if we were to consider the
command-line interaction expendable, it seems useful beyond measure to
include functionality to run shell scripts in Guile. The operating system
starts to look more like a library than an environment, and the user would
feel like they were in Guile mode as soon as they boot up. What a joy!

Of course, the goal "get Guix bootable and running primarily Guile Scheme
programs" is a pretty big goal, and fairly imprecise. I'd consider getting
the WM packaged a secondary goal to getting a Guile shell running, so a
project might be simply be "get Guix bootable and run ls through the
guile-scsh" or some such a thing. Any feedback or ideas? My biggest barrier
is not really knowing how much work needs to be done, or how much I could
expect to get done in a summer. It seems that working 40 hours a week for
three months would probably empower a body to do a fair amount.  I don't
really understand how an operating system becomes bootable, so I'd need
some guidance on what exactly needs to be done to get that happening - that
is, what exactly is the nature of the gulf between, say, boot-to-Guile, and
Guix becoming a bootable distro? I don't know where to plug it all
together, so to speak! I am certainly more than willing to learn; just
explaining that this is all new to me. As you may have guessed, it is not
my OS hacking skillz that interest me in the project, but my desire to see
functional programming get used in practical software. I'm willing to learn
just about anything to contribute to that goal :)

Broadly though, it seems like the order of business would be boot-to-Guile
+ Guix → dmd → Guile-scsh → nwm. Obviously those chunks are discrete, and
you could chop them off at any point and still be better off than you were
before. I could also see an argument for reversing the order of Guile-schsh
and nwm, but as an arch user I always think of shells before window
managers :D

My ideal project result would be a bootable distro that I can configure and
interact with in Guile Scheme. If it had a wm, that'd be the icing on the
cake (as wms always are! :P). Thoughts?

Thanks so much!

[Chris] Dale


On Thu, Apr 11, 2013 at 7:18 AM, Ludovic Courtès <ludo@gnu.org> wrote:

> Brandon Invergo <brandon@gnu.org> skribis:
>
> > Check out nwm:
> > https://github.com/nizmic/nwm
>
> Indeed, that looks like something we want to have.
>
> Ludo’.
>

[-- Attachment #2: Type: text/html, Size: 3788 bytes --]

Re: Google Summer of Code project concepts

[Ludovic Courtès]

Hi!

Chris Dale <adventureonthehighseas@gmail.com> skribis:

> As you may have guessed, it is not
> my OS hacking skillz that interest me in the project, but my desire to see
> functional programming get used in practical software. I'm willing to learn
> just about anything to contribute to that goal :)

Guix is written mostly in a functional style, so hacking in there would fit.

> Broadly though, it seems like the order of business would be boot-to-Guile
> + Guix → dmd → Guile-scsh → nwm. Obviously those chunks are discrete, and
> you could chop them off at any point and still be better off than you were
> before. I could also see an argument for reversing the order of Guile-schsh
> and nwm, but as an arch user I always think of shells before window
> managers :D

The bootable thing requires some design and hacking on the core of
Guix.  So I don’t think it’d be reasonable as a summer project.  (Plus I
hope that some progress has been made by this time!)

> My ideal project result would be a bootable distro that I can configure and
> interact with in Guile Scheme. If it had a wm, that'd be the icing on the
> cake (as wms always are! :P). Thoughts?

We’d just need to come up with a more precise task list, I suppose.  :-)
I can’t really offer to mentor work on Guile-SCSH or on a WM, unless
there’s specific integration work with Guix.

WDYT?

Ludo’.

Re: Google Summer of Code project concepts

[Cyril Roelandt]

On 04/09/2013 04:00 PM, Nikita Karetnikov wrote:
>> That's a fair question. I suppose I don't much know -- the Summer of
>> Code ideas site listed "package window manager" as one of the
>> projects, so I assumed there was a lot to be done. Maybe that's more
>> about packaging the dependencies of the larger projects.
>
> I've just checked the page.  Yes, I feel that it's about packaging the
> dependencies.  So if you like tiling WMs, you can package one (by the
> way, there is a patch [1] that adds dwm to 'core-updates').  Then you
> can package things like PDF viewers and other graphical tools.  For
> example, you can create a list of tools which are shipped with GNOME.
> This will reduce the amount of work when we decide to package a
> non-tiling WM.

Indeed, this project is more about packaging a __Desktop_Environment__ 
rather than a simple Window Manager.

By the way, I pushed the dwm patch in the core-updates branch.

>
> So, here is a to-do list that summarizes the above:
>
> 1. Choose a WM.
>
> 2. For instance, find which packages are shipped with GNOME.
>
> 3. Use 'guix import' and 'guix package -A' to identify the missing
>     packages.  It will help to determine what should be done first.
>

One thing to do for huge packages such as GNOME/KDE would be to package 
the graphic toolkits they use, and which are used by many pieces of 
software. This would probably require quite a lot of work.

Cyril.

Re: Google Summer of Code project concepts

[Chris Dale]

[-- Attachment #1: Type: text/plain, Size: 1225 bytes --]

> We’d just need to come up with a more precise task list, I suppose.  :-)
> I can’t really offer to mentor work on Guile-SCSH or on a WM, unless
> there’s specific integration work with Guix.
>
> WDYT?
>
>
 That's the question I had, that Nikita brought to the forefront. What
would be the precise nature of this integration? I mean, you did list
wm-packaging as a summer project, and I don't much know what would be
required to make it happen, nor what would make it the length of a summer!
 I suppose being bootable is also secondary. I'm a fairly happy arch user,
but if I could drop a Guix userland distro on top of it, I could easily see
myself doing that full time.

I would be totally willing to integrate the guile-scsh and nwm, especially
since neither project is yet fully realized, but I just don't know what
exactly that would entail. Part of the appeal of a package manager is the
modularity of the packages you install :P

So I guess, the starting place for this precise task list would be: getting
the Guix distribution to the point where it can be dropped onto a normal
Linux distro and used as a normal distribution. I'd like to integrate scsh
and nwm, if that's a real place to go.

[-- Attachment #2: Type: text/html, Size: 1564 bytes --]

Re: Google Summer of Code project concepts

[Nikita Karetnikov]

[-- Attachment #1: Type: text/plain, Size: 1463 bytes --]

> I'm a fairly happy arch user, but if I could drop a Guix userland
> distro on top of it, I could easily see myself doing that full time.

Guix can be used as a package manager.  Try something like the following
(I suggest to create a chroot first):

$ git clone git://github.com/NixOS/nixpkgs.git nixpkgs-github

$ git clone git://git.sv.gnu.org/guix.git
$ cd guix
$ ./bootstrap
$ ./configure --localstatedir=/nix/var --with-nixpkgs=nixpkgs-github
$ make && make check

(You might need other packages [1].)

If you don't want to run 'make install', you'll have to prepend
'./pre-inst-env' (it sets the needed variables) to all commands.  For
instance, this command should build GNU Hello:

$ ./pre-inst-env guix build -K hello

Don't forget to run the daemon [2] prior to that:

$ ./pre-inst-env guix-daemon --build-users-group=nixbld &

Also, it seems that your current distro contains non-free packages.  I
highly recommend you to switch to a free one [3] (e.g., Parabola [4]).
There is a guide that might help [5], but I haven't tried it myself.

> Linux distro

Please don't use this term [6].

Don't hesitate to ask if you have any questions.

[1] http://git.savannah.gnu.org/cgit/guix.git/tree/README
[2] https://gnu.org/software/guix/manual/guix.html#Invoking-guix_002ddaemon
[3] https://www.gnu.org/distros/free-distros.html
[4] https://parabolagnulinux.org
[5] https://wiki.parabolagnulinux.org/Migration
[6] https://www.gnu.org/gnu/why-gnu-linux.html

[-- Attachment #2: Type: application/pgp-signature, Size: 835 bytes --]

Re: Google Summer of Code project concepts

[Ludovic Courtès]

Hi Chris,

Chris Dale <adventureonthehighseas@gmail.com> skribis:

>> We’d just need to come up with a more precise task list, I suppose.  :-)
>> I can’t really offer to mentor work on Guile-SCSH or on a WM, unless
>> there’s specific integration work with Guix.
>>
>> WDYT?
>>
>>
>  That's the question I had, that Nikita brought to the forefront. What
> would be the precise nature of this integration? I mean, you did list
> wm-packaging as a summer project,

We listed desktop environments (DEs), which is a different beast.  For
instance, packaging a tiny WM is as simple as this:

  http://git.savannah.gnu.org/cgit/guix.git/commit/?h=core-updates&id=c5c555b186a894e6bd3d5709c5199fcab1f0b7d0

Conversely, adding GNOME means packaging all the GNOME stack, which
includes dozens of related packages and tools, plus specific issues to
make sure it supports our file system layout.  It’s may be slightly less
difficult for GNUstep, but still quite involved.

Is it something you would be interested in?

> So I guess, the starting place for this precise task list would be: getting
> the Guix distribution to the point where it can be dropped onto a normal
> Linux distro and used as a normal distribution.

That’s already the case, in the sense that you can use it atop your
already running GNU/Linux system.

> I'd like to integrate scsh and nwm, if that's a real place to go.

Again, I don’t clearly see what that integration would be, nor whether
it’s really in the scope of Guix as a project.  Surely having packages
for these in the distro is desirable, but that’s insufficient for a GSoC
project.

HTH,
Ludo’.

Re: Google Summer of Code project concepts

[Chris Dale]

[-- Attachment #1: Type: text/plain, Size: 1704 bytes --]

> We listed desktop environments (DEs), which is a different beast.  For
> instance, packaging a tiny WM is as simple as this:
>
>
http://git.savannah.gnu.org/cgit/guix.git/commit/?h=core-updates&id=c5c555b186a894e6bd3d5709c5199fcab1f0b7d0

Ah yes, my mistake.

> Conversely, adding GNOME means packaging all the GNOME stack, which
> includes dozens of related packages and tools, plus specific issues to
> make sure it supports our file system layout.  It’s may be slightly less
> difficult for GNUstep, but still quite involved.
>
> Is it something you would be interested in?
>

I would definitely like to get involved in making this more palatable. Not
to mention it sounds like a challenge! I would definitely have to learn
more about the workflow involved before I could draw up a proposal. I would
have to ask: would the coding be primarily Guile or C?

> That’s already the case, in the sense that you can use it atop your
> already running GNU/Linux system.
>
That's true. I was referring to having a nice little cocoon of Scheme all
around me, so I could ignore the scary world outside :P

> Again, I don’t clearly see what that integration would be, nor whether
> it’s really in the scope of Guix as a project.  Surely having packages
> for these in the distro is desirable, but that’s insufficient for a GSoC
> project.
>

Yeah, that's fair. Hopefully I'd have time over the summer to package them
up anyway!

In the run-up to the proposal submission period, I'd like to have some
experience packaging for Guix. Is there any particular piece of software
that anyone would like me to focus on?

> HTH,
It certainly does, thank you :)

Cheers,
Dale

[-- Attachment #2: Type: text/html, Size: 2139 bytes --]

Re: Google Summer of Code project concepts

[Cyril Roelandt]

On 04/13/2013 12:19 AM, Chris Dale wrote:
>> Conversely, adding GNOME means packaging all the GNOME stack, which
>> includes dozens of related packages and tools, plus specific issues to
>> make sure it supports our file system layout.  It’s may be slightly less
>> difficult for GNUstep, but still quite involved.
>>
>> Is it something you would be interested in?
>>
>
> I would definitely like to get involved in making this more palatable. Not
> to mention it sounds like a challenge! I would definitely have to learn
> more about the workflow involved before I could draw up a proposal. I would
> have to ask: would the coding be primarily Guile or C?

The coding would primarily be done in Guile, but you'll probably need to 
be able to read the languages used by the DE you will be working on.

>
>> That’s already the case, in the sense that you can use it atop your
>> already running GNU/Linux system.
>>
> That's true. I was referring to having a nice little cocoon of Scheme all
> around me, so I could ignore the scary world outside :P
>
>> Again, I don’t clearly see what that integration would be, nor whether
>> it’s really in the scope of Guix as a project.  Surely having packages
>> for these in the distro is desirable, but that’s insufficient for a GSoC
>> project.
>>
>
> Yeah, that's fair. Hopefully I'd have time over the summer to package them
> up anyway!
>
> In the run-up to the proposal submission period, I'd like to have some
> experience packaging for Guix. Is there any particular piece of software
> that anyone would like me to focus on?

Is there any simple piece of software you use every day, but that is not 
packaged in Guix yet ? That might be a good starting point. You could 
also package a small WM, such as twm or wmii. We have support for the 
client-side of X in the core-updates branch, so you could package small 
GUI programs.

Cyril.