I’ve been pretty quiet on here since I last wrote about how I’d done a further revamp of my Emacs config, so I thought that subject would be a good reason to write another blog post.
It’ll be a mostly short one, and one to muse over something that’s been bugging me for a while now: my decision to lean heavily on
customizeto set all sorts of settings.
Initially, when I nuked my original config over a year ago, it seemed to make a lot of sense. Let all the tweaks and set values “hide” in a file of their own and try and keep the hand-edited config files as small and as clean as possible. Recently though I’ve got to thinking that this obscures too much, hides too much detail, and removes the ability to actually document what I’m doing and why. It also does make it tricky to adapt some settings to different platforms or even environments on a single platform.
Another problem I’ve run into is this: when I made the second round of changes and decided to lean heavily on
use-package, I soon ran into the minor issue of some packages not making sense, or even being needed, on some platforms (stuff that’s useful on my macOS machines isn’t always useful on my Windows machines, that sort of thing). While
use-packagecan handle this easily thanks to the
:ifkeyword, I’m still left with the fact that
package-selected-packagesstill gets populated.
package-selected-packagescontain a list of installed packages likely makes sense if you’re using just the Emacs package system and you’re not doing the installing with
:ensure. But with
:ensureI feel like I’ve got far more control over things and can adapt what gets installed when depending on which Emacs I’m running where.
But, because I’m syncing my
~/.emacs.d/.custom.elto all my machines too, any
use-packagethat has a
:ifto not bother using a package has little effect because the package still ends up being listed/loaded/seen as part of the installation.
Ideally, I think, I’d like to be able to have
package-selected-packagesheld in its own file, or I’d only ever use
~/.emacs.d/.custom.elfor local stuff (and so stop syncing it).
Starting today I’m going about a process of moving as much as I can out of
~/.emacs.d/.custom.eland into hand-edited files. In some respects I guess I am going back to how I used to manage Emacs configuration, but this time it’s not a massive monolithic file-of-Lisp, it’s neatly broken down into sensible sections and it’s also biased towards a “grab and config this package” approach.
Meanwhile, I’ve not seen any good discussions online about
customizevs “hand-edit”, which strikes me as a little odd as it feels like the perfect “religious issue” for people to have endless disagreements over. I guess, over the next couple or so weeks, I’ll find out if switching back was a good idea.
Just under a year ago I decided to totally rewrite my GNU emacs config. As I wrote at the time, it’d been following me around all sorts of machines since the early 1990s, starting life on an OS/2 Warp machine and travelling via MS-DOS, GNU/Linux, Windows and, these days, macOS.
The changes I made last year have served me really well, but there were two related issues with it that bothered me a little: the fact that I was maintaining a local library of elisp code in the repository and, worse still, I was storing the packages I’d installed from elpa and melpa in the repository as well.
While this did mean it was pretty easy for me to start up a new installation of emacs on a machine – all I had to do was clone the repo and run up emacs – I wasn’t happy with the duplication involved. I didn’t like holding code in my
.emacs.drepo that was already held in package archives.
The solution I saw was in two parts:
- Get some of my code, that might be useful to others, into melpa.
- Somehow sort my own package archive for my personal code.
Over the past week or so I’ve worked on this approach. It initially started with me tackling item 1 above: I tidied up and submitted
uptimes.el. This was a really helpful process in that it allowed me to brush up on my elisp and emacs knowledge. It’s a good 15+ years since I last wrote any significant elisp code and things have moved on a little in that time.
Having done that I’d managed to move a handful of my own packages out of my local library of code, and so out of my
.emacs.drepo, but it left me with the problem of what to do with the rest of it.
That’s when I discovered
,----[ C-h f package-upload-buffer RET ] | package-upload-buffer is an interactive compiled Lisp function in | ‘package-x.el’. | | (package-upload-buffer) | | Upload the current buffer as a single-file Emacs Lisp package. | If ‘package-archive-upload-base’ does not specify a valid upload | destination, prompt for one. `----
package-upload-filetoo, of course). This meant I could, in effect, start my own personal package archive and look at tackling issue 2 above.
This did give me one small problem though: how and where would I host the archive? I did consider hosting it on a DigitalOcean droplet, but that felt a little like overkill for something so simple. And then I realised: GitHub Pages! All I needed to do was keep the package archive in its own repo (which I would have done anyway) and then make the whole repo the source for a GitHub Pages site. A quick test later and… it worked!
So, by this point, I’d farmed some of my code off to melpa, and now had the rest of it in “delpa” (which I’d called my personal archive). I could now use the emacs package management system to install third party packages and also my own.
But I was still left with one issue: I was still holding the installed packages inside my
.emacs.drepo by way of ensuring that all machines were in sync in terms of what was installed. Now I needed to work out how to solve that.
use-packageI would be able to declare which packages I needed, how they’d be installed and, most important of all, it could be set to handle the fact that the package wasn’t even installed. If a package is requested and there is no local install
use-packageis smart enough to get the emacs package system to install it.
So, given that, all I need to do was create a startup file that would declare the packages I use and I’d have a setup that should, once I’d cloned
Except… yeah, one more issue.
use-packageisn’t part of GNU emacs yet so I’d need a method of getting it to auto-install so it could then handle everything else. As it was that was as easy as adding this to the start of my
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Make sure the package system is up and running early on. (require 'package) (add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/")) (add-to-list 'package-archives '("delpa" . "http://blog.davep.org/delpa/")) (package-initialize) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Bootstrap `use-package' (unless (package-installed-p 'use-package) (package-refresh-contents) (package-install 'use-package))
With that in place I was able to nuke all my config on a machine, clone a fresh copy of
.emacs.d(having now ceased tracking and storing the installed packages in that repo), run up emacs, wait a few moments and then find that everything was installed and ready to use.
.emacs.dis now a lot smaller than it was before and, I think, even easier to maintain. Right now I think I’m very close to the ideal emacs config that I wanted to create when I did the complete rewrite a year ago.
I want to like Gboard. On paper it looks really rather good. It’s a keyboard from Google, it ties in with your account, it syncs things, it has clever searching for emoji and gifs and the like… what’s not to like?
Problem is, I’ve been a user of SwiftKey since around 2011 (I think it was). I’m very used to how SwiftKey works and it also contains a lot of handy things. I like that it has smart completion, that it learns how I type a bit skewed and that it takes this into account, that I can turn off the fancy swipe typing and instead make use of handy gestures like swipe-left to delete a word. I like some of the themes a lot.
Into the mix comes my iPad, which I use on occasion. The standard Apple keyboard is horrible and, sadly, I find SwiftKey on iOS just as frustrating. It seems to lack enough key features there (especially the word deletion gesture, as far as I can tell) that it’s also a bit annoying. My dream of a consistent typing experience across all devices just wasn’t happening – until I found Gboard on iOS.
That felt almost right. And from what I could tell it worked almost exactly the same on iOS and Android. So it felt like a good time to try and force myself to use Gboard on my Google Pixel and Nexus 7.
Sadly, though, I’m just not getting on with it. It’s okay. It’s not bad. It’s just… not good. I’m finding that it lacks enough useful things that it’s a frustrating experience. Little things like: when I enter Google Search, there’s no word completion in the keyboard (SwiftKey has that); the word deletion gesture (swipe left from the backspace key) seems very hit-and-miss; the most obvious completion for a word sometimes appears in the middle slot but, other times, in the left slot. And so on.
Nothing huge. Nothing that’s a show-stopper. But a handful of a little things that make me miss the comfortable home that is SwiftKey.
Don’t get me wrong, it does have some very handy and cleaver features too. The searching for emoji – including showing them up as word completions – is rather clever. The gif-search thing is all kinds of fun too (mostly used to annoy the hell out of my son on twitter).
None of those quite make up for the bits I miss from SwiftKey though.
All that said, I’ve being making a point of pushing on with Gboard, thinking that most of my issues might just be because I’m too used to my “old home”. Mostly this was working well, until I noticed something this morning. While reading the description for Gboard I noticed this handy thing in the “Pro Tips” section:
Sync your learned words across devices to improve suggestions (enable in Gboard Settings→ Dictionary → Sync learned words).
Useful! I’d assumed that this was the case anyway – it’s Google after all – but it’s good to know I can ensure it’s turned on. So I went to turn it on. This is what I found:
What the hell Google? Sure, I do have a Gsuite account on my phone – as in various apps have access to a Gsuite account (Gmail, Drive, etc…) – but it’s not the primary account on my phone and it’s not the account I’d really want to be doing the dictionary sync with anyway. If I’ve got dictionary sync I want it tied to the keyboard no matter the app I’m in, and no matter the account I’m using in that app. I want the keyboard to be tied to a specific account when it comes to sync (just like SwiftKey does it).
This, I think, is a show-stopper for me.
I can overlook the other niggles, I can learn to cope with it not being quite so perfect in some situations; but the blanket inability to do something as simple as cloud-sync the predictions and learn from how I type – things that are, these days, central to what Google’s about – it’s frankly stupid.
I guess I’m going to have to keep Gboard as a backup keyboard for those times when I need to find the perfect gif.
Over the past couple or so weeks I’ve been having some issues with Google Now. It first seemed to start on my Nexus 7, then appeared on my Nexus 6. More recently, even as of today, I’ve seen it on my Google Pixel. The problem is that, in the Google Now launcher (or on the Pixel, in the Pixel launcher), the Google Now page (that you swipe to the left for) sits empty for ages. All I see is the little animated waiting circle and nothing else. Once or twice I’ve had the Google app die and restart or, more often than not, after quite some time it finally loads up.
The latter happened a little earlier and I noticed something I’d not seen before:
What’s with that “Achievements” menu option? You’ll notice that the whole of the menu is blank – no profile picture or anything and none of the menu options seemed to work.
Eventually, after I’d left it for a while, it ended up working.
And, once this happened, no “Achievements” option.
Presumably this is some back-end server issue, I’m being served up something I’m not supposed to be seeing and it’s confusing the client app. Okay, I don’t know that’s the case, but it has that sort of feel.
So now I need to go looking for what this Achievements thing is all about.
Using Google, obviously.
Like many programmers, I have a couple of “Hello, World” projects that I’ve carried with me over the years. One is 5x5 (which has been used to get to grips with things as diverse as the Palm Pilot and GNU emacs). Another is Norton Guides database readers.
I’ve made Norton Guides tools that have allowed web servers to serve guides (
w3ng), that have allowed you to convert guides to HTML (
ng2html), that have let you read guides on OS/2 and GNU/Linux (
eg) and also have let you read guides in Microsoft Windows (
weg). It’s a problem I know fairly well and one where I know the solution well enough so I can concentrate on learning the new language or environment.
And so jsNG was born.
At its core is a library of code for opening and reading data from Norton Guides databases. While I doubt it’s good ES6 code, or even good node.js code, it’s been very useful in giving me a fun problem to solve and it’ll carry on being something I’ll tweak and tinker with by way of trying new things out.
On top of this I’ve built a handful of tools for working with Norton Guides databases. The most useful one at the moment (the others are more in the “test the library” than the “make something handy with the library” category) is
ngserve. This is designed as a simple Norton Guides database HTTP server.
When run, you give it a list of guides to serve:
and it does the right thing. It has a small number of command line options that help configure what it does:
Possibly the most useful are the ones that let you change how it handles “higher” DOS characters and, if you don’t like the default colours and stuff, the option that lets you point to your own style sheet (note for now you’ll need to host the stylesheet somewhere else – ngserve won’t serve it for you; I’m aiming to change that in some way in the near future).
jsNG does have a fairly basic design compromise at its heart. In the very early version I started out using the async functions for opening and reading the guides. This got very tedious very quickly and I could see that it was going to make for a very messy library with a very messy interface. While it might not be in the spirit of node.js programming I decided to go with the sync version of the file IO functions and code up the core library based around this.
This approach also means that I took another leap that I never have done with Norton Guides before: rather than doing the traditional thing of keeping an open handle into them and reading direct from the file as you navigate the guide, I simply read it all into a buffer in one go and keep it in memory. This is a “guides are small, memory is cheap, things will go faster” approach.
It does mean that when you load up a load of guides into
ngservethey’re all sat in memory. The upside of this is that things should be a lot faster and the code is a lot easier to follow (I think). To put this in some perspective: I have a directory here that contains 110 Norton Guides files. They total 36M in size. If that seems like a lot of stuff to hold in memory… remind me how much is being used by your web browser so you can look at some hilarious kittens. ;)
ngservea little more. I’d also like to do a new version of
ng2htmlwith this – a version that makes it far easier to control the style of the output. I’m also tempted to do a CLI-based reader in pure ES6; something similar to
All in good time.
subscribe via RSS