1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
+++
title = "Rethinking my weblog"
date = 2020-03-07T02:44:00Z
+++
It's been a while since I have posted anything on my weblog. I will be laying
out some of the reasons for this, as well as what I've been meaning to do with
my site and blog going forward.
<!-- more -->
## The problem
There are several reasons why I have neglected my weblog for the last year or
so. It certainly hasn't been because of lack of imagination or content, since I
did have several different ideas I want to write about, and I still have
several drafts I started and still haven't finished (most of which I probably
won't finish). The biggest two reasons were that I became occupied with a lot
of different things including university, work, personal projects, hobbies,
procrastination, and well, life; and the second is honestly just laziness.
Now if I am completely honest I have to say that laziness is actually the
biggest factor of those two, especially considering that this laziness towards
my blog has been aggravated by my growing dislike of web (and other software
for that matter) in its current state. And that, ironically (or unironically)
includes my own blog and site, which run on Django using a blog engine I
personally developed.
Which also leads me to another problem related to the neglect of my weblog: the
neglect of my blog engine and Django app - w3blog. The causes and reasons for
the neglect of this project of mine - which I haven't updated since January of
last year (much like the blog itself) - are essentially the same.
I am not going to go into details in this post as to how and/or why I came to
dislike "modern" and "mainstream" software, but there are a couple details that
are relevant to this post. The most important of these is that I changed my
workflow quite drastically in the past couple of years, in a way that I believe
has made me much more productive using a computer. The second relevant detail
is bloat, and my dislike of it. What this basically means, is that I have come
to dislike the state and the way my site and blog operate.
The first annoying thing for me, is that I have to access the Django admin page
to author/publish posts and articles, which is a kind of CMS for sites built
using the Django framework which my blog engine uses. It's not a bad system per
se, and it is actually what other people that are more used to a Windows or
macOS-like workflow would call "user-friendly". However, I've gotten really
used to vim, not only for programming, but also for everything else that
involves typing text. I use vim for writing articles, for University reports,
for composing emails, for editing config files; you get the idea. In general my
workflow has become much more keyboard-oriented, and web interfaces are just
not made to be operated with just a keyboard, which well, sucks for me.
The second thing which might not be as important from a pragmatical point of
view is bloat. By using Django for my site I am adding a lot of stuff that is
simply useless for my use-case. Actually for most projects, most of the
"features" of Django are just bloat, which is the case for most of these
do-it-all frameworks. I don't mean to shit on Django, since I still find quite
fun and interesting to use simply because it's so easy to build many kinds of
sites with it. However, the fact is that it is bloated.
So if for some reason you have read all of above, you now may be wondering.
Then why did you do it that way? Well, the reason is simple, I had different
preferences and opinions back when I started this weblog and its engine, and I
didn't know better. Yes, I know about Flask, and I've used it for some
projects, but back when I started my blog engine, Django was what I knew how to
use best. I still would have ended up wanting to change the way my blog works,
simply because the way I use computers has changed so much in the past two
years.
## The solution
I've been meaning to change the way my weblog functions for a long time, more
than a year actually. Over the course of this time I came up with different
ideas to better adapt the publishing of articles and posts to my usual
workflow.
One of the first ideas I came up with was making some kind of app or module for
Django that would allow me to access the Django admin's functions over some
kind of TUI from my local machine without having to manually ssh each time I
wanted to make changes. I ended up giving up on this idea since I realized it
would just end up making everything more complicated, and I would spend a lot
time writing something which might not even be that useful in the end. In the
end I realized it would be better to completely change the back-end from the
ground up, since there was another goal that I wanted to achieve which was to
streamline, de-bloat and use a more minimal back-end.
The project to reform my weblog went into a kind of hiatus for some time, but a
couple of months ago I started to think about it once more. And so I started to
think what the ideal blog engine/back-end for my 2020 self would be.
The idea that I ended up coming with was some sort of back-end that would read
markdown files - where each md file was a post or article, glue it to a
template and serve it. This way, I thought, I could just have a git repository
with all of my articles, and then I would merge and push to master each time
that I wanted publish something new, and then maybe by using some kind of CI,
the changes to master would be pulled automagically on the server.
After some digging around on the worldwide web, I realized that the ideas that
I had were (obviously) not new at all, and there already exists software that
works in precisely this way. This kind of software are called static site
generators (I'll call them SSG for short). The three SSG that I found and
caught my attention were Jekyll, zola and Hugo.
Jekyll is the veteran of the three, and it's even used by GitHub for GitHub
Pages. One other thing that I liked about it, is that it uses jinja (or
something similar) for templates. It seems pretty good to me, but it has a
couple nuisances for me. First of which is the fact that it is written in Ruby,
and I don't know anything about Ruby. So if I wanted to take a look into the
code or tinker around with it I would be lost, or I would have to learn Ruby,
which I have no intention of doing.
Hugo seemed interesting to me because it's written in Go, which is better than
Ruby, and which I would be much more willing to learn than Ruby if I had the
need (might actually even do it out if interest). However, Jekyll and zola both
uses a Jinja or Jinja-like template system, of which I am already familiar.
Another thing is that Hugo seems (at least to me) more complicated to configure
to your liking than Jekyll or zola.
zola is the one that caught my attention the most. I liked how simple it is to
set up, and the fact that it uses a Jinja-like template system; the fact it is
written in Rust, a language that I've recently started learning and that I've
come enjoy using. Another thing that liked about zola, especially compared to
Jekyll is the way it builds URLs, i.e. it doesn't the outdated and useless
.html extension in the end, resulting in cleaner URLs. Maybe there is a way to
change this in Jekyll, but I didn't find any information on it.
I haven't decided yet which back-end to use, I might even write my own should I
decide that none of the above fulfill my needs. One thing is certain, I will
completely revamp my blog and site. After I finish revamping it, I will try my
best to write more constantly.
|
