DEV Community: Zack

⚱️ A Python script to register for a pottery class

Zack — Tue, 18 Feb 2020 17:40:11 +0000

I've been waiting a long time to take a pottery class. In a city of almost 1 million people, there are surprisingly few pottery classes and there are even fewer pottery classes that happen outside working hours. One of the classes I knew about had only 12 available seats that instantly sold out when registration opened. In fact, I missed the registration for this class several times already.

I learned that the demand was so great for this pottery class that the website maintainers had to pick a random time to open registration to prevent the servers from crashing. Since I couldn't spend all day refreshing the pottery website to see if registration was available, I decided to write a program to help sign up for this class.

A script to alert when a website changes

I made sure not to miss the registration this time by writing a script that monitors the registration website and sends an alert to my phone when it changes (when registration opens). Their are tons of online services that do this, but they cost money if you want to check a site more often than once every 15 minutes. However, writing this code is incredibly easy and satisfying.

The script I wrote is in Python which does the image processing and the alerting. The website snapshots are taken with a Node script (using puppeteer) which is run from the Python script.

I learned some subtle things about website tracking while doing this - namely website scraping is easier if you can block ads and that SMTP is the best free notification service. More on that below, but if you just want the code, the script and the instructions for using it are on my Github: https://github.com/schollz/websitechanges.

Block the ads before taking a snapshot

The screenshot of the website is downloaded by using puppeteer, which is very easy to do (its one of the examples!).

However, one subtlety here is that I need to compare two screenshots in time for changes. Since ads can change every time you reload a page, I realized it is important to remove ads to get a reproducible view of the website. This is really easy to do with puppeteer. First download a hosts file and then load it into the Node script:

const fs = require('fs');

hosts = {};
//now we read the host file
var hostFile = fs.readFileSync('hosts', 'utf8').split('\n');
var hosts = {};
for (var i = 0; i < hostFile.length; i++) {
    if (hostFile[i].charAt(0) == "#") {
        continue
    }
    var frags = hostFile[i].split(' ');
    if (frags.length > 1 && frags[0] === '0.0.0.0') {
        hosts[frags[1].trim()] = true;
    }
}

And then in puppeteer you can block all the requests to everythin in the HOSTS file:

/* ... puppeteer setup omitted */
await page.setRequestInterception(true)
page.on('request', request => {
    var domain = null;
    var frags = request.url().split('/');
    if (frags.length > 2) {
        domain = frags[2];
    }
    // just abort if found
    if (hosts[domain] === true) {
        request.abort();
    } else {
        request.continue();
    }
});

This way, all the ads are removed and you just get a blank space or no space where they were.

SMTP is the easiest, cheapest way to send notifications

The pottery website registration could occur at anytime in the middle of the night (it ended up being at 4:43 AM). I needed a way that the website change could notify me, namely by sending a text message. I can use my phone to play a loud sound when the message arrives. But how to send a text message?

It turns out to be very easy! To send a notification to your phone, you simply send an email! Your phone provider usually supplies an email address for your phone. Here's the ones I know of:

Verizon: PHONENUMBER@vtext.com
Sprint: PHONENUMBER@messaging.sprintpcs.com

But, then, how do you send a email from a program? You can use email API service. However some of these, like mailgun, entice you with an offer of a free tier only to later remove the free-tier. But the alternative is easy, fast, and free.

The alternative is to use SMTP which is provided with almost any free email service. For example, you can use a new Gmail account with a random username and password. To enable SMTP in Gmail:

If you are using a remote server, read the caveat at the bottom ofo this page.
Go to the "Settings", e.g. click on the "Gears" icon and select "Settings".
Click on "Forwarding and POP/IMAP".
Enable "IMAP Access" and/or "POP Download"
Goto https://myaccount.google.com/lesssecureapps and turn "Allow less secure apps" to "ON".

That's it! Now you can send emails in Python using a function like this:

import os
import smtplib
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart

def send_email(smtpemail, smtppass, to, subject, body, attachment):
    img_data = open(attachment, "rb").read()
    msg = MIMEMultipart()
    msg["Subject"] = subject
    msg["From"] = smtpemail
    msg["To"] = to

    text = MIMEText(body)
    msg.attach(text)
    image = MIMEImage(img_data, name=os.path.basename(attachment))
    msg.attach(image)

    s = smtplib.SMTP("smtp.gmail.com", "587")
    s.ehlo()
    s.starttls()
    s.ehlo()
    s.login(smtpemail, smtppass)
    s.sendmail(msg["From"], msg["To"], msg.as_string())
    s.quit()

Now you can have your program send a notification to your phone, with an image of the changes.

Back to Pottery

I wrote this script the night before the pottery class registration was set to take place. The exact time the registration was set to open was random. But then, at 4:43 am, I got a notification:

I checked the website and saw that indeed the registration had opened and I got myself registered!

Interestingly even though I thought I'd be the first there were already two other people registered by the time I was done registering! That means I'm not the first to do this type of thing for this particular class. But my code is open-source at https://github.com/schollz/websitechanges so I hope everyone else will have a chance to try it too.

Gmail SMTP getting blocked

There is a caveat about using SMTP with Gmail. Gmail will tend to block SMTP access if you create the account on one computer and then use it on a remote server (like Digital Ocean).

To get around this, make sure to create the account on the remote server, if that's where you plan to use it.

To do that, SSH into the remote server using

ssh -D 8123 -C -N user@remoteserver

The -D parameter will bind a SOCKS port to 8123. Now goto Firefox settings and change the SOCKS port to 8123. Now Firefox will use your remote server and you can setup SMTP remotely. Then change it back when you're done!

🎹🌎 Pianos for Travelers

Zack — Thu, 19 Dec 2019 15:39:38 +0000

Pianists are lucky. The piano is an instrument that - unlike trumpets, saxophones, etc. - sometimes is available to play for free. These free-to-play pianos are called "public pianos" (or "street pianos") which often appear in airports, train stations and parks during good weather.

Pianists know that these public pianos exist, no one knows where most of these pianos are and as such they exist in the world as a sort of magical entity whose secret location needs to be discovered. I am attempting to discover the location of all of them, and make a map of every piano in the world.

The result of this attempt is a website: Pianos for Travelers. This blog post tells about how the website was made.

Getting the data

I estimate that there are thousands of public pianos in the world and at least one in every major city in the world. Obviously I cannot go to every city in the world to find every piano, so I am attempting to use the internet to find their locations.

There is a handful of websites that compile piano lists including a slowly updated wiki and an out-of-date map, forums, subreddits and etc. I collected hundreds of piano locations going through these types of websites and manually cataloging their coordinates in a file.

After going through every website I could find, I only had a few hundred pianos - there were still over a thousand out there. Luckily, I realized that social media actually has tracked locations of people using the hashtags #publicpiano and I was able to use APIs to collect their coordinates as well. This netted hundreds of more pianos.

At this point, until I find another source of pianos, I will be bootstrapping myself and heeding user input to gather the locations of more pianos. This is usually where the other websites failed, and mine might too, so I'm still looking for alternatives to this practice.

Creating the website

I designed the Pianos for Travelers site with my good friend. We used a very simple stack - Go std-lib http router, with Postgres 12 backend, JQuery v3 frontend, and using Tachyons for CSS. (I actually disagree that Postgres is very simple, but it is very powerful when it comes to GIS information).

The Go language constantly impresseses me with how fast we can move into production - for example we needed a CAPTCHA and found an amazing package by dchest that was basically a dropin into our std-lib web server. Same thing happened when we switched to Websockets. We found the entire site took less than two weeks to build (and we only spent our free time on it).

Shipping the website

The website, Pianos for Travelers, is live now. We posted about it on sites that might have interest in places with pianos (Piano forums, subreddits) and it gained a little traction. It is up for perpetuity now, though so I'm hoping it provides some useful information to the people that find it.

Now what do I read? A web app for blazing fast book recommendations.

Zack — Wed, 04 Sep 2019 13:16:41 +0000

(x-post from nowwhatdoiread.com)

What book are you reading right now? Do you enjoy it?

If you answer “yes” to either of those questions then stop reading this blog and go read your book!

If you answer “no” to either of those questions then its time. Its time to get a new book to read.

“But,” you profess, “there is nothing to read.” I believe you. I believe because you’ve asked your friends, you’ve searched Amazon.com, you’ve checked Goodreads.com, you’ve browsed the library shelves, the Barnes & Noble shelves, and no single book has caught your attention. And, now, you’ve rightfully concluded that there is nothing to read.

Don’t give up the search, yet. There is a book out there just for you - a book that is so good that you won’t put it down even when it’s 11:30 pm and you have to wake up at 5 am for work.

How do I know there is a book out there for you? I know because I’ve been in the same situation. I’ve searched, and gotten tired of searching and gave up. But then I found a better way to search. This better search led me to a book out there, written just for me. This way to find books has worked not just once or twice but every time. Now, I’m able to find an amazing book anytime I have the question: “now, what do I read?”

A new way to search for books

How do I find my next books to read? I do this the same way everyone does in 2019: using a web app.

A web app is just a fancy name for a computer program that is accessible on the internet. A web app’s computer program can hold information about millions of books inside its circuit brain. It can use its gigahertz processor to find the most relevant book suggestions and use the internet to display them on a website. Unlike your friends and friendly librarian, a web app can take any request, at any time, and give you an unbiased book suggestion in milliseconds.

I made such a web app with my computer. And, since my computer is not owned by Amazon / Barne’s and Noble / Powells or other online booksellers, it won’t try to manipulate you because it wants you to buy something.¹

Note: My web app does use Amazon Affiliate links which sends me money for link clicks. This money pays for hosting ($12/year) after which I direct all profits from to supporting the actual Amazon via the Amazon Conservation Association.

My web app is further optimized to only show the best books with similar traits and exclude books that are sequels or multiple books from the same author.²

The web app written in Golang. The key to its speed is utilizing the Badger keystore and precomputing all the similarities for a million books. Fuzzy searching is provided using the amazingly fast junegunn/fzf library. Images are inlined with base64 to make all the assets bundled and its minified with tdewolff/minify to get that extra boost in speed. Also, there is no Javascript so the server does the heavy lifting making the rendering appear instant.

The web app is called nowwhatdoiread.com. Go ahead, try it.

An example of using nowwhatdoiread.com

Here’s an example from my life. For some reason, I read Boy’s Life by Robert McCammon. I thought it was a biography but it turned out to have magic and horror. I don’t normally read horror but I loved this book. I thought that there wouldn’t be many books like this.

I used nowwhatdoiread.com and entered “Boy’s Life” and found Weaveworld by Clive Barker. This book blew me away and I liked it more than Boy’s Life. But, after finishing Weaveworld I was again dismayed. It was so good and unique I thought I wouldn’t find anything close to it again. But then, I asked the web app for books similar to Weaveworld and found The Library at Mount Char by Scott Hawkins. This book was even better!

I still find great and relevant book suggestions using nowwhatdoiread.com. The last book I put in The Library at Mount Char and now I’m currently reading Kraken by China Miéville, which I’m enjoying.

This example led me down a particular set of genres, but I’ve found the genre doesn’t matter and I’ve gotten good recommendations for all other sorts of books. I’ve found book suggestions for all genres, as there as the web app doesn’t have any bias towards a particular genre.

The cycle continues

Every book I read now gives me more books to read with the help of this web app, nowwhatdoiread.com. Though I made it mostly for myself, I’m opening it up to the world so that you can find a book and support a charity at the same time.

Maybe it will work for you. Maybe it won’t.

In any case, I hope that instead of asking “now, what do I read?” you can just say “now, I read.”

💻↔️🖥️ Transferring files between two computers

Zack — Sat, 04 May 2019 01:51:36 +0000

There are a lot of ways to transfer files.¹

Above the basic necessity of preserving the data during the transfer, sharing data should be fast, secure, and -- most of all -- easy. Most file transfer utilities I've used encompass two thirds of these qualities. I've wanted to make a utility that encompasses all three, without compromising any one of them.

relay > uploading

File transfers should be as fast as possible - the time it takes to transfer the file is often spent waiting. Faster file transfers means less waiting.

A common way to transfer a file is to first upload data to a server, and then, once uploaded, the link is shared with someone who goes to download it.² This method is easy, but slow -- the transfer rate of the file is half the harmonic mean of the upload and download speeds which makes it slower than either just uploading or downloading.³

There are better ways than sequentially uploading and downloading. Instead, you can use a relay server to create a full-duplex real-time communication layer between the two computers so that "uploading" and "downloading" occur simultaneously between the two computers. This effectively increases the transfer rate because its not sequential and only limited by the slower of the two transfer modes (uploading or downloading).

key exchange > passwords

Transferring data should be secure. Whenever you share data, it goes through a network of servers that can "see" the data, so it should be encrypted to stay private. A common way to do end-to-end encryption is with a password. You use a password to encrypt your file, then send the password-protected file, and after which the other person uses the same password to decrypt it.

Passwords are easy, but passwords can be weak. It turns out many people use the same passwords so that breaking an encryption can be as easy as just trying each password in a list of pwned accounts.

Weak passwords can be used to make strong passwords using PAKE: password authenticated key exchange. PAKE is a cryptographic method where two people share a password which is then used -- via back-and-forth communication -- to generate a strong key. The strong key can then be used for all further encryption. Since the two people generate the strong key by exchanging information, no one else could possibly learn the strong key even if they have the original password.⁴

There are other ways to exchange a key, but in general you can get better security by exchanging a key rather than using a single password on both computers.

no port forwarding > port forwarding

Finally, transferring data should be simple, ideally with a single command and no maintenance or other programs needed.

Often it is not easy though.

Another common way to transfer a file is to use SSH or FTP. Both protocols are ubiquitous and relatively simple to use, but their simplicity relies on one of the computers to be running a server (like openssh) and it requires the server computer to have port forwarding enabled. It can be pretty much assumed that most pairs of computers don't meet these requirements (say, two computers in a café) so that makes these common utilities hard to use in most cases.

File transfers can be easier by eliminating the need for hosting a server or port forwarding. Again, using a relay server allows any two computers to connect to one another without resorting to port forwarding or fiddling with a server.

croc = fast + secure + easy

I've been working on an open-source tool that takes these ideas to heart: croc. Because its open-source and implemented in a language that easily cross compiles (Go) it can be implemented anywhere and thus will (hopefully) always be a fast, secure, and really easy way to send data.

AFAIK, croc is the only CLI file-transfer tool does all of the following:

allows any two computers to transfer data (using a relay)
provides end-to-end encryption (using PAKE)
enables easy cross-platform transfers (Windows, Linux, Mac)
allows multiple file transfers
allows resuming transfers that are interrupted
does not require a server or port forwarding

In developing croc I took a lot of inspiration from other CLI tools like toss and magic-wormhole which had some but not all of the qualities above.⁵

If you'd like to give it a try, the code is available online at https://github.com/schollz/croc.

I wrote about sending a file in 2017 and have tried to maintain a list of ways to send files since then. ↩
Some good server-based file-sharing tools: https://send-anywhere.com, https://send.firefox.com, https://ipfs.io/ ↩
For example, if you are transferring a file by uploading at 5 Mbit/s and then, after finishing the upload, downloading at 8 Mbit/s, then the effective transfer rate is 1/2 * 2/(1/5+1/8) = 3.1 Mbit/s - which is slower than either. ↩
PAKE additionally will prevent eavesdroppers. If anyone "listens in" on the information exchange, then all parties will end up with different strong keys and no one can decrypt anything between them, alerting the users that a eavesdropper is present. ↩
toss cleverly encodes port information in the code phrase, making it simple but it requires using connected computers (no firewalls) and the long random-ish code phrase is hard to "tell" someone. magic-wormhole has most everything (currently its missing capabilities for multiple file transfers and file resuming), but it requires installing lots of the Python ecosystem which is tricky for non-developers (and Windows users). ↩

Project graveyard

Zack — Sun, 19 Aug 2018 16:23:31 +0000

I like to write code and always have - my earliest project is a band name generator from 2003. On Github I have over 230 repos, but I also have some on Bitbucket, Gitlab, and my own self-hosted fossil.

Like others, I've had projects that I stopped working on and stopped using altogether - thus relegating them to the project graveyard. Here is a sliver of projects that ended up not meeting my expectations and have been buried in their grave of 1's and 0's.

🌅 sundial

Get the next sunset and sunrise time based on latitude and longitude.

I write most programs in Python and Go but I specifically wrote this one in C because I was planning on using it on an Arduino. I wanted an Arduino to know the time of sunrise and sunsets so it could be used to open/close a chicken coop door to let the chickens out at the right times.

The code here works great, however I when I put it on an Arduino it was always off by hours. I learned the error occurred because the Uno boards use a double with 32-bit precision, not 64-bit so there wasn't enough precision to actually make the mathematical calculations in the code. A hardware issue which I didn't see anyway around - oh well, to the grave you go.

What I learned:

Equations for calculating sunrise/sunset times.
Someone, somewhere, may find your code useful. I got a huge PR out of the blue from someone who found this code immensely useful even though it had no use to me anymore.

🥚 Food identicons

A identicon made of foods.

I thought since people recognize food really well and are used to seeing recipes, that you could make an identicon that could uniquely identify some bytes with 9 pictures of food arranged in a square.

The program basically works, but it turned out to be hard to get nice pictures of food that are easily discernible so the identicons looked strange and indecipherable.

What I learned:

How hard it is to find and collect high quality images.
How to work with images in Go.

🎶 musicsaur

Music synchronization across browsers.

This is the one that saddens me the most. I was living in a two story house and I wanted to easily play music on both stories with two computers, so I wrote this program to synchronize music playing through your browser! It could could also play it headless on Raspberry Pis which was great fun.

I was never really satisfied that it worked well enough. Though it worked, every once and awhile you'd get a song that had >30 ms latency between the start times and then it would sound wonky. I used Javascript to control the skipping, but that is always problematic because Javascript is slow and can take ~0-10 ms to accurately skip to the position and it was near impossible to figure out exactly how much time is needed to account for the skip.

If you want to try, it still works, but you just need to use commit b775910 from the tcolgate/mp3 library since they made a breaking change since I've played with it.

What I learned:

How hard it is to work with streaming audio.
How to use HTML5 audio in Javascript
Time synchronization routines

🎲 No dice

Generating random numbers from squiggles.

I had an idea of generating random numbers just by drawing quick squiggles and counting the intersections and then doing some modulus. Of course its slower than dice, but its better than nothing if you have no dice. I did some coding to figure out how "random" this can be, but realized that since humans are doing the drawing I'd need to sample from actual humans instead of simulating human drawing with this code.

What I learned:

How hard it is to simulate human actions.
How to do bezier curves

📘 bol

A distributed, synchronized journal.

All my life I've wanted to create the perfect distributed, synchronized journal. Nothing has ever satisfied. This is one attempt that I abandoned. It had a nice idea and worked across platforms, but I just didn't like using that much because of the UI and didn't have the will to make improve UX. I stopped using it so it became abandoned.

Since bol I've worked on a totally CLI version, gojot. However I've abandoned and rewritten gojot 5 times and I still don't use it now. Lately I've been pretty happy with a web version of another program I wrote, cowyo but I've actually found myself recently rewriting this one into rwtxt.

What I learned:

How hard UI/UX design is and how hard I am to please
How hard it is to make distributed programs

👥 kiki

A distributed, offline-friendly social network.

There are all sorts of reasons to have alternatives to Facebook, so I decided to try to make one myself. I took a lot of inspiration from scuttlebutt but wanted to make something that was so easy to use that my mom could use it and wanted something that could be made private if I wanted to.

I had a lot of fun writing the code, but in the end I realized I wouldn't use it. To use it would encourage other people to use it and then I'd be stuck with all the problems facing other social networks - how to regulate bad behavior while encouraging openness, etc. I had no desire to write code to regulate content but that what you have to do nowadays if you have a social network.

What I learned:

How hard social networks are to maintain
Creating distributed message passing system

🎹 pypiano

Let your computer play a piano duet with you.

Here is one happy story. I wanted to create an AI to play music with me at the piano. The obvious way to do this at the time was to use Python - they have a great gaming (pygame) library which handles realtime MIDI out-of-the-box. It turned out, though, that development in Windows was super problematic and I found pygame would work with some functions but not with others (see my entire complaints here: https://rpiai.com/piano). So I gave up and abandoned it.

But, this is a happy story because the project came back from the grave. I had an inclination it'd be easier to write this in Go because it requires so many little async processes, easily done with goroutines. After a few more non-programming obstacles I was happily using the code: PianoAI. Maybe its my favorite project I've ever made.

What I learned:

How hard it is to do realtime applications, especially with MIDI
How MIDI works
Heuristically learning synthetic piano lines

I could go on and on and on. At least I can say that I've genuinely learned a lot from writing and abandoning code - trying (and maybe failing) is my favorite way to learn. I will continue to abandon projects, I think because I just like the journey more than the destination, even if that destination is the graveyard.

Self-hosting with fossil, an alternative to git

Zack — Tue, 14 Aug 2018 14:27:12 +0000

Github, Gitlab, Bitbucket are all web interfaces for git. They all do similar things that add on features that aren't implicit in git, like issues and wiki, etc.

Unbeknownst to some, fossil is an alternative to git that actually has built-in issues, wiki, and easily self-hosts. This is a quickstart to get started with hosting and cloning fossil repos. The official quickstart is very good, although I realized a few tricks in getting the fossil hosting to work on HTTPS behind a reverse-proxy and getting fossil to work with Go.

Before you begin

First, download fossil. There are already binaries available for fossil for Windows, OS X and Linux. You can find them at fossil-scm.org.

New fossil

Making a new fossil is easy - you can make a new fossil with the init subcommand.

$ fossil init -A schollz 3.fossil
project-id: 7165366dc9d0d3c827573c8ef12cb760f2caa236
server-id:  56adcebbf59b06eb4b621d3daca59f5aa87a9a08
admin-user: schollz (initial password is "35a6g1")

This will make a new repository, 3.fossil, with a user schollz and default password 35a6g1. Make sure to save each fossil repo with the extension .fossil - this is very important if you want to do hosting.

You can then change the default password for schollz. Here you have to enter the password on the command-line, but I like to add it to a file to prevent it from showing up in the bash history.

$ vim pass # enter your password in this file
$ fossil user password schollz `cat pass` -R 3.fossil
$ rm pass # this ensures your password doesn't enter the bash history

Want to add another user? Its also easy:

$ fossil user new user2 user2@somewhere.com -R 3.fossil

When you clone the fossil (see below) you will be able to enter the username and password to authenticate the transfer.

Hosting fossils

Say now you have several fossils in the same folder. Make sure that each has the .fossil suffix - this is very important.

$ ls fossils
1.fossil 2.fossil 3.fossil

Then you can start a server that uses HTTPS:

$ fossil server . --https --port 8079 --repolist

The --https flag implies HTTPS, so you have to host a reverse-proxy that uses SSL. Its super easy to do this if you are using Caddy as a reverse-proxy (which easily adds HTTPS). In this case your Caddyfile will look like:

fossil.schollz.com {
        proxy / 127.0.0.1:8079 {
                transparent
        }
        gzip
        log logs/fossil.schollz.com.log
}

where you just replace fossil.schollz.com with yourdomain.com.

Cloning fossil

Cloning is easy, just make sure to include your user name so you will have the rights to push changes (unless you want to just have your own copy). If you are using "fossil server ." like above, then you need to add /repo to tell it you want to clone repo.fossil. For instance, to clone 3.fossil

$ fossil clone https://schollz@fossil.schollz.com/3 3.fossil

You will be prompted for the password, which is the same password that you set up top. Now you can open the repo.

$ fossil open 3.fossil

Things are then pretty similar to git. You can add and commit files:

$ touch README.md
$ fossil add README.md
$ fossil commit README.md # this will automatically push

You can easily create pull (get latest changes):

$ fossil sync

Private and public repos

Private repos

It's pretty easy to make your fossil private. Just goto Admin -$ Security Audit and then click "Take it private".

Public repos

This is the default. However, sometimes if you take your repo private you'd like to make it public again. Making your repository public again is a little more involved.

Basically there are two types of users: "nobody" and "anonymous" users. The "anonymous" refers to permissions given to anyone who logs in. The "nobody" refers to the permissions given to anyone who visits the site. To make a repo public again you have to redefine the permissions for both these types of users by going to Admin -$ Users.

The typical permissions for "nobody" for public access are "gjozr":

The typical permissions for "anonymous" for public access are "chmn":

Configure for `Go`

In order to use fossil with go get you need to make sure you have the right remote import paths specified in the meta tag.

Basically, if you are following the above and you have a fossil repo hosted at https://yourdomain.com/hello-world then you need to include the meta tag:

<meta name="go-import" content="yourdomain.com/hello-world fossil https://yourdomain.com/hello-world">

You can do this by changing the default fossil skin (Admin -$ Skins). There is a really nice Google Code skin available. For convenience, I already have the CSS, Header, and Footer. Just edit each component (Step 4 under Skins) and then check both boxes in Step 7 and hit "Publish Draft1".

General

I like to have the README.md in the main repo be the first thing you see on the web UI - just like Github/Gitlab/Bitbucket. To do this, make a README.md file and then goto Admin -$ Configuration and look for the Index Page and change it to /doc/tip/README.md. Make sure to then press "Apply Changes" at the top.

Another trick - you can add fossil as a parameter to your ~/.zshrc if
you are using oh-my-zsh (if you aren't using it, why?). Just make sure
you have this line:

plugins=(git history fossil)

DEV Community: Zack

⚱️ A Python script to register for a pottery class

A script to alert when a website changes

Block the ads before taking a snapshot

SMTP is the easiest, cheapest way to send notifications

Back to Pottery

🎹🌎 Pianos for Travelers

Getting the data

Creating the website

Shipping the website

Now what do I read? A web app for blazing fast book recommendations.

A new way to search for books

An example of using nowwhatdoiread.com

The cycle continues

💻↔️🖥️ Transferring files between two computers

relay > uploading

key exchange > passwords

no port forwarding > port forwarding

croc = fast + secure + easy

Project graveyard

🌅 sundial

🥚 Food identicons

🎶 musicsaur

🎲 No dice

📘 bol

👥 kiki

🎹 pypiano

Self-hosting with fossil, an alternative to git

Before you begin

New fossil

Hosting fossils

Cloning fossil

Private and public repos

Private repos

Public repos

Configure for Go

General

Configure for `Go`