I made a previous post (Enabling Wake-On-LAN (In Ubuntu 20.10)) about enabling Wake-On-LAN on my server, but it didn't seem to work after a re-boot. I looked in the logs using journalctl and noticed that the wol.service that I set up didn't get enabled after the re-boot. I thought about it and I remembered that when I was working with bluetooth and set up a service for it I had to make it wait for the bluetooth service to start first or it wouldn't work and realized that there was nothing in the wol.service file to tell it to wait so I went poking around and found what I hope to be a fix.

We need to update the /etc/systemd/system/wol.service that I created in that earlier post. Previously it looked like this:

[Unit]
Description=Enable Wake On Lan

[Service]
Type=oneshot
ExecStart = /sbin/ethtool --change enp4s0 wol g

[Install]
WantedBy=basic.target

We need to update the [Unit] section by adding

Requires=network.target
After=network.target

To let systemd know that we don't want this to run until after the network service has run. I also changed the WantedBy to multi-user.target. So the updated file looks like this:

[Unit]
Description=Enable Wake On Lan
Requires=network.target
After=network.target

[Service]
Type=oneshot
ExecStart = /sbin/ethtool --change enp4s0 wol g

[Install]
WantedBy=multi-user.target

Now reload the daemon and re-enable it.

sudo systemctl daemon-reload
sudo systemctl enable wol.service

To make sure I didn't introduce any errors I ran it once.

sudo systemctl start wol

Then I rebooted it.

sudo reboot now

This time in journalctl I saw this:

Dec 07 00:02:17 erebus systemd[1]: Finished Enable Wake On Lan.
Dec 07 00:02:17 erebus systemd[1]: wol.service: Succeeded.

And running ethtool showed that it was enabled.

Wake-on: g

Well, insofar as it's working now, yes. But since I change more than one thing I don't really know exactly what did it (was it one of the three lines I changed or all of them?). Anyway, since it works I'll let it lie for now.

• The Arch wiki has a page on Wake-On-LAN that tells you many different ways to set it up – I copied the systemd file almost exactly. It has quite a bit of useful information (too much maybe), but not all the commands will work out of the box on Ubuntu (because it's Arch).

This is how to mount a LUKS encrypted drive with cryptsetup in Ubuntu 20.10 (Groovy Gorilla). My use-case is I have a headless server that has an external USB drive that's encrypted with LUKS that I need to mount from the command line. I like the flexibility it gives a little more than the what the Gnome GUI does so I'll probably use it on my desktop as well. I previously documented how to do it with udiskctl in this post but I like cryptsetup a little better. This assumes that you know the partition/device (in my case it's /dev/sdb1). That previous post shows how I found it so I'll just do the decrypting and mounting here.

The syntax to decrypt the device is:

sudo cryptsetup open <device> <name>

As I mentioned above, in this case my device is /dev/sdb1. The name can be an arbitrary one (although there are limitiations on special characters so let's say it can be any alpha-numeric name) and I'll use wddata as the name. Then my command to decrypt the drive is:

sudo cryptsetup open /dev/sdb1 wddata

This will prompt you for your password and then the encryption passphrase. Once the command succeeds, it adds a link in /dev/mapper using the name you passed in so you can mount the device (assuming the directory you want to mount it in exists) like this:

sudo mount /dev/mapper/wddata /media/data

Where wddata is the name I told cryptsetup to use and /media/data is a directory that I had previously created.

Besides the man-page for cryptsetup on my server, I was pointed to use cryptsetup from this StackOverflow post:

• https://askubuntu.com/questions/63594/mount-encrypted-volumes-from-command-line

The accepted answer uses udiskctl but further down is an answer by George Schölly using cryptsetup. The syntax in the answer is the older cryptsetup syntax (which should still work) so it doesn't look exactly like what I used.

These are my notes on getting Wake-On-LAN working in Ubuntu 20.10. I have a server that I use to run most of the computation on when I use emacs/jupyter but I have it in a corner upstairs and although it's only a little walk, I find that the fact that I have to stop what I'm doing and go upstairs to push that little button on the front makes me lazy and so it ends up running more than it has to so I thought I'd enable Wake-On-LAN so I can suspend it and wake it up whenever I need to. I'm only going to use suspend (APM S3). When I tried to use hibernate (S4) it ended up shutting down my machine (S5). Interestingly, my BIOS menu has an option to enable waking up from shutdown, but since my disk is encrypted, and I didn't set up a separate SSH server, I have to go enter the passphrase to unlock the disk before the operating system can boot up, so it kind of defeats its own purpose.

So, that's how I got one machine working with Wake-On-LAN. Hopefully I won't have to look so hard the next time. Here's the pages that I stole this from.

• TechRepublic on using ethtool and setting up a systemd service for this (don't use the systemd file here, though).
• Stack Overflow on how to suspend and hibernate from the command-line
• Stack Overflow on what the difference is between suspend and hibernate
• Stack Overflow on using tcpdump to look for the Magic Packets on the remote machine
• Stack Overflow on editing remote files as root with emacs (not documented here, but maybe later)
• Stack Overflow on editing a local file as root with emacs (not used here, but I can never remember the syntax)

1. McCarthy C. The Kekulé Problem [Internet]. Nautilus. 2017 [cited 2020 Nov 24]. Available from: http://nautil.us/issue/47/consciousness/the-kekul-problem

This is a note on using memoization with recursion - specifically with the generation of a Fibonacci Number. The fibonacci numbers form a sequence where

\[ F_0 = 0, F_1 = 1 \]

and then for the rest of the numbers greater than 1

\[ F_n = F_{n-1} + F_{n-2} \]

So, starting from 0 you get 0, 1, 1, 2, 3, 5, 8, etc.

Calculating the sequence is often done with recursion because you can pretty much take the definition and convert it to a function with little translation.

def fibonacci(n: int) -> int:
    """Calculates the n-indexed fibonacci number

    Args:
     n: the index of the number in the (zero-based) sequence to get

    Returns:
     fibonacci number at index n
    """
    assert n >= 0
    if n < 2:
        return n

    return fibonacci(n - 1) + fibonacci(n - 2)

expected = 55
actual = fibonacci(10)
print(actual)
assert expected == actual, actual

55

Remember that n is the index for number, not the count (the second number in the sequence has index 1).

The problem here is that recursion like this has memory limits and takes a long time.

from graeae import Timer
TIMER = Timer()

expected = 102334155
n = 40
with TIMER:
    actual = fibonacci(n)
    print(n)
    assert actual == expected, actual

2020-11-09 21:11:05,852 graeae.timers.timer start: Started: 2020-11-09 21:11:05.852071
2020-11-09 21:11:50,249 graeae.timers.timer end: Ended: 2020-11-09 21:11:50.249808
2020-11-09 21:11:50,251 graeae.timers.timer end: Elapsed: 0:00:44.397737
40

Less than a minute might not seem like a big deal, but even pushing it up to 45 makes the wait too long (I gave up and killed the process so I don't know how long it ran). So what's the solution? Let's try memoization.

So, what's memoization? Is it what Elmer Fudd does when he memorizes? No, memoization comes from the latin word memorandum which means "to be remembered". What we're going to do is create a cache dictionary that will match arguments to our function call to their outputs. Then if a function call comes in that uses arguments that were used before, we can just grab it from the cache instead of re-doing the calculations.

We're going to use a python decorator from functools named wraps that allows you to build a decorator that looks like the original function. It isn't necessary for the decorator to work, but it makes it look more like the original functior passed to the decorator so it's a good practice to use it.

from functools import wraps

def memoize(function):
    """Adds caching

    Args:
     function: the callable to memoize

    Returns:
     callable with caching and the original function
    """
    cache = {}
    @wraps(function)
    def wrapped(*args):
        if args not in cache:
            cache[args] = function(*args)
        return cache[args]
    return wrapped

Although it works as a decorator, since we already defined the fibonacci function we can just pass it to memoize to add the cache.

fibonacci = memoize(fibonacci)

Now let's see what happens.

with TIMER:
    actual = fibonacci(100)
print(actual)

2020-11-10 15:45:08,117 graeae.timers.timer start: Started: 2020-11-10 15:45:08.117332
2020-11-10 15:45:08,118 graeae.timers.timer end: Ended: 2020-11-10 15:45:08.118691
2020-11-10 15:45:08,120 graeae.timers.timer end: Elapsed: 0:00:00.001359
354224848179261915075

Note: I originally tried renaming the memoized function, but since the recursive calls go to the original function name, this doesn't produce and improved function. You have to use the same name as you did when you defined the function.

So memoization really helps, even more than you might expect. The reason why is that the first recursion term (fibonacci(n - 1)) gets evaluated first, so each recursive call goes backwards by one until it hits the base-case where n < 2 and then all the rest of the calls are evaluated, but after one run through the indexes you've already hit all the cases you need for these other calls so rather than making more recursive calls, everything gets pulled from the cache.

As is often the case, when you implement something useful in python you'll find that it's already been implemented, in this case as part of the python standard library.

from functools import lru_cache

@lru_cache(maxsize=None)
def fib_o_nacci(n: int) -> int:
    """Calculates the n-indexed fibonacci number

    Args:
     n: the index of the number in the (zero-based) sequence to get

    Returns:
     the nth fibonacci number
    """
    assert n >= 0
    if n < 2:
        return n

    return fib_o_nacci(n - 1) + fib_o_nacci(n - 2)

Note: in python 3.9 there is a cache decorator that is the same thing as the lru_cache with maxsize=None but I'm running this on python 3.8 right now so I can't use it.

with TIMER:
    print(fib_o_nacci(500))

2020-11-09 21:53:19,405 graeae.timers.timer start: Started: 2020-11-09 21:53:19.405955
2020-11-09 21:53:19,407 graeae.timers.timer end: Ended: 2020-11-09 21:53:19.407891
2020-11-09 21:53:19,409 graeae.timers.timer end: Elapsed: 0:00:00.001936
139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125

Okay, so, I think it works, although I'm not checking the values, the speed seems to be an improvement.

The problem at hand is that we're given a sequence and we want to find the longest combination we can find in it that is non-decreasing (each element after the first is greater than or equal to the previous element).

This will be a brute-force solution using nested for-loops. This will use the itertools.combinations function to generate the candidate solutions.

from itertools import combinations

def brute_force(sequence: iter) -> tuple:
    """Finds the longest non-decreasing sub-sequence

    Args:
     sequence: the source collection of items

    Returns:
      the longest non-decreasing sub-sequence in the sequence, number of for-loops
    """
    count = 0
    for length in range(len(sequence), 0, -1):
        count += 1
        for sub_sequence in combinations(sequence, length):
            count += 1
            if list(sub_sequence) == sorted(sub_sequence):
                return sub_sequence, count
    return

Here's what it's doing.

1. The outer loop counts down from the length of the sequence to zero.
2. The inner loop generates combinations of the current length in the outer loop
3. If the sub_sequence is in sorted (non-decreasing) order then it is as long or longer than any other non-decreasing sub-sequence so choose it as the longest sub-sequence.

• From Python Algorithms

This is a brief note on the python itertools.combinations function.

from itertools import combinations

To make sure it's behaving the way I think it will I'll also use some other built-ins.

from itertools import count
from math import factorial
from math import comb as n_choose_k

The combinations function takes two arguments:

• iterable: the source that you want to make combinations from
• r: the length of the sequences you want to make

It returns all the r-length subsequences in the iterable (combinations).

• Hetland ML. Python Algorithms: mastering basic algorithms in the python language. New York, N.Y: Apress; 2010. 316 p. (Expert’s voice in open source).

• GitHub Repository for code in the book.

I've been trying for a while now to figure out how to change the Firefox Reader font. The default (serifed-font) is Georgia, which is nice enough, but I like to change things up now and again. I would sometimes just edit the CSS in the Developer's Tools, but I finally stumbled upon how to do it so I'll save it here for my future self.

The procedure is pretty simple, this is it in outline:

1. Create the chrome folder for it if it doesn't exist.
2. Enable the use of this folder.
3. Find the CSS you want to change.
4. Add a userContent.css file to the chrome folder and add the CSS you want to use to it.
5. Restart Firefox

So, that's one way to change the font for the Firefox Reader. Not exciting, but finding out how to do it was hard enough that I thought I should note it for later.

This is a test of running javascript in org-babel blocks. For some reason I couldn't find any documentation about setting it up so this is also a place for me to collect what to do.

Note: I actually did use this org-babel page for some of it, but it wasn't enough for me to really figure out what was going on.

Okay, so this was a very basic hello world for javascript in emacs. The lack of sessions is kind of disappointing, but I don't know how useful this is going to be, anyway, since javascript is so tied to the browser, but there it is.