crustulus.de — erlesenste, handgeschriebene freie Software

FreeDict — Takeaway Dictionaries

2017-12-14T00:00:00+01:00

FreeDict is a project to provide truly free translation dictionaries for any use case scenario. I'm proud to announce that our dictionaries are now available for you as a "takeaway" using Aard2, a modern dictionary client for Android. In this article, I'm going to give an overview what has been done so far, where to get the dictionaries and how to install them.

At our FreeDict HackFest this year, we started working on getting our dictionaries to a modern mobile platform. Since we are focusing on free and open dictionaries, Android was a natural choice. The Aard project provides a nice dictionary client, called Aard2.

Aard2 uses the slob format, a binary format featuring nice formatting and compression. There is already a converter from the TEI format (which is the format that FreeDict uses). All the work left was to adjust tei2slob to our needs. Thanks to Karl Bartel for taking care of this. The adoption of slob also required a handful of changes to our tooling and after quite some work, all dictionaries are now available in the slob format.

Getting The Dictionaries

Our website still needs a general redesign, therefore I decided to provide a temporary download page with all the Aard dictionaries from FreeDict. The usage is very simple, just install Aard2 from the playstore or from F-Droid and download one of the slob dictionaries to your smartphone. Aard2 will take care of detecting the dictionary.

API Access

If you are fancy to make use of our data, you can simply integrate our API into your application. You can retrieve a list of dictionaries from either

http://freedict.org/freedict-database.xml

http://freedict.org/freedict-database.json

The releases of each dictionary section contains different platforms (as for instance dictd or slob) and the URL provides direct access to the dictionary file. Thinking long-term, it would be great to directly integrate our API into Aard2, so that users do not need to download dictionaries manually.

Why Fixing Bugs Is Actually Fun

2017-10-27T00:00:00+02:00

Last weekend I attended a Debian Bug Squashing Party in Salzburg, at which I applied as Debian Maintainer. In contrast to my usual blog articles, I want to comment this time on the social side of free software hacking and show that fixing bugs is actually a lot of fun.

‘Bug Squashing’ is developer slang way of saying ‚bug fixing’ and usually people meet and work collaboratively on improving the quality of the packages in Debian. When I visited my first BSP in Salzburg, I knew only that a debian/ directory existed and wasn't sure how debhelper was going to help me. I was surrounded by Developer's (DD) and felt quite greenhornish. It didn't take too long until I realized that I wasn't the only person to be new to packaging and so I simply started reading packaging tutorials. It is not a secret that Debian's (developer) documentation isn't particularly exhaustive, but the people behind Debian are so friendly and helpful!

There's always somebody in the IRC channel #debian-mentors (irc.oftc.net) and being at a BSP speeds up the question-answer cycle dramatically. It makes working on with unfamiliar tools fun.

This year I focussed on dotify-cli, a software to convert and emboss braille texts with an braille embosser. The author has split the software into many small units and this results into a lot of packaging work. Two days weren't enough to get the job done, but it was still an extreme speed-up, because I would otherwise not have worked on it for two days.

I'm maintaining packages in Debian for more than five years now and I never considered to become an official Debian Maintainer, mostly because I was too lazy to apply. For people not familiar with the terminology: Debian Maintainer is a privilege level which allows the package maintainer to upload certain packages to the archive, without asking a Debian Developer for help.

Packaging and programming is only one part of what makes a BSP fun. In the evenings, people do all sorts of things. For instance, a few of us played a simple game with the aim to flood the universe with paper clips, while others enjoyed the night with a few drinks.

Hopefully this article has made you curious and I'll see you in one of the upcoming Debian events! Just browse the list of regions on the events page or click the BSP link to find the list of upcoming and past events.\ Tip: If you are unable to afford travel costs, Debian can sponsor some or all of your travel expenses, so that this is no reason to not attend!

Rust On L4re — Safe Language Meets Safe Microkernel

2017-07-17T00:00:00+02:00

I have started working on a port of Rust to L4Re, Fiasco.OC or simply to the L4 variant of the TU Dresden. It's a third-generation microkernel with many nice features, most notably strong safety guarantees through complete isolation of components and virtualisation of processes, but it lacks Rust support.

Why Rust

Rust brings safety, concurrency and zero-cost abstractions to a world, where normally programming in unsafe languages like C and partly C++ is the norm. On the other hand, L4Re is a microkernel built on top of isolation and offers many safety features, not found in other operating systems. Complementing this with Rust's safety guarantees is the right thing to do.

Rust has proven that it can be as efficient as C++ or even close to C. Various projects already demonstrate Rusts usefulness (e.g. Servo) and it is even used in systems programming by the Rust OS Redox and as a language for the userland of the SEl4 microkernel.

Roadmap

In the first phase, I have integrated Rustc into BID (the L4Re build system). Phase two encompasses patching Rust's standard library. I'm in the middle of this very process, the first patches have already landed in liblibc (the libc binding library).\ In the third phase, I will map L4Re's inter-process communication primitives (IPC) to Rust's strong type system. This crucial for a microkernel OS, because virtually all system services have to communicate in a safe, yet efficient manner.

What Works

My aim is to bring Rust support to L4re, but also bring L4re support to Rust. I have patched BID, so that Rust programs and libraries can be compiled for L4re. This is in an early stage and is going to change in the future.

The standard library of Rust consists of many small libraries, all united under the std crate. std has not been ported yet, but all other libraries already run smoothly.

Practical Insights

All of this is ready-to-use in a GitHub repository in the branch stdlib. Below, I'll explain what I did / how to reproduce this.

If you are curious and want to try out Rust on L4re, you can already do so. You will need a computer with GNU Make, GCC, GCC Multilib and Rust. I've tested it on a GNU/Linux, but you might have success on other platforms, too.

First of all, a L4Re snapshot is required, which you can download from http://l4re.org/download.html. This snapshot also contains l4linux which is not required and causes trouble if you don't have the Linux headers available. I hence suggest

$ cd *snapshot* && rm -rf src/l4linux

You have to configure and build your build tree then:

$ make setup
$ make -j8

To avoid headache, you should set the OBJ variable, which points to the build tree of L4/L4Re. Assuming that the current working directory is the root of the snapshot, this can be accomplished like this

$ echo O=`pwd`/obj/l4/amd64 >> src/l4//conf/Makeconf.local

NOTE:

It could be that the above setting is not enough. When you later compile a program and it cannot find the object directory, change O= to OBJ_BASE=.
Please do not use spaces in your path.
Please DO NOT use ~/ to denote your home directory. This will lead to errors with no recognizable relation to the issue.

With a basic L4Re system in place, adding a patch to build simple Rust binaries is actually not too complicated. The patch is only 113 lines long. You can view the patch or download it straight away:

$ curl -o /tmp/l4.diff paste.debian.net/download/976734
$ cd path/to/l4/snapshot
$ patch -p0 < /tmp/l4.diff

Most of the relevant changes are in the src/l4/mk directory, in the files rules.mk and binary.mk, used by prog.mk. I won't explain all the changes here. If you are familiar with make, you'll understand the changes after some digging.

An example (C) program is located in src/l4/pkg/hello. CChange to this directory, remove the C source and add a main.rs with the following content:

#![no_std]
#![feature(collections)]
#![feature(lang_items)]
#![feature(panic_unwind)]

extern crate panic_unwind;
extern crate libc;
#[macro_use]
extern crate collections;

use libc::*;

/// Empty panic formatter...
#[lang="panic_fmt"]
#[no_mangle]
pub fn panic_fmt() -> ! {
    loop { } // no handling
}

#[no_mangle]
pub extern "C"
fn main(_: i32, _: *const *const u8) -> i32 {
    let nums = vec![1, 2, 3];
    unsafe {
        printf("I can count: \0".as_ptr());
    }
    for elem in nums {
        unsafe {
            printf("%i, \0".as_ptr(), elem);
        }
    }
    unsafe {
        printf("\n\0".as_ptr());
    }
    0
}

This program does nothing spectacular, in fact, it's pretty boring and verbose. This is because most of the convenience from the std crate is missing.\ The Makefile could look like this:

```make^ PKGDIR ?= . L4DIR ?= $(PKGDIR)/../..

TARGET = hello SRC_RS = main.rs

REQUIRE_LIBS += libpanic-rust libcollections-rust libcore-rust liballoc-rust export RUSTC_BOOTSTRAP=1

include $(L4DIR)/mk/prog.mk ```

Right, now you expect you could run that program? Not quite. Currently, Rust needs custom core library versions to run on L4Re. The source code of these libraries need to be packaged and built. This is automated by a script. If you're curious, change to src/l4/pkg/libstd-rust in the mentioned GitHub repository and read the README. I won't detail that here, because it's a temporary solution. But if the build files have been generated, building the library is as easy as typing make in the generated build/<libname> directory.

Rust Is Already A Cross Compiler!

If you are more familiar with the Rust ecosystem, you might wonder why the integration is not happening within the Rust compiler, because this one already provides cross-compilation. The answer is a bit more difficult. The BID is a sophisticated build system and using Cargo or Xargo would require bypassing it. Interoperability would become a nightmare. L4re has custom startup- and teardown code and custom linker flags; it is best, if all of that is handled by BID itself. The Rustc compiler should receive it's linking instructions from BID and carry out the operation.

In the future, if you grab a snapshot from L4Re.org, your Rust compiler will automatically be used when you write Rust code within the L4Re source tree, only the target "l4re" would need to be activated using Rustup.

Integrating Rust into the BID doesn't mean that you have to throw away Cargo and all its convenience. In fact, Cargo integration is a long-term goal. This is not easy, because both BID and Cargo handle dependency management and define a "package" differently.

L4re + Rust support is evolving, so stay tuned!

ISOlang - Efficient Language Code Handling In Rust

2017-03-19T00:00:00+01:00

When working with texts in different languages, the reliable identification of them is problematic, because of conflicting standards. For instance, Wikipedia uses ISO 639-1 codes (with two letters) and FreeDict uses three-letter codes from the ISO 639-3 standard. Converting between those can be tedious and retrieving an English name even more. The Rust crate isolang can make this very easy and fast.

Using different language codes has it's use case for many applications. The two-digit codes from the ISO 639-1 standard for instance are short and widely used. They however don't map to all available languages, which is problematic for less widely spoken languages, because these don't have a two-letter code. The 639-3 codes can map all available languages (past and present), but they are often quite different to the 639-1 codes, so mapping between those is hard.

Rust is known for its potential to optimize and for the isolang crate, I decided to invest some time to make it perform fast. A key to this is to have all information available during compile time, so that on program startup or data access, no additional work needs to be done.

The crate provides an enum with the ISO 639-3 codes and offers methods to convert from and into 639-1 codes and into an English language string. Using the three-letter language codes for the enum was the most sensible solution, because it allows the unique identification of all languages.

As an example of the usage, have a look at this very short example:

use isolang::Language;

let iso_639_1 = Language::from_639_1("de").expect("Illegal ISO 639-1 \
    language code given").to_639_3()

That doesn't look like much, but that is intentional. You don't want to care about this simple task and all you need is contained in the data segment of your binary. Not a single of your precious cycles is wasted for initialization or allocation. This is possible thanks to a static Map from the PHF crate.

One missing feature is the conversion from an English language string to the Language data structure. This is not included because it is a slightly problematic mapping, because some language names might have multiple codes assigned and it is hard to properly identify them that way. It could be added, if need be.

I'm using this crate in CRAFT, a word2vec text preprocessor.

Submit Useful Bugreports With Back Traces

2016-10-11T00:00:00+02:00

Sometimes applications simply crash and then it's often hard to submit a useful bug report to get the issue resolved quickly. This article walks through the steps to get a meaningful backtrace, which can be submitted along with a bug report. It is meant as a gentle introduction to debugging on (Debian) GNU/Linux. It also discusses how to get a core dump from a system service when using systemd.

This article covers only a portion of possible bug causes: more specifically crashes of programs written in C, C++ and similar languages. It also mentions some Debian/Ubuntu-specific procedures, but can be used for other GNU/Linux systems as well.

Motivation

It all began with a Debian bug squashing party in Salzburg, hosted by Conova (thanks). At the event, a group of Debian developers, maintainers and other folks gathered at a large table and started hacking. While I researched the list of bugs, it turned out that some bugs simply lack enough information to get fixed easily. So I started on these "low hanging fruits".

Reproducing The Fault

Getting a core dump is slightly different for ordinary user programs and system services. Both scenarios are discussed below.

Ordinary User Programs

Before we can start reproducing the fault, we need to prepare our shell to produce a so called core dump, as soon as the program crashes. A core dump is an image of the whole memory, which was used by the process during the crash. You can configure your shell session temporarily by entering the following:

$ ulimit -c unlimited

Running the faulty program in this "prepared" environment will lead to the creation of a new file called "core".

Now you need to find out the name of the program and run it from the prepared shell session. For instance, let's look at the program BRLTTY. This particular program needs root privileges and is a daemon service. So to run it from the shell, I would type:

sudo service brltty stop # stop the running deamon
sudo brltty

Now the steps to get the program to crash have to be performed. After the crash, the shell should show something like this:

zsh: segmentation fault  sudo brltty

The output might vary slightly, depending on the shell in use. This indicates some memory issue, i.e. an invalid pointer operation and it is now time to collect information for the bug report.

System Services

Obtaining a core dump from a system service is slightly more complicated, because they are not started from a user shell and hence the core dumping property must be set elsewhere. If systemd is used, the service unit (the file which tells systemd how to handle the service) needs to be extended. It is best to initialize a directory under /etc/systemd/system/ with the name of the service unit and .d as suffix, e.g.

sudo mkdir /etc/systemd/system/brltty.service.d

Within this directory, any file on .conf will be parsed and will extend the service unit file. For BRLTTY, I did enter the following:

echo -e "[Service]\nLimitCORE=infinity\n" > /etc/systemd/system/brltty.service.d/core.conf

Afterwards, the configuration has to be reloaded and the service restarted:

systemctl daemon-reload
systemctl restart brltty

After a crash, the core file will reside in the current working directory of the daemon. That's most likely /.

If you want to have more control about where core files end up and to which program they belong, add the following line to /etc/sysctl.conf:

kernel.core_pattern = /tmp/core-%e-%p

This will tell the kernel to put core dumps into /tmp and name it with the binary name and its pid. To activate the new setting, just type

sudo sysctl --system

Installing Debugging Symbols

Debug symbols are essentially names within the program, which help the programmer to identify a particular part of the source code. These are normally stripped of the binary for performance and size reasons. Therefore these need to be installed (or compiled in) additionally.

For Debian and Ubuntu, the debugging symbols can be found inadditional packages, which can be easily installed using APT.

Note: The following paragraph is slightly different on Ubuntu, please see the Ubuntu Wiki.

Add a new entry in /etc/apt/sources.list, which looks like this:

deb http://deb.debian.org/debian-debug stretch-debug main

and alter the relese information, as appropriate.

From here on, the instructions apply for Ubuntu again.

After the repository has been added, updating the package list with sudo apt update is required. Now it is possible to search for the package with the debugging symbols, i.e. packages ending on dbgsym or dbg. For the brltty case, that would be aptitude search brltty and then sudo apt install brltty-dbg.

Getting A Core Dump

To reconstruct what happened when the program crashed, it is possible to save a full memory backup (core dump) of the running program. This can then be examined with GDB, to figure out, where the program faulted. If you have not yet installed GDB, do so using sudo apt install gdb.

When you have a core dump in place, you can examin it with the file utility, which would output something like this:

core: ELF 64-bit LSB core file x86-64, version 1 (SYSV), SVR4-style, from
'/sbin/brltty', real uid: 1000, effective uid: 1000, real gid: 1000, effective gid:
1000, execfn: 'sudo brltty', platform: 'x86_64'

Note that the full path of the executable is contained in the above output. This is helpful for running GDB, as explained in the next section.

Obtaining A Backtrace

It is not a good idea to attach the core dump to a bug report, because it might get really big and it might also contain private data, even passwords and other credentials. For a lot of cases, the programmer just wants to know where an error occurred and this information is contained in a back trace. The GNU Debugger (GDB) is able to retrieve the backtrace, if you provide the full path to the binary and the core file as first and second argument, respectively. This is gdb /sbin/brltty core for the BRLTTY example. After launching GDB, it will display a command prompt and await more commands. The following command will print the desired output:

thread apply all bt full

The output can then be attached to a bug report.

Where To Go Now?

With this knowledge, you can now provide quite useful bug reports. It is not always necessary to be a programmer to help out and programmers on the other hand appreciate people, who took some care before reporting a bug.

If you plan to use your knowledge for the next Debian Bug Squashing Party, you might want to read an introduction to the Debian Bug Tracking System or an introduction to a helper program called reportbug, which eases reporting bugs greatly.

git-hub — A Command-line Interface To GitHub

2016-09-03T00:00:00+02:00

GitHub is a very useful platform to host free and open source software. For Git users who use the command line for managing their repositories, it can be much quicker to use the command line to also manage their development issues. This article introduces git-hub, a really useful utility to manage pull requests, issues and clones from and at GitHub.

Installation

Debian/Ubuntu

If you are running Debian (or a derivative like Ubuntu), installation is as easy as sudo apt install git-hub. Unfortunately, git-hub is not yet part of Debian stable (ATM Jessie) or in the current Ubuntu releases. See the installation from source as an alternative.

From Source

Make sure to fetch the dependencies first: Python >= 2.7, Git >= 1.7, Docutils. The last one are required to build the manual page. On Debian/Ubuntu, simply execute: apt install python-all git python-docutils.\

Then you clone the repository:

$ git clone https://github.com/sociomantic-tsunami/git-hub
$ cd git-hub

If you are on Debian/Ubuntu, type:

$ make-deb
# dpkg -i *.deb

Otherwise the usual

$ make
# make install

will do the job.

Set Up A Git Repository

There are two ways to set up a git repository for git-hub. It can directly clone repositories and I won't detail the instructions here. Have a look at the manual page.\ If, however, a repository already exists, which has been the case for me, it is easy to configure it to authenticate with GitHub:

cd <repo>
# that will ask for user name and password and create an authentication
# token:
$ git-hub setup
# add upstream to newly created hub section; replace USER and REPO name
# (REPO has to be without the .git suffix)
echo -e '\tupstream = USER/REPO' >> .git/config

The last one can be done by hand too, make sure that you use a tab character for indentation. For GladTeX the last line in .git/config looks like this:

upstream = humenda/gladtex

Tip: With the above instructions, git-hub is only set up for one repository. If you want to give it access for all repositories you might have on GitHub, add this to ~/.gitconfig.

[hub]
    user = YOURNAME
    oauthtoken = TOKEN

The token can be obtained from the repository configuration, for which you just identified. Just look into .git/config.

Usage

Git-hub uses subcommands, as does Git. Every subcommand and also git-hub accept the -h switch and are therefore self-explanatory. For instance, listing issues could look like this:

$ cd fd-dictionaries
$ git-hub issue list
[4] update Chapter 4 of the HOWTO (installation of FreeDict DTDs) (humenda)
    https://github.com/freedict/fd-dictionaries/issues/4

Closing an issue and typing a explanatory message in the favorite editor is easy too:

$ github issue close -e 42

An editor will open and will display a file similar to a git commit. After the user has typed a message, saved and quit, the issue will be closed with that message.

If you want save yourself typing overhead, I suggest the following aliases in your ~/.zshrc (or ~/.bashrc):

alias gh='git-hub'
alias ghi='git-hub issue'
alias ghp='git-hub pull'

My experience is that ghi list is so quick to use that I hardly use the web site, if I want to manage issues.

Debian Jessie On A Lenovo Yoga 700

2016-08-23T00:00:00+02:00

The Lenovo Yoga 700 is a laptop with a 360° rotatable touch display and comes with Windows 10 preinstalled. This article is split into two parts. The first part walks through the installation and set up of Debian Jessie GNU/Linux on this machine and what needs to be done to get all of the hardware working. The second part deals with useful configuration hints for this model and finally a general note on interoperability with Windows.

Part I — Installation

Hardware Specification

The Lenovo Yoga is equipped with a 500 GB SSHD (with 8 GB of SSD cache), 4 GB RAM, a 14" touch display and no optical drive. Other sites on the web will have more information about the model. lspci detects the following connected devices:

00:00.0 Host bridge: Intel Corporation Device 1904 (rev 08)
00:02.0 VGA compatible controller: Intel Corporation Device 1916 (rev 07)
00:04.0 Signal processing controller: Intel Corporation Device 1903 (rev 08)
00:14.0 USB controller: Intel Corporation Device 9d2f (rev 21)
00:14.2 Signal processing controller: Intel Corporation Device 9d31 (rev 21)
00:15.0 Signal processing controller: Intel Corporation Device 9d60 (rev 21)
00:16.0 Communication controller: Intel Corporation Device 9d3a (rev 21)
00:17.0 SATA controller: Intel Corporation Device 9d03 (rev 21)
00:1c.0 PCI bridge: Intel Corporation Device 9d15 (rev f1)
00:1f.0 ISA bridge: Intel Corporation Device 9d48 (rev 21)
00:1f.2 Memory controller: Intel Corporation Device 9d21 (rev 21)
00:1f.3 Audio device: Intel Corporation Device 9d70 (rev 21)
00:1f.4 SMBus: Intel Corporation Device 9d23 (rev 21)
01:00.0 Network controller: Intel Corporation Device 3166 (rev 99)

Installation

Debian Jessie provides a solid basis for everyday work, but the hardware support with its 3.2 kernel is too old. Since this laptop was meant to work flawlessly, I chose to install stable instead of testing. Since the Yoga 700 is equipped with a touch display, it is advisable to use a desktop environment with support for this. Debian's default environment GNOME is a good choice, so pick wisely when downloading an installation image.

The WiFi card is not supported by the stock Jessie kernel, hence I downloaded a full CD image, to perform the installation off-line. I wrote the image to a USB drive using:

dd if=debian*.iso of=/dev/sdb

It is advisable to run the installation in text-mode, because the graphics card is not fully supported with the Jessie kernel as well.

When the partition manager showed up, I chose to shrink the partition of Windows and create a Debian partition on the freed space with 20 GB. The rest of the installation went smoothly and EFI boot was set up without any manual interventions. This surprised me the most, because installation was in fact easier than without EFI, where the user was always confronted with a "Do you really want to overwrite the MBR" screen.

When the Debian installation was done, I rebooted and ended up with a non-working X setup. I changed to the virtual console using control+alt+f1 to find out the source of the error. The X log said:

(EE) no screens found(EE)

Note: Lenovo changed their Laptop layout to swap the F<num> keys with some other functionality. Use fn + F<num>, to obtain the old behaviour.

Further digging in the log file revealed, that the chip set was not supported. After some hours of try and failure, I discovered, that installing two packages from backports was the solution. I first fetched linux-image and firmware-iwlwifi (the first from backports, the second from testing), put them on the USB drive and installed them on the target system:

mount /dev/sdb /mnt
cd /mnt/sdb
dpkg -i linux*.deb
dpkg -i firm*.deb
cd
umount /mnt

After a reboot, I was indeed able to set up a wireless connection.

Note: If installing the firmware does not work for you, you can get the missing files from https://github.com/OpenELEC/iwlwifi-firmware. These need to be moved to /lib/firmware.

To fix the X error, I set up backports to install a newer package for the graphics card. After I inserted the required lines in /etc/apt/sources.list, I ran:

apt-get update
apt-get dist-upgrade -y
apt-get -t jessie-backports install xserver-xorg-video-intel
service gdm3 stop && service gdm3 start

Fine-Tuning: Configuration

The Lenovo Yoga 700 is certainly not the most advanced laptop from Lenovo and its hardware support on GNU/Linux might not be complete, but it can be easily adapted.

Faster Boot And Faster Everything

The internal SSHD will cache frequently used files (supposedly mostly programs) and will indeed deliver good performance after using the machine for a short while, re-boots included. It is however fairly easy to speed up the boot process even more by installing readahead. This program will simply gather a list of files used during boot and will load them in advance and in parallel to the kernel cache (main memory) to speed up the boot process. The installation is as easy as:

apt-get install readahead
sudo touch /etc/readahead.d/profile-once
reboot

The next boot will take longer than usual, but subsequent reboots should be faster.

There are two services which are often not necessary on a regular laptop/desktop system: exim4 and ModemManager. Disabling services influences boot time and potentially increases batter lifetime, because the CPU doesn't need to wake up as often. The email server exim4 and the modem manager can be disabled like this:

systemctl disable exim4
systemctl disable ModemManager

Longer Battery Lifetime

For this particular laptop model, the Debian installer did not install the laptop-mode-tools, which it normally does. It can be manually installed:

apt-get install laptop-mode-tools

This increases battery lifetime noticeably.

Mounting the Windows NTFS Partition

The more recent Windows versions do not properly shutdown, but hibernate the system. This has the advantage that users get the impression of a really quick boot up of Windows but the downside that volumes are never cleanly unmounted and hence it's unsafe to access them from another operating system. The quickest solution is to disable hibernation in Windows all together. In Windows, type cmd in the search field of the start menu, choose the appropriate entry and start a shell with administrator privileges by right-clicking the item and selecting "run as administrator". Once in the command interpreter, type:

powercfg -h off

After this, the Windows partition can be used from Debian, instructions can be found here.

GladTeX 0.6 — A Modern Rewrite Of GladTeX In Python

2015-11-10T00:00:00+01:00

i have just released GladTeX 0.6, a maths preprocessor for HTML documents. In this article, I will introduce the new features of GladTeX and will give practical examples on how to use GladTeX, i.e. to render MarkDown files with formulas.

About

GladTeX is a preprocessor for HTML files to enable math formulas within HTML documents by embedding images and generating an alternative text for blind people. Everything surrounded by <eq>...</eq> will be taken as a LaTeX formula and converted.\ Additionally, GladTeX can be used to transform Markdown documents to HTML with formulas, if used with Pandoc.

Where To Get It

I have decided to rewrite GladTeX in Python. Before it has been a Perl/C mixture which was hard to port and not working on Windows. Python in contrast is a nowadays wide-spread scripting language with the ability to write platform-independent code very easily. From this version on, there's a Windows executable available. On Debian and derived systems (like Ubuntu) you can also install GladTeX using

sudo apt-get install gladtex

I am maintaining this package and keep it up-to-date.

The latest version can be easily build from source. It boils down to execute sudo python3 setup.py install on the command line.

To run GladTeX you will need a LaTeX distribution like MikTeX (for Windows) containing preview.sty and dvipng. Both are included in MikTeX and Texlive.

Embedding GladTeX Into Other Applications

I've decided to split the program into two parts: a library and a command line frontend. This way it's easily possible to embed the library gleetex into another application. This application can choose to either also parse HTML files and produce HTML with formula images or just use gleetex as a simple way to convert LaTeX formulas to images. There's no separate library documentation yet, but I've payed attention to document all the classes extensively, so feel free to just browse the source.

Shell-piping support has been added as well, so that formula images can be created without a HTML document. This might be useful for web site generators, etc. Consider the following:

echo '<eq>\gamma\alpha</eq>' | gladtex -d images -o /dev/null

or on Windows

echo "<eq>\gamma\alpha</eq>" | gladtex -d images -o nul

Additionally there's a cache containing formula → image mappings which is now a gzipped json file and can be hence post-processed by scripts as well.

MarkDown and GladTeX

It is possible to embed formulas into MarkDown files when using Pandoc as a converter. It is as easy as surrounding formulas by a \$ sign (or double \$\$ for display math), like this:

This is an inline formula: $\frac{1}{m^2}$

This is displaymath $$\frac{\frac{1}{m}}{\big(\tau\cdot (\pi + \gamma)\big)}$$

Pandoc brings the --gladtex option and with the new GladTeX version, converting a file called input.md is as easy as:

pandoc --smart -t html --gladtex input.md | gladtex -d images -o output.html

Which will create a file called output.html with images containing the desired formulas and all images located in a separate images directory.

High Test Coverage

Something which is not immediately visible from outside is that the new GladTeX is now fully tested with unit tests. I hope to make GladTeX as bug free as possible. It actually saved a considerable amount of time when developing GladTeX, because I discovered a lot of problems very early.

Review - Installing Debian Jessie On A Lenovo Thinkpad X250

2015-05-11T00:00:00+02:00

This article reviews the installation process of Debian 8.0 on a ThinkPad X250. It is not meant to be a step-by-step guide and is more a review of how the installation currently works and what to expect from it. It also details some fixes to issues encountered after installation for this specific laptop model.

Although I am going to mention accessibility every now and then, this is definitely not only focused on that topic, but rather a mixture of everything.

Preparations

First of all I downloaded the official Debian amd64 netinstall CD image and wrote it to a USB stick. Normally I would have used dd, but I felt like I needed a change and tried out pv to get a progress bar to watch. However that didn't work out like expected, since pv's progress bar made progress much faster than the actual write took place. This is most probably due to kernel buffering, wherefore I sat there waiting for a bit longer without an indication of progress. Next time it'll be dd again.

Installation

When I booted the ThinkPad with the USB drive connected to it, I heard a beep, which was the sign that the installation menu had come up. After pressing enter, BRLTTY started directly and printed text on my braille display, so that worked seamlessly like in the previous Debian versions. It would be nice if BRLTTY would be restarted after the language has been chosen, so that the text table can be changed. Currently the installation starts off with the US-American braille text table and that is quite annoying to get rid of it if you don't know by heart how to open the preferences menu with a key combination of the braille display. One fix is to press alt+f2, followed by enter to get a shell and restart brltty there. For that you need to find out BRLTTY's process id, use ps aux | grep brltty and look up the pid of BRLTTY there. Then execute:

kill <pid>
brltty -t <yourtable>

A few dialogs later, the automatic network discovery started. It complaint that firmware for the Wi-Fi card would be missing. Although I would've liked Wi-Fi to work from the very beginning, a LAN cable wasn't too much trouble in my situation. Next time I might actually prepare an USB drive. For those who still want to do it, the adaptor identifies itself as Intel Corporation Wireless 7265, kernel module iwlwifi.

The partition manager looked familiar. I wanted to try encryption of my home partition for the first time. Here I failed to actually set up encryption, because I haven't had a look at Debian's installation guide and didn't read the on-screen tips carefully enough. So I decided to postpone it to a later point. I don't want to have an encrypted root partition anyway and encrypting /home is not too hard, if there's no data on it. I would have also liked some guidance on what to do with a SSD drive (which file system to pick and which mount options), but apparently for recent Linux kernels that is not as important as it used to be.

The rest of the installation went smooth without any issues. In the package selection screen, I chose Mate as a desktop environment and was astonished that there was no category "laptop" to bee activated for laptop users. Sure, there's a service laptop-detect installed by default, but that is not all one can do.

After The Reboot

After the reboot, I installed the firmware for my Intel wireless card (see the Debian wiki for more information) and configured my wireless connection.

Unfortunately my ThinkPad stayed quiet after the installation and I wasn't able to get any sound at all. By looking at the sound card configuration:

cat /proc/asound/cards

I discovered that the Intel sound card is recognized as two devices, one with the identifier HDMI and one with PCH. The default output method was HDMI (ALSA index=0) and hence I got no sound. That can be resolved by loading the appropriate module (snd_hda_intel) with the option index=1, to tell it the preferred main audio sink:

echo 'options snd_hda_intel index=1' > /etc/modprobe.d/sound.conf

After that I still couldn't play any sound, so I checked all controls in alsamixer (package ALSA-utils), unmuted eveything, raised the volume to maximum and still got no sound. Until I finally found out that the hardware muting facility of the ThinkPad cannot be influenced by ALSA. I must have accidentally pressed fn + f1 and muted my speakers with it. The fix was simple to press either fn + f3 or fn + f4.

For battery usage optimization I would have expected that laptop-detect, which seems to be a service running in the background, would have pulled in laptop mode tools. Running apt-get install laptop-mode-tools wasn't to dificult though. I feel that this enhances the life time of the battery.

After all the system now runs smoothly and thanks to Unison I had all my configuration and personal data within a few minutes on the new machine. Orca works smoothly, not only because the new laptop is much more powerful than the old one.

Mate — An Accessible Alternative To GNOME 3

2014-07-16T00:00:00+02:00

I am generally no friend of continuing "dead" technology, as GNOME 2 was termed. I payed little attention to the rumors that Mate, a GNOME 2 fork, was under active development. Since in recent Debian Unstable, the GNOME Shell accessibility experience is very poor and GNOME-shell seems to have a lot of bugs, I've tried out Mate and I will present some (quick) notes about what works. This article is of course about accessibility, but also covers some aspects of GNOME-shell and Mate in general.

Currently there is GNOME-shell 3.8 in Debian unstable, but other components are already at 3.12 (just for the Arch users ;)). I had a couple of issues:

Even though I activated accessibility features as described in the Debian wiki I got no good user experience at all. I activated all possible GNOME-shell extensions to get a nautilus-managed desktop and so on, but the main applications panel (Alt+F1) remained unusable. Other GUI elements were however greatly accessible.
When switching to the Linux console and back to the GUI session, the keyboard always switched to US-American layout which I found quite disturbing. I thought this to be a bug in my X configuration, but see below.
The GNOME terminal ignored the space and return keys, as long as I didn't pressed "shift" at the same time. Typing was a pain.
The start up of GNOME 3 is very slow compared with GNOME 2.

Every now and then there were little issues which bothered me while using GNOME 3, but I admit that the shift to GNOME 3 was not easy from an accessibility point of view.

Due to a recent article about Mate I thought I would give Mate a quick try and I went with apt-get install mate and inserted the following into my .xinitrc

exec mate-session

To enable accessibility by hand, one starts the session using startx and switches back to the console. Then the following command enables accessibility features upon the next mate-session:

DISPLAY=:0 gsettings set org.mate.interface accessibility true

After a restart of X, I got a traditional GNOME-2-alike desktop. As I said, I don't like the idea of another desktop environment which also continues some of the old technology used in GNOME, but recent Mate releases dropped also obsolete packages and renewed their infrastructure. And the result was amazing:

The full panel, desktop and all icons are accessible.
- The old menu with three entry points is back and is a great thing to use the computer efficient.
- One can "easily" switch off the computer.
The mate-terminal works again.
The annoying keyboard-layout-switch when switching to a console and back is gone.
It is QUICK! No numbers here, but it was really faster when starting the session and at least with a screen reader, it doesn't feel that sluggish when navigating.
There are also minor issues: when selecting an item, Orca says "not selected", even though the current element is selected.
I soon discovered that Firefox and Iceweasel were not accessible, this is due to a bug. There is a temporary hack, namely:
```
sudo su
cd /usr/lib
ln -s i386-linux-gnu/gtk-2.0 .
```

Conclusion: For the fairness it has to be said that a lot of accessibility work done in GNOME will directly benefit Mate without that their developers do much development and I am thankful for the GNOME project having an open ear for such issues. I don't think that I will fully abandon GNOME 3, but for a while I think that Mate will become my stable work environment and I'll see how GNOME 3 develops in the mean time.

Sharing Text Between CLI and GUI clipboard

2014-04-02T00:00:00+02:00

For blind programmers using text editors like Vim, the command line is in most cases the most convenient work environment on GNU/Linux. On the other hand, some tasks are not possible on a virtual tty, like for instance, browsing complex web pages. The only alternative is to constantly switch to a graphical X session. Copying text between a tty and a X session is more or less a pain. In this short article, I'll describe xclip and some convenient ways to use it with Vim / ZSH / GNU screen.

First of all, you should install this handy little program, e.g. through using apt-get install xclip. If you are not using a Debian-derived distribution, you can have a look at http://xclip.sourceforge.net for the source code.

To copy the text hi to your clipboard, type:

echo "hi" | xclip -d :0

You can view the contents of your clipboard using

xclip -o :0 -i

The :0 denotes the X screen that the X server is running on. In 99 % of all cases, using :0 should be enough. In rare cases, :1 should be used, change to this if you get an error message.

You can of course also copy files into the clipboard. This is as easy as

xclip FILENAMe

where FILENAMe needs to be an existing file.

Using ZSH, you can define a handy middle-line alias which allows commands like:

echo "my text"  | CLIP

For this, open your ~/.zshrc and insert

alias -g CLIP='xclip -d :0 -selection clipboard'

This has the handy advantage that you can paste your data into stdin of xclip as well. Just type CLIP, paste your data and press ctl + d.

To paste text from the GUI to your local Vim instance, you can easily define a command in your ~/.vimrc like this:

com Paste  :call CopyX()
func! CopyX()
    exe ":s/$/\r/g"
    exe ":.!xclip -selection clipboard -d :0 -o"
endfunc

Executing :Paste will then paste text from the X clipboard to your Vim buffer below the current line.

You can also use the clipboard from GNU screen. The following is based on a blog article. and uses instead xclip. Put the following into your ~/.screenrc:

# read and write screen clipboard to X clipboard.
bind > eval writebuf "exec sh -c 'xclip -d :0 -selection clipboard < /tmp/.screen-exchange'"
bind < eval "exec sh -c 'xclip -selection clipboard -o >/tmp/.screen-exchange'" readbuf

Then you can use Ctl-A + > or < to easily get the contents into or out of the screen clipboard buffer.

GladTeX — embed LaTeX-quality equations in HTML

2014-03-16T00:00:00+01:00

A few months ago I searched for a solution to embed equations in HTML together with the LaTeX-equation in the alt-tag (alternative text). This allows blind people to read documents with equations together with their sighted colleagues. Pandoc finally gave me a hint, since it supports conversion from Markdown to HTML with the --gladtex option. So I learned about GladTeX. I patched this program.

The idea is that you embed <EQ>...</EQ> tags into your HTML document which then get processed by GladTeX. GladTeX will autogenerate the equation with LaTeX for you. It also takes care of inserting the image tag into the HTML document and positioning it correctly.

GladTeX is an older piece of software. It was written by Martin Gulbrandsen who wrote and maintained this piece of software until 2010. Then it got quiet around this little program.

As I discovered it, I noticed quickly that this program could be of great value for blind people using a screen reader. For people with a screen reader, the best way to read equations is through LaTeX. GladTeX just didn't insert the alternative text for the image (for a historical reason). I decided to develop this feature. The result is now that every image in your output document has automatically alternative texts inserted for each equation. Additionally, you can choose that equations which are longer than 80 characters are automatically outsourced into a separate file. The image then becomes a link pointing to an external HTML file containing the long version of the equation. This is necessary because e.g. line breaks are ignored inside alternative texts. Blind people can now work with sighted colleagues on one (HTML) document. As soon as an image occurs, the sighted person will see the equation nicely formatted and the screen reader user the LaTeX equivalent.

If you want to have an example how it could look like then you just have to visit Wikipedia with an arbitrary maths article. They use at least the same approach.

I mentioned earlier that I stumbled over GladTeX by using Pandoc. With pandoc you can convert a lot of document formats into even more document formats. With the mentioned --gladtex option, you can transfer the following document into a HTML with picture and automatic alternative descriptions:

# My Example Document

##  blah

## Pythagoras Law

Short: $c^2 = a^2 + b^2$

The conversion is as easy as:

pandoc --gladtex --smart -o blah.ex blah.md
gladtex -d images blah.htex

(provided that the file is called blah.md)

The project home page is at http://humenda.github.io/GladTeX. There you can obtain the source code to compile it on your system, which is not too hard. The program has also been patched to run on Windows, but there is no binary build to download yet.

GPG — Value The Privacy Of Your E-Mail

2014-03-07T00:00:00+01:00

GPG is a widely unknown encryption and signing service for electronic mail. Its features can be handy: you can safely deliver banking information via e-mail when using GPG or verify the authenticity of the sender of a message. I wil describe the basic setup for a GPG key, GPG configuration and GPG key signing.

The Web Of Trust

A basic principle in GPG is the web of trust. The web of trust is build around the principle that you trust people and in turn they also trust people. If you write an e-mail to another user with GPG and three people you trust trust him, you automatically trust him too. Trust in this context means that you trust that the e-mail has come from him or her. When using GPG, every message gets a signature that helps to verify the authenticity of the sender. Signing in this context is meant to be the same as signing of a document by hand.

Creating A Configuration

While creating a configuration is the most boring step in using a new piece of software, I will start with it nonetheless to save us some typing on the command line. First create the hidden directory .gnupg in your home directory, e.g. by typing on the command line:

mkdir -p ~/.gnupg

Then you can open the (most probably empty) file .gnupg/gpg.conf in your home directory. Enter the following text into it:

keyserver hkp://pgp.zdv.uni-mainz.de:11371
keyserver-options auto-key-retrieve
# security: newer algorithms:
personal-digest-preferences SHA256
cert-digest-algo SHA256
default-preference-list SHA512 SHA384 SHA256 SHA224 AES256 AES192 AES CAST5 ZLIB BZIP2 ZIP Uncompressed

key-server: Keyservers are directories of keys from users who chose to upload their keys. When you upload your key, people can sign your key (in order to say that they trust you) or even distrust you.\ You can choose any server you want, they are synchronized.
auto-retrieve: With this option, you are specifying that keys not in your key ring are automatically retrieved (e.g. when opening an e-mail). If this is missing, you always have to type gpg --retrieve-key <id>.

Generating A Key

Before anyone can trust you, you need to generate a private and a public key; the public key will be for everyone to encrypt messages send to you. The private key on the opposite is just for you which allows you to decrypt the messages again. Furthermore you can sign your -emails with the private key. You generate such a key using

gpg --gen-key

GPG will ask you a couple of questions. First of all, you select which key type you want, it is safe to answer "1" (for a RSA key). Afterwards, you can select the length of the key and the validity period. Then you enter your name, your e-mail address, the comment field may stay empty. The rest of the instructions is self-explanatory.

You should keep in mind that the private key must stay private, since it allows signing your e-mails with your name and decrypting your personal messages. The public key can be distributed, since with this key messages can be only encrypted for you.

For the web of trust it is required that you trust yourself ultimately, which is a good thing anyway. Do the following:

Execute gpg --list-keys and note down your key id. The key id can be found after the key word pub, followed by the length; the characters after the / are your id.
Now you edit your key using gpg --edit-key <yourid>. You are now in a text-mode interface.
You can add e-mail aliases, if you have multiple mail addresses or a provider with multiple names like gmail vs. googlemail. Use adduid and answer the questions.
Now use the command uid for selecting all user IDs. If you have two user IDs, use uid 1<return>uid 2.
Finally, you should trust yourself ultimately using trust 5.
Type save to save the key.
After you have done the modifications, use gpg --send-key <id> to send the key to the configured server.

Exchange Finger Prints And Trust Other People

Each key has a finger print. It is like with real finger prints: you can use them to check whether the signature from an e-mail really belongs to the sender or whether the e-mail was caught or modified during its way to you. To get your finger print use

gpg --finger-print <id>

Check this finger print with the person which wants to trust you. For unknown people it might be even advisable to ask them for their identity card. You have to do the same on the foreign key: exchange the finger print with the person who you want to trust.

When you and your partner have exchanged the finger prints and you are sure that you trust him, run

gpg --edit-key <friend_id>

This of course assumes that the key is already in your llocal key ring. Since you have configure auto-retrieve for GPG, this should happen as soon as you open a signed e-mail of the person.

The trust procedure is nearly the same except that you only trust other people with level 4 and 3. Level 4 is for people which you saw from face to face, level 3 for people whom you only trust marginally. For level 4, you can also sign the key, using sign (imagine you would sign the identity card). Don't forget to safe and upload the key afterwards.

Using GPG In Real Life

I hope I have walked you through a basic setup of GPG. Now you should choose an e-mail-client which makes using GPG really easy. I have here a personal, not comprehensive list, sorted by preference. I am not suggesting Thunderbird. It is a choice, however the plugin Enigmail has some issues like old-style signatures or own configuration handling and therefore I would suggest Claws-Mail to those users.

mutt: This is a command-line client for GNU/Linux or UNIX which has great options for GPG like sending automatically encrypted e-mails to people who you trust. Scripts can also exclude people from receiving GPG signatures if their

mail program don't support signatures. Claws mail : A powerful e-mail client with a graphical user interface. Unlike Thunderbird and friends, claws mail has integrated GPG support and doesn't ignore your GPG settings, but rather uses those which you have edited yourself in .gnupg/gpg.conf. K-9 Mail : K-9 Mail is a fork of the original Android e-mail client which brings a lot of neat features for mail reading on a telephone together with (optional) GPG support.

Accessibility In Android

2013-09-15T00:00:00+02:00

Finally I got my hands on a Samsung smartphone and tried out the accessibility provided with Talkback on an Android 4.2.2. I want to give a short overview what is already working and what not. Fortunately, I cannot (and don't want!) compare the accessibility to the other big mobile operating system which has currently accessibility features.

The telephone I'm using is a Samsung Galaxy S+. The good thing about this model is that it has (in contrary to the Samsung Galaxy S) regardless of the age a relatively fast CPU (1.4 GHZ). Since the Android on this telephone was too old and it didn't get updates, I decided to flash it with CyanogenMod with the help of a friend of mine.

After the screen reader Talkback was enabled, the usual start screen was presented to me. The next step was to get used to “Explore By Touch”. It clearly needs some time to get used to the gestures, especially when your used to navigate rapidly with a keyboard. I soon discovered that the six horizontal icons at the bottom of the start screen were not announced by Talkback. Since the phone vibrates when sliding over an icon, one can use those icons nonetheless.\ In general, the user interface runs smoothly on this phone, even though it is already a bit out-of-date.

Everything from choosing applications to run, writing SMS, making a call, using the Google Playstore to install new applications works great. The android keyboard needs clearly some time to get used to, but this is more a touch vs. keyboard issue.

The first application I've added was eSpeak, since I cannot stand “natural sounding” speech synthesizers. In my opinion they cannot speak fast and accurate. eSpeak was a good choice there, since it is free as in freedom, can speak really fast and is not resource-hungry. One has to note that the on-board applications from android are not the best in regard of accessibility. Specifically, the mail client and the browser were inaccessible. There are anyway better solutions out there, one should take those. For me K-9-Mail works great, it even has PGP support and advanced IMAP configuration settings! The browser of my choice is firefox, since I don't trust Chrome in general.\ Further more VLC, StreamServe and a file explorer from RythmSoft are handy too. The only non-free application here is the file manager.

While there are already a lot of acccccessibility features, there are also quite obvious down sides. One is that navigation in edit views is not really possible. You can delete characters, but you can't go back one word and so on. However Firefox can do this since version 24. Furthermore edit fields with multiple lines are not readable line by line. As far as I understand, the eyes-free keyboard (also from the Playstore) aims to work around those limitations, but I haven't yet get used to it, because it hinders me interacting efficiently with my phone.

Furthermore there is no really good accessible text editor or eBook reader out there. The first one lacks support due to the fact that multiline edit views are not accessible, the latter has just not been “invented”. Firefox does a great job with “Explore By Touch”, so the same would be basically possible with an eBook reader. The best you'll find are eBook reader which start reading (with their own speech capability) with a gesture and stop reading when you tap on the screen. Sufficient scrolling is impossible. I will read my texts in Firefox, there are enough possibilities to generate HTML.\ A DAISY player free of charge is also not available, which is also one would like to have.

Conclusion\ There has been much done about accessibility in Android and I have switched over to android full-time. There are just a few portions on the system (at least on mine) which are non-free and this is also a pleasing fact. There is a lot of mumbling from the users of the other big phone OS with accessibility. Some of those users of this system argue that Android would be really unusable. That might be true for specific use cases, but in general, Android is much more open and much more configurable/flexible and hence can fit requirements. Accessibility is there, one just needs to want it!

Encodings In CGI Scripts Using Python3

2013-09-12T00:00:00+02:00

As some might have noticed, I have rewritten my internal blog handling to make the appearance more uniform with the general web site design and to allow comments in the future. Since I now have switched „full-time” to Python 3.x, I had some real problems with encodings in Python3-CGI scripts, which I here want to discuss.

It all started with an error of a Python 3.x script with Apache on my server saying:

UnicodeEncodeError: 'ascii' codec can't encode character 'xxx' in position 0: ordinal not in range(128)

Since I am encoding everything in UTF-8 and all my systems use this encoding, I didn't expect problems. I first tried to write directly UTF-8 characters to sys.stdout, like:

import sys
bprint = sys.stdout.buffer.write
text_ugly = "öäü……·"
bprint( text_ugly.encode('utf-8') )

Strange enough, this worked only with one CGI script, the other one still threw an error, even though both read the same source. So I added the following two lines to my apache.conf:

AddDefaultCharset UTF-8
SetEnv PYTHONIOENCODING utf8

I thought that to be the nicest solution, but it didn't work out either. I then read numerous threads all discussing the same problem, but the people there found solutions I could not use. My concrete problem was a UnicodeEncodeError saying that surrogate characters could not be encoded to UTF-8. Something weird turned my Umlauts into surrogate characters, or more specifically, just one character. All umlauts before this one and after it were fine!

This article pointed me at least to an understanding of the problem. Not all functions in Python 3 are (or were) fully Unicode-compatible, like e.g. os.environ and produced sometimes surrogate characters. In my case it were os.listdir(). On my local laptop, I'm running Debian Unstable with Python 3.3.x, my server has Python 3.2. The problem only occures on my Server,, so I guess the Python developers might have fixed it. My simple solution is now to do the encoding like:

s.encode('utf-8', errors='surrogateescape')

uTeXer: replace (math) Unicode

2013-08-04T00:00:00+02:00

When I am reading scientific papers or technical books, I'm often stumbling over formulas. Since I'm using a screen reader, I can't read (in most cases) the Unicode signs and therefore they must be corrected (transcribed into LaTeX commands) by someone else. Another annoying thing are the ligatures produced by LaTeX, found in a lot of PDF's, because they can't be read by speech synthesizers.

The solution is simple but yet it seems to me that I was the first to implement that way. I have written a little Python script which uses the Unicode table from the W3C (which also ships LaTeX signs!) which replaces the occurring Unicode sequences into LaTeX / removes Latin ligatures.

Since the taste of people which LaTeX command to use is quite different, I also added customization capabilities to override (or even add) new Unicode points.

You can have a look at the project page or check out the source using:

git clone https://github.com/humenda/utexer.git

Have fun!

Chroot At Boot Time

2013-07-04T00:00:00+02:00

I wanted to experiment with more up-to-date software while preserving my stable working environment. Of course a frequent desire. Therefore I build a Debian unstable chroot and tried to get X running. But I didn't want to run chroot manually. In this article, I want to show you how I start my chroot with X support at log-in-time on a separate console. It should be mentioned that other tutorials already discuss this topic, but they didn't work for me.

Most tutorials mention that you have to bind-mount /dev, but you should mount /proc and /sys as well. All directories must be mounted with the option “--bind”. I assume that you replace \$CHROOT:

mount --bind /dev $CHROOT/dev
mount --bind /proc $CHROOT/proc
mount --bind /sys $CHROOT/sys
mount --bind /sys $CHROOT/sys

If you want to use your host's infrastructure, in Debian e.g. x11-common and dbus, you should bind-mount also the following:

mount --bind /run $CHROOT/run
mount --bind /tmp $CHROOT/tmp

Really handy is now to enter the mount points in the fstab, to execute them right at system boot:

/dev $CHROOT/dev none bind 0 0
...

Now a simple chroot is not that uncommon. It might be cool if you could log into the system like you log in on the console at the host. So let's adjust the /etc/inittab-file for this. In this file, there might be a line like:

1:2345:respawn:/sbin/getty 38400 tty1

and similar lines for each console which is activated (on Debian 6 tty's). I now changed line 5 to:

5:23:respawn:/usr/sbin/chroot $CHROOT /sbin/getty 38400 tty5

Note: if your doing that on a non-Debian system, chroot might be located elsewhere, try whereis chroot for the correct path. Furthermore it can happen that your system doesn't use getty but agetty instead (like Arch). Here the example for my Arch chroot:

6:23:respawn:/usr/sbin/chroot $CHROOT /usr/bin/agetty 38400 tty6 linux

Reload the inittab file afterwards with telnit Q.

Now I have got the possibility to switch on console 5 to do my packaging work in Debian unstable and have a look at the latest developments in Debian.

I have tried to get X running with startx in Arch, as I did in Debian unstable. Unfortunately this is impossible with Debian as host system. You need for GNOME 3.8 the latest dbus. Dbus in turn needs ConsoleKit or loginctl (on arch the latter). Loginctl is a systemd service, not available on Debian currently.

Activities In Debian

2013-04-18T00:00:00+02:00

In the last months, quite a few changes went into Debian, especially because Wheezy will be released soon. At this point a short overview about activities from me or about things which I've translated in the Wiki and are noteworthy to mention.

accessibility of the graphical login manager (GDM3)
brailleUtils 1.2.1 in Debian Unstable
Debian FreeDict team is being founded
Notes for accessibility of java

Accessibility Of The Graphical Login Manager GDM3

It was already documented in the Debian Wiki that GDM3 would have no support for Orca. This was due to the switch to GNOME3. Luckily a new version of GDM was uploaded just in time, where the problem has been fixed.

brailleUtils 1.2.1 in Debian Unstable

I have packaged the latest version of [brailleUtils](https://github.com/brailleapps/brailleutils9, a utility to print braille with braille embossers from the command line. This release brings the following changes:

support for new printers
there is now a separate package named brailleutils which makes the example-front-end of brailleUtils available as a command (using a shell script).
I have written a manual page for brailleUtils, since there was none yet in the project.

Therefore one can now print quite easily braille texts from the command line.

Debian FreeDict Team Being founded

A short while ago, I have started to found a Debian team. There is already a Wiki page and an IRC Channel: #debian-freedict on irc.debian.org. Helping hands are of course wanted!

Accessibility Of Java

In the Debian Wiki was just documented what is needed to achieve accessibility for graphical java interfaces (like those of Swing). One just needs to install libatk-wrapper-java and then uncomment the following line in /etc/java-6-openjdk/accessibility.properties (for java 6, else adjust the path):

assistive_technologies=org.GNOME.Accessibility.AtkWrapper

Scanning And Recognizing Text On The Console

2013-04-02T00:00:00+02:00

The usual problem seems to be that there are a lot of tools which do the job, but the available front ends don't fulfil the personal requirements. Look at the current scanning front ends:

XSANE does not use Tesseract / Cuneiform (as OCR back-ends) by default which are the best (where I tend to take Tesseract, it's fully free and gives better results). Furthermore batch scanning is not comfortable (to many steps in between).
There is LIOS. The main disadvantage for me is that it is poorly accessible (at least at the first glance with Orca) and not very intuitive. Please note that this are my impressions.

Therefore I've decided to reinvent the wheel and write another front end, just a little, functional one. The result is Papierzutext which is a little program written in Python to scan, recognize and read text. Currently it scans the text, recognizes it with Tesseract and displays / and saves the text into a file. Features include:

scan pages with options like density, etc.
when set, recognize text during the scanner draws back the lamp (otherwise the computer is idle)
use exactimage to refurbish the picture
save recognized text and images so that text can be reviewed, pages deleted etc. after restarting the program
set OCR language

Please try it out and send me feedback. You can obtain the program by checking out the git repository:

git clone http://www.crustulus.de/git/papierzutext

For Installation hints, look into the file INSTALL.

And now some critics. While this program is suitable for scanning books with only texts, tables and more complicated layouts are difficult. Also the orientation recognition (how the paper lies on the scanner) does not work satisfying. These are problems of Tesseract and this program is only useful if you use Tesseract > Version 3.

Have fun!

Virtualisation With Braille And Speech

2013-03-30T00:00:00+01:00

I keep translating the Debian wiki page about accessibility into German. This helps me following the latest accessibility developments within the project. This way, I recently learned about accessible virtualization, which I am going to introduce here.

I already knew about the -curses option for QEMU/KVM to start a guest on the console, which gives basic accessibility through the host's command line screen reader. However, qemu supports sound card pass through and the simulation of a braille device, which both together enable the full usage of the guest system.

To enable braille in the guest, qemu simulates a braille display of a specific vendor. All requests from the guest system to this virtual device are then passed onto BRLTTY, which has to run on the host system. BRLTTY is a command line screen reader and it also features a braille API (BRLAPI), so that other applications can control the braille device. Qemu uses this facility to pass-through output from the screen reader in the guest system to the physical device on the host machine.

The discussed options are:

-soundhw all -usbdevice braille

That's it, assuming you have BRLTTY set up and you know how to use qemu.\ Please have a look at the Debian Wiki page about accessibility for more details.

Own Radio Stream With Icecast

2012-12-26T00:00:00+01:00

I like to listen my music everywhere where I want:wq , not only at the computer . My smart phone has not enough space for all my music and anyway, I don't like to keep the music on my notebooks and my smart phone synchronized. Therefore a own streaming server is the easiest solution. I'll describe here a quick setup which assumes Debian GNU/Linux (or Ubuntu), but can be done on other *nixes as well.

The first step is the installation of Icecast, on Debian or Ubuntu:
```
# apt-get install icecast2
```
Then the admin, source and relay-password need to be changed (in the file /etc/icecast2/icecast.xml. On Debian/Ubuntu, you will be automatically prompted for those during the installation.
Verify that the service is up and running by visiting http://localhost:8000.

Icecast is only the service which handles the incoming client connections. The real noise comes from a source which is provided by other programs. One of those is Icegenerator, which will stream mp3 or ogg audio files.

Download the source from http://www.becrux.com/index.php?page=projects&name=icegenerator (where you also find basic instructions on how to set up the program).
Now some dependencies must be installed, on Debian/Ubuntu:
```
# apt-get install libshout3-dev libid3-dev
```
(I hope I haven't forgot one)
In the unpacked source the typical ritual: ./configure; make; make install.
Afterwards, the program is located in /usr/local/etc/icegenerator.conf. There various things can be set like the server where Icecast runs (here 127.0.0.1) or the port. More interesting is to set the mount point, which is the location where your stream becomes available, I chose /listen:
```
MOUNT=/listen
```
Then the user name and password to login into the Icecast service need to be set. The password is the one you chose during the Icecast installation.
The format is automatically set to mp3, which you can leave untouched, if you don't want to stream ogg vorbis files.
Now set the path to the audio files and activate recursive search:
```
MP3PATH=/path/to/mp3s
RECURSIVE=1
```
The logging output can be set to a different file path which makes it possible to start Icegenerator as user.
Finally, you can start Icegenerator by invoking /usr/local/bin/icegenerator and enter in your player http://localhost:8000/listen (or the URL which was configured).

I was not able to add path's (MP3PATH) containing spaces. It's simpler to create a separate directory with lots of symlinks to the desired music.

Tunneling Ports Behind NAT over SSH

2012-12-26T00:00:00+01:00

It can be useful to make a service from your machine available for others, might it be a http server, a game server or even a icecast streaming server. Unfortunately the pain called NAT can prohibit that sometimes. The simple solution is to forward the port from your local machine to a server. The problem I had was that most sources in the internet explain how to forward a port from a host to the local computer by binding the port on this local machine. The fastest way for tunneling is in my opinion to tunnel over SSH, since it has already all facilities for this task. Throughout this article I'll use the term host for referring to the server which will tunnel the port out of the NAT.

First of all, a configuration option has to be set in the host's sshd_config, located at /etc/ssh/sshd_config. There has to be set:

GatewayPorts yes

in order to allow binding ports on the host not only on the loop back interface
but also on all others. Then the service needs to be restarted, on Debian/Ubuntu
with 
sudo service ssh restart

After that the service on the local computer can be started and the tunnel created with the following command

ssh -N -R <bind_address>:<local_port>:localhost:<host_port> <your_host>

Explanation:

-N

Do not spawn a shell

-R

Forward the port with from-to syntax. See below

<bind\_address>

Specify the address (interface) where the port should be bound to. Standard is loop back (where it isn't reachable from outside).

The lazy can use '*' to bind it to all interfaces.

<local\_port>

The port on the local computer.

<host\_port>

Port on the host where the service becomes available.

<your\_host>

The host where the ssh server runs.

Example:

ssh -N -R '*':1234:localhost:5678 myuser@foobar.org

Notes In LaTeX Made Easy

2012-09-30T00:00:00+02:00

I'm nearly writing everything in LaTeX, this ranges from letters to scientific works over taking notes. Yes, taking notes can be easy even with LaTeX, which I now want to explain. The idea behind is that I like to take notes when reading a scientific book to remember later on what was in there. Also in a lecture it can be quite handy to take some notes and to have them structured later on in a nice way.

The most annoying thing when writing down notes in LaTeX is the ever repeating

\begin{itemize}
\item ...
\end{itemize}

I like to be able to use the dash for a new item, as I would on the paper. That's not hard, one must only understand how LaTeX handles signs. First of all, you need to know that you can redefine every letter in TeX. Then you have to know that you can rename control sequences.\ When renaming a command, you give the old command a new name and the old one doesn't exist anymore. Consider the following:

\newcommand\myname{\text{Erasmus Fuerchtegott von Gerstenbein}}
\let\notmyname\myname

Newcommand just creates an alias for the argument in braces. \let does the actual renaming. If I would use

\newcommand\notmyname\myname

I would have two times the same command, using \let removes the old \myname. In order to rename the dash, \let is the best choice.

\let\--

I decided to overwrite \- with the -, because I think that I'll never need to insert hyphens in notes. You can of course be creative and choose something better.

Then you have to make the dash active, which means that you can use the dash actually as a control sequence. For this you need catcode, please see http://en.wikibooks.org/wiki/TeX/catcode for details.

\catcode`-=\active

Then you can simply define the dash as \item using let:

\let-\item

If you structure your notes, you also need to insert headings or something similar which interrupt the itemize environment. Because

\begin{itemize}...\end{itemize}

means a bit of overhead, I redefined them to the lesser and greater signs. Those I stored in \lesser and \greater.

\let\lesser<
\let\greater>

% redefinition:
\catcode`<=\active
\catcode`>=\active
\def<{\begin{itemize}}
\def>{\end{itemize}}

After all, we now can write something like this:

\documentclass{scrartcl}

% ...

\begin{document}

\section{Love Live Of The Butterfly}

<
- live of butterfly in four states (egg, larva, pupa, adult)
- produces eggs
- has interesting courtship ritual with some kind of dance
>

If you want to use HTLatex in order to get an nice HTML file with links and a table of contents, you need to insert the definitions below the \begin{document}, otherwise the compilation will fail.

I have put those redefinitions into a file which you can download here. You can use it by typing \input{latexkeynotes.tex} (it applies the same regarding htlatex).\ Please note that this prohibits dashes in filenames, if you plan to input more files.

Debian/Backporting a package (or how to rebuild a package for your architecture

2012-05-27T00:00:00+02:00

In this article, I will summarize here what is needed to build Bitlbee 3.0 for 64 bit and how to rebuild a package in general.

For proper building of a package, you should have "dpkg-buildpackage" installed, which you can get using

aptitude install dpkg-dev

Then you should install all the needed dependencies for the package you're planning to build. Either you know them or you look them up in the README of your package. The debian-ic way would be

apt-get build-dep <package>

Having said this you have to make sure that the new version of your package has no additional dependencies. For Bitlbee, just download the source you find in my blog article.

I now assume that you have your new source available. Do an

apt-get source <package>

to fetch the "debian" directory of the package you want to build. The debian directory is a special directory containing information about how to build the package. If you choose to backport a package, copy the debian-directory from the just downloaded source to the source of the new version.

You now have to look into three files which are in the debian directory (not necessary if your just rebuilding Bitlbee for 64 bit):

control: are all dependencies met (have a look at this file, it should be self-explanatory)
debian/rules: ideally, there are rules like build: install: etc. If you never have looked into a Makefile, you should not make any changes.\ For Bitlbee, I had to modify some of the ./configure arguments in order to includeOTR.
changelog: This one tracks the changes as well as the version numbers. You need to add a new entry at the top, looking similar to this:
```
accessodf (3.0~b-1) unstable; urgency=low

  * backport of the package for Debian Squeeze
  * included OTR support.

 -- Sebastian Humenda <nospam@thanks.com>  Mon, 21 Mai 2012 14:21:13 +0200
```
Please be careful with the spaces, all of them must be entered exactly as shown. (two before the "*", else always one space)\ Some hints on versioning:
- The Debian version is always the last part of the number and begins with the "-". It's usually a 1.
- The version is always something like major.minor.minorminor. By adding a "\~b", you make sure that your package is labeled with 3.0, but it has actually a lower priority than 3.0 (like a beta release). With this you make sure, that the Debian version of Bitlbee will be installed, when you upgrade.

When you have done all modifications to the debian directory (or none if not needed), you can build the package as follows (assuming you are in the source directory of your program):

dpkg-buildpackage

In the directory above (".."), you need the orig.tar.gz-file, which you got with the "aptitude source" command. Without this file dpkg will report an error. For Bitlbee it's http://crustulus.de/deb/bitlbee_3.0\~b-1.tar.gz.

If everything went fine, you will have some warnings on the screen and afterwards a Debian package in "..".

Congratulations!

Braille-accessible output of Gnuplot

2012-04-27T00:00:00+02:00

There is no easy way for blind people to have a quick look at a mathematical function or at a data plot of measurements. All available solutions rely on sighted assistance.

Recently, I had to plot some measurement data that I had taken from an oscilloscope. It was dissatisfactory to not be able to see what kind of curve I had plotted, so I wondered whether I could get an ASCII representation of the plot. In the old days, where the text console was the norm and not the exception, people needed a solution to have a look at their plots without printing it to paper, first. So they developed a "dumb" terminal driver for Gnuplot, which approximates the plot in ASCII art. This is extremely handy, because a braille display for the blind is made exactly for this purpose: to display text.

The following example illustrates how to plot $x^2$ optimized for a 40 cell braille display. Open Gnuplot and enter the commands (as shown below behind the gnuplot> prompt):

gnuplot> set terminal dumb 42 20
Terminal type set to 'dumb'
Options are 'feed  size 42, 20'
gnuplot> f(x) = x*x
gnuplot> plot f(x)


   100 *+------+-------+------+------+*
       **      +       +  f(x)+********
    90 +*                            *+
    80 ++*                          *++
       | **                        ** |
    70 ++ *                        * ++
    60 ++ **                      ** ++
       |   *                      *   |
    50 ++   *                    *   ++
    40 ++   **                  **   ++
       |     **                **     |
    30 ++     **              **     ++
    20 ++      **            **      ++
       |        **          **        |
    10 ++      +  ***  + ***  +      ++
     0 ++------+----******----+------++
      -10     -5       0      5       10

To ease the understanding of the characters for a braille display user, I'm going to explain a few of the used signs here. The "-" sign marks a horizontal line, the "|" sign a vertical line. The "+" signs are just to show where the numbers are. The most interesting sign is the "*", since the function is plotted with it.

The commands above do the following:

set terminal dumb 42 20: Set the output to ASCII with 42 characters on each line and 20 lines in total.\

Details on width and hight of the resulting graphic can be found further below.
f(x) = x*x defines the function. You can define variables before and use them in the expression. There are already functions predefined (e. g. sin and log) so you can use them in your function definitions.
plot f(x): plots the defined function.

A second example with measurement data could look like this:

gnuplot> set terminal dumb 42 20
Terminal type set to 'dumb'
Options are 'feed  size 42, 20'
gnuplot> plot 'data.dat' with points


   90 ++---+-----+----+----+-----+---++
      +    +     +  'data.dat'   A    +
   80 ++                             +A
      |                               |
   70 ++                             ++
      |                               |
   60 ++                   A         ++
      |                               |
      |                               |
   50 ++                             ++
      |          A                    |
   40 ++                             ++
      |                               |
   30 ++                             ++
      +    +     +    +    +     +    +
   20 A+---+-----+----+----+-----+---++
      1   1.5    2   2.5   3    3.5   4

data.dat contains measurement data, as you might have guessed. The data points are represented using the character A. Gnuplot is clever enough to distinguish between different data sources, a second data file within the same plot would have different point markers (for this example B).

About width, height and the margin

Different braille displays have different length and therefore it makes sense to adjust the size of the plot to your needs. The dumb terminal of Gnuplot accepts two options: width and height. For a 80 cell display, you could therefore type:

gnuplot> set terminal 80 30

The number of lines always depends on how much you want to navigate up and down, but also on how big your graph is. In general, I like to use 20 lines with a 40 character display.

Gnuplot likes to make plots look nice. For an ASCII plot, this is useless and for blind users, this is simply a waste of space. Therefore the margin (left/right) can be omitted or decreased:

gnuplot> set rmargin 0

The left margin can be left unchanged or calculated manually. There is always one space from the y-Axis label and it is followed by the number. For a two-digit number you would use:

gnuplot> set lmargin 3

(or even 4 if you have also negative numbers). But again, I suggest leaving the left margin unchanged.

You can save those instructions into a file and load it every time you open Gnuplot, so that you save some typing. Open e. g. braille.plt and put something like this into it:

set terminal dumb 40 20
set rmargin 0

and load this file using

gnuplot> load braille.plt

You can there predefine some functions too, if you like.

AccessODF now in Debian (and Ubuntu)

2012-04-09T00:00:00+02:00

I now have packaged another program for Debian (and for Ubuntu), which will eventually tripple down into the next release: AccessODF. The web site describes it as follows:

AccessODF is an extension that can be used in OpenOffice.org Writer and in LibreOffice Writer. It enables authors to find and repair accessibility issues in their documents, i.e. issues that make their documents difficult or even impossible to read for people with disabilities.

But such a tool is only handy if you can install it easily; in Debian, use your favorite program to install the package accessodf. E. g. type:

apt-get install accessodf

Odt2braille (http://sf.net/p/odt2braille) depends on AccessODF in order to perform checks on the document before converting to braille. So this helps you also to write your documents correctly in the first place, if you want to emboss it later in braille. And there's another handy thing: if you plan to export your ODF file later to a PDF, you'll probably get a bit more accessible PDF too.