Sabotaged Quirky boots

No comments
I have created the very first Sabotaged Quirky (I probably need to think of a better name!).

This is a total rethink, completely unlike any Puppy. I even decided to abandon Woof*. Instead, I have created a package, named "woofs", that gets installed in the Sabotage build environment, and has a script 'create-quirky', that builds a filesystem. The filesystem is then written to a USB-stick or SD-card, and it is bootable.

I get a desktop, though horribly broken. JWM is at least running.

The appendage on "WoofS" is S from Sabotage, though it could also be read as multiple barks! -- much better than just one bark!

There is an awful lot to explain about what is new/different. Basically, everything. The only thing that I am retaining is the Puppy-like UI -- JWM/ROX-Filer and the usual selection of applications, and, as much as possible, the convenient utilities.


Sabotaged Quirky

1 Comment
For those who read this blog, and are wondering what is going on, re me not posting recently, I am very busy.

I have kind of gone into a tunnel, porting packages into Sabotage. The idea being to build Quirky from those binary packages.

However, I am planning to go a lot further than that. A revolutionary new Quirky, using the directory hierarchy and 'butch' compile-from-source package manager from Sabotage.

Plus some security ideas.

After all, this is what Quirky is all about, trying new ideas. I have codenamed it "Sabotaged Quirky", or just "SQ".


More pkgs committed to Sabotage

No comments
I am having so much fun with Sabotage. I have found it to be very easy to understand. Beautifully designed, and simple logical shell scripts everywhere. The only binary executable is 'butch', a super-fast CLI package manager.

rofl0r is the main guy maintaining Sabotage:
https://github.com/sabotage-linux/sabotage

I forked it, and I am adding packages, so as to be able to compile all of the packages used in a typical Puppy or Quirky.
My commits:
https://github.com/bkauler/sabotage/commits/master

I haven't quite decided how I will integrate Quirky with Sabotage. I have been thinking as well of improved security.


SmartGit GUI for git

2Comments
My knowledge of git is rudimentary. With my recent interest in Sabotage Linux, I am now itching to be able to contribute to the project, which is on github.

So, I thought that I would make life easier for myself by using one of the GUIs for git. After playing with a few, some of which wouldn't even start, I have settled on SmartGit.

This is a commercial product, free for non-commercial projects. Their website:
http://www.syntevo.com/smartgit/

It needs Adobe's Java JRE v7, which I got from here:
http://www.oracle.com/technetwork/java/javase/downloads/jre7-downloads-1880261.html
I got 7u80, expanded it in my Sabotage project partition, and then created /root/.smartgit/smartgit.vmoptions with one entry:
jre=/mnt/sdb5/apps/jre1.7.0_80
...which is where my JRE is expanded.

The SmartGit download expands to directory 'smartgit', and inside that just run bin/smartgit.sh. That's it, off she goes.

There are setup questions, and I chose to connect to github (where you need to already have an account), and chose the Sabotage repository:
https://github.com/sabotage-linux/sabotage.git

Then chose to clone it, also specified to clone it in my project partition, /mnt/sdb5/projects/sabotage

Hey, simple and it works. Looks good. Now all I have to do is learn how to use it

Well, there are some tutorials:
http://www.syntevo.com/smartgit/welcome

Note, I'm running Quirky April 7.2.1 64-bit. I am back on this slightly older Quirky, as Sabotage does not like Quirky Xerus.

Maybe I should start a Forum thread for discussing Sabotage and SmartGit.


Compiling Sabotage OS

6Comments
I posted about using a ready-made Sabotage x86_64 musl rootfs:
http://barryk.org/news/?viewDetailed=00353

I was most intrigued by the directory layout. Very simple and logical. Packages are installed into /opt, with symlinks created from the normal locations in the filesystem. /usr is just a symlink to ".".

This is kind of like Gobolinux. But, I recall looking at Gobolinux many years ago, and just now took another look:
http://www.gobolinux.org/?page=at_a_glance
I thought then, and still do, that it is "too different". Well, obviously it works, but it is not for me.

Sabotage, on the otherhand, is really still the standard Linux directory hierarchy, with the advantage of packages getting installed in /opt -- which is really nice, as you can see at a glance everything in a package.
You can even do stuff like install a package by putting it in /opt, then run "butch relink <package>" to create the symlinks (butch is the package manager).

Note, "butch unlink <package>" will remove all the symlinks. Neat. That effectively uninstalls the package.

There doesn't have to be any separate package database, as /opt is itself the database.

I have some reservations:

Musl seems to be compiling just about everything these days. Sabotage have 700 packages, but I see that Alpine Linux compiles many more with musl.
So, I guess that musl is OK. Great of course for creating static utilities. The space saving, well, when we are compiling apps that are many megabytes in size, such as Firefox, the saving of musl is probably insignificant.

Probably the same thing could be said about busybox, that Sabotage uses.

Sabotage was originally developed by Josiah Worcester:
https://github.com/pikhq/sabotage
Development stopped in 2011. The project was forked by a couple of guys:
https://github.com/sabotage-linux/sabotage
...what is good to see is that it is still active.

I decided to give it a go. I got the source from github:
# git clone git://github.com/sabotage-linux/sabotage

This will build the entire distro from source. What I found though, is that it does not like Quirky 8.0, or rather one of the header files, for which I can blame Ubuntu.
So, I booted up my good old Quirky April 7.2.1, built from packages compiled in T2. This is very much a "vanilla flavoured" build, just about anything will compile. And indeed, sabotage is off and running, compiling that is.

I will post a report sometime.

Just a thought: Quirky and Puppy are chameleons, Woof* builds them from the binary packages of any distro. No reason why Woof* cannot build from the binary packages created by Sabotage.


Pages: [1] [2] [3] [4] [5] ...