Background

Many students participate in over-night programming events dubbed “hackathons”. Such events provide a good opportunity for students to try their hand at solving one problem over a 24 to 36 hour period. However, in a bid to provide a working solution to the problems they have chosen to work on, students often resort to using a rather unfair mix of proprietary software, framework and non-free cloud services. While this does enable them to build something “novel” very quickly (ie. in the 24 to 36 hour time period reserved for the hackathon), it does not do much in terms of challenging them or creating deeper learning
opportunities.

At the same time, the rules and constraints of the hackathons themselves are very broad and generic. The organisers tend to focus more on the encouraging students to build “seemingly novel” solutions to the problems they are working on. Focus on using Free Software or GNU/Linux is completely absent as is any focus on self-hosting the software and hardware infrastructure required to build the solution. The absence of such a focus means that a valuable opportunity to convey the value of software freedom to students is lost.

In this essay, I try to examine why students make the sort of technology choices they make and how, by optimising for convenience and ease-of-use, students miss out on building better capability and appreciating issues related to online privacy and software freedom.

A student hackathon in progress at SIT Tumkur

What is a “hackathon”?

I am not sure why such programming and problem-solving contests are called “hackathons”, but they are. They are organised by engineering colleges to encourage students to solve problems and build solutions over a focused 24 to 36 hour time period. Students are required to choose a theme they would be working on and then provide an abstract of what they are trying to achieve. They then use the hackathon to actually build a working solution and demonstrate it.

The problem with “hackathons”

The focus of various hackathons is usually “vertical” in nature – ie. they focus on specific technology domains or sectors in which students can pitch their projects. These verticals, such as IoT, machine-learning, socially relevant solutions and so on don’t offer any constraints or guidelines about how the
problems must be solved. Hence, students are free to choose the software, the architecture, the technology stack, the operating system and so on.

This, I feel, is the loss of a great opportunity. In my view, it is not just enough to come up with novel and innovative solutions to problems. It is not the “what” that is as important, as the “how” and “why”. (In other words, “what” problem a student chooses to solve is not as important to me, as “how” they choose to solve it and “why”, ie. their reasons for choosing to solve it.)

While the “what” part of the problem-solving might focus on selecting which problem to solve such that it could be a commendable achievement and which could be attempted in the 24 to 36 hour time slot, the “how” part of the solution would look at the issues related to the ideology, architecture, licensing, freedom, privacy and the self-hosted nature of the solution.

Hence, if I am optimising for freedom, learning and control, the “how” aspect is more important for me than the “what” aspect. The world is full of extremely novel and innovative products. But very few of them are built to respect the freedom of their users.

What is there to gain by creating more solutions that only add to the body of proprietary software, hardware and network services that already exist?

Why do students participate in a “hackathon”?

My observation is that students participate in hackathons for some or all of the following reasons:

They really care about the problems they are proposing to solve and feel that the environment of a hackathon will actually enable and motivate them to build the solution they want to build

• They get credit for participating in such events and it would look good on their resumes
• They seek to compete and achieve something in front of their peers
• They want to test themselves to see if they can build something working in a sprint and with limited time
• The prize money is something to aim for as well!

Dear student, the way I look at it, these goals above don’t provide enough long-term value to a student. It is not enough to focus on the outcomes, ie. achieving the goals of the project or showing that you are capable of building such-and-such thing. A hackathon is one of the best opportunities to learn and challenge yourself. The 24-hours that you spend with complete focus, all amenities and no distractions can help you learn a lot.

Hence, think beyond just building whatever you’ve set out to build. Aim for finishing the hackathon with a lot more insight, exposure, awareness and inspiration than what you came in with. I have some tips how can do exactly this and more.

Advice for students participating in hackathons

Dear Student,

If you are participating in an upcoming hackathon, please consider the following points. They might enable you to carve an extremely valuable learning experience out of the hackathon. Making some (or all) of these choices will only affect “how” you build your project – not what you set out to build. As a side-effect, you will have chosen a more ethical means of building a solution – one that does not force the users of that solution to sacrifice their freedom, choice, control or privacy.

Hack (verb)

Hackathon is a word derived from the verb, to hack. So if you’re participating in a hackathon, the first choice you could make is to hack. A hacker hacks. You are participating in a hackathon – imbibe the spirit of the hacker ethic in your work.

Who is a “hacker”?

Hacker: noun

A person who enjoys exploring the details of programmable systems and how to stretch their capabilities, as opposed to most users, who prefer to learn only the minimum necessary

A person who delights in having an intimate understanding of the internal workings of a system, computers and computer networks in particular.

One who programs enthusiastically (even obsessively) or who enjoys programming rather than just theorizing about programming.

What is the “hacker ethic”?

As Stephen Levy summarized in his book Hackers: Heroes of the Computer Revolution

Hackers are doers. They care about doing things. They care about access & freedom of information, and improvement to quality of life.Z

If you can understand the hacker ethic and how it has influenced the free software movement, you will be able to understand and adopt the same values into your work and life.

Can you use the hackathon as an opportunity to examine, understand, validate and adopt the hacker ethic?

Don’t focus on convenience!

This advice might seem absurd at first. But let me explain.

While observing the choices that students make during hackathons, I concluded that most of the choices are aimed at cutting down on the amount of work that they need to do. This is a strange choice! Why would you, as a student, want to save work for yourself? Doesn’t doing something enable you to understand it better? By eliminating the need to do even very simple and basic things, are you also not forgoing the opportunity to learn so much?

For example, at a hackathon I observed that almost 90% of the students chose to use a cloud-hosted and proprietary database software called “Firebase” for their database needs! When queried about the reasons, they pointed out how simple it was to program it from a mobile application or a web application alike. They did not consider the fact that they were forcing their users’ data to be stored on “somebody else’s computer” (ie. the cloud) and the software that was being used to store this data (ie. the firebase database) was proprietary and out of their control.

The other 10% of the students used MySQL, Postgres, MongoDB and SQLite for their database needs and went about setting up and maintaining these databases by themselves.

Focus on “doing things yourself”

The problem here is simply that of an excessive focus on “convenience”. Using firebase, for example, might be extremely simple and maybe you integrate it into your project quickly. But what is it that you learn by using it? How to consume an API to use proprietary software to store simple data?

Think again. Are you participating in the hackathon to have convenience? Are you going to stay awake for 20 hours (or more) at a stretch just so that you can take such short-cuts?

When you do things yourself, you learn so much more and you have so much more in your control. Plus you don’t impose your choice of using proprietary software onto your users.

Choose self-hosting

The corollary to rejecting convenience is to choose self-hosting. You choose self-hosting when you build and maintain all aspects of your project yourself. You host these “aspects” on your own hardware – laptops, single-board computers, micro-controllers, servers, virtual machines etc.

Choosing to self-host is a required condition to choosing free software to power your project. If you can not self-host a tool, how do you know if that tool is free/open source software?

What can you self-host?

There is always a way to host everything you need yourself. It could be that you are not aware of such tools or ways of doing things. Can you use the hackathon to discover ways of self-hosting everything?

You should be able to be build everything you need and hence, control whatever you have. This includes databases, network services (DNS, DHCP, email, NTP etc), file services (object storage, block storage, shared file-systems), application servers, containers, virtual machines, time-series databases, monitoring
systems, wireless networks and so much more.

Self-hosting in the context of IoT

Usually, an IoT solution consists of the following “layers”. You should have complete control on all these aspects of your solution. The reason I single out IoT here is because I feel that there is not enough information out there about how one can build 100% of one’s network, cloud-backend and firmware infrastructure using Free and Open Source Software exclusively.

Consider the following points:

Your hardware and physical setup

This includes your micro-controllers, single-board computers, circuits, PCBs, serial and network cabling etc.

Choose your hardware such that you retain the freedom and flexibility you require to build your project.

Firmware, programs, source code, network connectivity

Any hardware you choose should offer two basic freedoms to you:

(a) The freedom to program the hardware using GNU/Linux

(b) The freedom to compile and execute your programs using a compiler or interpreter licensed under a Free/Open Source Software license

Choose your networking setup such that:

(a) you can run the wireless and wired network using your own access point to aid control and debugging (extra points for you if you can run this access point using a free software operating system such an OpenWRT or LibreCMC)

(b) you don’t have to blame someone else when your program does not work

Metrics storage, analysis and alerts

Often tutorials or books that talk about IoT introduce and use proprietary software hosted on the public cloud to storage sensor data and metrics. Functions related to analysis and alerts, then, are also handled by the same set of proprietary software running on the cloud.

Instead of this, can you choose to use Free Software tools such as InfluxDB, Prometheus and OpenHAB to store your sensor data? Can you use a simple instance of Grafana to graph and analyse this data? Can you send out alerts and detect anomalies using the various features offered by the tools mentioned above?

These are very capable, comprehensive and easy-to-use tools. Don’t choose to use proprietary software just because that is all that you are aware of. At any juncture when you have to make a choice of what software to use for a purpose, search and evaluate how you can do it yourself using free software
tools.

Remote access and control

Most IoT solutions that connect to a network (wired or wireless) need the ability to remotely access and control the device. Often, the simplest way of doing this is to use protocols such as MQTT. The significant value-add that is provided by cloud-hosted IoT backends is an effortless way to use MQTT.

However, if you spent some time understanding how MQTT works, you could do the entire setup yourself. Using tools such as OpenHAB or Home Assistant, you can get ease-of-use while still being able to use free/open source software and self-hosting it on a single-board computer (eg. Raspberry Pi) or your laptop.

Can you optimise for learning, instead of delivery?

In my view, the reason students take so many short-cuts during hackathons is because they are optimising to deliver what they have committed on as the deliverable for their project. There is nothing wrong in focusing on this – however, if this focus forces you to take short-cuts and does not create enough learning opportunities for you, then you are not capturing enough value from the hackathon!

Instead, my advice is to focus on learning. Whatever you do as a part of building your project, evaluate how not doing what something “conventionally” can provide greater learning opportunities to you. Often this learning will emerge because you use to self-host a Free Software tool for your project or because you choose to do something yourself.

By focusing on learning, there is a good chance that you will be proud of your achievement at the end of the hackathon. And this still does not change your ability to actually deliver on your intended goal – it might just change the way you deliver it.

Use a Free Operating System!

I would have thought that in 2018 it would be obvious that students (and developers) would use GNU/Linux. But my observations suggest the contrary.

When all aspects of your work are actually free software tools, why run them on a proprietary and non-free operating system? Programming languages such as Python, Ruby and NodeJS are all licensed under various free software licenses. Databases that you use, such as MongoDB, SQLite, MariaDB/MySQL and PostgresQL are also free software tools. Your programming IDEs such as vim, Atom or even the Arduino IDE are all licensed and available under free software licenses to you. Arduino libraries and MicroPython (to name a few of the embedded IoT toolkits) are also free software.

There is a lot more value to derive from these when you run them on GNU/Linux. While almost all of them are cross-platform and can run easily on Windows or macOS, I don’t see how doing that provides your a better learning opportunity or an opportunity to get better at doing whatever you’re doing.

So use Debian GNU/Linux or Ubuntu or Fedora on your laptops and run all the tools that you require seamlessly. No need to use virtual machines to run GNU/Linux just because you want to use Docker to run something in a container.

Can you choose to build free software?

While it might be too early to think about releasing and sharing your software publicly, I would actively encourage you to do that. Doing this is not only an ethical choice to make, but also provides unprecedented learning opportunities.

If you need help to figure out how you can release your project under a Free Software license and which license you should choose, I would be glad to help you out.

Choose free-software on the cloud, not software-as-a-service

This is another way of talking about a point I made earlier. Consuming and using software offered as a service (eg. database as a service, MQTT as a service, analytics as a service etc.) is a covert way to use proprietary software. Most of the times the software that is used to power such services is not available
to you to study, setup, modify or self-host. Additionally, your data is stored on (and locked-in to) such software-as-a-service offerings and once you use them for some time, it might be difficult or impossible to leave the platform and choose something else.

When you have to use software that does not run on your computer (ie. software which is hosted on the “cloud”), ensure that it is free software. This will give you the freedom and choice that you need in future. Don’t choose to use a software-as-a-service offering just because it is accessible, popular, free-of-charge or convenient. Making these choices neither offers learning opportunities to you, nor freedom, privacy and control.

Don’t make short-term choices that will remain with you in the long run.

Reject APIs that deliver convenience at the cost of control and freedom

Using APIs that are backed by proprietary software offered as a service is another way you compromise on your freedom and learning opportunity. Often an API is just an easy way to do something that requires no setup and gets you “productive quickly” and by doing “lesser work”.

Thing about this: Is it essential to use an API to build whatever you’re building? Can you do 2% more work and eliminate the API? Can you self-host a tool and use the API on a network and with software that you have complete control on?

How about substituting the API with a protocol? Eg. A popular way to send an email is to use a web API offered by a service provider. Instead of using a proprietary API, can you build a SMTP server on your own to achieve the same goal? It would be a wonderful excuse to learn how to setup mail services!

APIs are conveniences that can cost us our freedom if we are not careful and vigilant. Don’t make these choices now to deliver something quickly which might limit what you can do in the future.

Take the hard way!

Convenience does not facilitate learning, it eliminates it. You should optimise for learning. You should welcome problems and challenges because they present a learning opportunity to you.

“There is no such thing as a problem without a gift for you in its hands. You seek problems because you need their gifts.”

Richard Bach, “Illusions”

Take the hard way. Don’t avoid problems because you perceive them to be difficult and an impediment in achieving whatever you’ve set out to. Problems that we face when we build something are essential to helping us learn and become more effective at what we do. All problems – technical, personal, time-management, collaboration etc – are just indicators of what more we need to learn.

When you eliminate the problem, you also eliminate the possible lesson associated with solving it. Is that why you are participating in a hackathon?

The “gift” of a problem is the learning and capability that emerges from attempting to solve it. The problem is not permanent, the learning is.

Keep a work diary

Maintain a simple “work diary” to record what you need to work on, what problems you faced, solutions you considered when trying to solve the problem and finally, how you solved it. Use this diary to also note down questions that came to your mind but which you could not answer conclusively right then. If you take an inventory of such questions, challenges and problems, you can re-visit them again after the hackathon and continue your learning and study.

Maintaining a work diary is also a good way to reflect upon what you did. It is not always possible to recollect how we did something or why. A diary would be a good way to record these things while we are doing them and while they are fresh in our minds.

Later, you can use this diary to publish an article or a blog-post about “how you built X”!

Get in touch!

I am always reachable via email: abhas@deeproot.in. Please feel free to write to me in case I can add value to your work or help you become more effective in creating learning opportunities.

All the best if you’re participating in a hackathon in the near future and I hope that you find the advice above useful and actionable.

Recently, while having a discussion with a friend on how to handle a
major technical issue in their college, I mentioned some collaboration
opportunities that would have come up if they had chosen to use free
software in the first place. When he said that “no one in the college
will listen”, that got me thinking.

Do we only talk about something we consider useful if we feel that
someone is listening to us? What do we loose by talking even when no one
is listening to us? What if they started listening and we were not there
to talk? Then that is our loss as well as theirs’!

Since we can’t know when (or whether) they are listening to us, one
thing we can do is to keep talking!

Hence, if we want to talk about free software, it shouldn’t matter to us
if those we are talking to don’t listen to us. I am confident that, over
different points of time, different people will listen. If we can
motivate ourselves to keep talking plainly, it will matter.

The next question is – how do we talk in an efficient manner? I believe
recording thoughts in a publishable form is a good way to refer to them
or share them later on. If we can write about whatever we want to talk
about, it becomes “reproducible”. And the next time, we can re-use it to
make a similar point.

So to summarize – (at least) in the context of free software, don’t stop
talking just because you feel that no one is listening. They will listen
sooner or later.

I thought, instead of just mentioning about the coverage, if I could
offer some more details and clarification and share the experience,
maybe that might be of greater value.

Open Source For You (OSFY) – January 2019 issue

Here is a link to the ToC of
the Jan 2019 issue of the OSFY magazine. I will link to the actual
article once it is posted on the main website – maybe in a month or so.

Please do purchase the issue if you want to read this article. If you
are not able to find a copy easily, do mail me and I will find a copy
and courier it to you.

Linux v/s GNU/Linux

The company is called “DeepRoot Linux” because in the year 2000 when it
was setup, it seemed like an excellent hack. I think it was in 2006 when
RMS asked me for the first time why it wasn’t called “DeepRoot
GNU/Linux” and I explained how changing the company’s name is a very
complex and costly process. I had added that apart from the name of the
company, I generally use GNU/Linux to refer the operating system.

That excuse seemed sufficient for many years, until a few months back, I
got asked the same question again by RMS:

Founder & hacker-in-charge, DeepRoot Linux

Why is the name “DeepRoot Linux”? That name promotes the name
“Linux” at the expense of GNU.

And then I realised that nothing stops me from calling the company
“DeepRoot GNU/Linux” irrespective of the company’s legal name. And so,
after 18+ years, I updated the logo to indicate this oversight:

Our logo now includes “GNU” before “Linux”!

The only reason I’m reciting this story here is because the article
mentions “DeepRoot Linux” and I thought it is important to explain why.

FOSS v/s Free Software v/s Open Source

If I have to talk about software that provides freedom and is
distributed under licenses that provide + protect such freedoms for
users and developers, I use the term “free software”.

Many people use the term “Open Source”. Or a compromise term: “Free /
Open Source Software”. Or even “Free / Libre / Open Source Software”.

I feel that saying “free software” is sufficient and provides us with an
occassion to explain the importance and significance of freedom in
software.

Most places in the article I use the term “free software” itself. But as
I read it again now, I realise that some place the article also uses
“FOSS”. Right now I am very upset about this negligence on my part and
how I didn’t realise this while reviewing the content on multiple
occassions.

Being consistent is very important and I am sorry I was not consistent
enough in my usage of my preffered term: “free software”.

Image Credits

The photo used in the article was probably taken by a student at NIT
Durgapur in Feb, 2018 when I was there to an interaction with the
students. Thank you – I am glad to use your photo in most places where I
need to use a photo. I owe you for this!

The importance of editing

After I wrote close to 5000 words for this interview, I realised how
some of the statements were very open-ended and did not serve to make
any point. But I had spent too much time interating over the draft. The
editorial team at EFY helped a lot and their edits were very useful.

However, I felt that maybe if I re-wrote the first 40% of the content, I
could’ve written it better. At many places, it wasn’t clear enough, it
didn’t have enough facts and it didn’t really make a conclusive point. 🙁

Thanks EFY Editorial Team!

The editorial team at EFY was very patient and helpful. Thank you Rahul,
Niraj, Shweta and Aashima! An additional thanks to Rahul Chopra
(Editorial Director, EFY Group) for suggesting this and
supporting.

Links to resources mentioned in the article

Books

‘Hackers: Heroes of the Computer Revolution’ by Stephen
Levy (Wikipedia)
Source code, documentation and sytems written and designed by D. J.
Bernstein – https://cr.yp.to
‘Coders at work: Reflections on the Craft of Programming’ by Peter
Seibel (Wikipedia)

Essays

The GNU Manifesto
The Cathedral and the
Bazaar

Presentations

Some pointers on why freedom matters even for students and what it
means to be a hacker – https://abhas.io/students-hackers/

For those who have teaching roles in academic institutions
(especially faculty members in engineering colleges), Abhas offers
a roadmap on why it is important to choose free software to
optimise for freedom and learning.
https://abhas.io/for-teachers

For entrepreneurs who want to consider building a business around
free software
https://freesoftware.business

In this presentation (extracted from a talk at Swatantra 2017), I
explain the problem of ‘black boxes’ and how we can get rid of
them using free software and self-hosting. –
https://abhas.io/no-black-boxes

Overview

Here are some free software projects that students can work on. I expect
that multiple students will work on the same project but with different
approaches.

Some of these project are research and documentation projects (tagged:
research) while others are development and documentation projects
(tagged: development).

Modalities

These projects are only meaningful if we do them in the right way.
Here are some modalities for these projects if you choose to work on
them with me:

The projects should only be done on a GNU/Linux operating system and
without the use any proprietary software

All projects will require regular reporting so that we can review
work on time and ensure that you are progressing in the right
direction.

You should be ready to learn a lot – I will help you define the
learning goals and the research, documentation, note-taking and
outlining techniques that could be useful.

The version control system we will use is git. This will be backed
by a private and self-hosted project management system, bug
tracking system, CI system and wiki.

Documentation would need to be written using markdown and will also
use git as a storage and collaboration backend.

You can chat with me via
Matrix/Riot.im in case
you need to use instant messaging. Otherwise, email and the
project management system should be sufficient for discussions.

Any mobile applications that we develop for Free-Android will not
depend on any proprietary software or service and will also be
licensed as free software. Study the requirements for publishing
software in the F-Droid repository and use
that while building your software.

Web Applications

Themes for Starli

About

Shaarli is a self-hosted
bookmarking tool. It helps you store your bookmarks on your own server
and annotate and share them publicly (if you wish).

Why?

The default and available themes by the Shaarli community are not
minimal enough!

What? & How?

We need to build two sorts of CSS themes for Shaarli:

A minimal theme – similar to the way emails are listed in a mail
client

A dark theme – which uses white text on a dark background – again
listing the links in a manner similar to how mails are listed in a
mail client

Simple CI system for gitea

About

Gitea is a web-based git version control system.

Why?

Unlike full-blown version control systems like Gitlab, Gitea does not
have an integrated Continuous Integration (CI) system. It however has
support for other third-party systems such as Drone CI and others.

What?

Here is what we will do as a part of this project:

Understand how webhooks work with Gitea

Integrate a CI system with Gitea that will run a CI pipeline on
every git push

Document how to integrate a CI system with Gitea

Package and release a set of Docker containers that can be deployed
and shared easily

Patch for gitea to customise front page

What?

Gitea has a default front page that explains its features.

As a part of this project, we will develop a patch for Gitea that will
enable a Gitea admin to replace this front-page with a statically
generated website pointed to by a configuration line.

Static site hosting for gitea

What?

Make it possible to use Gitea along with a CI system to deploy static
websites on git push.

WordPress-libre development

About

WordPress is a very popular content management system (CMS) and blogging
engine.

Why?

There are multiple problems with WordPress and its plugin ecosystem
today. Primary among them is the way Javasript code is loaded and used
across a website.

What?

We will modify the WordPress source code and that of major and useful
plugins to achieve the following:

All javascript and CSS should be loaded locally and not from a CDN.

All non-trivial javascript should be
LibreJs compliant.

It should be possible to take stock of the licensing of all the
components that affect a single WordPress instance.

Jekyll – Rails shopping cart integration

About

Jekyll is a static site generator written in
Ruby.

What?

Make it possible to integrate a static Jekyll website with a (Ruby on)
Rails shopping cart engine. Specifically, we are looking at integrating
the Solidus shopping cart with
Jekyll.

How?

The final result should enable a developer (or user) to put in some
simple Liquid tags onto any jekyll page to connect and embed a shopping
cart with it.

Jekyll podcast framework

It should be trivial to use Jekyll to publish a podcast, make sure the
podcast website can be viewed without using javascript, to customise the
looks of the website and finally, to publish it RSS feed.

OSEM conference management system

Package and document the OSEM conference management
system so that it is easy to use and effective for
running the cPf for a conference related to free software.

Self-hosted audio conferencing, recording and interview system

How does one use self-hosted free software to interview someone over the
Internet and also record the conversation? What if there are multiple
people in an audio conference?

Setup, document and package an effective way of doing this.

Extensible and customisable email signup form

Build a framework to build an embeddable email sign-up form that can
work standalone or with a static website. It should be possible to code
the form using a simple text based definition language and without
having to write custom HTML or configure or customize a database.

Markdown newsletter submission system

Build a Jekyll-based newsletter submission system that can be used to
send a newsletter to an email list by just writing and publishing a new
jekyll post.

Coreboot

Skulls-derived Coreboot distribution for X220 and X200

Build, test, package, document and release a
Skulls-based or like Coreboot
distribution for the X220, X200 and X201 Thinkpad laptops.

Custom logo integration into coreboot

Build, test, package, document and release a set of scripts (+ docker
container) to embed a custom image or graphic for use with Coreboot
during the boot phase of the computer.

X200T Libreboot flashing success

The X200T uses a very different type of BIOS chip which makes it very
challenging to flash coreboot onto it. Document and package the process
of running Libreboot and Coreboot on the X200T laptop.

Heads integration, validation and documentation with X230

While Heads works well on the X230, documentation and packaging are
required so that users can use it easily and effectively.

Chromebook Coreboot distribution

Many Intel-based chromebooks (our development efforts will revolve
around falco) can run Coreboot by default. Build, package, document
and release a Coreboot distribution for the falco chromebook.

Hardware Boards and IoT

Documentation for Bus Pirate v2 and v3

About

The Bus Pirate is a
mult-tool that talks to electronic stuff. One great use for the Bus
Pirate is to flash BIOS chips on a motherboard over the SPI bus.

What?

We need to test and release documentation that will enable anyone to use
the Bus Pirate to (at least) flash BIOS chips with Coreboot.

Testing and documentation for Numato Opsis

The Numato Opsis is a HDMI2USB
board that can be used to mix, capture and stream video from multiple
sources.

We need to test and document simple, yet reliable ways of using the
Numato Opsis to (primarily) record and stream free software events and
conferences. This will take the guesswork and complexity out of using
the Opsis board and it will become a default way to do such recording
and streaming.

Rock64 u-boot network boot

The Rock64 SBC from Pine64 has a SPI flash which runs u-boot. This is a
unique feature of this board and because of this we can get it run in a
diskless manner and boot off the network.

Test, package, document and release a reliable method to boot the rock64
off the network.

vim-arduino IDE

Build a vim plugin to enable vim to act as an Arduino IDE to program
microcontrollers.

vim-micropython IDE

Build a vim plugin to enable vim to act as a micropython IDE for rapid
development.

Documentation for PADI

PADI is an inexpensive wireless microcontroller from Pine64. It can run
FreeRTOS among other firmware.

Write documentation and examples on how to use PADI for common tasks in
place of other wireless microcontrollers.

PADI with relay + RGB LED + MQTT client support

Use the PADI microcontroller to build a wifi power switch.

FreeRTOS + micropython packaging

Package a custom distribution of FreeRTOS with micropython for various
microcontrollers.

FreeRTOS + esp32

Package a toolchain and development environment to run FreeRTOS on the
ESP32 microcontroller.

Document proprietary software in each SBC OS distribution

The operating system images of almost all single-board computers contain
proprietary software. Study the OS images of the Raspberry Pi, Orange
Pi, Odroid, Rock64 and Nano Pi boards to document which parts of these
images are proprietary software.

Application Software & Solutions

Webinar demo and documentation using openmeetings

Evaluate if it is possible to use Apache OpenMeetings for Webinars. This
will ensure that people don’t have to use proprietary software for
running their webinars.

Self-hosted video streaming

How do we stream a talk or lecture to the Internet using commodity
hardware? Build, document and package a self-hosted solution for doing
that.

Jitsi Meet with login and no public registration

Jitsi Meet is a very useful free software tool for video conferencing
and desktop sharing. However, the default way it is packaged is a “demo”
and it allows anyone to use it publicly.

We need to build a wrapper application around Jitsi Meet so that it can
be self-hosted easily and used for video conferencing and desktop
sharing securely and privately.

Telecom & VoIP

Container distribution for compiling FreePBX dependencies

Compiling and getting FreePBX to run can be very frustrating because it
not only does it have complex (and many times, undocumented)
dependencies but also multiple steps that have to be executed carefully.

By building a container distribution for FreePBX, we can compile
wanpipe, freetdm, dahdi and freepbx in a simple and reproducible manner.

Desktop Applications

Basic web-browser using Gecko / Quantum

It should be possible to use the Firefox engine to build mini
web-browsers. This project will explain, document and automate this
process of build Gecko / Quantum based web-browsers.

Electron-like desktop apps using Gecko / Quantum

Similarly, desktop applications which are browser-based should NOT only be
powered by Webkit or chromium. We should be able to build such
frameworks and application using Gecko and Quantum as well.

Mobile Applications

Mobile application for OpenWRT

Build a free software mobile application for Free-Android that can be
used to control an OpenWRT device over RPC.

Mobile application for OpenHAB & home-assistant

While both OpenHAB and Home Assistant have very easy-to-use and free
software mobile applications, it would be good to build a custom
application which exposes a limited set of features and makes these
systems more usable.

Mobile application for MQTT native

Build a mobile application that can natively talk to a MQTT server for
managing a self-hosted IoT installation.

System Software

DNSSEC with tinydns

Build documentation and package software to get tinydns to work with
DNSSEC.

Git Push-based tinydns management

Build a text-based database format to version control DNS records over
git and publish them via tinydns.

Extend tinydns.in management app to latest Rails and REST API

We have a rather old Rails application to manage DNS records for
tinydns. It should be re-written using the latest release of Rails and
so that it also exposes a REST API

Test out, package and document dovecot full text search (fts)

Dovecot is an IMAP server that can also act as a deliver agent among
other things. In conjugation with a search engine, it can index a
mailbox and enable full text search for it.

Build, document and package the full text search capabilities of
Dovecot.

Integrate, document and package Kerberos with OpenLDAP

Integrate, document and package Kerberos so that it can be used along
with Append for single sign-on in a GNU/Linux network.

In my personal opinion, it is meaningless if we attend an inspiring talk
by Dr Richard Stallman today and are not able to reflect on his message
and act on it.

Here is a small set of things that you can do. There is no timeline.
But please see which of them are relevant to you.

A few months back, I wrote about how we can personalise and deepen our
involvement with free software. Consider
those points in addition to what I’ve outlined below.

Write about it

The first thing to do would be write about the experience, what you
learnt, what you agree with or disagree with (and why) and so on.

Writing about this will enable you to record your opinions and also
share them with others. Later, if your perspectives change, you can
revisit this writing and reflect on what has changed and why.

Ask questions & Seek help

If you did not ask questions after the talk or didn’t get a chance to,
then you can still ask questions. There are multiple forums where you
can ask these questions.

Similarly, if there is a conceptual, philosophical, technical or social
issue that you feel you need to seek help about, then do reach out.

Audit and review your own software usage

An easy thing to act upon and do is to audit and review your software
and technology usage and then change it based on learning that you’ve
drawn from Dr Stallman’s talk.

Desktop and Laptop

The quickest and most impactful thing you can do is use Free Software
and GNU/Linux on your desktop or laptop computer. A good way to do that
would be to install Debian GNU/Linux or
PureOS on your computer.

Servers

Do you know about what software you run on your servers? What if the
operating system and software you ran on your servers was GNU/Linux?
What if you could power the services that you run on your server with
Free Software?

Services

All the software that affects our lives does not run on computers within our
control. Much of it runs on other people’s computers (often termed as
“cloud”) while some of it is only accessible as a service.

Service offered as a Software Substitute (SaSS) is a way for proprietary
software developers to offer the value of the software but not the
software itself. This is just another form of proprietary software that
robs you of your essential freedom to use, study, change and
redistribute the software.

Review your use of such services and see how you can substitute them
with self-hosted and free software services.

Mobile Devices

Operating systems on mobile devices are another form of proprietary
software. As are the applications which run on these operating systems.

These proprietary software applications are more invasive since the
mobile phones are with us all the time and they have multiple types of
sensors that can track our location among other things.

Using free software on mobile devices is not only a way to have your
freedom but also protect your privacy.

Proprietary Software on GNU/Linux

It is possible to run proprietary software on GNU/Linux as well. Many
times we don’t even realise that we are using proprietary software on
GNU/Linux.

Check if there are any such cases in your daily software usage and then
replace them so that you can have more consistency between your beliefs
and your actual technology usage.

Tell at least 3 others about it

If you learnt something useful and valuable in the talk, why not tell at
least 3 others about it? And then point them to other resources where
they can learn a lot more?

You can contribute further!

Release software

Are you a programmer? Do you build software?

Consider releasing it under a free software license – preferably a
strong copyleft license like the GPLv3.

Participate

Help others discover, adopt and appreciate free software

Write or translate documentation

Write tutorials about something you’ve done or figured out

Give talks

Build a local community and free software user’s group

Support & Donate

Many volunteer free software projects accept donations today. See if
the free software project you love accepts donations. Then donate
to the project or to individual developers who contribute to it.

Donate to the Free Software Foundation – your contributions are
the most important manner in which FSF finances its operations,
pays staff salaries and continues to advocate for software
freedom.

Donate to other non-profit organisations such as the Software
Freedom Conservancy as a way of indirectly supporting some of the
biggest free software projects they help and contribute to.

Reach out

I would personally be glad to help you in your journey to use, promote,
release and support free software. Please feel free to get in
touch.

Photo credit: Prof Renuka Prasad B from RV College of
Engineering.

Talk Slides

The PDF slides that I used for my talk are available for
download. Or
you can preview them online as
well.

Or you can also view these as a JPEG slideshow of
images.

Tutorial Slides

I also presented a tutorial and live demo of a how to build an IoT
solution without using proprietary software. You can either download the
slides or view them in your
browser itself.

Or, you can view them as a JPEG slideshow of
images.

More to come!

I will add some more commentry on this topic in a few days time. Please
do visit again.

Foremost – I consider myself to be a sysadmin. More than a “job
description”, its an attitude and value system. And today, on SysAdmin Day, as
a tribute to sysadmins and hackers everywhere, I thought I must share my
perspective about why I am a sysadmin.

Sysadmin first, Programmer next

Why do you program? To solve a problem. Who defines the problem to you?

Being a sysadmin is a process of discovering new problems in new
situations. Sometimes, you can solve those problems with quick hacks and
creativity. When you can’t, you write a program.

Thinking like (and as) a sysadmin enables me to always first assess
existing tools, methods and options. Then when you write code it is to
fill in a gap or extend or fix an existing system.

For me, thinking as a sysadmin is a way of generating long-term
programming projects. It also enables me to choose more complex
programming projects that depend on servers or services or
infrastructure being in a specific state.

An opportunity to know things

Often focussing just on programming does not give us sufficient exposure
to how things work “under the hood”. A program can also often depend on
a variety of services and understanding how those services work and how
they interact with each other can be integral to how the program is
developed.

But most importantly, intricate knowledge of how things happen at the
operating system, network, hardware or service is a very important
skill. These insights can help in designing more efficient systems and
programs.

Laziness is a virtue!

As a sysadmin (and a programmer) I am lazy. If I set something up and
its working, I rarely want to make changes to it. The same holds true
for a program as well.

However, the reason such laziness is a virtue is that if you know that
you are going to be lazy in future, you can do two things pro-actively:

You can build a process that is not costly (in terms of effort) and
which encourages rapid change

You can foresee issues that might come up and compensate for them
in advance

Being a sysadmin has taught me a lot about responsibility, accountability and collaboration

When I build and operate and maintain services that others use, there
is a lot of responsibility that lies on me. I need to my work
responsibly (can’t do a bad job that doesn’t offer the value a user is
looking for), carefully (ie. I can’t be careless) and quickly (who wants to
wait an inordinate amount of time waiting for a fix).

I should also hold myself accountable if (or when) I make a mistake that
affects users. I should also build things in a manner that they are easy
to monitor and maintain by others should I be unavailable.

These are all things I repeatedly learn as I perform my sysadmin roles
at home, at my workplace and for our customers alike. I don’t think
there is a better way to learn these values and practice them on a daily
basis.

“Being There” takes a new meaning

Its often said that being a sysadmin is a thankless job. People are
quick to point out when you mess up and don’t want to leave you alone
till you’ve solved their problem.

Hence, “being there” and available takes a new meaning. There will
always be situations where I might need to do things when there are
other conflicting priorities to deal with.

The delight of a job well done!

What is the experience of discovering a system that’s been running for 4
years without requiring a reboot, login or maintenance? … which you
didn’t even know was still online and working and providing a service to
its users?

The sheer delight of making a discovery of this sort is beyond compare.
It makes the whole process of administering systems so worth it

Learning, taking risks and building confidence

Doing things, getting my hands “dirty” and seeing them work out is great
learning. Doing such thing repeatedly builds confidence and that gives
me the ability to take risks, make quick decisions and build bold
cross-connections.

All these things are integral to choosing to be a good sysadmin.

I can type fast! 🙂

It would be painful to have a command in your head and then be limited
by your ability to only type so fast to see what would come out of
executing it.

I learnt to touch-type because I took up typing in school. And much
later on, it only helped me become very productive as a sysadmin. More
so with hackable mechanical keyboards.

Hardware development as a sysadmin

I like to think that it is possible to visualise any problem in a
“sysadmin manner”. I imagine hardware development that way. Knowledge of
how to connect systems together can help build hardware that works and
connects in creative ways.

(How about running a web-server on a micro-controller so that Prometheus
can scrape its sensors’ values and show them to you on a Grafana
dashboard?)

Thinking in pipes

I often think in “pipes”. Pipes are an excellent way to do quick hacks
on the command-line. And if you can extend that value system a bit
further, you can connect things in disparate ways without having to
over-engineer them or re-invent the wheel.

Getting the computer to work for you…

… as compared to us doing something ourselves. Often, our methods of
choosing to do things are not optimized for using the power of a
computer to our advantage. We do too much manual labour because
automating something on a computer is tedious job.

One thing being a sysadmin has taught me is about the power of
automation. If I can get the computer to do something and do it again
and again, it definitely isn’t going to get fed-up or tired. On the
other hand, unless I did that I would be using my own time in the most
sub-optimal manner.

Understanding an operating system or a network or a system well enough
to use all of its power in our favour is an excellent sysadmin skill.
And I am fortunate to have had the opportunity to examine this value the
hard way – by making mistakes. Very tedious ones at times!

My powerpack: GNU + Debian + vim + SSH + Bash + Ansible + Docker

I don’t like monolithic systems because they go against the “unix”
philosophy of one little tool doing one thing well. (I’m talking about
systemd here, of course!)

A combination of GNU utilities, Debian, vim, ssh and bash form the most
important tools that I can ever need to get work done. And now ansible
and docker complete the power-pack to provide the elements I’d been
missing. I believe that knowing just these tools well is sufficient to
handle any sysadmin task effectively. Just these.

Its a practice – it needs practice

“The Practice of System and Network Administration” is an iconic book
that I discovered quite some time back. When I discovered it and read
it, I realised that it contained every bit of information and set of
practices that a sysadmin would ever need. Not just technical skills,
but the book could also teach us so many non-technical skills that are
essential in our sysadmin lives.

Among most bits of advice that stood out, three things stood out for me:

the authors chose to look at sysadmin work as a practice – like what
a doctor would do!

their advice on fixing each problem just once is my personal ethic
for building automation and productising sysadmin work

their chapter on time-management was a gem – being to “get things
done” and remaining productive are essential traits and
time-management plays no small part in that

Like with all other practices (badminton or medicine, for example), the
practice of being a sysadmin also needs practice. Its not a designation
one earns solely out of getting hired or promoted or delegated. Being a
practicioner is what matters – without practical, actionable skills and
knowledge, I couldn’t have been a sysadmin at all.

With the detachment of a doctor and the empathy of a nurse…

Finally, I feel, being a sysadmin has helped me develop greater empathy
for users of any system I build. Excelling at building systems that
people like to use and which solve their problems is great fun. However,
at the same time one can not sacrifice stoic objectivity and pragmatism.

Being a sysadmin is a healthy mix of both.

Strength of a community and aspiring to contribute back…

I can not do justice to a subject as critical as system administration
without talking about what it means to be a part of a community. I am
glad that sysadmins love to share what they build. And when sysadmins
write software to solve problems, its fascinating to learn about how to
build little bits that do a significant job.

Unless everyone could share and collaborate and help each other, it
would be impossible to learn. I learn not just from forum posts where
someone might have got a solution for exactly the same error I’m facing.
When sysadmins write documentation or books, create automation tools,
package software or get it to inter-operate, there are many more ways to
learn from.

“We should all own the content we’re creating, rather than just posting to
third-party content silos. Publish on your own domain, and syndicate out to
silos. This is the basis of the “Indie Web” movement.”

I chanced upon the world of IndieWeb and microformats while trying to search
for a system to publish short notes (neuron is something I discovered in this
process). Here is a summary of the research:

What is the IndieWeb?

The IndieWeb website and wiki is very thorough and
detailed. Though a bit difficult to read at first (its full of outbound links
and so requires patience to really get a feel of the while field), it is a
great resource.

Steps to get started: (Borrowed from the IndieWeb wiki)

Get a personal
domain: Builds
identity, makes it easy to search for you.
Find a place to host your
content:
You can host on a git repo (eg. github, gitlab etc), on a virtual server, a
single-board computer or anywhere else.
Set up your home
page

Mainly: Set up web sign-in on your own domain
… so that you can use your own identity on the IndieWeb

Add info about yourself: You
can use microformats to add information about yourself so that when someone
mentions you, they get it all in a structured / standard manner.
Add links to existing social media:
So that you can cross-post, hyperlink your posts and most importantly, own and
self-host your content and not hold it captive to a 3rd party silo.
Publish content on your domain and add microformats to your
content
Syndicate your
content: You can now
post only to your own domain and have that content reach your existing social
media accounts.

Microformats

Microformats are a simple way to add more meaning to your HTML.

http://microformats.org/wiki/Main_Page

Tools

Implementing these steps is a lot of very tough work. Using tools that do these
things makes it simpler.

Transformative

IndieWeb personal website software
written in Ruby
Supports “notes, articles, bookmarks, photos and more”
Developed by Barry Frost

This is one of the best tools I found. You can see it live on the developer’s
website. It handles most things for you so you can focus on the content.

Micro.blog

Micro.Blog is unique service that enables you to post to the IndieWeb.
MicroBlogs can be mirrored to our own domains and they provide an interface to
do the posting.

As an additional feature, MicroBlog supports
ActivityPub as well. So while you
post using microformats, you can also federate your content via ActivityPub and
have people follow you from Mastodon, for example.

They are also writing a book about “microblogging”.
Read the drafts here.

Source code: https://github.com/microdotblog

Microblg.pub

Microblog.pub is unique: It serves ActivityPub primarily but supports the
IndieWeb equally. It is designed as single-user tool and does not use
javascript ANYWHERE (very very unique).

https://a4.io/: The developers’ own MicroBlog.pub instance

https://micropub.rocks/

This website gives you a comparitive report about the status of micropub
implementation status on servers and clients. Good way to discover servers &
clients that you could use!

Sitewriter

Sitewriter is a tool that helps you add IndieWeb services to your static
webite. Check out the documentation, service and
source code.

Bridgy

Bridgy is a service (and software) that helps you connect your website to your
social media accounts.

Quill

Quill is a simple tool that support IndiaAuth and then lets you compose and
make posts to your website.

WordPress with IndieWeb

WordPress is said to have one of the best and most mature IndieWeb
implementations. If you use WordPress, check it out.

Source Code

IndieWebify

This website and tool walks you through the process of IndieWeb-enabling your
website. Its a great way to not just understand the steps involed but also test
out if you have implemented them correctly on your website.

Lets try this out together…

I am yet to try this out myself… but, at least, now I have some clarity on
what to do and why and what to expect out of that process. So lets try this out
together…

Screenshot above is from the IndieWeb.org webpage.

Why?

Lets assume that you’ve been a GNU+Linux and Free Software user for a
very long time. Maybe 15 years. Maybe even more.

What is the first thing that occurs to you when you encounter a problem?
Or something breaks down? You search, you discuss on mailing lists, you
read source code. Basically, you use all the resources you have the
liberty to use. What you don’t do is accept the problem or dynfunction
or break-down as a norm and build your life around it.

However, there are also those things that we use on a daily basis and
which don’t provide us this respectful liberty to learn or fix or extend
things. These “things” could be hardware or software or services or
systems. Often, given our constraints of time or patience and so on, we
just cover up these things with a “SEP Field” and go on with our lives.

“SEP Fields”

Now the “SEP Field” is a fantastic device to use. It enables us to
create blindspots where we would otherwise see problems. By eliminating
the awareness of the problems, we also do away with the itch to solve
them.

What’s an SEP Field? It was invented by Douglas
Adams in the book
Life, the Universe and Everything as a sort of “cloaking device”:

An SEP is something we can’t see, or don’t see, or our brain doesn’t let us
see, because we think that it’s somebody else’s problem. That’s what SEP
means. Somebody Else’s Problem. The brain just edits it out, it’s like a
blind spot.

More details on the H2GT2G Fandom Page.

What if?

But what if we did not have to compromise in this manner? What if we
could access products that respected our liberty to hack by default?
What if “someone else” could take away the risk and expense (time +
money + patience) involved with experimenting and arriving at the
required answers?

Its not that we don’t wish we didn’t have to compromise. Its just that
all the resources (time + opportunity + patience + funds) do not line up
together at the same time.

That is reasoning I’ve had behind building the “Libre Tech Shop”. A shop
for technology products that are free in the sense of their license
and also free in terms of the opportunity the provide to learn, hack and
do things on our own terms.

Such products would ship with free software, would not track you and
would not force non-self-hostable and non-free/libre software backend
ecosystems on you. Most importantly, in the spirit of the community,
they would ship with documentation that aims at equiping users to
repair, extend and fix things on their own.

So – what does it take?

1. The Mostly Harmless website

How do I launch a shop without a product website describing the products
and the work and company behind them?

I spent about 9 months building the
mostlyharmless.io website. This time I
chose to write HTML using jekyll instead of using wordpress. And was
very happy with the control and exactness I was able to deliver!

2. The Libre Tech Shop

The center piece – https://libretech.shop.

There are many things I’ve tried to achieve with this website:

100% LibreJS Compliance

Additionally – the functionality works fine with Javascript disabled
(and in IceCat!) Doesn’t work
with lynx yet… but it just might, one day.

While I do have a payment gateway that I can trivially connect to
Woocommerce and put into action, I have deliberately not enabled it
since it requires proprietary Javascript to work. Instead, for now, I’ll
manually send out payment links to customers who want to use a payment
for payments. Otherwise, direct bank transfers are a good and respectful option
by default.

Prominent product properties:

product details
source code
documentation
discussion & help

And finally – the “Freedom Quotient”

3. Documentation for Libre Products

What’s the point of offering Libre Products without sufficient
documentation? Documentation is the significant half of the ecosystem of
Libre products since it helps create true ownership by way of access to
tools, knowledge and details. It is also a good mark of how repairable a
product is.

https://docs.libretech.shop/ is where you will find instructions and
documentation for products sold on the Libre Tech Shop.

4. Source code hosting

Source code is hosted using Gitea customised to look prettier.
https://sovran.dev/ is now the new source code host for all Mostly
Harmless and personal projects.

5. Discussions and Support

How does a community of libre product owners connect? Where do they go
to ask questions before making purchasing discussions? How do I address
problems and make the solutions self-documenting?

I settled on using Discourse for this. I was able to customise Discourse
extensively.

Check out the result at: https://ask.libre.support/

ask.libre.support is a pun. People often used to ask “if the software
is free (ie. gratis), why do you charge for support?!” Well, lets not
say “free support” anymore. Let say “Libre Support” – ie. Support for
Libre Products offered in the spirit of the free software movement – to
enable you to acquire greater competency and deeper ownership over the
products you “own”.

6. The Matrix Channel

Finally, I setup Synapse for mostlyharmless.io to build a secure and
self-hosted group chat room.

You can join in to ask quick questions (and more) via text chat:

https://matrix.to/#/#guide:mostlyharmless.io

7. The Request Tracker

After more than 10 years, I learnt to use RT (Request
Tracker) once again. It is
very nice to come back to Perl once again!

RT tracks emails sent to guide@mostlyharmless.io, emails generated by
form submissions on the websites and orders generated via Woocommerce.

Now I won’t misplace incoming emails and I will answer them promptly. 😉

Challenges… and mishaps.

I feel that if what I’m seeking to achieve here is awareness, it would
be grossly incomplete without a listing of the failures. It took me close
to 3 years to actually launch the Libre Tech Shop. These were some of my
challenges:

1. Lack of precedent

The lazy me will always search for a precedent so that I don’t have to
do all the thinking and all the “doing”. There is a certain comfort in
being a consumer rather a creator.

When I was searching for a LibreJS compliant shopping website, I found a
few implementations but no guide on how to achieve it. Of course
shop.fsf.org is a great example of Drupal-based e-commerce that is both
elegant and ethical. But – alas! – they’ve not released that piece of
code… (I wonder why?!)

I did realise (repeatedly) that I will finally have to put in the hard
work. But many times, the scale of the work involved is such a daunting
task in itself. When is there an easy way out?

2. Elegance

There are so many e-commerce tools that are free/libre software. Some
are complex, some are ugly, some are simple, some are too tied to hosted
and proprietary backends, some have licensing issues, some are aimed at
large teams and some just require too much work!

How does one choose? Why does one experiment so much? When I knew that
Wordpress + Woocommerce is “good enough” why was I searching for an
answer with other platforms? Yes – its fun to explore and understand.
But its also frustrating and a non-starter.

When I look back now, WordPress + Woocommerce was “just right”. I
could’ve saved so much anguish if I’d understood and appreciated its
strengths early on – instead of taking such a expensive trip to realise
it finally.

3. Working alone & staying motivated

Mostly Harmless is an OPC (one-person company) – legally and literally.
One of my biggest flaws is that I don’t know how to delegate or work too
well with others. Often working with others is more frustrating and so I
work alone.

But when you’ve got not one to hold you accountable and there is no
(apparent) cost for delays or for doing / not-doing something, its tough
to remain motivated.

Will anyone care that the shopping website can work with LibreJS enable
and even with Javascript disabled? What’s the point of putting in so
much effort anyway? What if no one visits or buys a product?

As I keep telling myself – even if its not worth it, lets just do it
and get it out of the way.

Otherwise what would be there to show for so much wasted time?

4. Building an ecosystem – not just a shopping site

By the time the libretech.shop website was ready, I realised that I
needed a forum, a email tracker and a group chat… not to mention
self-hosted source code and of course, documentation. Each of these (as
evident above) was a mini project in itself.

I realise now that that a shopping site without such an ecosystem would
be worthless – since it wouldn’t live up to its purpose of offering
“ethical and hackable products with convenience”.

The more one wants to offer, the more that one has to do. Trying to
deliver elegance and delight is tough!

5. Mishaps and server failures…

Finally – what do you do, when a careless server issue wipes your all
your work and “production” source code? And you didn’t have backups?
(Backups are for novices, anyway. And “real” developers code in
production!)

Well – you start again from scratch. One more time. With “worn-out
tools”.

I’m glad I didn’t give up. I’m still worried I will.

Credits

I’m thankful to a lot of people who have contributed in multiple ways to
help launch all of these websites:

Navdeep Singh – who built the first LibreJS compliant prototype for
wordpress + woocommerce and then also learnt enough Ruby to build a
Rails + Solidus prototype! His research and contribution was
invaluable.

Amit, Nishant, Prayas, Nandan and Rohit – for supporting the
effort since its inception, for regular testing and constructive
feedback.

Dedication

I am sure Rajeev Karwal sir
would’ve been been proud to see all of this launched finally. I miss his
honest counsel, encouragement and wisdom at this juncture. This effort
is dedicated to his memory.