This morning I've been pondering on the following question: should I
try to achieve "ready for others to use" as soon as possible, or
should I concentrate on making sure all existing functionality is of
The big difference is that the former would hopefully result in
contributions from others sooner, the latter is would hopefully avoid
a deluge of bug reports.
I am leaning towards the former. Perfectionism is good, but it makes
things take a really long time and if things take too long, I get de-
motivated. "Write shit, but fix it quickly."
So what would it take for ick to be ready for others to use? Note that
it doesn't have to be perfect, it needs to work just well enough that
others are able to do at least something useful with it.
Here's my list, and I would appreciate feedback on this. Quick first
reactions are fine, no need to polish and do deep thinking.
* ick builds and publishes its own .deb packages. Presumably
would mean others can do the same for their own projects.
* Ick has at least a rudimentary notification system. The current
approach is to run "watch icktool status" and that's not really
good enough. Notification by email would be enough, I think.
* Uses Qvisqve for authentication. The current approach of having
every API client create its own access tokens is silly.
* ick constructs a build graph of all pipelines at the starts of
build. This means that it won't be necessary to trigger each
pipeline by hand and opens up a future where executing different
actions concurrently on different workes is a possibility.
* ick can do incremental builds by populating the workspace from=C2=A0
previous build. This means that if one source file changes, it's
no longer necessary to do a full build.
What do you all think? Is there something you can think of that ick
must do before you'd be willing to give it a try?
I'd welcome feedback on this (text reproduced below):
Would that be sufficiently useful for your initial needs? Is there
something there you'd be willing to do without?
- - -
Ick will need a way to notify users about build failures. Later on,
the same notification mechanism can be used for other things, but
start with the minimal thing that is useful. Here's a sketch.
Notifications will be configured in the project resource in the
* The controller will trigger a **notification service** to
send the notification. Don't want to burden the controller
the details of how notifications are sent, but the
to trigger a notification. (It will do this by
telling a worker to
do it, so that we don't need to have the
controller do blocking HTTP
calls to other services.)
will be triggered only on failures. Later on, this
needs to be
configurable and include options like a "build now
succeeds, when it
previously failed", and possibly also "always
* Later on, ick
needs to be able to flexibly notify via a number of
IRC, Matrix, SMS, RSS/Atom, etc. Probably also
like Slack will need to be supported. However,
we'll start with just
* The notification emails will always be sent with the same
information, and this will be configured by the sysadmin.
will always be sent with the same mail server, also
the sysadmin. Probably using `/usr/sbin/sendmail`
rather than SMTP.
Aiming for minimal necessary configuration to start
* The template for the emails will be hard-coded in the source
The mails will containt the following information:
name of project that was built
* build number
* build id
* log id (for
use with icktool)
* last 1000 lines of build log
* exit code of build
er on, this will need to extended, but the above should suffice for
The top-level `README` says:
"Ick2 is written in Python 2 (do not ask for Python 3, it will
happen when it happens)."
However the generated package uses python3 in all the dependencies,
as you can see in `debian/control`.
That makes me think that the README section is outdated/mistaken.