I have late­ly been start­ing a ton of project­s. Usu­al­ly that would mean that I would be aban­don­ing a ton of pro­ject­s, but I have been fin­ish­ing them. I have been do­ing this by treat­ing my projects like they are not pet­s.

For ex­am­ple, let's take grafi­to a web fron­tend for sys­tem logs.

I start­ed it. I worked on it for a week or two of spare time, and now it's DONE. To­tal­ly done. It has no miss­ing fea­tures. It has no bugs. It is DONE.

It does what I want it to do, it does it well, it's pou­b­lished in all the ways that make sense, and I don't have to think about it any­more.

Sure, if some­one finds a bug, I will fix it. If some­one asks for a fea­ture, I will con­sid­er it. But I am not go­ing to spend time on it un­less there is a good rea­son to do so.

I am spe­cial­ly not go­ing to spend time on it just be­cause I like it, or be­cause I want to keep work­ing on it. I am not go­ing to pet it, or feed it, or take it for walk­s.

I am not go­ing to think about what fea­tures I could ad­d. It does what it does. It's pret­ty unixy, in that it does one thing and does it well. It is not a pet, it is a tool.

That is how I am han­dling my projects nowa­days. I wrote tar­trazine which is a syn­tax high­light­ing tool in a cou­ple of weeks and it's done. Six­teen? DONE.

Some projects are not fin­ished. Cryc­co is not fin­ished. I will work on it some more. Be­cause it's not done yet. It has miss­ing fea­tures, it has bugs, it has things I want to do with it.

This is spe­cial­ly im­por­tant for free and open source project­s. Main­tain­ers get over­whelmed. Start­ing a project is fun but main­tain­ing it is like hav­ing a pet par­rot, re­quir­ing con­stant at­ten­tion, feed­ing, clean­ing, and who will out­live you.

That at­ti­tude is not sus­tain­able. Imag­ine you were a hob­by car­pen­ter mak­ing ta­bles. Would you say "ta­bles are nev­er fin­ished, they are aban­doned"? No, you would say "this ta­ble is done, I will make an­oth­er one if I want to".

That is a healthy at­ti­tude. This is not re­li­gion, and this is not a job. If I start a new project I will fin­ish it, or I will aban­don it, but I will not cre­ate projects that will re­quire my at­ten­tion for­ev­er.

I had been read­ing about re­mote KVMs for a while. There are sev­er­al, like PiKVM, JetKVM, etc. I de­cid­ed I want­ed one to ac­cess my serv­er at home be­cause it has a nasty ten­den­cy to lose net­work con­nec­tiv­i­ty, and I want­ed to be able to fix it with­out hav­ing to go to the of­fice and plug in stuff in­to it.

This is not like run­ning RDP or VNC on the serv­er in that to the serv­er this is hard­ware. It works no mat­ter how crashed or dis­con­nect­ed the serv­er is, as long as it has pow­er. It is like hav­ing a mon­i­tor, key­board and mouse plugged in to the server, but re­mote­ly.

I had all the hard­ware I need­ed:

• A Radxa Ze­ro, which has OTG sup­port so I could use it as a USB de­vice.
• A USB cap­ture don­gle, which are cheap and easy to find, to cap­ture the HD­MI out­put of the serv­er.

But I just could not make it work. PiKVM, the most pop­u­lar one, makes it pret­ty dif­fi­cult to make it work on any­thing oth­er than the ex­act hard­ware con­figs they sup­port, and those are ex­act­ly the ones I don't have.

I could not find any im­ple­men­ta­tion that was easy to set­up and sup­port­ed the hard­ware I had, so I de­cid­ed to write my own.

You can get the code at GitHub of course. It com­piles to a sin­gle bi­na­ry. It on­ly re­quires you to have ffm­peg in­stalled, and it should just work as long as your hard­ware sup­ports OT­G, you have a USB cap­ture don­gle, and you plug all the ca­bles cor­rect­ly.

One USB ca­ble and one HD­MI ca­ble go from the serv­er to the Radxa Ze­ro (the HD­MI via cap­ture don­gle) and you run the one bi­na­ry built from this code on the Radxa Ze­ro. It will start a web serv­er on port 3000, and you can ac­cess it from any brows­er.

The web in­ter­face is very sim­ple, but it work­s. You can see the video feed, and you can send key­board and mouse events to the serv­er. You can even pro­vide a disk im­age that the serv­er will think is a USB drive. I sup­pose you can even in­stall the OS in the serv­er that way, but I have not tried it.

If you want to ac­cess it more re­mote­ly, just set­up a VPN in the KVM it­self.

This is an oc­ca­sion­al se­ries of posts where I will share ideas for pro­grams that don't ex­ist, but should. The goal is to in­spire de­vel­op­ers to cre­ate use­ful tools that can make our lives eas­i­er. Or, more like­ly, to re­mind me about these ideas so I can cre­ate them my­self. Or even more like­ly, to just get them out of my head so I can stop think­ing about them.

Idea 4: A modern version control system that has fewer features

For some things you don't need Git. But for those things you may still need ver­sion con­trol.

Imag­ine a ver­sion con­trol sys­tem just for you. Un­less you are a de­vel­op­er, in that case it's not for you, it's for your dog or some­thing.

I want a ver­sion con­trol sys­tem that is bet­ter than "doc­u­men­t.­doc" ➡️ "doc­u­men­t2.­doc" ➡️ "doc­u­men­t.­fi­nal.­doc" ➡️ "doc­u­men­t.re­al­ly­fi­nal.­doc"

Not a lot bet­ter but bet­ter.

Let's be ul­tra­op­ti­mistic and just dream of what would be ide­al.

• Us­er cre­ates a file and says "this file is im­por­tant and will change"
• Mag­i­cal­ly the sys­tem rec­og­nizes the idea and says "ok"
• Us­er saves a new ver­sion of the file.
• The sys­tem says "ok"
• Us­er says "oop­s, where is my old ver­sion?"
• Sys­tem says "here"

Some­times the sys­tem may al­low the us­er to see the dif­fer­ence be­tween one ver­sion and an­oth­er ver­sion. This re­quires app sup­port in gen­er­al if the file is not an or­di­nary text file.

• Some­times the us­er may want to make a copy of an old ver­sion.
• Some­times the us­er may want to "name" an old ver­sion.
• Some­times the us­er will want to over­write the last ver­sion with an old­er one.
• Some­times the us­er will want to get back a file he delet­ed.

That's it. That's all the fea­tures.

The sad part is that we had this in the 80s, in VM­S. But any­way, it would be nice.

If I were to im­ple­ment this I would do a sim­ple im­ple­men­ta­tion and then write a user-lev­el filesys­tem to let the us­er ac­cess it trans­par­ent­ly.

Fur­ther, maybe a li­brary that al­lows us­ing this from your own code? So you can save ver­sioned?

Would be nice.