[[!meta title="Road map"]]

This is the road map for ick development. It does not stretch very far,
because predicting the future is difficult. This road map also doesn't
give any dates, this is a hobby project. It's also open for discussion.

Ick is now usable by others. If you try ick and have problems, do tell
us, see the [[contact]] page for contact information.

Ick is by no means an abandoned project, but we're taking a breather
while waiting for other developments. Most importantly, ick will want a
web UI, and that and other features will require end-user
authentication. The Qvisqve software ick uses for authentication will
be getting that support in 2018. Once it does, ick will start adding
support for that.

Until then, the plan is to make small, incremental improvements to
ick, fix bugs, improve documentation, smooth rough corners, and
gather experience on using ick.

The long-term goal is to develop ick into a hosted service, which can
be run on a commercial basis, without compromising on software
freedom.

# Roadmap towards hosted ick

```roadmap
hosted_demo:
  label: |
    Lars run a hosted
    demo service for
    himself and users
  depends:
    - user_friendly
    - secure_from_users
    - secure_for_users
    - on_demand_workers
    - trigger_service
    - multiarch

user_friendly:
  label: |
    Ick is reasonably
    user friendly to
    techies.
  depends:
    - webui
    - self_registration

multiarch:
  label: |
    Ick supports building
    for multiple
    architectures.
  depends:
    - worker_tags
    - concurrency

secure_from_users:
  label: |
    Ick is safe and
    secure from users
    doing silly things.
  depends:
    - networkless_containers

secure_for_users:
  label: |
    Ick is secure for
    users to use.
  depends:
    - isolation
    - secrets

secrets:
  label: |
    Ick provides a way to
    securely use secrets:
    ssh keys, pgp keys,
    Qvisqve access
    tokens.
  depends:
    - owned_resources

networkless_containers:
  label: |
    Containers have, by
    default, no network
    access. Trusted users
    can allow specific
    builds to have
    network access in
    containers.
  depends:
    - owned_resources

concurrency:
  label: |
    Ick can execute
    several actions in
    the same build
    concurrently.
  depends:
    - worker_tags

worker_tags:
  label: |
    Ick allows projects
    and workers to have
    tags, and can choose
    which worker to give
    an action to, based
    on tags

on_demand_workers:
  label: |
    Ick can create
    and destroy
    workers on demand
  depends:
    - worker_tags

trigger_service:
  label: |
    Ick can trigger
    multiple builds when
    a git repo changes,
    or when an ick build
    finishes, or after
    some time has passed

isolation:
  label: |
    Users can only see,
    manipulate their own
    data
  depends:
    - owned_resources

owned_resources:
  label: |
    Each resource is
    owned by its creator

self_registration:
  label: |
    Users can create
    an account by themselves
    via a web browser
  depends:
    - webui

webui:
  label: |
    Ick has a web UI
    that allows creation,
    updating, triggering
    of projects, builds,
    viewing status, logs
```

# Roadmap legend

```roadmap
goal:
  label: |
    This is the end goal:
    if we reach here, there
    is nothing more to be
    done in the project
  depends:
  - finished
  - blocked

finished:
  status: finished
  label: |
    This task is finished;
    the arrow indicates what
    follows this task (unless
    it's blocked)

ready:
  label: |
    This task is ready 
    to be done: it is not
    blocked by anything

next:
  status: next
  label: |
    This task is chosen 
    to be done next

blocked:
  label: |
    This task is blocked
    and can't be done until
    something happens
  depends:
  - ready
  - next
```