Adding an ‘s’ to Marked Text

Jay Bosamiya has an excellent tip for adding an ‘s’, or some other
character, to the end of text that has some Org mode emphasis markup
added.

This comes up all the time for me and I usually end up fashioning the
HTML or \(\mathrm{\LaTeX}\) markup by hand. It’s nice to have an easy
solution.

Posted in General | Tagged , | Leave a comment

Open Source Tools

I prefer open source software but I’m not an absolutist. I no longer
have much interest in patching my OS, for example, so I feel
comfortable using macOS because the eco-system—or walled garden, if
you prefer—allows me to integrate my tools and workflow across my
various devices easily.

I do insist on one principal, however: I never commit my data to
proprietary software and especially not software that runs as a
service on someone else’s computer. As I’ve said before, if Apple were
to go out of business tomorrow, it would take me less than a day to
move everything over to Linux and be back up and running with no
loss of data. Mostly I do that by keeping my data as plain text except
for things like PDFs, music, and pictures where there are open source
applications to deal with them.

What I don’t understand are people who are willing to commit their
only copy of important data to things like Google Docs1. Some of these
people are writers and others who literally commit their livelihood to
the vicissitudes of Google’s plan-of-the-day for world domination.
Just when you have a comfortable workflow established, the service
provider decides to end-of-life an important cog in that workflow.

It gets worse though. Companies like Google have shown themselves to
be unreliable custodians of your data. Even if you’re willing to pay
the privacy costs for those “free” services, why would you risk having
your data held captive because the provider of that service doesn’t
like your data?

Think that’s an exaggeration or won’t happen? Consider the case of
Dennis Cooper, an artist, who lost 14 years of writing, research, and
pictures when Google decided it didn’t like his blog on Blogger and
deleted his account. That included Gmail and his contact list.

More recently, several users have had their Google Docs accounts
frozen
because Google decided, mistakenly it turns out, that they
contained disagreeable material. Again, these were professional
writers who had their work product sequestered because Google thought
they might be guilty of BadThink™.

You can say, and rightfully so, that these people were stupid and got
what they deserved but it’s astounding how often I see presumably
technically competent folks blithely admitting—or even boasting—that
they use Google Docs or some other similar service to hold their
important data. Please don’t do that. There are plenty of other
great solutions available that don’t put your data at risk.

Footnotes:

1

I’m using Google as an example of a provider of the type of
dangerous services I’m talking about but they are far from the only ones.

Posted in General | Tagged , | Leave a comment

Niklaus Wirth and Compiler Construction

Many years ago, I did a stint as a compiler writer. I don’t do that
anymore but I’ve continued practicing what I learned by implementing
several little languages for various tasks. Mostly, I’ve leveraged
lex and yacc for those chores but my first little languages were
implemented using the simpler recursive descent technique for
parsing. Yacc is more powerful in the sense that it can parse LR(1)
languages in addition to the more restrictive LL(1) languages but
many or even most languages are LL(1) and certainly any reasonable
little language will be.

I mention all this because Hanspeter Mössenböck’s paper Compiler
Construction—The Art of Niklaus Wirth
popped up in my RSS feed. Most
readers are probably familiar with Wirth as the designer (and
implementer) of Pascal and Modula{23} but he implemented many
compilers and is an expert on language and compiler design. The paper
is a retrospective on Wirth’s philosophy of language and compiler
design.

One of the things that popped out as me was his belief that compilers
should be simple, reliable, and fast and that he preferred that over
the heavy complexity that aggressive optimization brings. Ironically,
according to the paper Wirth’s compilers generated code that was
nearly as fast and those that did heavy optimization. He achieved that
by focusing on generating good code to begin with rather than
generating bad code and letting the optimizer fix things up.

He also preferred parsing with recursive descent because he felt it
forced the language designer to keep the language approachable and
simple. He believed that C would have been a better language if
Ritchie had restricted its grammar to LL(1) because it would have
avoided some of the syntactically dubious constructs that made their
way into the language.

If you have any interest in (computer) language translation—even if
only for little languages or DSLs—the paper is worth a few minutes of
your time. Also, Wirth’s book Compiler Contruction is available as a
PDF in many places such as here. The book expands on some of topics
that Mössenböck discusses in the paper.

Posted in General | Tagged | Leave a comment

An Application of Org-element

The other day, I saw this query on the reddit Emacs subreddit. I
already have solutions for this type of problem but I’m always
interested in the how people use Org mode to record and report data so
I followed the link that primitiveinds provided for his solution to
generating time reports.

Even if, like me, you already have your time tracking and reporting
needs under control, primitiveinds’ solution is worth looking at for
its own sake. It works by looking for CLOCK entries in an Org buffer
and accumulating the relevant information in the CLOCK line as well
data about the associated task. That might seem like it would require
routine but tedious text manipulation but primitiveinds leverages the
org-element functionality to easily handle the task.

He starts by calling org-element-parse-buffer to generate a tree
representation of the Org buffer. Then he uses org-element-map to
examine each CLOCK element (and only CLOCK elements) to extract the
necessary information. It’s a great technique that can easily be
adapted for other parsing of Org data. The code that primitiveinds
presents is easy to follow and he provides a nice explanation of what
it’s doing.

If you need to programmatically examine Org data for further
processing, you should take a look at primitiveinds’ post. It’s
definitely worth a read.

Posted in General | Tagged , | Leave a comment

SBCL 1.4.6

Most of my Lisp programming lately has been in Emacs-lisp so it’s been
a few months since I’ve used Common Lisp. The other day, though, I
noticed that Version 1.4.6 of Steel Bank Common Lisp (SBCL) had just
been released so I decided it was time to upgrade SBCL and my
Quicklisp library.

As usual, the upgrade completed without incident and the regression
tests—which I always run with an upgrade—completed with no unexpected
errors.

It’s always a pleasure to work with SBCL and, of course, with Slime I
can do so from within Emacs. If you like Lisp and want to try out
Common Lisp, I unreservedly recommend SBCL. It’s an industrial
strength Lisp system that’s actively maintained and works seamlessly
with Emacs. It’s easy to install and update so there’s no reason not
to give it a try.

Posted in General | Tagged , | Leave a comment

C++ and Pointers

The other day, I wrote that C++ is not my favorite language and that
it’s eliminated most of what’s useful about C while retaining most of C’s
disadvantages. Then I saw this post, which says that the 2018 C++
committee is planning the deprecation and later removal of pointers
from the language. My immediate thought was that that proved what I
wrote.

Of course, the post is almost certainly an April Fools joke but here’s
the thing: No one seems to be sure. There’s a long discussion over at
Hacker News where half the commenters are sure it’s a joke and the
other half are convinced it’s true. I asked DuckDuckGo and it didn’t
know either.

It speaks volumes about the language that this should be so. The
language is so full of cruft and has made so many dubious decisions
that knowledgeable people can’t decide if this is another dubious
decision or a joke even though the discussion is happening on April
first.

I’m sure lots of Irreal readers have coded in
C++—I’ve coded in C++—and many of them
probably like the language but its appeal escapes me. These days there
are better alternatives for almost any project so it baffles me that
folks continue to choose C++. No doubt that’s begging to be ruthlessly
schooled on why folks do choose C++ but that’s part of what make the
Irreal community so much fun.

Posted in General | Tagged | Leave a comment

Back to RSS

Lately, I’ve noticed a renewed interest in RSS. The reasons for that
are not hard to understand. As yesterday’s post made clear, social
media has become a toxic wasteland interested only in collecting the
intimate details of our lives and selling them to their real
customers, the advertisers.

The driving force behind the movement back to RSS is the belief that
“news” obtained from social media is over processed white bread
rendered mostly useless by questionable algorithms and adulterated
with advertiser sponsored “content.”

Wired has an article on the return to RSS that considers the major
practical question about that return: what should I use as my RSS
reader? It used to be that for most people the easiest answer was
Google Reader. Then, of course, Google killed the product leading many
to predict the death of RSS and, as a consequence, blogs. Happily
neither of those predictions came true but that still leaves the
problem of what to replace Google Reader with.

If you’re an Emacs user, I can’t recommend Christopher Wellons’ Elfeed
enough. It’s very flexible and runs right in Emacs. Mike Zamansky has
an excellent three-video series on it (1, 2, 3) if you want to see it
in action and how you can customize it.

Before Elfeed, I used Feedly and really liked it. It runs in your
browser so you don’t need to worry about a separate application. I’d
still be using it except I wanted to move my RSS reading into Emacs.
If you’re not an Emacs user or don’t want to use it for reading RSS,
Feedly is an excellent choice.

The Wired article talks about other readers as well. It’s an
interesting article and provides insight into the reinvigorated
interest in RSS. Definitely worth a read.

Posted in General | Tagged , | Leave a comment

Enough Is Enough

I’m not on Facebook. I’ve never been on Facebook. At first it was
simply a matter of not being a 14 year old junior high schooler.
Later, even adults started hanging out there but I still thought it
was silly and exhibitionist. That makes me an outlier, I know, but it
turns out I was on to something, if only fortuitously.

By now, almost everyone knows about Cambridge Analytica and their use
of Facebook data, supposedly to influence the election. But as Karl
Voit says, the issue isn’t Cambridge Analytica but Facebook.
Collecting and selling your data is their business plan and that’s
exactly what happened with Cambridge Analytica. Despite their demurral
and professed distress at what happened, Cambridge Analytica’s use of
the data was, in fact, well within Facebook’s guidelines and
apparently not uncommon.

Voit goes on to explain that Facebook collects that data whether or
not you agree to the collection and, according to others, even if you
aren’t on Facebook
. Worse, you can’t delete the data. When you try,
it’s no longer visible on your Facebook page but Facebook still has it
and still sells it to anyone willing to pay.

If you want to be horrified, take a look at this tweet thread (click
on the tweet to see the whole thread) that details the type of data
Facebook and Google collect about you:

If that doesn’t scare you, how about the fact that Facebook captured
and retained the phone detail logs
from users of their mobile app?

As Bruce Schneier points out this problem is pandemic. There’s no
longer any excuse. You can wait and hope someone else or the
government solves the problem or you get off Facebook and stop using
Google. Or you can continue to let them collect your most intimate
data and sell it to anyone interested.

Posted in General | Tagged | Leave a comment

A C++ Configuration for Emacs

If you’ve been around for a while, you know that I don’t think very
much of C++. It has all the disadvantages of C while managing to lose
what makes C worthwhile. Others disagree, of course, and in any event
may be required to use it for some or all of their projects.

If you’ve got to use C++, you might as well use Emacs to lighten the
load. (Yes, I’ve heard of Visual Studio: not in this lifetime.) The
problem is that it’s tricky to make a good configuration for C++. When
I see one that looks interesting or useful, I usually write about it
for those who choose to or must use C++.

Nils Deppe not only uses Emacs to write his C++, he’s been doing it in
terminal mode, which he prefers. Lately, he’s been experimenting with
using the GUI version—why wouldn’t you: it’s almost always superior—so
that he can edit Jupyter notebooks from within Emacs. Because of this
and because he was fed up with RTAGS, Deppe has rewritten his C++
configuration
.

He works on a laptop so he’s strived for speed and good battery
performance. His post has some animated gifs that show things in
operation. He also included a link to his Emacs configuration so you
can see exactly how he’s set things up. If you’ve been looking for a
decent C++ configuration for Emacs, you should take a look at Deppe’s
setup. It may be just what you’ve been searching for.

Posted in General | Tagged | Leave a comment

The Right Tool for the Job

On the The Unix Heritage Society mailing list, someone started a
thread commemorating the death of John Backus, who, in addition to
inventing the Backus-Naur form, lead the team that developed the
original FORTRAN. Someone else made a disparaging remark about FORTRAN
and that precipitated a long discussion of the good, the bad, and the
ugly of FORTRAN. Most people who’ve never used FORTRAN—and many who
have—aren’t aware that except in strings and a couple of other places,
blanks don’t affect the syntax and can be omitted. I recall once
looking at a FORTRAN compiler where the first thing it did after
reading a card image was to eliminate all the blanks.

Steve Johnson, the inventor of Yacc, the Portable C Compiler, and
Lint, offered a funny story about FORTRAN and blanks at Bell Labs. His
post is worth reading as an interesting piece of Bell Labs history but
what struck me was how the choice of the right tool for a job enabled
Johnson to complete a task much more quickly than even the world-class
engineers and computer scientists at the lab expected.

The TL:DR is that Johnson, just out of college, had a summer job at
the labs. He was assigned to write a program implementing a state
minimization algorithm. His supervisors expected it to take him the
summer to complete the program. But Johnson had heard about this new
language, SNOBOL, that seemed perfect for the task. Once he got SNOBOL
running, it took him only 3 weeks to do the job.

All of us have go-to tools that we turn to first. In terms of
languages, it might be C, Lisp, Python, Ruby, JavaScript, R, or
whatever we’re most comfortable with. But stopping to consider what
tool will make the job easiest can yield large dividends.

Posted in General | Tagged | Leave a comment