Here is Kite’s farewell for you to read.

Kite did open-source many parts of their technology/software stack, though I didn’t check how comprehensive those parts are, and if that is anywhere near enough to fork/continue their work.
I wonder if there already exists an open-source project focusing on ML-based code completion for e.g. Python – let me know in the comments if you know one!

Kite cites two reasons for a shutdown: 1) technology not being quite there yet, and 2) failure to monetize.
Kite had up to 500k daily developers using the platform, but apparently extremely few were willing to pay for it.
If you do look at current ML code assistants, there seems to always exist at least some free tier – I wonder if that is forced by the same lackluster, non-paying developers attitude as for Kite.

Kite’s farewell had another interesting number: 18%.
That is by how much individual developer’s productivity could increase thanks to Kite’s assistance.
This isn’t bad at all; for a team of 5 largely independent developers, it’s almost one extra “affordable” developer.
Kite was striving to achieve a “10x improvement”, but at least to me the 18% improvement sounds good enough for sales.

I’m very curious to try some of these assistants out.
I can imagine them to be very helpful for relatively experienced developers when starting to work with a new library/ecosystem – for example, OpenVision Python bindings.
Even the common autocomplete can significantly simplify “onboarding” to a new library – and a more intelligent autocomplete should be able to help with boilerplate code (that you usually don’t have when you begin), as well as with some idiomatic expressions and statements.

Have you already played with some of the smarter code assistants?
What was your experience?
Please share

There’s still a ton of maintenance work needed, but at least it’s accessible again .

The blog went offline in early April 2021 – because the trusty physical server at home, built sometime before 2008 from off-the-shelf components, finally malfunctioned badly enough to not be fixable remotely over ssh.
(Or maybe it was still fixable, but at 13+ years old I thought it’s better not to fix anymore.)

It had previously survived (and recovered from) several hardware failures:

• (there might have been earlier failures that I no longer remember)
• PSU: after showing higher-than-normal deviations from standard voltages (+.3V, 5V, and 12V), the PSU died with a puff of smoke. It was replaced with a comparably cheap ATX PSU, that served fine for many more years.
• CPU fan failure: as the CPU heatsink was rather small, even with powersave CPU mode it was still getting too hot – so I had to shut it down and wait until I was able to replace the fan.
• OS disk: the server started with an old 320GB Seagate. When SMART data started deteriorating (unreadable/remapped sectors), I have swapped it out for a small and cheap 60GB Kingston SSD.
• Second CPU core: that server used a rather old dual-core AMD Athlon X2. I think it was old back when it was installed . At some point second core (#1) was showing 100% usage, and the server would restart within some minutes after booting. I am still surprised and impressed this was fixable remotely! Maybe the issue wasn’t too bad if the server could still boot and last for a few minutes. The fix was to disable the problematic core permanently from within Linux.

That chapter is over now.
Will the new chapter bring more regular posting?
Other, non-text content?…

We’ll see

There is a special font, called Sans Forgetica, designed to better retain the text that you read… Wow.

I can see how this may become abused – for example, for advertising

Anyway, you can download the font, and even a Chrome extension to show any text chunk in this Unforgettable font from the font’s website: http://sansforgetica.rmit/.

Here’s my blog URL for you to remember, hehe

The 2018 World Cup is now underway in Russia. The story of how it ended up there involves some names you might recognize: James Comey, Robert Mueller and Christopher Steele. Guest: Ken Bensinger, author of “Red Card: How the U.S. Blew the Whistle on the World’s Biggest Sports Scandal,” who has written about this story for The New York Times.

An additional reason appeared when I started researching the topic.
Apparently, Windows 10 no longer even creates the recovery partition during installation!
The entire WinRE is now stored on that same system reserved partition, which contains your window’s BCD!
The recovery partitions should only be present on Windows 10 installations which were either upgrades from a previous Windows version, or (as in my case) were installed within about 6 months after Windows 10 became available.

These instructions are also useful if you wish to increase the size of your system reserved partition – for example, if Windows 10 updates are failing because of that partition’s lack of free space.

WARNING: changing partition tables on your hard/solid-state disk may easily result in complete data loss!
Instructions below are provided as-is, to be used at your own risk. See full disclaimer on the About page.

WARNING: although it is also possible to merge the system reserved partition and windows 10 partition (so that the entire Windows 10 uses only 1 primary partition), I do not (and will not) offer instructions to do so. In fact, I recommend that you don’t merge the system reserved and windows 10 partitions.

Merging system reserved and recovery partitions, step by step.

1. First, we need a convenient partition manager; I have used a free MiniTool Partition Wizard, but other great free partition managers (like AOMEI Partition Assistant and I guess a few others) should be sufficient for us. Download and install one of those. It is impossible to use Window’s own Disk Manager for the steps below.
2. My starting state is this:

   [ 189MB free space ] [ system reserved, 100MB ] [ windows 10, 100GB ] [ recovery, 450MB ] [ free space ]

3. Your starting state may look a bit simpler, like this:

   [ system reserved, 100MB ] [ windows 10, 100GB ] [ recovery, 450MB ]

   Presence or absence of free space at the beginning or end of the disk should not make any difference (unless your windows partition has very little free space).

4. Our goal state is:

   [ system reserved, 900 MB ] [ windows, 100 GB ] [ free space ]

5. Create a full disk backup! Yes, I really did that. I can highly recommend booting into Clonezilla (or your Linux, if you dual-boot), and performing a full disk-to-image backup. If anything at all goes wrong – you should be able to completely restore your system to the previous functional state.
6. Verify that your full-disk backup can be restored (is readable/decompressible/whatever). Clonezilla has an option (enabled by default) to perform this check after disk imaging is complete – this was sufficient for me.
7. Verify that you have a functional WinRE: start Administrator CMD (or PowerShell), and run reagentc /info – it should tell you that WinRE is enabled, and also tell you that it’s using partition 3. I’d also strongly suggest that you create a separate bootable USB with WinRE – Windows 10 has its own tool to do so.
8. (optional) If you, like me, had some free space at the beginning of the disk, before the system reserved partition – then it makes sense to first extend the system reserved partition there. Use your partition manager to do so – either as a one-click Extend partition operation (and then select the free space upstream, all of it), or as a Resize partition to move the left edge of system reserved to disk’s beginning. Reboot. This worked flawlessly for me. If your Windows 10 does not boot anymore – try fixing boot using your bootable WinRE, or the WinRE on your disk. If that fails – restore your disk backup, and look for a different solution…
9. When merging system reserved and recovery partitions, one has to keep in mind the free space requirements of these two partitions (for UEFI, for MBR). They are a bit weird, so I picked 900 MB as the target size for system reserved; with this size, at least 320 MB have to be free on that partition after we are done. After merging the free space (189 MB) and the sysres partition (100 MB) I already had 289 MB, and needed to add (900-289=) 611 MB. Start your partition manager again, Extend system reserved partition using your Windows 10 partition, and reboot again. If there is no option to extend: first shrink the windows partition from the left edge by the calculated number of MB (611 in my case), then extended sysres partition into the freed space – and reboot. After this step, the disk should look like this:

   [ system reserved, 900 MB ] [ windows 10, ~100GB ] [ recovery, 450 MB ] [ free space]

10. Now we are going to move the WinRE from a dedicated partition to a sysres partition, in a few easy commands. Start Administrator CMD or PowerShell, check that your WinRE is still active: reagentc /info. Now disable it: reagentc /disable. Verify with another reagentc /info. If disabling failed, and you wish to have the WinRE functionality – do not proceed! I have no idea if proceeding after failure here would result in a functional WinRE. Do not reboot, keep the CMD/PowerShell open!
11. Delete the recovery partition, apply changes, do not reboot! (although it should actually be safe to…)
12. (possibly optional) Create an unformatted placeholder partition where your recovery partition used to be, to prevent Windows from creating it again when you re-enable WinRE. In my case, disk layout after this step is:

    [ system reserved, 900 MB ] [ windows 10, about 100 GB ] [ Unformatted primary partition ]

    Do not reboot.

13. Back to your elevated privileges CMD/PowerShell window: simply run reagentc /enable, and confirm with reagentc /info. As there is no other place to put WinRE now, reagentc should save it to the (now big enough) system reserved partition.
14. Delete the placeholder partition. Your final state should be similar to:

    [ system reserved, 900 MB ] [ Windows 10, ~100 GB ] [ free space ]

Congratulations, you have just successfully merged the system reserved and recovery partitions of Windows 10!

• camera: Honor has an extra low-res “depth” camera, while Lenovo doesn’t
• frame/body: Lenovo has a metal unibody design and performed ok in the scratch/burn/bend test, while Honor has a plastic body, easy to scratch screen, and did not perform as good as Lenovo in the test
• Lenovo has a bigger battery

For about the same price (Lenovo P2 being a bit more expensive) one can buy a 4GB/32GB Lenovo P2 or a 4GB/64GB Honor 6X.

After using both phones for a while, I feel that Honor is a much better value overall.
Here’s a brief comparison, based on my use.

Lenovo P2 vs Honor 6X: practical use impressions

Honestly, regarding cameras, I feel that LG G2 mini and Samsung S4 mini had better cameras…
Fewer megapixels, no 4K video recording – but great photos, and no problems with videos.
This is probably a single major disappointment.

1. touch -d “Jun 01 00:00 2011″ /tmp/.date1
2. enter into your BIG dir
3. press C-x ! (External panelize)
4. add new command like a “find . -type f \( -newer /tmp/.date1 \) -print”

I’ve used a slightly different approach, specifying desired date right in the command line of External Panelize:

1. enter your directory with many files
2. press C-x ! (External Panelize)
3. add a command like find . -type f -newermt "2017-02-01 23:55:00" -print (man find for more details)

In both cases, the created panel will only have files matching your search condition.

This will duplicate both metadata and btrfs system data.
Verify with: sudo btrfs fi df /toplevel:

Data, single: total=10.00GiB, used=3.88GiB
System, DUP: total=64.00MiB, used=4.00KiB
Metadata, DUP: total=512.00MiB, used=286.18MiB
GlobalReserve, single: total=96.00MiB, used=0.00B

Explanation: on SSDs, mkfs.btrfs creates metadata in single mode (because of widely spread SSD deduplication algorithms negating duplicate entries). However, second copy of metadata increases recovery chances, especially so if your SSD does not deduplicate writes. Hence the desire to add metadata/systemdata duplication after the filesystem is created.

Exactly what the title says: Raspberry Pi colocation service, yay! At only 30 EUR/year as of this writing.

My current email server was configured eons ago, it works well,
but I have no desire to painfully transfer all the configuration…
Better install something new, shiny and exciting, right?

I had 3 #self-hosted, #mail-server bookmarks:

• Mail-in-a-box
• iRedMail
• Modoboa
• Sovereign

(Sovereign, the 4th one, was addded after reading more about Mail-in-a-box.)

Here are my notes on what seemed important about these 4.

• iRedMail
• has free and paid web-UIs
• no DNSSEC, DMARC, HSTS
• amavisd with clamav
• has useful manual parts
• containerized
• not attractive
• Modoboa
• less sophisticated than Sovereign or Mail-in-a-box
• web-UI, also for amavisd filters
• overall: focuses on better UI
• has useful manual parts
• recent (experimental?) LetsEncrypt support
• has (some) unit tests
• containerized
• not that attractive
• Sovereign
• has more than I need, but components can be deactivated
• has EncFS support (useful, but questionable because of reboots…)
• no dedicated web-interface, configs are text
• has proper testing against a vagrant virtual machine
• can be dockerized using github.com/kisamoto/dancible
• attractive as “the next solution”, or to borrow EncFS support
• Mail-in-a-box
• the most sophisticated email server (except for EncFS which is not used here)
• simple but useful web-UI
• no amavisd, clamav, UI for filters
• has good relaying manual
• more or less requires a separate machine (overwrites configs?)
• has no well-established testing, not even for development; this is being worked on as of New Year 2017
• problems with owncloud (which I don’t really need)
• hub.docker.com/r/mtrnord/mailinabox/ , github.com/mail-in-a-box/mailinabox/blob/docker/containers/docker/run
• postscreen is not yet configured, it is not obvious if it were beneficial
• the most attractive; might be reasonable to fork and modify (e.g. drop owncloud?)

MIAB appeared really attractive,
but then – do I really want to dedicate one of the VPS to the mail server only?
Not in my case – too low emails volume/traffic.

So running it in an LXC (or some other) container would make sense.
And this is actually possible, some of the users over at MIAB’s discussion forum
have been running MIAB inside docker container for over a year now with no issues.
(An extra upside is that web-UI can be left unexposed, preventing external access to it.)
A possible long-term downside is, of course, lack of tests – Sovereign looks much better in this regard.

Sovereign looks very good overall. In fact, MIAB feels like
“Sovereign’s email component + webui for it” (MIAB was inspired by Sovereign).

One extra MIAB-specific feature is DNSSEC support.
MIAB takes on the role of your nameserver, and thus is able to setup (and refresh, when necessary)
all the DKIM/DNSSEC/etc-relevant DNS records for you.

As soon as I’ve started adding “containerization” to the mix, dozens of other projects entered my field of view:

• github.com/indiehosters/email, inspired by MIAB, looks ok; lacks webmail, fail2ban, SPF, DANE, DNSSEC, but uses vimbadmin instead of a custom-coded MIAB UI
• github.com/tomav/docker-mailserver looks great! No UI, no SQL backend, only 2 text files (accounts and aliases) for all configuration – yay!
• github.com/lava/dockermail, much less active/polished, not really interesting
• github.com/frankh/docker-compose-mailbox adds roundcube and vimbadmin containers; uses SQL; not sure why it has only 10 stars on github…
• github.com/adaline/dockermail – looks ok, less active and seems simpler than docker-mailserver
• poste.io : has free (downloadable) and 2 paid versions; packed with many features and containerized; there is no Dockerfile, but of course you can examine what’s inside the public image anyway; actually, looks good – not sure how posteio-specific the data directory structure is, though… still something to try
• mailgun.com – SMTP service with a more than sufficient free quota for a few low-traffic websites; can be coupled with some forwarding service to avoid any need in an email server; but not this time, I want a mail-server
• yunohost.org : I’m not entirely sure why this is here, maybe it does have email support built-in? ok, yes it does – this is a debian-based “home-server” software, which also includes LDAP and SSO and XMPP and DNS and nginx. Hmm, not bad. I wonder how well it works out of the box.
• kolab.org : groupware; looks interesting as well, but I have no group (yet) to have a use for a full groupware solution
• not reviewed: mailcow.email, mailcow.email/dockerized, github.com/andryyy/mailcow

Finally, one can build an own LXC container, either by following this ArsTechnica series,
or after examining the install scripts of MIAB or Sovereign.
Then automate all of this, keep it well-maintained – and there you have it, one more mail-server solution!

To re-cap:

• MIAB looks very good – feature-rich, easy to install, and just works – you should try it!
• docker-mailserver looks great – I should try it!
• poste.io, yunohost.org and kolab.org are also some interesting solutions to try, along with Sovereign

Not much of a summary, but this is definitely an accurate reflection of reality.

There are two major obstacles for a somewhat-dated Windows 7 when it sees modern hardware:

• USB 3.0
• SSDs and newer disk drives in general

Fortunately, both problems are easy to fix.
Just follow the steps below; skip steps 1 and 2 if you already have a bootable Win7 flash drive.

1. Obtain/buy/create the Windows 7 ISO image.
   On Linux, creating an ISO image is as easy as dd if=/dev/sr0 of=/path/to/image.iso – assuming that /dev/sr0 is your DVD reader.
2. Create a bootable Windows 7 installation flash drive.
   On Linux, WinUSB can handle this; on Windows, you can use Rufus, or Microsoft’s own tool for this.
3. To add USB 3.0 drivers to the Win7 on your flash drive, download and use this: Windows 7 USB 3.0 Creator Utility:
   1. Run the utility as Administrator.
   2. Depending on the speed of your USB stick, this may take up to 15 minutes.
   3. Wait for a message along the lines of Creation finished! or Upgrade finished.
4. The steps above fix the first obstacle: lack of USB 3.0 drivers in the Windows 7 installation image.
   Now we are going to preemptively fix the second obstacle: not recognizing modern HDDs/SSDs.
5. Go to your hardware manufacturer’s website and locate the (model-specific) SATA/storage driver.
   Using Dell’s hardware as an example:
   1. go to downloads.dell.com
   2. there, click Laptops (or Desktops), then find and click your hardware model
   3. you will see a list of drivers for that model; search for “serial-ata” or “storage”
   4. download the latest version of the driver that you have found (it would be intel storage technology in Dell’s example case)
6. Depending on the manufacturer, drivers may need to be extracted from the (self-extracting) archive. In the case of Dell’s drivers,
   1. launch the downloaded executable file
   2. it will usually present 2 options: Install and Extract; you should extract
7. In the downloaded (and, possibly, extracted) drivers folder locate Windows7-specific drivers folder, and simply copy that folder to the USB stick with your Win7 installation.
8. Be sure to remember what is the driver’s folder name – if Windows fails to see your SSD, you will need to manually browse for these drivers during installation.

That’s it!

Sources used:

• this video – or rather this one;
• Install Win7 to USB3.0 Computers Readme – also has information on other methods of injecting USB 3.0 drivers into windows USB stick.

But I always keep looking for new/improved tools, as right now I feel the best one does not exist…
(If the best one can exist at all – requirements and conditions change all the time, so there is no fixed perfect immovable target.)

I have been contemplating trying out the TSW methodology, but neither Keep nor Trello are quite there yet.
I ended up using Evernote; after recent management changes and actually trying to become profitable it may as well last long enough.

Everything was fine and calm until I have found workflowy yesterday.
In essence, it is very similar to the text-file-based system that I have been using for at least half a year.

Briefly, it is a web-based text editor on steroids, with possibly infinite nesting lists and seemingly full keyboard shortcuts control – no mouse needed.
I recommend that you try the demo – it seems to be fully functional, and there is no need to sign up.

This discovery made me read through pages and pages of this class of software tools.
Here is a very brief summary of my findings:

• org-mode for emacs: taking notes, organizing to-do lists and projects, writing structured text; I can definitely see the benefits – especially for tasks/projects management; however, for rich content – with attached/embedded files/images – this probably won’t work that well; see also orgzly;
• TagSpaces (also on github) is a tags-based files manager; cross-platform, offline, stores tags in filenames (in square brackets) – this is probably the least interfering/locking-in solution, the only things changing are file names; TagSpaces users are expected to synchronize the tag-controlled filesystem (which can be some specific directory tree) using 3rd-party tools such as [BT]Sync, SyncThing, Dropbox, Box, etc;
• many kinds of Evernote-like tools and wikis, that people also use to take notes; the two most mature and usable and feature-rich are probably Laverna (looks great, uses markdown, can be self-hosted, unclear how to search by multiple tags) and Paperwork (same thing with multiple tags); WizNote also deserves a mention; among other tools: git-backed magpie, yipgo, Marks, KeepNote, zim, etc;
• hamster-GTD is a (yet another?) variation of TSW/GTD – not a tool, but a system;
• Artificer (formerly Overlord S-RAMP), a system for any kind of interconnected, hierarchical data; see also Artificer GTD example;
• magnolial, workflowy clone (haven’t tried it yet); another clone is HackFlowy – trying its offline demo shows that only a basic list functionality is present.

Now that I think of it, TagSpaces is a neat idea…
Especially for photos – assigning tags actually updates filenames, which is great for photos.
And you can easily search by those tags later in TagSpaces.
In fact, TagSpaces looks very interesting for organizing lots of directory/file-based data.

Laverna looks quite exciting! And seems to be actively developed.
But there seems to be nothing quite comparable to WorkFlowy… Need to test it some more.

Recently, however, I have come across some real-world data, which not only had contamination in it, but also quite a noticeable percentage of adapters.
I did a quick test of multiple tools to see if they fit my requirements:

• should be easy/logical to use: no arcane/convoluted command lines or config files
• should detect adapters automatically, either using its own database or a provided plain FASTA file
• should be reasonably fast
• must leave no adapter traces behind: I prefer aggressive trimming

I have tried the following tools:

• fastq-mcf from the ea-tools package
• skewer
• TrimmomaticPE
• cutadapt: haven’t used it directly, but it is used by some of the compared tools
• bbduk from BBMAP
• autoadapt
• TrimGalore!

As input, I have used 2 FASTQ files, each about 8.4 gigabytes
(or 3 785 687 KBytes together in 2 bzip2-compressed files, or 129 753 452 lines / 32 438 363 reads per file).
Time was measured with bash’s built-in time.
The all_adapters.txt is a plain FASTA file I took from FastQC distribution a long while ago,
and possibly added some more adapter sequences scavenged from the internet.

fastq-mcf (ea-tools)
fastq-mcf ~/bin/all_adapters.txt -o R1.clip.fastq -o R2.clip.fastq input_R1.fastq input_R2.fastq

• non-obvious way to specify 2 outputs for 2 inputs, but not complicated either
• can be given a file with dozens of adapters: will auto-identify which adapters to trim
• single-threaded, uses 315M RES and 380M VIRT
• 83.5 minutes on a loaded system

Reads too short after clip: 137 684
Clipped ‘end’ reads (input_R1.fastq): Count 895 775, Mean: 24.36, Sd: 17.32
Trimmed 2 072 551 reads (input_R1.fastq) by an average of 4.46 bases on quality < 7 Clipped 'end' reads (input_R2.fastq): Count 850 718, Mean: 25.70, Sd: 17.19 Trimmed 8 729 083 reads (input_R2.fastq) by an average of 4.44 bases on quality < 7

skewer
skewer -x ~/bin/all_adapters.txt --mode pe --threads 8 input_R1.fastq input_R2.fastq

• looks much fancier: uses colors and has a text-mode progress bar
• is multi-threaded, but appears to be extremely slow – much slower than single-threaded fastq-mcf – update: it is incredibly fast if instead of 96 adapters you just give it 3 or so;
• can read up to 96 adapters from the file… should be fine for most purposes
• uses very little RAM (~4 megabytes RES, ~450M VIRT)
• really slow: real 177m52.933s , user 1212m3.644s (7 threads)

32 438 363 read pairs processed; of these:
12 339 ( 0.04%) short read pairs filtered out after trimming by size control
94 409 ( 0.29%) empty read pairs filtered out after trimming by size control
32 331 615 (99.67%) read pairs available; of these:
934 379 ( 2.89%) trimmed read pairs available after processing
31 397 236 (97.11%) untrimmed read pairs available after processing

TrimmomaticPE
TrimmomaticPE -threads 8 -trimlog trimmomatic.log input_R1.fastq.bz2 input_R2.fastq.bz2 lane1_forward_paired.fq.gz lane1_forward_unpaired.fq.gz lane1_reverse_paired.fq.gz lane1_reverse_unpaired.fq.gz ILLUMINACLIP:/usr/share/trimmomatic/TruSeq3-PE-2.fa:2:40:15

• failed to start without seemingly optional arguments to ILLUMINACLIP with an uninformative error message
• uses 1.5+GB RES, 7.8GB VIRT, and does not fully utilize all 8 threads (CPU load only at around 500%, where 100% means 1 core)
• does not seem to be I/O bound, but log file is huge: contains all read identifiers
  • it might be better to disable log file (do not specify -trimlog) for higher I/O speed
• comes bundled with some adapters already, but:
  • does not detect adapters itself: you have to know which file to choose
  • adapter files are structured in a way preventing merging them into a single file: adapter names have special meaning to Trimmomatic
• real 19m39.431s, user 71m8.600s , sys 23m44.556s: much faster than either skewer or fastq-mcf

Input Read Pairs: 32438363
Both Surviving: 31591307 (97.39%)
Forward Only Surviving: 750772 (2.31%)
Reverse Only Surviving: 8023 (0.02%)
Dropped: 88261 (0.27%)

NOT trying cutadapt:

• looks great based on reading the manual
• only accepts adapters on the command-line, and does not come with adapter files to use
• is in Python/Python3, so could be easier re-used from Python programs

BBMAP
bbduk.sh in=input_R1.fastq.bz2 in2=input_R2.fastq.bz2 out=bbduk_clean_1.fastq out2=bbduk_clean_2.fastq ref=~/bin/all_adapters.txt

• refused to load some JNI library:
  

  Error: Could not find or load main class utilities.bbmap.jni.

• changed into bbmap/jni and ran export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64 ; make -f makefile.linux, but this didn’t help
• failed to run

autoadapt (relies on FastQC and cutadapt)
autoadapt.pl --threads=8 input_R1.fastq autoadapt_clean_1.fastq input_R2.fastq autoadapt_clean_2.fastq

• first runs FastQC to a temporary file (0.5GB RES, 4.8GB VIRT)
  • fastqc is started with --threads 8, but only 1 file is fed to fastqc…
• auto-detected adapters, from FastQC’s output:
  

  Detected the following known contaminant sequences:
  Illumina Single End PCR Primer 1 (AATGATACGGCGACCACCGAGATCTACACTCTTTCCCTACACGACGCTCTTCCGATCT)
  TruSeq Adapter, Index 7 (GATCGGAAGAGCACACGTCTGAACTCCAGTCACCAGATCATCTCGTATGCCGTCTTCTGCTTG)

• used over 15 GB RAM! + swap!
• this is too much, killed and re-starting with 1 thread
• uses cutadapt (<8M RES, <31M VIRT), looking for adapters anywhere (and not only at 3' like TrimGalore does); here's the generated command sample:

  cutadapt --format fastq --match-read-wildcards --times 2 --error-rate 0.2
  --minimum-length 18 --quality-cutoff 20 --quality-base 33
  --anywhere=GATCGGAAGAGCACACGTCTGAACTCCAGTCACCAGATCATCTCGTATGCCGTCTTCTGCTTG
  --anywhere=CAAGCAGAAGACGGCATACGAGATGATCTGGTGACTGGAGTTCAGACGTGTGCTCTTCCGATC
  --anywhere=AATGATACGGCGACCACCGAGATCTACACTCTTTCCCTACACGACGCTCTTCCGATCT
  --anywhere=AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGTAGATCTCGGTGGTCGCCGTATCATT
  --paired-output autoadapt/autoadapt.tmp.f_zxQr95/autoadapt_R2.fastq.tmp
  -o autoadapt/autoadapt.tmp.f_zxQr95/autoadapt_R1.fastq.tmp
  input_R1.fastq input_R2.fastq && cutadapt --format fastq --match-read-wildcards
  --times 2 --error-rate 0.2 --minimum-length 18 --quality-cutoff 20 --quality-base 33
  --anywhere=GATCGGAAGAGCACACGTCTGAACTCCAGTCACCAGATCATCTCGTATGCCGTCTTCTGCTTG
  --anywhere=CAAGCAGAAGACGGCATACGAGATGATCTGGTGACTGGAGTTCAGACGTGTGCTCTTCCGATC
  --anywhere=AATGATACGGCGACCACCGAGATCTACACTCTTTCCCTACACGACGCTCTTCCGATCT
  --anywhere=AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGTAGATCTCGGTGGTCGCCGTATCATT
  --paired-output autoadapt_R1.fastq -o autoadapt_R2.fastq
  autoadapt/autoadapt.tmp.f_zxQr95/autoadapt_R2.fastq.tmp
  autoadapt/autoadapt.tmp.f_zxQr95/autoadapt_R1.fastq.tmp

• uses its own directory for intermediate/temporary files, then moves to destination – not good…
  • the problem is that program’s partition may not have enough space for all the intermediate data
  • actually, cutadapt is run twice:
    • first to the temporary directory
    • then to the final destination, using temporary/intermediate files as inputs
• ran out of space in /home… created a copy of cutadapt under ~/data volume
• /usr/bin/time -f '%C: %e s, %M Kb' ~/data/autoadapt-tmp-copy/autoadapt.pl --threads=1 input_R1.fastq autoadapt_R1.fastq input_R2.fastq autoadapt_R2.fastq
• over 1h CPU time already, and still about half-done… should try with --threads=2 or 4, maybe RAM use will be somewhat better?
• total time 9979.87 seconds (2.8 hours), max RAM 235 480 Kb
• trying in 4 threads: again 15+ Gb RAM and 7+Gb swap, killed at this point;
  • the problem seems to be somewhere in the read splitting code – apparently, it keeps reads in RAM (???) while splitting…
  • looking at the split files: they are all partial, so autoadapt.pl somehow attempts to parallel-split into all thread segments at once
• trying to edit splitFile() function to use GNU split command; hopefully, mergeFile() does not use gigabytes of RAM…
  • for testing: hard-code tmp dir name; skip actual fastqc
  • this now works great! let’s wait for merging…
  • mergeFile() still eats ~2.5Gb of RES
• because of all the splitting, temporary directory size easily jumps to about 3x the original file size, or ~48 GB for ~16 GB of input files
• 3007.68 s (50 minutes – this does not include the initial FastQC run), 2 523 952 Kb (this is mostly the file merging operation)
• it does not show any stats at the end

Trim Galore!
trim_galore --fastqc --path-to-cutadapt /usr/bin/cutadapt3 --paired input_R1.fastq input_R2.fastq

• the trim_galore perl wrapper itself consumes just a few megabytes of RAM
• uses cutadapt for actual work
• auto-detects adapters, although somehow the Illumina adapter found is only a substring of what was found by autoadapt/FastQC…
  

  Found perfect matches for the following adapter sequences:
  Adapter type Count Sequence Sequences analysed Percentage
  Illumina 17429 AGATCGGAAGAGC 1000000 1.74
  Nextera 0 CTGTCTCTTATA 1000000 0.00
  smallRNA 0 TGGAATTCTCGG 1000000 0.00
  Using Illumina adapter for trimming (count: 17429). Second best hit was Nextera (count: 0)

• can run FastQC itself on the processed data, if so instructed by a command-line option
• trims and summarizes each file separately

Total reads processed: 32,438,363
Reads with adapters: 6,878,225 (21.2%)
Reads written (passing filters): 32,438,363 (100.0%)
Total basepairs processed: 3,276,274,663 bp
Quality-trimmed: 11,132,367 bp (0.3%)
Total written (filtered): 3,226,980,229 bp (98.5%)

• cutadapt processes about 4 million reads/minute on my work PC i7

Total reads processed: 32,438,363
Reads with adapters: 6,030,241 (18.6%)
Reads written (passing filters): 32,438,363 (100.0%)
Total basepairs processed: 3,276,274,663 bp
Quality-trimmed: 40,530,133 bp (1.2%)
Total written (filtered): 3,199,297,597 bp (97.7%)

• length is checked after cutadapt:
  

  Number of sequence pairs removed because at least one read was shorter than the length cutoff (20 bp): 145312 (0.45%)

• 1955.49 s (32.6 minutes), 228 592 Kb (this is likely FastQC’s top RAM use)

How do I evaluate the quality of trimming?
Notably, all trimmers removed the “Adapters detected” section from FastQC’s output.
For now, I’m simply choosing the smallest pair of processed read files
(under the assumption that the smallest is the most aggressively trimmed).

File sizes after trimming, R1+R2
16’750’631 trimmomatic
16’770’603 autoadapt, threads=1
16’771’639 autoadapt, threads=8 // after swapping Perl splitter function for GNU split
16’924’934 trimGalore
16’963’937 fastq-mcf
17’057’065 skewer

Looking at FastQC plots, major differences can be seen in read lengths distribution (which depends on how much of the sequence tail/head was trimmed),
per-tile quality (trimmomatic and skewer do not perform any kind of quality trimming by default, others do), and k-mer content.
For k-mer content, trimmomatic, trimGalore, and skewer look the most natural: there is a background of random-looking lesser spikes (up to 2-4),
and one or two bigger spikes (up to 12). For other tools (autoadapt, fastq-mcf) k-mer content looks like a flat line (but likely also 2-4)
with several huge spikes (up to 35-40). In fact, only autoadapt, trimgalore, and skewer got a “warning” on k-mer content – all others got an “error”.

Overall, Trimmomatic and trimGalore appear to be the two best adapter trimmers, both by aggressiveness+FastQC reports and by speed.
But trimGalore detected significantly shorter adapter, and also Trimmomatic produced a smaller, more aggressively trimmed file.
On the downside, Trimmomatic does not auto-detect adapters! This can be alleviated by first running FastQC on the input files,
then checking /usr/share/trimmomatic/ for matching adapter files – those which contain both adapters detected by FastQC.

Will use Trimmomatic for now.

Important update:

• It is possible to (quite easily) construct a file with all the adapters for Trimmomatic, and it will happily try to trim anything from that file; Trimmomatic is now my sledgehammer – give it anything, and it will crush it.
• I have just used cutadapt directly, on a peculiar case of Nextera transposon contamination throughout the length of reads. The advantage of cutadapt is that you can specify how many times to trim the adapter – by default it is just 1, but I’ve set it to 20 and got rid of all Nextera leftovers. cutadapt is now my scalpel – I use it in pathological cases, when I know what (and how much of it) to cut out.
• Specifically for Nextera, I’m now using NxTrim – a tool from Illumina, which examines the reads and splits them into several categories: proper MP, PE, single-end/overlapping reads, and unknown. After NxTrim, individual reads should still have other sequencing adapters clipped.

Disclaimer

The story, all names, characters, genomes and incidents portrayed in this blog post are fictitious.
No identification with actual persons (living, dead or undead), places, companies, and processes is intended or should be inferred.
No animals were harmed in the making of this blog post.

Let’s try answering a question:

why are there many incomplete/draft bacterial genomes, and much fewer complete genomes?

The answer is simple: insufficient value/cost ratio.
This can also be summarized as the good enough principle: if something is good enough, it does not get improved.

Sample scenario 1.
Players: Principal Investigator (PI), Bacterial Genome (BG), Biologist (B), Sequencing Company (SC), (optional) Bioinformatician (oBI), Genomes Database (GD).

B is interested to work with BG, and gets PI‘s approval to sequence it.
Biomaterial is sent to SC, which sequences and even assembles the BG.
BG looks overall great and comes in just a handful fragments.
oBI is (optionally) involved, to annotate and describe the BG.
B works happily with the BG, describing and characterizing all the interesting biosynthetic features it contains.
An article is prepared, and oBI is (optionally) involved again, to prepare and submit the BG to the GD.
Preparing the BG, oBI has to answer a question if this BG contains any plasmids.
Upon closer examination, oBI finds that one of the fragments is actually the complete chromosome, and all others are just unplaced fragments of it.
oBI knows that this genome could probably be merged into a single draft scaffold
using bioinformatics tools and manual examination in maybe a few days (or a week… or two? ).
oBI also knows that with a little bit of B‘s help (a few primer walking experiments) it should be possible to have the complete BG within a month or two.
However, BG stays a draft, and is not going to be complete any time soon.

Why?

Let’s look at motivations of all the players, and see if any of the players wants the complete BG:

• PI wants publications; spending extra time/effort to make BG complete does not present any obvious benefits;
• BG wants to be left alone;
• B wants to publish exciting new findings; they are already supported by the draft BG, so there is clearly no need for a complete BG;
• SC was happy to get payment in time; SC is also proud to be able to provide genome assembly as an extra service with its (primary) sequencing offers;
• oBI has interest in finishing the BG: it will then be complete; however, there are 5 more other BGs awaiting processing, and the backlog of semi-written manuscripts only keeps growing… finishing this specific BG will not result in a perceived benefit to oBI;
• GD stores genomes; it doesn’t care much if the genome submitted could have been better.

Surprise!
Looks like none of the players sees benefits in actually finishing the BG,
simply because efforts spent (or time waited) does not bring any perceived benefits to any of the players.

Sample scenario 2.
Players: Bacterial Genome (BG), Biologist (B), Sequencing Company (SC), non-optional Bioinformatician (noBI), Genomes Database (GD).

This time, B (who is interested in quickly publishing a short genome announcement) asks for noBI‘s help from the moment the BG is provided by the SC.
noBI has a cursory look at the BG, and although there is a huge discrepancy between thousands of contigs on the one hand and insanely high coverage on the other,
the BG otherwise appears good enough for further work, especially after scaffolding; after all, this is just a genome announcement, not a full-blown article!
There is also some weirdness about the coverage distribution of the BG, but noBI carelessly ignores that.
The BG is worked on: annotated, examined, described, prepared for submission to the GD.
Meanwhile, the announcement article is also nearly complete.
Genome is submitted, and GD‘s response comes back: some scaffolds contain orangutan and human DNA, and some scaffolds contain known adapter sequences in the middle…
“Oh crap“, thinks noBI, “I should have checked the raw reads for adapters and contamination, in spite of having the BG assembly already…”
The GD also kindly offers an easy way out: just remove the obviously-orangutan scaffolds, and remove/mask/discard adapter sequences.
This is the easy way, leading to a quicker genome announcement, and a slight bump to the personal publication records of both B and noBI.

The right way is, of course, to clean raw reads from adapters and contamination, re-assemble, re-scaffold, re-annotate, re-describe the BG,
then prepare again for submission. This can delay the quick genome announcement by about a week,
but will highly likely result in a more contiguous and more correct BG – although still not complete.

As we have learned from Scenario 1, perceived benefits of going the right way (as opposed to the easy way) are nearly non-existent…

There was a genome I have finalized manually a few years ago.
I had some good quality data, obtained a 300-something contigs initial assembly,
then scaffolded and manually finalized to about 10 scaffolds.
There was simply not enough evidence (data) to keep merging scaffolds, so I had to stop.

Nowadays, as bacterial genome sequencing prices are akin to weekend supermarket shopping expenses,
nobody is going the extra mile to produce a better quality, more contiguous, or even a complete genome.
And this feels sad…

On the other hand, consumer markets function like that for decades.
An old water heater with a failed heating element is not repaired: it is replaced by a new water heater,
because human time cost to repair the old one is higher than just buying a new one.

Funnily, universal basic income might change that: without the need to spend 40+ hours a week at work
(and thus being unable to repair that water heater on one’s own),
one might just order that heating element and fix it – instead of buying the new one.

Would universal basic income have the same effect on draft and incomplete bacterial genomes? I have no idea.

Price per terabyte of WD Red HDDs

the notebook you are searching in has been moved or renamed since the saved search was created

(which is not true).

I had this problem, and found a solution.

Go to your Evernote on a client where you can edit saved searches (Windows for me),
edit all the searches, and make sure that notebook name is quoted in the search (and also, possibly, with all proper letter cases).

I found this solution by first creating a search from the web-beta interface, it looked like this: notebook:"Mynotebook" tag:1-now
All the crossed-out searches (despite working totally fine on Windows) looked like this: notebook:Mynotebook tag:1-now
or even like this (note the lower-case 1st letter of the notebook name): notebook:mynotebook tag:1-now.

After editing saved searches and synchronizing, they all appear (and work) just fine in the beta web-interface.

If you cannot edit your searches right now, there is another workaround: all the saved searches work fine for me from the Shortcuts menu (a star in the left panel).

Hope this helps!

So I have decided to add a swap partition.
It worked amazingly (and very easily), there was even no need to reboot – at all.
I still did restart, just to make sure the system is bootable – and all was perfectly fine.

My initial setup is very simple: a single /dev/sda1 partition on the /dev/sda disk, fully used by btrfs.
Different important paths/mountpoints are btrfs subvolumes, using flat hierarchy.
For this example, let us assume that /dev/sda (and /dev/sda1) is 25GB large, and that I want to add a 2GB swap /dev/sda2 after /dev/sda1.

Brief explanation before we start:

1. shrink btrfs filesystem by more than 2GB;
2. shrink btrfs partition by 2GB;
3. create new 2GB partition for the swap;
4. resize btrfs filesystem to full size of its new-size partition;
5. initialize swap and turn it on.

Here are the very easy steps! Just make sure you do not make mistakes anywhere

1. If your btrfs volume with ID 5 (top level) is a separate mountpoint: mount it now, e.g. sudo mount /toplevel.
2. Take note of your current partition label and UUID: sudo blkid.
3. Resize btrfs filesystem down (shrink) with a good margin; for example, if I want to add a 2 GB swap, then I can sudo btrfs fi resize -3g /toplevel – here, I’m shrinking btrfs filesystem by about a gigabyte more than necessary. The process is very quick if you have free space, so you can even use a larger margin – say, sudo btrfs fi resize -5g /toplevel.
4. sudo parted, then print to make sure what is the number of your btrfs partition, then resizepart 1 (where 1 is the partition number), and answer a few questions: yes, new_size_here (in our example: 23.0GB), yes. You can also create a swap partition from parted, then quit parted with q and Enter.
5. sudo partprobe to let the OS know that partitions have changed.
6. I have used cfdisk to create a 2GB swap partition: it has a very simple ncurses UI, and is very intuitive. After creating swap partition, do run sudo partprobe again.
7. Resize btrfs filesystem back up to take all of the partition: sudo btrfs fi resize max /toplevel.
8. Simply to be sure, run a scrub: sudo btrfs scrub start -B -r /toplevel.
9. Initialize swap; you can specify uuid and/or label which you may already have in your fstab: mkswap --label=swap --uuid=your1234-your-uuid-1234-youruuid1234 /dev/sda2.
10. sudo blkid to make sure your /dev/sda1 UUID stayed the same (or to get swap uuid/label if you haven’t specified any).
11. Optionally, add the swap line to your /etc/fstab. Then turn on swap with swapon -a.

That’s it! Amazing, isn’t it? On-the-fly filesystem and partition resizing!