Orgmode on Noetic Nought

Weekly #28 (2026)

Wed, 15 Jul 2026 16:34:00 +0530

I’ve decided to start posting weeklies inspired by some folks from the OCaml and the Bangalore Indie Web communities.

I spent a bunch of time over the weekend updating the setup of Orgzly Revived and Termux and my scripts for syncing everything between my phone and my laptop. I hadn’t bothered copying over my setup to my current phone since it felt too brittle after using it for a few months on my previous phone.

With Orgzly being revived and getting continuous improvements, and the availability of LLMs to debug and fix annoying breakages that I don’t want to sink time into, hopefully this time everything will work better…

Hopefully, this will all help me continue to be regular with these weeklies.

Android playstore and F-droid

While working on this setup I stumbled on this site “Keep Android Open”. It is a site which explains the planned changes to Android’s permissions for installing apps. The change seems like an iOS-ification of Android where only apps by developers registered with Google can be installed, even if they are not distributed via the Play Store. I had received a notification from Google about deleting my developer account since it was inactive and I didn’t pay much attention to it. This proposed change is so much wider reaching, though, and needs more investigation.

Phones stand in for earthquake sensors in Venezuela

I read an article about how Google runs an earthquake warning system that’s great for countries without a public-funded earthquake warning system. It’s the first time in a long time that I felt something from Google gave me the “Don’t be evil” vibes. For a company that managed to worsen their search for increasing traffic and ad revenue, this is pleasantly surprising!

Google Summer of Code updates

I’m co-mentoring a student for GSoC again this year. Last week, we submitted his mid-term evaluation and he’s good to go for the rest of the GSoC period.

It’s been an interesting experience mentoring this year, with Zulip maintainers allowing and encouraging students to use LLMs for their work. There’s a detailed AI usage policy here for all contributors, but I think the current breed of LLM agents make it easy to fall into the trap of cedeing control to them, and letting them drive you. It does need conscious effort from contributors to wrestle with the problem they are working on and understand any AI generated code well enough to critic, modify, explain and own it. We have been trying our best to make sure my mentee doesn’t fall into those traps and is making the time and space to be thoughtful and deliberate with their AI use.

Also, I’ve applied to attend the mentor summit for the first time and I’ve been accepted! If everything goes well, I’m hoping to attend the GSoC summit for the first time, in October in Berlin!

Home-built Websites for personal needs

My fitness trainer has built a website for himself using Lovable and Claude! The idea is to ease his workflows to track the progress of everyone who trains at the gym (in person or virtually). I could tell at first glance that the website is AI generated, but it’s pretty cool that he could make the time and was able to build something for himself.

A couple of weeks ago, an architect friend reached out to me to have a chat about a new SaaS startup that she’s working on with a friend to help improve the workflows for architects to go from first draft sketches to proper plans/models. She has a couple of CS students/interns who are “vibe-coding” the first version of their app. They are also training some models for the transformation, I believe.

Whatever qualms and complaints I have about the use of LLMs for knowledge work and all the current buzz and hype around it, I enjoy stories like these of it empowering people to build things they need to improve their workflows. I also enjoyed this thread (somewhat old, now) from Hacker News of people sharing what they are building with LLMs.

Ads on Instagram - BBC Documentary

I watched this BBC documentary on how Instagram allows ads promoting child abuse. Sadly, I’m not surprised by everything that the documentary explained. I’ve previously come across ads that are phishing scams, crypto scams, etc., and it didn’t look like Meta was doing anything to prevent such ads. I wasn’t surprised to learn that they don’t seem to be doing much in this case too. I don’t think these problems are unsolvable if these platforms care to take responsibility, given the tech available today.

Video on the discovery of Nitroplasts

I watched this video shared by Chaitu on nitroplasts, the organelle that lets Eukaryotes fix atmospheric nitrogen into ammonia. Until this recent discovery, it was thought that only Bacteria and Prokaryotes can do this, and this is the first instance of an algae (Braarudosphaera bigelowii) that seemed to have “engulfed” a bacteria that can do this, which eventually turned into an organelle (similar to the evolution of mitochondria). This seems like a much more recent evolution than mitochondria and chloroplasts and possible provides a window into how such organelles get formed. And studying nitroplasts in Bigelowii could lead to research that could reduce our dependence on synthetic fertilizers, for instance.

Sid’s birthday

We attended Sid’s (nephew) 4th birthday. This was his first birthday after his little sister was born. He was so excited by all the toys he got, but also wasn’t expecting any of us to bring gifts for his sister. He wanted them all, but understood on adults explaining it.

I like how he was cautiously sharing his new toys with her too. He got a new robot which dances with lights and music to Indian songs. He understandably didn’t want to share it. It had enough moving parts and seemed breakable in his little sister’s hands. His dad tried to explain that his sister is playing with it carefully, and he kept repeating “Of course, she will break it!”, until he saw that this line of argument wasn’t working. He came back later saying, “It is too bright for her” (with all the lights that glitter).

Carnatic Cafe

I usually avoid eating out at South Indian restaurants in Delhi, but in solidarity with Chaitu who ate at a couple of Indian restaruants after we left from his place in Vienna, we ended up eating in Carnatic Cafe. I found the Vada in Vienna to be better than here, but the Rava Masala Onion Dosa was great!

Penguin Bookfair by Hubhawks

We attended the Penguin Book Fair by Hubhawks. I wasn’t aware it had a “Buy by the bag” pricing. The available selection of the books didn’t seem compelling enough to spend more than a few minutes in the small hall filled to the brim with people. Many of whom were trying to fill up their bags to the brim, err.. I mean the zipper, to make the most of the pricing model but frustrated by it.

GitHub Gists from Emacs Orgmode

Tue, 26 Apr 2022 12:37:00 +0530

TL;DR: I released my first Emacs MELPA package – ox-gist – An Orgmode backend to export and update sub-trees and buffers to GitHub gists. It was a great experience contributing to MELPA.

Motivation

I often share bits and pieces of my journal.org file with others, mostly for reading, some times for comments. The file contains different subtrees for each day with subtrees for different topics, meetings, articles, etc.

Orgmode lets you export subtrees to specific file names using the EXPORT_FILE_NAME property (and FILE_NAME buffer export option when exporting full buffers). It is easy to create these exported files on a publicly accessible webserver using the power of Emacs TRAMP mode. For instance, I often set the property to some thing like /ssh:muse-amuse.in:~/public_html/<filename> to publish stuff.

But, exporting to HTML is a distraction some times because I start fiddling with CSS and styling. Exporting to a simple org file doesn’t seem to cut it because there’s no styling at all, and making longer exports hard to read in a web-browser. Exporting to a GitHub Gist is a nice middle ground because GitHub renders Orgmode files reasonably well. Additionally, the comment functionality is pretty handy.

I could also directly use @defunkt’s excellent gist.el to share stuff as Gists. I’ve used it in the past, and it works well when I don’t care about having the contents of the Gist locally on my machine. It’s also quite easy to update existing/old Gists in this scenario, since there’s a single “source of truth” and gist.el makes it quite easy to update Gists.

But, this isn’t good enough when I want to have a “synced” copy of the text on my machine. Also, it doesn’t work very well when I want to share just a subtree from my notes file, and not the entire file. I’ve to export the subtree to a temporary Orgmode buffer and then create a Gist from that buffer.

Hackish wrapper around `gist.el`

A couple or so years ago, I wrote a wrapper around gist.el to let me post Orgmode subtrees as a Gist and also update them when I edited these subtrees locally. There was no support for exporting entire buffers since that wasn’t my use-case. This wrapper code was just a part of my .emacs and worked reasonably well for me.

A few weeks ago, I ended up procrastinating on writing and sharing notes for a discussion with a friend, and extracted this wrapper as a separate package – org2gist – to make it easy for other people to use.

MELPA submission and feedback

I submitted this as a package to MELPA while being skeptical about whether it would be accepted. I wasn’t sure if my thin wrapper around gist.el would meet MELPA’s criteria for a “Reasonably innovative package”:

MELPA provides a curated set of Emacs Lisp packages, not an exhaustive list of every single Emacs Lisp file ever created. By default, MELPA maintainers will reject packages that duplicate functionality provided by existing packages. Please try to improve existing packages instead of creating new ones when possible.

It was a pleasant surprise to get very helpful reviews from the MELPA maintainers. They not only thought the package was good enough to include in MELPA, but also looked at it’s code and gave great feedback — not just basic quality checks before accepting the package into MELPA.

I’m pretty sure mainting a package repository like MELPA is a lot of work, but as an end-user it mostly just worked for me and I never really gave it much thought. It was eye-opening to submit the package to MELPA and see first-hand the care and effort the maintainers put into what goes into the repository.

@riscy (a MELPA maintainer) suggested a different approach that I hadn’t thought of — turning the wrapper into an Orgmode Export backend.

Current version: `ox-gist`

It turned out to be a great idea which I ended up implementing. The user interface became much cleaner, since it used the Orgmode Export UI. And it also forced me to “complete” the feature-set by adding support for exporting entire Orgmode buffers to GitHub Gists, not just subtrees.

The package now adds an Orgmode export backend that lets you export a subtree or the whole buffer as a GitHub Gist, similar to how you’d export to HTML or LaTeX from Orgmode. The GitHub Gist ID is saved for each exported buffer or subtree and is to update a Gist when re-exporting an already exported subtree or buffer.

Outro

The package has now been added to MELPA as ox-gist. Feel free to give it a spin and give feedback directly to me or on the issue tracker!

I don’t know if anyone else would find the package useful and use it, though, MELPA tells me that 20-odd people atleast downloaded it. I’m happy this code may be to a handful of people.

Also, I now have a new found appreciation for MELPA and the work put into it by the maintainers. I’m glad I took the time out to submit this package to MELPA.

Thanks to Shantanu for reading drafts and helping me restructure this post.

Clock in and get-shit-done

Tue, 22 Dec 2015 00:00:00 +0530

I had setup a couple of hooks about an year ago that turn off all notifications while I’m clocking in. But, I find myself switching to the browser and jumping to twitter, out of habit. I’ve tried get-shit-done in the past to help myself break this habit. But enabling get-shit-done manually is step that quickly became a non-habit.

So, I hooked up get-shit-done into an org-clock-in-hook. The snippet below is what I added into a function that is added to this hook.

(with-temp-buffer
  (cd "/sudo::/")
  (shell-command "HOME=/home/punchagan get-shit-done work"))

get-shit-done needs to be run as root, since it does things like modifying /etc/hosts and restarting networking. Just calling get-shit-done as a shell command fails with the error sudo: no tty present and no askpass program specified. I found a couple of ways to fix this. The snippet above piggy-backs on tramp to allow for a way to enter the password for sudo to use. This also means that I don’t need to enter the password, as long as the tramp connection is alive.

For someone worried about having such an easy way of running something as root, using something like gnome-ssh-askpass as the askpass program might work better.

(shell-command "SUDO_ASKPASS=\"/usr/lib/openssh/gnome-ssh-askpass\" get-shit-done work")

org-drill for making it stick!

Sat, 17 Jan 2015 00:00:00 +0530

Those who read the last few posts here, would know that I have been experimenting with org-drill (a spaced repetition extension to Org mode). I have been using the system (almost) religiously for the past 2 months, and I do find that it has helped a great deal! (in some respects). I have also spent a considerable amount of time trying to reduce the friction to put new stuff into the system, and am constantly on the look out for further improvements.

Using this system has definitely helped with retention, and I find that I can recall quite a few things I have read a few weeks ago, that I would normally have been unable to. Though, I can recall a lot of information, I have been having a feeling of “fragmentation”: the feeling of just retaining individual bits/fragments of information, while losing out on actually internalizing the knowledge; not seeing the big picture, etc.

Wozniak (the author of super-memo) warns against learning without understanding, and memorizing before actually learning stuff. I haven’t consciously added stuff into the system that I didn’t understand (when I added it), but, later it does feel like I have lost some connections or the understanding, and am only holding onto the fragments of information.

The problems as explained in (read: as interpreted by me from) Make it Stick appear to be:

The understanding (if any) at the time of adding stuff into the spaced-repetition system is untested. It may just be familiarity masquerading as understanding.
The lack of any spaced repetitions for the overall concept/understanding and actual repetitions only for individual bits doesn’t help retention of the understanding (even if there was any, in the first place).

To work around this, I’m going to try adding questions that test understanding, to the system. The Super-memo team strongly recommends keeping the drill items small and easy to answer. This may be helpful in keeping each drill session short, but I would really like to add conceptual questions to the system, and see how it goes. I hacked org-drill to allow me to type out answers, before looking at the “correct” ones. This is an adaptation of a system that a fellow Hacker Schooler uses, and shared. Also, hopefully forcing myself to type out the answer will help me get around the problem of sometimes saying “yeah I know that”, then looking at the answer only to reaffirm the feeling of familiarity, rather than actually testing myself. I’m still going to continue adding quick and short questions that test “bits of information”, though. But, hopefully the additional conceptual questions are going to tie things together and help fill in the gaps. Lets see how this goes!

For those interested, my hacks to org-drill below. The code is really a hack, and welcome any suggestions on cleaning up the code.

(advice-add 'org-drill-presentation-prompt :around 'pc/org-drill-presentation-prompt)

(defun pc/org-drill-presentation-prompt (old-fun &rest fmt-and-args)
  "A presentation prompt that allows capturing answers."

  (let ((cb (current-buffer))
        (heading (nth 4 (org-heading-components)))
        (entry-id (org-entry-get (point) "ID"))
        (input ""))
    (switch-to-buffer-other-window "*org-capture-drill-answer*")
    (org-mode)
    (insert "# Hit C-c C-c once you are done answering!\n")
    (org-insert-heading-respect-content)
    (insert (format "Answer: %s" heading))
    (org-entry-put (point) "QUESTION_ID" entry-id)
    (goto-char (point-max))
    (insert "  ")
    (org-time-stamp-inactive '(16))
    (insert "\n\n  ")
    (while (not (and input (equal input "")))
      (ignore-errors
        (execute-kbd-macro input))
      (setq input (read-key-sequence nil)))
    (switch-to-buffer-other-window cb)
    (apply old-fun fmt-and-args)))

(advice-add 'org-drill-reschedule :around 'pc/org-drill-reschedule)

(defun pc/org-drill-reschedule (old-fun)
  "Calls the original reschedule, but also archives the answer"
  (prog1 (funcall old-fun)
    (let ((cb (current-buffer)))
      (switch-to-buffer-other-window "*org-capture-drill-answer*")
      (pc/org-refile-to-datetree "drill.org_archive")
      (message (buffer-name))
      (switch-to-buffer-other-window cb)
      (kill-buffer "*org-capture-drill-answer*"))))

(require 'org-datetree)
(defun pc/org-refile-to-datetree (journal)
  "Refile an entry to journal file's date-tree"
  (interactive "fRefile to: ")
  (let* ((journal (expand-file-name journal org-directory))
         (date-string (or (org-entry-get (point) "TIMESTAMP_IA")
                          (org-entry-get (point) "TIMESTAMP")))
         (dct (decode-time (or (and date-string (org-time-string-to-time date-string))
                               (current-time))))
         (date (list (nth 4 dct) (nth 3 dct) (nth 5 dct))))
    (org-cut-subtree)
    (with-current-buffer (or (find-buffer-visiting journal)
                             (find-file-noselect journal))
      (org-mode)
      (save-excursion
        (org-datetree-file-entry-under (current-kill 0) date)
        (bookmark-set "org-refile-last-stored")))
    (message "Refiled to %s" journal)))

How I learnt to use Emacs' profiler

Sat, 03 Jan 2015 02:01:17 +0530

I learnt to use Emacs’ profiler yesterday, after many hours of yak-shaving, trying to get Memacs working. Memacs is a memory extension system for Emacs written by Karl Voit, that I have been meaning to try out for a long time now. Seeing lots of review posts at the turn of the year and watching Karl’s recent Emacs Chat with Sacha Chua pushed me to try and finally set it up.

I started writing a module to create a Memacs file – an org archive file – from my browser history. It was pretty easy to write, and I had it spitting out a huge file with 22k entries after about a couple of hours of work. Then I excitedly pulled up my agenda, and turned on the option to view archived entries, only to be super-disappointed. It turned out to be extremely slow! Actually, the agenda never came up with the 22k entries file that I had. At least not in 5 or so minutes, before I got impatient. The performance was unacceptable even when I reduced it to 5k entries.

I was pretty sure it wasn’t that slow for Karl in his demo and tweeted to him, asking for a workaround. Meanwhile, I looked at his dot-emacs, but wasn’t able to dig out what was needed to speed up things. He confirmed that his performance was way better than what I was getting.

First, I ruled out the possibility of it being because of the SSD, since clearly my CPU usage was peaking, and the task was CPU bound and not I/O. Next, I tried using the same file on a different machine (with a different version of Emacs and org-mode), and it worked blazingly fast. So, it was either the version of Emacs or org-mode that I was using.

I should have stopped, thought clearly, and started experimenting with org version, but hindsight is 20-20. I tried Ubuntu’s pre-built Emacs and agendas were fast! I suspected my Emacs build, since I recently started building Emacs from git. I built two or three other versions of Emacs, and wasted a lot of time, before realizing that I wasn’t using the org-mode source bundled inside Emacs for the tests, and there were two “independent” variables.

Finally, I began bisecting org-mode’s source and found that all hell broke loose with an inconspicuous change around release 8.2.6. It turns out that org-overview was broken before this, and collapsing all the trees in a newly opened org-buffer (default option) wasn’t working. Once this bug was fixed, opening huge org files would slow down by a great deal, in turn causing agenda generation to be unbearably slow.

All I had to do was add a #+STARTUP: showeverything to the top of the file. This speeded up things by about 50 times! It turns out, I later found out, that all of this is documented on Worg. I did try a few search engine queries, but sadly none of them brought this up. Adding the following to my config, speeded up agenda generation by about 150-200 times!

(setq org-agenda-inhibit-startup t) ;; ~50x speedup
(setq org-agenda-use-tag-inheritance nil) ;; 3-4x speedup

In the course of all this debugging, I learnt how to use Emacs’ profiler. The profile reports along with git bisect, eventually helped me figure out what the problem was.

To profile the CPU usage, all you have to do is add a call like

(profiler-start 'cpu)  ;; or M-x profiler-start

at the place where you wish to start it. Emacs will then start collecting information about where time is being spent, by sampling every sampling-interval seconds (default 10^6 nanoseconds = 1 milli second).

You can view the information being collected, at any point of time using

(profiler-report) ;; or M-x profiler-report

The report is a nice, interactive tree with the percentage of time spent in each call. You can stop profiling by calling (profiler-stop). If you have more than one report, you can compare them by hitting = in one of the report buffers. I’m definitely going to use this for other things! (like speeding up my startup?)

Now that I have Memacs working with reasonably fast agenda views, I’m looking forward to collecting as much personal information as I can! Thanks Karl for writing Memacs. I am going to be a pretty heavy user, I think! There seem to be a few rough edges, though, and I hope to help smoothen them out a little bit, over the next few weeks.

More input sources for org-drill

Tue, 04 Nov 2014 00:00:00 +0530

I’ve been trying to use org-drill regularly for the last few weeks. I don’t know how well it’s been going but I have been sticking to the routine religiously. I haven’t yet really tried out incremental reading, but in an attempt to make it as easy as possible, I wanted to have a pdf-reader integration, and some kind of integration with Kindle highlights. Browser integration is pretty straight-forward, thanks to some simple java-script.

I looked for a pdf-reader with some sort of plugin support, but I found nothing in Evince or Okular. I thought about pdfjs but it seemed slightly clunky to open pdfs in a browser, though I might shift to this if I don’t like what I finally ended up with. Good old xpdf seemed to be the only pdf reader that had some support for custom keybindings that allowed users to run external commands. With a little Python, I was able to setup a work-flow to capture snippets from xpdf, to add to org-drill. Custom key-bindings somehow don’t seem to work on xpdf bundled on Ubuntu. So, I ended up downloading and using the binary available on the xpdf site.

For Kindle highlights support, with minor updates to Thamer Mahmoud’s clip2org, I have a simple way of getting all the “new” clippings/highlights as org-drill headlines. I haven’t really started using this, and once I do, I may end-up automating even the merging of these items into the org-drill notes file. I’m looking forward to making better use of my Kindle, with this feature!

I don’t know if it would be useful to have more context information like section titles/chapter titles when capturing from html/pdf, but it seems like an interesting problem to try to solve.

Also, it might be easier(?) if I probably tried to have a DE level keybinding, and some code to get selection and file name of the currently active window/application.

Simple org-clock and gnome/pidgin integration

Wed, 22 Oct 2014 16:43:35 -0400

See update below

I have been trying to get back to using org-mode and its clocking functionality, more often than not. I used to use it a lot, a few years ago, and haven’t been using it, since I had been in my last job.

To help with it, I decided to integrate clocking in and out with changing status on Pidgin, and turning notifications on and off in Gnome. Here’s a few lines of code that does this for me.


(defadvice org-clock-in (after pc/org-clock-in (&optional select start-time))
  "Turn gnome notifications off."
  (dbus-send-signal
   :session
   "org.gnome.SessionManager"
   "/org/gnome/SessionManager/Presence"
   "org.gnome.SessionManager.Presence"
   "SetStatus" 2)
  (shell-command "purple-remote setstatus?status=unavailable"))

(defadvice org-clock-out (after pc/org-clock-out (&optional switch-to-state fail-quietly at-time))
  "Turn gnome notifications back on."
  (dbus-send-signal
   :session
   "org.gnome.SessionManager"
   "/org/gnome/SessionManager/Presence"
   "org.gnome.SessionManager.Presence"
   "SetStatus" 0)
  (shell-command "purple-remote setstatus?status=available"))

Update <2014-11-01 Sat>

@baali tried to use my code, and it turns out it didn’t work for him, because I forgot to mention that (ad-activate 'org-clock-in) needs to be run, after the defadvice code. I have no idea how it worked for me, without doing that. May be because I have defadvice for other functions?

Also, while debugging this, I found that defadvice is a deprecated way of doing this, and add-function is the way to go now. But, instead of advising the function, I decided to make use of org-clock-in-hook.

Here is the new code.

(defun pc/turn-off-notifications ()
  "Turn gnome notifications off."
  (dbus-send-signal
   :session
   "org.gnome.SessionManager"
   "/org/gnome/SessionManager/Presence"
   "org.gnome.SessionManager.Presence"
   "SetStatus" 2)
  (shell-command "purple-remote setstatus?status=unavailable"))

(defun pc/turn-on-notifications ()
  "Turn gnome notifications back on."
  (dbus-send-signal
   :session
   "org.gnome.SessionManager"
   "/org/gnome/SessionManager/Presence"
   "org.gnome.SessionManager.Presence"
   "SetStatus" 0)
  (shell-command "purple-remote setstatus?status=available"))

(add-hook 'org-clock-in-hook 'pc/turn-off-notifications)
(add-hook 'org-clock-out-hook 'pc/turn-on-notifications)

Learning to use Org-drill

Tue, 14 Oct 2014 00:07:04 -0400

Org-drill is an Org-mode extension that provides spaced-repetition and flash-card functionality. It has a wonderful documentation on Worg, but somehow I couldn’t get myself to read the whole document, and setup org-drill, until now.

The setup is quite straight forward, once you have org-mode along with the contrib packages. Just (require 'org-drill), and you are all set! To add a new card, all you need to do is add a :drill: tag to the items you wish to “Org-drill”. You can start a review session with simply M-x org-drill. You will be shown flash cards, and you can rate how correct and comfortable you were, in answering the questions. Based on your responses, the cards are scheduled for review. Start another review session, whenever you need one!

What I could only understand once I got myself to read the whole document was that:

The default scope of a drill session is the current file. But, you can start sessions with scopes like current tree, current directory, or a specified list of files. This is super-useful!
The review sessions are not automatically scheduled, based on when you schedule failed flash-cards. Scheduling the review for a card only sets a due-date for them, and effects, what you are asked in your next session.

Cram mode and incremental reading are also things I want to try, as I go along.

Happy Learning!

Recurse Center, 2014-07-21

Tue, 22 Jul 2014 10:46:29 -0400

Yesterday

It was exciting to have so many new Hacker Schoolers in the space. But, the excitement was kinda distracting too.
I spent most of the day looking at shairport, and libshairport and trying to wrap it, so I can use it to get data for the spectrum analyzer via the Air-play protocol. I was able to call it using ctypes, but it doesn’t seem discoverable.
I also briefly looked at Julia and dwm, to try and port dwm to Julia. It doesn’t seem like too much work, but is going to take me a while given how comfortable I’m with both Julia and C.
Yaron Minsky’s talk on distributed systems was a great introduction to Distributed systems.
After the talk, I spent a little time updating my notes from an old org-mode workshop to present it at the emacs user group meet up today.

Today

I hope to get the spectrum analyzer to use libshairport and be able to play music sent through Air play.
Spend some time talking to the emacs user group about org-mode.
If I have any time, after getting this to work, I may play around with the dwm port.

Org based posts in Nikola

Sun, 20 Apr 2014 00:00:00 +0530

Chen Bin asked me to share my Nikola+Org work-flow, and share an example post.

The org source for any post can be found by changing the URL of a post from .html to .org.

I don’t have much of a work-flow, because I don’t post too often, but here is what I typically do, to make a new post.

I start off by creating a new post using

$ nikola new_post

and then give the post a title and start editing the post in Emacs.

I have a simple snippet that lets me insert tags, based on existing tags.

Once I’m happy with the content of a post, I run nikola auto to build the source and serve it locally, and see if the post “looks” reasonable, after being rendered.

Once, I’m happy with it, I commit the post and deploy it using nikola deploy.

I also have a plugin, that posts captured bookmarks and quotes onto the blog, with a single command. I should probably make the sources of my blog open, and push it onto GitHub.

Update [2015-05-13 Wed]

I use my own plugin for Nikola which lets me write posts in org-mode. There is a similar plugin by Chen Bin, that exports posts to intermediate html, that is then used by Nikola.
The source for my blog is now on GitHub
I also have custom elisp to be able to make a new post, and deploy the site from within Emacs.

Bookmarks and Quotes plugin

Sat, 19 Oct 2013 00:00:00 +0530

I used to have a separate page for bookmarks and quotes on the old blog. They will now be shared as regular posts with 5 or more bookmarks/quotes. I use a bookmarklet in my browser to capture links to an org-file using org-capture protocol and then I have a small plugin to Nikola, that looks at such captured bookmarks and quotes and makes new posts out of them. This workflow is inspired by Brett Trepestra’s web excursions plugin.

The plugin is currently a part of my blog source, and not published to Nikola’s plugin repository since it is very specific to my setup. But if anybody is interested, I can publish the code somewhere public.

If you are interested to get these links and bookmarks into your feed reader, you can subscribe to their feed: [quotes], bookmarks. These posts will also make it to the main feed, though.

UPDATE [2015-11-15 Sun 20:45]

The quotes feed no longer exists!
The bookmarks feed doesn’t really get too many updates. I use pinboard for my bookmarks, now.

Blogging with Nikola and Org-mode

Wed, 16 Oct 2013 00:00:00 +0530

Sigh! I made yet another change to the way this blog gets published. But, I have a feeling this mechanism, is here to stay!

We’ve been using Nikola quite regularly for our Ultimate site, and I quite like it. I’ve also contributed a bunch of features to Nikola to get it to work the way I would like it to. This weekend I ported my blog from o-blog to Nikola. The only thing that was stopping me from doing it, until now is the fact that all my posts are in org markup and porting them over to one of the formats that Nikola supports would be a PITA. So, I wrote a pretty simple plugin to Nikola to support posting from org files. And then with a little Python, I was able to move everything over to use Nikola.

Hopefully, I’ll keep my blog more updated, from here on!

Org-mode Workshop

Wed, 22 Jun 2011 00:00:00 +0530

Well, I’m not sure if it’s worth writing about. I conducted my first org-mode workshop along with Prof. Venkatesh Choppella at IIIT-Hyderabad. It was a 3 hour demo+talk kind of a thing, with a small audience of about 20 people, most of whom were new to Emacs.

We covered almost all the aspects of Org-mode after giving a brief introduction to Emacs. Outlining and note-taking part was simple and easy to understand, but the audience couldn’t really appreciate the part of keeping TODO lists and agendas and other stuff. I’m hoping, the reason was not me taking over from Venkatesh.

I think the workshop should’ve been more hands-on and we should’ve asked people to try out stuff on the spot, instead of showing off the things possible with Emacs. They probably would’ve appreciated a few things better, that way.

Hopefully, we will be doing more workshops on Org-mode and there are surely somethings to take away from this one. I hope at least one of the participants, gets hooked to Org-mode.

The talk outline is here.

Git powered wikis improved: My bit

Fri, 04 Feb 2011 00:00:00 +0530

I accidentally came across the blog-post Git-powered wikis improved - GitHub. And this particular paragraph caught my eye:

The new editor has the capability to support every markup language that GitHub Wikis support. If you’re a fan of Markdown, Textile, pod or RDoc, the function bar buttons (e.g. bold, italic, underline, etc.) will now work. We’ve even written brand new inline help for many of GitHub Wiki’s supported markup languages.

The language definitions the editor uses are JSON-based and easy to edit. If you’d like us to support a markup language that we don’t currently support, Gollum, GitHub’s wiki software, is entirely open source – fork our code and send us a pull request with changes that support your choice language.

I sent a quick patch for org-mode in the function bar, and it has been accepted. :)

If not anything more, I hope, at least a couple of curious people will explore org-mode and find it useful.

CHAGANTI 635888 Emacs

Thu, 03 Feb 2011 00:00:00 +0530

Puneeth Chaganti, hereby agrees as follows:

Developer hereby agrees to assign and does hereby assign to FSF Developer’s copyright in changes and/or enhancements to the suite of programs known as GNU EMACS, including any accompanying documentation files and supporting files as well as the actual program code.

Yay! I can now write code, that can go into Org-mode and Emacs! I’m looking forward to this!

Changes to Blog

Wed, 02 Feb 2011 00:00:00 +0530

Well, as you can see, I’ve changed my blog a bit. I had been trying to make it gel well with org-mode and looking for ways to allow me to share arbit stuff with separate feeds for tags, separate pages with independent feeds, etc.

I finally got around to tweaking the code of reprise to be able to do this. There are still a few things I would like to change, but I’ll make the changes gradually. The looks are also straight from uddegal’s [[reprise, with a few tiny tweaks. I hope it is alright to be using it. I really liked the theme.

Every tag now has a separate feed. /tags/emacs.atom will give you the feed of emacs for instance. Also, I plan to have a couple of more pages, one for all the interesting links I come across and another for interesting quotes. Both of these pages, have their own feeds too (quotes.atom and links.atom).

In the spirit of minimalism, I got rid of comments. I’ve been looking for ways of having comments without all the javascript cruft from disqus, but I didn’t find any satisfactory way to do this. So, the site will have no comments. You can write to me, in case you’ve something to say to me.

Adios.

Why I like Org as a markup

Wed, 12 Jan 2011 18:00:00 +0530

Org-mode, as a mode, is obviously awesome. The ability to move around whole blocks of text, for re-organizing documents and the usability of tables are just two brilliant features.

But, the org markup itself is such a cool thing. I’ve been looking at rst all day, and it’s such a pain to find out where your headings are, what level your current sub-heading is at, etc. (I’ll probably do a bit better, with some getting used to. I’m an org-addict. ;)). With org-mode it’s so intuitive! It’s so easy to find out, with just one quick look! I don’t think any other markup has this coolness! Org-mode FTW!

Pandoc can now do Org

Mon, 06 Dec 2010 00:00:00 +0530

Pandoc is a haskell library and a command line tool, that can convert markup from one to another and it does it pretty well. Until now it supported quite a few markups, but not orgmode. But now, Orgmode support has been added! Yay!

But, it can only read from other formats and write to org-mode format. The other way around, is not possible, but you can do that straight from org-mode, right?

I’ve often felt the need for an org-importer and hence decided to do something about it. I stumbled upon Pandoc, when I was moving my blog, and found it pretty neat. After, yet another request for an importer, on the org-mode mailing list, I decided to look at Pandoc. I was somehow under the impression that it was written in Python. But it turned out, I had to learn Haskell! A good excuse to learn a new language, eh? I brushed through a tutorial for a couple of days (and was blown off by the paradigm of the language) and was able to port the RST writer in Pandoc, to an Org writer. :)

You can get the latest version from here

WP to org-mode + hyde + disqus

Fri, 22 Oct 2010 00:00:00 +0530

Hello World!

My first post at my new home. Obviously, it was going to be about the move. You knew it, didn’t you? ;)

Well, I got some space on the web, along with a few friends. Thanks to my org-mode fanboyism, I now use it to maintain my homepage. I’ve successfully completed import of my Wordpress posts and comments. :)

I now use

Emacs and Org-mode ¹ to write my posts.
org-hyde.el ² to publish html in a hyde parse-able format.
hyde ³ to convert the html pages into a blog.
org-publish to publish other pages in my home page.
git ⁴ and a bash script for publishing.
Disqus ⁵ for the comment system.

Yes, I know it sounds rather complicated. :) But, now that I have it set up, it’s not all that difficult to make a post. It’s just a matter of one git commit and push. I need to fine-tune the shell script a bit, though.

How I moved

The move definitely wasn’t trivial. I guess, I could’ve started afresh but, what fun would that have been? ;)

This roughly how I did things – in the order that I did them.

Choosing `hyde`

I looked at a handful of options to maintain a blog, using org-mode — blorg, org-jekyll, blorgit, ikiwiki. After some assessment, I decided upon org-jekyll and jekyll. But then, I accidentally stumbled upon hyde.

I decided to go with hyde instead of jekyll ⁶ since

It’s in Python. I didn’t want to start figuring out Ruby, now.
It uses Django templates ⁷. And Django is something, I wish to learn. I’ve started with that. :)

Clean up `org-jekyll` to work with `hyde`.

I then “ported” org-jekyll.el into org-hyde.el.

removed stuff like categories and languages, that I was not going to use.
Added some code w.r.t timestamps, from org2blog, to it, so that my older org2blog posts could be easily ported.

Clean up older org2blog posts

org2blog can post either buffers or subtrees. I had posts in both formats. I converted all of them into subtrees of one tree, using some Python.

Import older posts

This was the most painful posts. Importing all the old posts from Wordpress. org-mode really needs a XHTML/XML importer!

I did all sorts of crazy stuff to get this done.

used pandoc to convert html to markdown
wrote some throw away regex code to convert markdown to org-mode.
wrote more regex code to convert html to org-mode.
hacked up a lot of stuff and finally got all the posts into org format! :)

A workflow for publishing

Set up git along with some bash code, to have a mechanism to minimize the effort in making a blog post. All this is still a lot of work, compared to the ease with which I used to use org2blog. That’s partly due to ssh restrictions in my hostel.

CSS clean-up

I’m using the same CSS for org-mode published files and hyde published files. I had to clean up my hyde templates and the CSS to make both of them look similar.

My first tryst with CSS hasn’t been all that bad. :)

Installing disqus and importing comments

Using disqus was one thing, I wasn’t sure I wanted to do. I would’ve loved it if comments could be managed with org-mode too. ;) ⁸

Anyway, I finally decided to go with it, and I’m quite happy with it. :)

I loved the ease with which comments could be imported.

Import Wordpress comments using the export xml file.
Generate a CSV file containing the URL map – mapping the newer urls to the older ones.
Upload the CSV file and tada!

Conclusion

I got to learn quite a few things, during all of this. I also have some bits of code, that I can share with you, in case you are interested. Leave a comment, if you wish. :)

I’m just hoping to reduce the additional steps required in publishing to ensure it doesn’t add to my already erratic blogging habits.

Org-mode - Homepage ↩︎
Org-hyde is a port of org-jekyll.el ↩︎
Hyde - Github ↩︎
Git - Homepage ↩︎
Disqus - Homepage ↩︎
Github - Jekyll ↩︎
Documentation - Django Templates ↩︎
I feel it is capable of doing that. It’s just my incapability that prevented me from trying it out. ↩︎

Some fun from #org-mode

Sat, 02 Oct 2010 00:00:00 +0530

This is a conversation from #org-mode, published without permission from plovs, BerntH and bremner. If any of you want any of the content removed, I will do so.

hi all

hi punchagan [18:36]

BerntH: ever used/tried blorg or blorgit? [18:47]

I like the way org-publish works, but blorg exports one org file as a blog. If blorg were to be re-written on top of org-publish, how should it be done? use one file per post or just one file for the whole blog? [18:52]

punchagan: another option is to use ikiwiki and use the org-mode plugin to render pages. This is what i do, although only a bit of the site is in org. [19:44]

bremner: can I have a look at your site? [19:45]

sure, it ain’t pretty, but: www.cs.unb.ca/~bremner [19:46]

thanks. I’ll keep this in mind. [19:47]

I just loved the way this site looks and behaves – http://julien.danjou.info/projects.html

well, the side bar at least is possible with ikiwiki. Other than that I suppose it is mainly a matter of css [19:48]

punchagan: nope [19:49]

ok BerntH [19:50]

punchagan ikiwiki does have an org-mode plugin [19:56]

plovs: yes, bremner told me that and I’ve seen on Worg too. :)

punchagan ah, yes, sorry

plovs: it’s alright. [19:59]

punchagan another possibility is org2blog, which uses wordpress

plovs: I’m the author of it. :D

lol, ik, that punchagan [20:17]

lol

plovs: were you kidding? or serious? [20:19]

punchagan sorry to say i was serious, but it will not happen again :-)

i really like org2blog, played with it yesterday

plovs: no. I was just wondering if you were playing around with me. :P

I’m happy some one thinks it is useful.

lol, no, i just didn’t recognized your name, although it is kind of hard to miss [20:21]

I hope you don’t mind, if I make this anecdote public?

org/elisp - sorting list of org-links on description

Fri, 20 Aug 2010 00:00:00 +0530

A small utility function that I used to sort the names of people who commented on my blog.

(defun org-get-link-desc-from-list ()
  """ Get link description of a list item containing just links """
  (let* ((item-beg (point))
       (item-end (org-end-of-item))
       (cur-item (buffer-substring-no-properties
                  item-beg item-end)))
    (goto-char item-beg)
    (org-columns-compact-links cur-item)))

sort-lines wasn’t good enough for me, since it was sorting alphabetically and it ended up being the sorted order of the urls and not the names. This function, when used with org-sort-entries-or-items gave me what I wanted.

Thanks to benny (on #org-mode), I also learnt the difference between let and let*.

Refile to date-tree

Fri, 30 Jul 2010 00:00:00 +0530

Useful to refile notes to the journal file, which is a date-tree. org-refile isn’t convenient to refile stuff to a date-tree.

(defun my/org-refile-to-journal ()
  "Refile an entry to journal file's date-tree"
  (interactive)
  (require 'org-datetree)
  (let ((journal (expand-file-name "journal.org" org-directory))
        post-date)
    (setq post-date (or (org-entry-get (point) "TIMESTAMP_IA")
                        (org-entry-get (point) "TIMESTAMP")))
    (setq post-date (nthcdr 3 (parse-time-string post-date)))
    (setq post-date (list (cadr post-date)
                          (car post-date)
                          (caddr post-date)))
    (org-cut-subtree)
    (with-current-buffer (or (find-buffer-visiting journal)
                             (find-file-noselect journal))
      (save-excursion
        (org-datetree-file-entry-under (current-kill 0) post-date)
        (bookmark-set "org-refile-last-stored")))
    (message "Refiled to %s" journal))
  (setq this-command 'my/org-refile-to-journal))

(defun my/org-agenda-refile-to-journal ()
  "Refile the item at point to journal."
  (interactive)
  (let* ((marker (or (org-get-at-bol 'org-hd-marker)
                     (org-agenda-error)))
         (buffer (marker-buffer marker))
         (pos (marker-position marker)))
    (with-current-buffer buffer
      (save-excursion
        (save-restriction
          (widen)
          (goto-char marker)
          (org-remove-subtree-entries-from-agenda)
          (my/org-refile-to-journal)))))
  (org-agenda-redo))

(org-defkey org-agenda-mode-map (kbd "C-c C-S-w") 'my/org-agenda-refile-to-journal)
(org-defkey org-mode-map (kbd "C-c C-S-w") 'my/org-refile-to-journal)

Enjoy!

Update [2016-06-16 Thu] Raam Dev pointed me to an issue and a suggested fix, that I have updated the above code with.

numpy, pacman and me

Sun, 31 Jan 2010 00:00:00 +0530

I’m now officially a part of the Arch Linux community! Arch Linux is a lightweight and flexible Linux® distribution that tries to Keep It Simple.

I have started using arch from less than a week or so. It took me a while, not too long, to realize the beauty of this distro. I was trying to tweak the settings of my org-mode’s remember (on Karmic), trying to make it work the way I liked it. After breaking my head with .emacs and lisp for a while, I realized the version of my org-mode was way different from the version of the docs, I was reading. It didn’t take long to figure out, which version of org-mode to get. As a matter of curiosity, I checked AUR for the version, and true to Arch’s reputation it was bleeding edge! I was still using Karmic, since I hadn’t got my Arch installation working the way I like it, yet. Out of laziness. sudo reboot; to hell with laziness!

I was setting up things I regularly use, tweaking my way around. After a day or so, I find python-numpy is out of date. And to top it, an orphaned package! I didn’t feel one bit good about this. After some futile attempts to suppress my discomfort, I sat down to work.

After an afternoon of effort, I created my first PKGBUILD. :) I now have python-numpy installed using pacman! Pleasure to join the Arch User Community! Also, thanks to lifeeth and Lynus Vaz, for the sparks.

PS: I’m using Arch with Openbox. It’s neat! PPS: org-mode is really awesome! It’s a world in itself. life in plain text, truly!]