Stebalien's Blog

Replacing Git-Link with Forge

2025-10-06T22:13:45+00:00

I recently learned that, as of v0.4.7, Forge’s forge-copy-url-at-point-as-kill command works on files and regions (like git-link). That is, when visiting a file inside a git repo, forge-copy-url-at-point-as-kill will copy a (web) link to the current file if the region isn’t active and will copy a permalink to the selected lines if the region is active. This completely replaces the git-link package for me.

Even better, because it’s a part of the Magit family:

It can copy links to commits in Magit’s blame buffers, log buffers, etc.
When visiting a file at a specific commit (e.g., by pressing RET on a diff hunk or a Magit blame section), it copies links at the commit in question.
It works in Magit status buffers, etc.

The downside is that it doesn’t integrate with VC, but if you’re using Magit that’s not going to be an issue for you.

Email actions in Emacs (notmuch)

2025-08-26T03:38:02+00:00

A few years ago I wrote microdata.el, an Emacs package for extracting and acting on microdata in email. Since then, I’ve been using it daily to open Discourse and GitHub PR/issue notifications from notmuch with a single keypress (C-c C-c) instead of having to find and click on the appropriate link.

Many automated emails include structured metadata using either JSON-LD and/or Microdata. Adoption isn’t great, but code forges like GitLab and GitHub use this to include metadata in their notifications indicating how to view the associated issue/PR/etc. in the browser.

This package provides commands for reading and acting on this metadata.

Configuration

You can install the package with the built-in use-package-vc (or straight, or Elpaca, etc.). I’ve never bothered to publish the package to MELPA so you’ll need to directly fetch it via git.

(use-package microdata
  :vc (:url "https://github.com/Stebalien/microdata.el"))

I distribute a notmuch integration library along with the package. However, there’s no reason it wouldn’t work with mu4e or Gnus (but you’ll have to write that integration yourself).

For notmuch, you can set it up like this (assuming you already have the microdata package itself):

(use-package notmuch-microdata
  :bind
  (:map notmuch-show-mode-map
  "C-c C-c" 'notmuch-microdata-show-action-view
  :map notmuch-search-mode-map
  "C-c C-c" 'notmuch-microdata-search-action-view))

With this configuration, pressing C-c C-c in the notmuch search view or when viewing an email will open the default action URL (typically the issue, PR, or forum thread) in your browser.

Matching GMail

Unfortunately, this package will never be able to compete with GMail’s built-in actions feature. Given recent advances in language models, applications like GMail simply read the email itself so there’s little pressure for senders to standardize on structured metadata in standard formats.

Dim Unfocused Minibuffer Prompts

2025-09-26T19:00:00+00:00

I can easily tell if an Emacs buffer is focused by looking at the buffer’s mode-line. On the other hand, the only indicator that the minibuffer is focused or not is the cursor, and that’s pretty easy to miss.

I wanted to avoid making any intrusive changes to the minibuffer, so I decided to style the prompt based on whether the minibuffer is focused. When not focused, I remap the minibuffer prompt face to shadow.

Focused:

Unfocused:

The code is pretty simple:

(defvar-local steb/focused-minibuffer-face-remap nil
  "Face-remapping for a dimmed-minibuffer prompt.")

(defun steb/focused-minibuffer-update (w)
  (when (eq w (minibuffer-window))
    (when steb/focused-minibuffer-face-remap
      (face-remap-remove-relative steb/focused-minibuffer-face-remap)
      (setq steb/focused-minibuffer-face-remap nil))
    (unless (eq w (selected-window))
      (with-selected-window (minibuffer-window)
        (setq steb/focused-minibuffer-face-remap
              (face-remap-add-relative 'minibuffer-prompt 'shadow))))))

(defun steb/minibuffer-setup-focus-indicator ()
  (add-hook 'window-state-change-functions 'steb/focused-minibuffer-update nil t))

(add-hook 'minibuffer-setup-hook #'steb/minibuffer-setup-focus-indicator)

My approach was heavily inspired by this Emacs Stack Exchange answer, but I tried to simplify the implementation and make the styling a bit less intrusive.

Grammar Tools in Emacs

2025-07-14T14:35:34+00:00

Up till now the only prose checker/linter I’ve used in Emacs is jinx. It’s an amazing spell checker for programmers and technical writers: it handles snake_case and CamelCase symbols, knows what to spell-check based on the text’s face, etc. Unfortunately, it’s just a spell checker and won’t catch any grammatical errors.

Now I’m looking for a local (offline) grammar checker. Something to catch stupid mistakes: repeat words, cut off sentences, tense disagreements, homonyms, etc. I tend to jump around a lot when writing and want a tool that’ll tell me when I started a sentence in one tense and finished it in another, or failed to finish it entirely. Ideally the tool would also provide general writing advice — wording improvements, etc. — but I’ll probably need a full language model for that.

Vale

I first tried Vale because it’s by far the simplest option and has great support for markup languages and can even lint prose within source code. To be honest, it looks like a great choice for teams that want custom rule-based prose linting. Its primary power is the expressivity of its rules allowing organizations to set and enforce writing standards (e.g., “don’t start a sentence with ‘but’”). Unfortunately, it’s not a general-purpose grammar checker, and I’m not trying to conform to some specific set of writing stylistic rules.

However, if that’s what you want, vale has great Emacs integration via flymake-vale. I say great because (a) it uses flymake (no language server setup required) and (b) only checks changed text making it very fast and lightweight.

Harper

Next I tried Harper. Like Vale, it’s mostly rule-based. However, it’s more focused on providing general-purpose writing tips than on enforcing specific stylistic rules: it can catch repeat words and tell me when a sentence is too long; it has some very basic grammar rules and can catch article/noun disagreements (a/an); it even has some rules to catch “it’s” versus “its”. I hate it.

Harper thinks “given its computed value” should be “given it’s computed value”.
Harper won’t catch errors like “Go to a the park.”
Harper likes to harp on “mistakes” like “long” sentences.

Harper is like that middle-school english teacher with their highly rigid rules about writing: great for teaching good habits to the notice writer but, at this point, I’ve ingrained them. When I break these rules, it’s (usually) because I meant to break them.

What I need is a tool to help me catch stupid errors and/or a tool to help improve the flow of my writing. Harper is not that tool.

Worse, the only Emacs integration I found was harper-ls, a language server. In Emacs specifically, this has a few downsides:

Eglot (the default language server package in Emacs) only supports a single language server per buffer, so I can’t use Harper along with some other language server.
Eglot expects Language Servers to be used in “projects” and will enumerate all project files when it starts the language server. Starting a language server in my home directory takes forever as it tries to enumerate all my files (including my backup snapshots…).
Eglot will start one language server per project (in this case, often per directory).

However, if you really want to use Harper, you can trick Eglot into treating all documents (with the same major mode) managed by harper as if they were in the same project. If you don’t care, skip to the next section.

First you’ll need to define a new project type for harper. In my case, I “root” the project in a guaranteed empty directory.

(cl-defmethod project-root ((project (eql harper)))
  "/var/empty")

(cl-defmethod project-name ((project (eql harper)))
  "harper")

This virtual “harper” project contains all files managed by the harper language server. Honestly, it’s probably OK to simply return nil here.

(cl-defmethod project-files ((project (eql harper)))
  (when-let* ((server (cl-find-if #'eglot--languageId
                                  (gethash (eglot--current-project)
                                           eglot--servers-by-project))))
    (mapcar #'buffer-file-name (eglot--managed-buffers server))))

Finally, add a project “finder” function that puts all buffers that would be managed by harper into the “harper” project, if and only if we’re acting on behalf of Eglot (eglot-lsp-context is non-nil).

(defun project-try-harper (dir)
  (and eglot-lsp-context
       (string= (cadr (eglot--lookup-mode major-mode)) "harper-ls")
       'harper))

(add-to-list 'project-find-functions #'project-try-harper)

LanguageTool

Finally, I broke down and set up LanguageTool: it’s by far the most advanced free-software grammar tool. The next step-up is Grammarly and/or LanguageTool’s online offering, but I absolutely refuse to use a remote grammar tool (I’m not sending all my notes, etc. to someone else’s server).

Unfortunately, it’s definitely a heavyweight. It uses at least 2.5GiB of memory, and you’ll need the 14GiB n-gram database if you really want it to do its job. On the other hand, it’s leagues beyond Harper and Vale in terms of catching grammatical mistakes.

In terms of Emacs integration, I ended up creating a fork of flymake-languagetool that has improved performance (avoids re-checking the entire document on change); excludes markup, code, etc. before sending text to LanguageTool instead of filtering errors afterward for improved accuracy/performance; and renders diagnostics in the correct location even when Emoji are present in the buffer. I considered using a language server, but I had enough of that with Harper.

I recommend you find a good LanguageTool docker container or something because setting it up from scratch isn’t a fun exercise. However, if you’re like me and (a) use Arch Linux and (b) avoid sketchy docker containers, read on.

On Arch, I installed the languagetool package from the extra repository (pick jre21-openjdk-headless when prompted), along with a few AUR packages: languagetool-ngrams-en, fasttext, and fasttext-langid-models. The fasttext packages are only used for language detection so they should be optional, but LanguageTool’s HTTP server complains if they’re not installed.

Next, you’ll need to create a configuration file to tell LanguageTool where to find everything:

fasttextModel=/usr/share/fasttext/lid.176.bin
fasttextBinary=/usr/bin/fasttext
languageModel=/usr/share/ngrams

You’ll need to pass --config /path/to/my/config.properties to the languagetool command (which you can configure via flymake-languagetool-server-command and flymake-languagetool-server-args:

(setopt flymake-languagetool-server-command "languagetool"
        flymake-languagetool-server-args
        '("--http" "--allow-origin" "*"
          "--config" "/path/to/my/config.properties"))

That’ll get you a basic functioning LanguageTool server.

Taming Org-Mode With Side Windows

2025-07-03T17:31:42+00:00

Org-mode will, occasionally, pop up a window that takes over half the screen. Specifically, this happens to when:

Capturing a note (org-capture): I get a half-screen window asking me to select the capture template.
Inserting a timestamp (org-timestamp): The calendar takes over half the screen (assuming org-read-date-popup-calendar is non-nil).

This is especially annoying in the second case because the calendar window invariably covers the window I’m referencing while taking notes. That is, I usually take notes with the following setup where the red window is the selected window and the gray window is some document I’m referencing.

In this case, attempting to insert a timestamp in my notes causes a calendar window to pop-up, covering the reference window:

The solution is to use side windows. E.g., I can put the calendar at the top of the screen above the notes/reference windows, replacing neither.

First, put calendar windows in a dedicated side-window at the top of the screen.

(setf (alist-get (rx bos "*Calendar*" eos) display-buffer-alist nil nil #'equal)
      '(display-buffer-in-side-window (side . top) (dedicated . t)
                                      (window-height . fit-window-to-buffer)))

Then, put org-capture template selection buffers in a side-window at the bottom of the screen, instead of taking over half the screen.

(setf (alist-get (rx bos "*Org Select* eos) display-buffer-alist #nil nil 'equal)
      '(display-buffer-in-side-window (dedicated . t)))

If you want to better understand Emacs window management, I highly recommend Mickey’s (of Mastering Emacs) excellent write up: Demystifying Emacs’s Window Manager.

Executable Org-Mode Files

2025-05-30T03:16:16+00:00

My Emacs config lives in a massive org-mode file and I often want to re-tangle from outside Emacs (because, e.g., I broke my Emacs session for some reason). I could just use a simple Makefile, but that’s no fun. Instead, I’ve turned my config into a self-tangling script by adding the following two lines to the top of my init.org file and marking it as executable:

#!/usr/bin/env -S sh -c 'emacs --batch --eval="(setq org-confirm-babel-evaluate nil)" --file "$0" -f org-babel-tangle'
# -*- mode: org; lexical-binding: t -*-

Now I can run ./init.org in my ~/.emacs.d directory and my config will tangle itself into the correct files.

This might sound like a weird gimmick – to be honest, it kind of is – but I’ve been tangling my config this way for years at this point and it “just works” with no dependencies other than Emacs.

A similar trick can be used to execute all org-babel blocks in an org-mode file, making org-mode a viable meta-scripting language for tying together scripts written in different languages – even scripts executing across multiple machines via TRAMP.

#!/usr/bin/env -S sh -c 'emacs --batch --eval="(setq org-confirm-babel-evaluate nil)" --file "$0" -f org-babel-execute-buffer'
# -*- mode: org; lexical-binding: t -*-
#+TITLE: Hello World

#+BEGIN_SRC elisp
(message "Hello World!")
#+END_SRC

Letters From A Maintainer

2021-01-28T00:00:00+00:00

This blog post is a series of letters from me, an OSS maintainer, to anyone contributing code to OSS projects. My goal is condense haphazard advice into a single document and help contributors understand a maintainer’s perspective on OSS.

For some context, I’ve been an OSS maintainer of go-ipfs and go-libp2p for over 3 years now, along with some personal projects including tempfile (rust), and horrorshow (rust).

These letters mostly draw on my experiences maintaining go-ipfs and go-libp2p. While they should be generally applicable, they’re most applicable to systems programming in go.

Contributing

If every stumbled on a new project and wanted to help out but didn’t know where to start? This is for you.

Do: Triage issues, new and old

Triaging issues, new and old, is time consuming. Any amount of time a contributor can commit to this is helpful as the task often falls to the project’s maintainers:

Reproducing old issues to trim down the backlog.
Asking clarifying questions on new issues.
Finding and calling out duplicates.

Do: Help on the forums (and IRC)

You don’t need a deep understanding of a project to start answering questions on a project’s forums. Most questions can be answered with a bit of searching. The difference between you and the person asking the question is that you have confidence in your ability to find the answers yourself.

Additionally, that bit of searching will teach you about the project and open up additional avenues for contributing to the project.

Do: Add Documentation/Examples

Again, this is a great way to start learning about a project as it forces you to learn how it works.

Do: Add Tests

Nobody likes writing tests. Unfortunately, this means that tests are one of the things many projects need most. If you want to start coding on a new project immediately and want to better understand how its internals work, one of the easiest ways is to start writing new tests.

Look through the code for some example tests.
Look through the issue tracker for issues labeled “needs test”.
Use code coverage analysis tools to find areas of the code that are poorly tested.
Open an issue tracking which areas you plan on testing. This gives the maintainer a chance to give you feedback and suggestions before you start actually coding.

Do: Fix Bugs

Go through bugs marked “good first issue” and/or “help wanted” and start fixing them. Unless the project is rigorous about project management, it’s probably a good idea to leave a quick comment asking if you should fix the bug just in case the labels are out of date.

Honestly, many issues in OSS projects are small and just need someone to spend a few hours debugging them. However, these kinds of issues tend to pile up into an mountain that nobody wants to climb.

Don’t: Airdrop (large) Patches

I know you really want that amazing feature. However, that amazing feature may not fit in with the rest of the project and may conflict other in-flight endeavors. Read Writing Code For Review before submitting patches.

Don’t: Spam Ideas

We’re all guilty of this. We see a shiny new project and have so many ideas about how it could be improved! Concrete feature requests with concrete designs are awesome! However, if you’re new to a project, that’s probably not the best place to start.

A deluge of “I think this project should do X” requests are quite frustrating for maintainers. Unfortunately, your idea probably isn’t new to the maintainer. By raising it in an issue, the maintainer now needs to address the issue. Addressing and managing expectations (i.e., “we don’t have time for that right now”) around half-baked ideas is really time consuming.

If you’ve ever written up a long, revolutionary issue on how a project could improve by 10x and found yourself completely ignored, this is probably why.

If you have an idea, write up a short post on the project’s forum (if it exists). This makes it clear that the idea is for discussion and that there are no expectation that any maintainers and/or devs will implement and/or respond any time soon.

Note: This advice really depends on the project size and activity. For small projects with little activity, a thoughtful feature request here and there can very be welcome.

Don’t: Hijack

Please be very careful not to hijack a discussion. If you think you have a similar idea/bug as an existing issue but aren’t sure, just open a new issue. Unfortunately, popular OSS collaboration tools like GitHub don’t support threaded conversations. This means any off topic discussion will stick out as a large blob of confusion in the middle of a long technical discussion.

Code For Humans

While there are many techniques for structuring readable code, the three I find most useful when reviewing are:

Modularity/Composability
Isolation
Good Abstractions

The best way to learn how to write good code is to read code. Read lots of code, both good and bad. Writing code is not a substitute.

Note: This post is not a substitute for reading a good book on software architecture or taking a class. Please take the time to do so.

Modularity/Composability

When a system is built of smaller components, the reader can independently understand each piece in isolation and how they fit together instead of having to understand the entire system all at once.

This sounds obvious because it is. The non-obvious part is how to put this into practice. The main take away is: modular designs are worth the effort; if you find yourself working on a large, messy service, try breaking it into smaller pieces.

On the other hand, modularity can make things more complicated by introducing indirection. Be careful: If you have co-dependent services (services that know about and/or call into each other frequently), consider merging them.

The best way to avoid this is to clearly define a component’s responsibility up-front and define the interfaces between components as early as possible (ideally in a design document before you even begin coding).

Isolation

Independent subsystems should behave and/or fail independently. For example, if two subsystems use a shared service, and one of these subsystems cancels a request, this cancellation shouldn’t affect the other subsystem.

This rule is never up for debate as interference between seemingly isolated services is extremely difficult to debug. Always decide and document up-front whether a service/component is shared or owned.

Good Abstractions

Abstractions/APIs are the UX of programming. The actual behavior of an abstraction/API must conform to the user’s expectation of that abstraction/API. Unfortunately, this is mostly subjective.

Advice:

Read tons of code. The more code you read, the more abstractions/idioms you’ll see and the better code you’ll write.
Use your code. This is the fastest way to find pain-points and affordance mismatches.
Take advice. If an experienced user thinks something is funky with your abstraction, pay attention. They’re your user.
Explain your abstractions to a rubber duck.
If you have to break your abstraction to access internals, it’s probably wrong or at least sub-optimal.

Examples:

A close method should close and cleanup all resources.
A close method should generally be idempotent (depends on the language) simply because it usually is (and is therefore expected).
In go, if a function returns a value and an error, the caller should be able to bubble the error up the chain and walk away. Specifically, the caller should not have to do anything with the value (e.g., close it).
If your code looks like it follows a well-known abstraction (e.g., one of the Go interfaces, etc.), it should actually conform to that abstraction. Familiarize yourself with your programming language’s standard & common libraries.

Breaking Changes

Breaking changes are changes that require downstream projects to react to changes made upstream. From least to most severe, IPFS and libp2p have the following interfaces that can “break”:

Compile-time APIs
Datastores/Databases
Network Protocols
Run-time APIs
Data Formats

Compile-time APIs

While annoying, compile-time API changes are the easiest to deal with as downstream projects usually either lock (e.g., with go modules) or vendor dependencies.

However,

Please don’t make breaking API changes for aesthetic reasons (unless you’re already breaking the API for other reasons). These kind of changes are extremely frustrating to downstream users.
Explicitly call-out all breaking changes when submitting a patch. These changes need to receive extra-careful attention, need to be called out in release notes, and may need additional review from stakeholders.

Database/Datastore

Changes to datastores/databases can be handled through an automatic migrations. However, while they’re supposed to be transparent, such migrations often take time and can fail catastrophically if not implemented correctly. Either avoid these kinds of changes or test your migration thoroughly.

Network Protocols

Network-protocols can evolve over time as long as a deprecation period is provided. However, this deprecation period gets longer and longer the more mature a system becomes.

The process usually looks like:

Add a new feature.
Wait some time (adoption period).
Enable the new feature by default and deprecate the old feature.
Wait a long time (deprecation period).
Remove the old feature.

Luckily, IPFS and libp2p are not yet mature enough for this to be a major issue. Users tend to update regularly so network-protocol deprecation periods can be as short as a few months.

Run-time APIs

Changes to run-time APIs are problematic because, unlike compile-time APIs, the end-user is responsible for dealing with incompatible run-time APIs. That is, the developer deals with compile-time API changes when compiling/distributing their app. The end-user deals with run-time API changes when they update their IPFS daemon or their Linux kernel and their app breaks.

Worse, downstream apps are often unmaintained. For compile-time APIs, this isn’t really an issue: different apps can be compiled against different versions of the same dependency (usually). For run-time APIs, this is a significant issue as one can usually only have one copy of the runtime dependency.

This is what Linus is talking about when he says “we don’t break userspace”. The Linux kernel breaks compile-time APIs all the time and expects module maintainers to update their code. However, ancient, unmaintained applications should continue to “just work”.

Data Formats

Removing support for old data/file formats is difficult to impossible. When data is structured and managed by some database, one can use migrations to migrate from one format to another. However, this doesn’t apply to the general case.

Users will backup files and then try to read them years later. They should be able to do so.
Data format changes are difficult to reconcile with content addressing (used everywhere in IPFS).

Really, it’s the second point here that makes removing support for old data formats (nearly) impossible. Re-formatting data changes the content address (at least in IPLD) which would break links to the data. Basically:

IPFS doesn’t break links.
IPFS can’t force-migrate data.
IPFS can’t remove support for old data formats.

Parallel Programming & Locks

Concurrent programming is easy(ish); just take a global lock and try to avoid deadlocking. Parallel systems programming is hard because it usually involves multiple complex synchronization primitives and multiple services all trying to maximally use multiple cores without blocking each other.

While it can be learned through practice, I highly suggest that you read a book on the theory (e.g., The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit). However, if you only learn one thing, learn this: locks are not pepper. Don’t pepper your code with locks and expect it to work.

First, we need to understand what a lock does. While a useful simplification, a lock does not, strictly speaking, “protect some variable(s)”.

The primary purpose of a lock is to protect a critical section where invariants are violated. For example, adding a key/value to a map (in Go) takes multiple instructions. Overall, this sequence of instructions leaves the map in a consistent state. However, the state of the map is not consistent while these instructions are being executed. If another thread attempts to read the map while it’s being updated, the read will try to operate on an invalid data structure and fail in unpredictable ways.
The secondary purpose of a lock (and most other synchronization primitives) is to prevent certain optimizations that are valid in a single-threaded context but invalid when observed from a separate thread. Before attempting to write a parallel program in a new programming language, you should read that programming language’s memory model (for example, the go memory model.

The most important part of using locks and synchronization primitives is to be consistent and deliberate:

Clearly document thread-safety. Specifically, which functions can be called at the same time and which can’t.
Never use locks “just in case”. If you don’t know if you need a lock or not, your code is buggy.
When you decide to use a lock, clearly document and consider the invariants maintained by the lock. For example, in Go, use the mutex “hat”.

Writing Code For Review

This post covers how to take a patch from an idea to a merged feature.

Before writing code

Before writing code, sit down and write up an issue describing the change you intend to make. Up-front discussion in can avoid having to scrap/rewrite/rework code during a review.

Please do this even if your code is perfect and well tested:

It may interact with other subsystems or in-flight projects that you aren’t aware of.
The feature may simply not be a high enough priority to warrant the maintainers attention. Reviewing code takes time.
The subsystem you’re modifying may have undocumented errata/bugs that need to be fixed first. While these issues should have been documented, should has little impact on reality.
The feature may introduce a significant maintenance burden. Code is never written and forgotten, the maintainer will need to move, fix, and update your code as the project changes.
The feature may not fit in with the goals of the project. That doesn’t mean it’s not useful, it just means it’s out of scope.

Remember, you see the project through the lens of what you need to achieve your goals. The maintainer sees it as a collection of interacting features, interfaces, and subsystems that they’ll need to maintain into the future.

Before submitting a patch/PR

Before submitting a patch/PR, run through the following list.

Cleanup

The first step when submitting a patch is to clean it up.

Avoid dead code.
- Even when documented as “dead”, it will bit-rot.
- When not clearly documented as dead, your reviewer will waste time reviewing it.
Never leave in commented-out code with no explanation of why it’s commented out. This usually indicates that some debugging logic got left behind.
Use a linter. For Go, I recommend golangci-lint.

Testing

After cleaning up your code, the next step is to make sure that the remaining code is well tested. Bugs caught in review waste quite a bit of time.

Test coverage is nice but not the end-all-be-all. Never trust your test coverage and don’t bother shooting for 100%. You’ll end up wasting time testing every error path instead of stressing the critical paths.
Systems programming is different. The concern is rarely “does this function work in isolation”, it’s usually “does this function/subsystem work when interleaved with everything else?”
- Write parallel stress tests. Even if they’re not deterministic, this will catch quite a few bugs.
- If you’re using Go, use the race detector go test -race.
Use it and/or integrate it before asking for review. You’ll likely want to rework your interfaces.
Explain your code to a rubber ducky (or your partner, a child, a wall, a friend (real or imaginary)). If you can’t easily do this, consider rewriting your code.

Note: TDD (test driven development) isn’t sufficient for systems programming. You’ll need to go back and write test-cases that stress your edge-cases and critical paths.

Documentation

Once your code has been tested, it’s time to go back through and fill in any documentation you may have left out along the way. It’s best to document as you go but you should always do an additional pass before submitting a patch for review.

Document most types and functions.
- Even if the type name is obvious to you, it may not be to others.
- Small internal or “idiomatic” types/functions don’t necessarily need to be documented.
  - Private error & result types.
  - Single-use helper functions.
Be brief. Use short sentences, short paragraphs, and plenty of punctuation and bullet points. Nobody wants to read an essay.
Small examples go a long way. Write them.
Specify implicit contracts: those not expressed in the types themselves.
- Is the function thread-safe? Under what conditions/assumptions?
- Can the function be called twice?
- Is it idempotent?
- Does it take ownership of the parameters?
- Can it panic?
Use comments to sign-post your code and call out interesting quirks.
- Comments are great for sectioning long functions. This is especially true for setup functions and/or request handlers.
- If you had to think about something while writing it, it should have a comment explaining your thoughts.
- If you had to fix a non-obvious bug, there should be a comment to prevent someone from making the same mistake.
- If it looks like something can happen but can’t, write that down. You’ll save someone some head-scratching later.
- If you write some code that looks useless, explain why it’s not useless or someone will remove it.
NEVER leave a comment that tells the reader to do/not do something without an explanation. Even if you’re the only one working on the project, you will almost certainly forget why when you revisit the code later.

Break It Up

Finally, when possible, pull small, stand-alone pieces out of large patches and submit them separately. This allows the reviewer to focus on the meaty changes.

Alternatively, break these separate patches into separate commits and clearly communicate that the patch should be read commit by commit.

At the end of the day, this step depends on the style of patch you’re submitting and the project’s policies. In go-ipfs, for example, cleanup patches with multiple small changes batched into a single patch-set are usually fine and save everyone time fixing merge conflicts.

Submitting a PR

The most important part of submitting a PR/patch is communication.

Clearly explain what’s being changed, why, and how.
Clearly communicate when something is ready and not ready for review.

For large changes, leave yourself a self-review.

Call out interesting changes.
Ask questions.
Ask for advice.
Call out alternative solutions that you’ve considered/tried.

For early feedback, submit a WIP patch with specific questions. WIP “please look, maybe” patches with no specific questions (code or design) are frustrating for reviewers as it’s impossible to know what’s done and what’s still WIP.

After submitting a PR

Code review is a discussion. It’s the responsibility of both the code author and the reviewer to work together to either merge or drop the patch.

Scope Creep and MVP

First, only you can prevent scope creep: It’s perfectly acceptable (and good!) to say “let’s punt that to a later PR”.

However, bugs, data races, potential DoS vectors, etc. are never acceptable. MVP means minimum viable product. Viable means bug free and useful.

On the other hand, explicitly unimplemented and/or partially implemented features are OK. However, a patch must never include a component that looks done but isn’t and, critically, should never reduce the stability of the program as a whole. Unimplemented/unfinished features that aren’t documented as such are bugs.

While partially implementing a feature, you may need to create a new interface that you know you’ll need to extend in the near future. When possible, make interfaces extensible from the start. When not, clearly document these interfaces as experimental/partial. Unfortunately, this isn’t always enough and the maintainer may ask you to finish the feature up-front.

Finally, don’t be a moving target. You will likely realize a better way to do something after submitting a PR. However, be careful to not repeatedly rewrite an in-progress PR as the previous review cycles will have been wasted.

Communication

You may have noticed the theme of this post: communicate clearly.

Clearly communicate when something is ready for re-review.
Clearly communicate when a review comment has been addressed.

A Two-Way Street

Review is a two-way street. The reviewer’s job is to find problems; it’s the author’s job to find and propose solutions. A good reviewer/maintainer will offer potential solutions and insights but don’t make your reviewer do all the heavy lifting.

This is especially true if you’re implementing functionality that the maintainer hasn’t explicitly requested. If you make the maintainer figure out how to plug the feature you need into the rest of the application, your patch will sit at the bottom of the pile until the maintainer has enough free time to figure it out (possibly indefinitely).

Finally, the less work a maintainer has to do, the faster they’ll be able to review code and the faster your patches will be merged. If a maintainer points out issues in your patch, offer potential solutions and indicate the ones you prefer. If a maintainer points out related changes that need to be made to take your change all the way through to completion, offer to make those changes. At the end of the day, unless you’re fixing a critical bug, you probably need your patches merged more than the maintainer does.

Becoming A Maintainer

Becoming a maintainer of an existing codebase involves understanding it to the point where you can confidentially review new patches and understand how they fit into the system as a whole.

There are three paths:

Rewriting/refactoring the codebase.
Reviewing code. This option forces you to read and understand the codebase.
Debugging issues, answering questions, and triaging bugs. Even more so than reviewing, debugging requires you to read and understand a codebase.

Unfortunately, the first option is only usually available when you’re the only maintainer so the only remaining choices are the second two.

Reviewing Code

Reviewing code is time consuming and it never gets easier; you just get better at it. Don’t expect to wake up one day and suddenly get a speed-code-review superpower.

Treat a code review like you would async pair programming. You should understand the code you’re reviewing better (literally, I’m not exaggerating just to make a point) than the author. You should be executing the code in your head. For parallel code, you’ll need to execute multiple parallel copies at the same time.

If you’ve been asked to review some code and you find yourself thinking “I don’t think I’m qualified to review this code”, that’s fine:

Review it as best you can anyways.
Ask someone to review the code as well.

If you do this enough, you’ll eventually be able to review patches on your own.

Debugging

Debugging is a skill and, the more you work at it, the better you’ll get, independent of the codebase. As an added benefit, the better you are at debugging, the better you’ll be at spotting potential bugs in your code as you write it. You’ll learn to recognize code “smells” and avoid them.

You will not magically get better at debugging by adding features or by fixing known/solved bugs. Once you’re practiced at debugging, being familiar with a codebase will help you debug faster however, the best way to get better at debugging itself is to debug unfamiliar systems with minimal information.

The key takeaway here is: debugging, especially debugging unfamiliar systems with little information, is a skill you need to invest time in. If you hand off hard issues to “someone who knows better”, you’ll never get better at it.

Being A Maintainer

Maintaining a large OSS codebase with many users is a rewarding experience. You often get to work directly with users to address their problems and with contributes to merge their patches. You make things happen.

However, maintaining an OSS project with a sufficiently large user-base will be frustrating at times.

Saying No

As a maintainer, your job is to have a high-level view of the project, figure out how all the pieces will fit together, and, ultimately, to say yes or no.

You will say no to many well-intentioned patches:

Good patches that implement useful features that are out of scope for the project.
Patches that require more work than they’re worth to bring into a mergeable state.
Correct but convoluted patches that you just don’t have time to review and/or simplify.
Features that aren’t worth the maintenance burden. There are many good features that aren’t general-purpose enough to be worth maintaining.

You will not have time to fix everything:

You will not have time to fix every bug.
You will not have time to implement every feature, no matter how awesome.
You will not have time to patiently answer every user’s question.
You will not have time to shepherd every patch.
Users and contributors are distracting. The more you have, the less time you’ll have to actually fix their issues.

Safety Tips

Maintaining OSS software is draining.

In most cases, front-line tech support and actual development work are isolated: those working front-line support aren’t ultimately responsible for fixing bugs and those fixing bugs aren’t directly in contact with customers. This means tech support doesn’t feel personally responsible for customer issues and allows developers to focus on their work.

As an OSS maintainer, you won’t have that luxury. Your users will come directly to you directly to complain about code for which you’re directly responsible.

Start training a replacement immediately and treat every new contributor as a potential maintainer. Even if you don’t completely burn out, you’ll need to hand off subsystems as the project grows.
Users don’t file bugs when something works. You will always hear complaints, you’ll have to listen hard to hear happy users.
You will feel like your users aren’t listening and are making the same mistakes over-and-over. That’s because every user is a different user, every contributor is a different contributor. The only solution is documentation or the patience of a kindergarten teacher. If you have to repeat yourself, it should be documented.
Clearly say no, maybe later (“postponed”), or maybe if someone else takes the time to implement this (“help wanted”). Saying no is always better than uncertainty and you won’t have time to address everything.
Create processes and follow them. They allow you to draw boundaries and say no while keeping the discussion impersonal. This is why governments use processes and couldn’t work without them.
Don’t take it personally or constantly second guess yourself. Just do the best you can then move on when you can’t take it any more.
Remember that there is only one of you. You can (and should) say “I don’t have time for that” and/or “that is not a priority right now”.

Fix For Lenovo X1 Carbon Not Charging

2018-05-07T00:00:00+00:00

I recently made the mistake of plugging my Lenovo X1 Carbon (Gen 5) into a 5 volt USB-C charger overnight. The LED on the side indicated that it was charging but, when I woke up in the morning, it obviously hadn’t. Worse, it now refused to charge even when plugged into the correct charger.

The fix is simple (although undocumented as far as I can tell). Basically, you need to reset the battery as follows:

Unplug from any power sources (this won’t work if you don’t do this).
Reboot into the BIOS setup (F1 on boot).
Navigate to the Power menu.
Select the “Disable built-in battery” option.
Wait for the laptop to power off and then wait 30 seconds.
Connect the power and start the laptop.

This will temporarily disable the battery which seems to reset any “bad charger” bits.

Hopefully, this will save others some time and frustration.

The X1 Carbon is otherwise a great laptop with an awesome keyboard. However, because this is my blog and I can rant all I want here:

The dedicated Ethernet port is pretty much useless given the ubiquity of USB-C. I’d have much preferred an additional USB or USB-C port.
The nipple seems a bit firmer than the one on my X220 and also seems to get into the “wandering cursor” state a bit more frequently.

DRACL (thesis)

2017-11-10T00:00:00+00:00

So, I never actually posted this and I figure someone out there may be interested… For my masters thesis, I designed (but never got a chance to implement) a decentralized (well, federated), privacy preserving, access control protocol. The purpose of this post is not to explain DRACL but to get you interested enough to download my thesis and take a quick look.

The primary contributions are:

First, an exploration of the privacy, security, usability, reliability, and performance trade offs involved in designing an such an access control protocol. We explore topics like,

Account recovery versus security: no completely trusted third parties.
Privacy versus efficiency: e.g., choosing to not update something reveals that it hasn’t changed.
Security versus efficiency: cached credentials, etc.
Ease of integration: no new services, no server-side network requests, no account management, etc.
Ease of use: groups, no surprises, etc.

etc.

Second, an interesting (not-yet-peer-reviewed-but-probably-mostly-correct-and-definitely-interesting) zero-knowledge (ish) set intersection protocol. We use this protocol to construct “keys” and “ACLs” such that the keys opaquely encode the set groups in which the user is a member and the ACLs opaquely encode the set of groups that have access to a particular piece of content. By opaquely, I mean that neither party learns anything about the sets that their keys encode (except what they learn through running the protocol, see below).

Given a key that intersects with an ACL, a user can prove that the key intersects:

Without either party learning anything other than the cardinality of the intersection (the user/prover learns this).
Without revealing any user/prover-identifying information to the website/challenger other than the fact that the user’s key intersects with the ACL being proven against.

Furthermore, we can expire keys after a period of time (and even allow semi-trusted third parties to “renew” these keys without granting these parties access to the protected content).

There are quite a few interesting features/guarantees that are hard to sum up succinctly so I recommend you try skimming the thesis. It goes through a lot of trouble to try to explain DRACL in an approachable manner.

The primary downsides are:

Complexity. We designed the system to be simple from a usability standpoint but, under the covers, the actual logic, protocol, and crypto is complex.
Size limitations. No user in this system can feasibly have more than 1000 or so friends/groups of friends at a time.
Expensive crypto. Not “expensive crypto” from a cryptographers standpoint but expensive crypto from a systems engineers standpoint. Authenticating can take multiple seconds of CPU time.

Stash

2016-09-13T00:00:00+00:00

Stash is a library for efficiently storing maps of keys to values when one doesn’t care what the keys are but wants blazing fast O(1) insertions, deletions, and lookups.

Use cases include file descriptor tables, session tables, or MIO context tables.

See the project page for more.

Disabling Firefox Addon Signature Verification

2016-08-07T00:00:00+00:00

As of Firefox 48, it’s impossible to disable mandatory addon signature verification without monkey patching Firefox or recompiling with MOZ_REQUIRE_SIGNING unset. Personally, I find this unacceptable as the user should always be in charge. It’s also completely useless as any party powerful enough to disable the signature verification in about:config could just as easily sideload a powerful (but signed) extension like greasemonkey and then install a malicious greasemonkey script.

Rants aside, the correct solution (for the user) is to either recompile Firefox with mandatory signature verification disabled or use the Firefox Developer build. Unfortunately, Firefox is a monster and recompiling it just isn’t a viable option for me (or anyone with a laptop). Also unfortunately, prepackaged Firefox binaries are missing some useful security features like PIE and dynamic libraries. Finally, the Firefox Developer build is a bit too bleeding edge for my taste (I would like my primary browser to be relatively bug free).

So, I’ve written a (disgusting) script that monkey patches Firefox’s omni.ja to make signature verification optional again. I’ve only tested it on Arch Linux but it should work on all unix-like systems. However, if your omni.ja file is not in /usr/lib/firefox/, you’ll have to tell the script where to find it (i.e., ./nosign.sh /path/to/omni.ja).

Requirements: coreutils, gawk, python2, sudo
Download: nosign.sh (signature)

NOTE: This script does not disable addon signature verification, only makes it optional. To turn it off, you still need to set xpinstall.signatures.required to false in about:config.

WARNING: This script updates the omni.ja file IN PLACE (using sudo).

WARNING: Use at your own risk.

Localtime

2016-06-16T00:00:00+00:00

Localtime is a small, light-weight go daemon for keeping the timezone up-to-date. It uses geoclue2 and systemd-timedated to do all the heavy lifting so it’s able to run with minimal privileges. See the project page for more information.

Pipe to Emacs

2016-04-09T00:00:00+00:00

While there are many ways to pipe to emacs, they all involve either shuttling text by repeatedly calling emacsclient or writing to a temporary file. However, neither are necessary.

Basically, while emacs can’t (yet) read from a named pipe (FIFO), it can read standard output from a process so, one gratuitous use of cat later…

(defun pager-read-pipe (fname)
  (let ((buf (generate-new-buffer "*pager*"))
        (pname (concat "pager-" fname)))
    (with-current-buffer buf (read-only-mode))
    (switch-to-buffer buf)

    (let ((proc (start-process pname buf "/usr/bin/cat" fname)))
      (set-process-sentinel proc (lambda (proc e) ()))
      (set-process-filter proc (lambda (proc string)
                                 (when (buffer-live-p (process-buffer proc))
                                   (with-current-buffer (process-buffer proc)
                                     (save-excursion
                                       ;; Insert the text, advancing the process marker.
                                       (let ((inhibit-read-only t))
                                         (goto-char (process-mark proc))
                                         (insert string)
                                         (set-auto-mode)
                                         (set-marker (process-mark proc) (point))))))))
      proc)))

…and you can read a from named pipe. As an added bonus, this function will try to autodetect the correct mode.

To actually use this, I recommend the following shell script:

#!/bin/bash
set -e

cleanup() {
    trap - TERM INT EXIT
    if [[ -O "$FIFO" ]]; then
        rm -f "$FIFO" || :
    fi
    if [[ -O "$DIR" ]]; then
        rmdir "$DIR" || :
    fi
}
trap "cleanup" TERM INT EXIT

SOCKET="${XDG_RUNTIME_DIR:-/run/user/$UID}/emacs/server"

# Create a named pipe in /dev/shm
DIR=$(mktemp -d "/dev/shm/epipe-$$.XXXXXXXXXX")
FIFO="$DIR/fifo"
mkfifo -m 0600 "$DIR/fifo"

# Ask emacs to read from the names socket.
emacsclient -s "$SOCKET" -n --eval "(pager-read-pipe \"$FIFO\")" >/dev/null <&-

exec 1>"$FIFO"
cleanup # Cleanup early. Nobody needs the paths now...
cat

You will probably need to set the SOCKET variable to your emacs socket filename.

Usage:

dmesg --follow | epipe

Map Range (Rust) Macro

2015-07-13T00:00:00+00:00

Below is a (rust) macro for applying another macro to a range of values 0..N where N is specified as a sequence of big endian octal digits. This is primarily useful for implementing traits for fixed-sized arrays.

This macro may eventually end up in some crate but I haven’t found a good place to put it (and it doesn’t really deserve its own crate).

The Macro

macro_rules! map_range {
    /* The actual macro */
    (%# apply $tmpl:ident, $shift:expr, $offset:expr, $by:expr, (0 $($rest:tt)*)) => {
        map_range!(%# apply $tmpl, $shift, $offset, $by*2, ($($rest)*));
        map_range!(%# apply $tmpl, $shift, $offset + $by, $by*2, ($($rest)*));
    };
    (%# apply $tmpl:ident, $shift:expr, $offset:expr, $by:expr, (1 $($rest:tt)*)) => {
        map_range!(%# apply $tmpl, $shift-$by, $offset, $by, (0 $($rest)*));
        $tmpl!((($offset) - ($shift)));
    };
    (%# apply $tmpl:ident, $shift:expr, $offset:expr, $by:expr, ()) => { };

    /* Convert from little endien octal to big endian binary */
    (%# convert $tmpl:ident, (0 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (0 0 0 $($binary)*));
    };
    (%# convert $tmpl:ident, (1 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (1 0 0 $($binary)*));
    };
    (%# convert $tmpl:ident, (2 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (0 1 0 $($binary)*));
    };
    (%# convert $tmpl:ident, (3 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (1 1 0 $($binary)*));
    };
    (%# convert $tmpl:ident, (4 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (0 0 1 $($binary)*));
    };
    (%# convert $tmpl:ident, (5 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (1 0 1 $($binary)*));
    };
    (%# convert $tmpl:ident, (6 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (0 1 1 $($binary)*));
    };
    (%# convert $tmpl:ident, (7 $($octal:tt)*), ($($binary:tt)*)) => {
        map_range!(%# convert $tmpl, ($($octal)*), (1 1 1 $($binary)*));
    };
    (%# convert $tmpl:ident, (), $binary:tt) => {
        map_range!(%# apply $tmpl, 0, 0, 1, $binary);
    };

    /* Public API */
    ($tmpl:ident @ $($num:tt)*) => {
        map_range!(%# convert $tmpl, ($($num)*), ());
    };
}

Example

use std::mem;

trait AsArray<T> {
    fn as_array(&self) -> &T;
}

macro_rules! array_impl {
    ($value:expr) => {
        impl<T> AsArray<[T; $value]> for [T] {
            fn as_array(&self) -> &[T; $value] {
                const LEN: usize = $value;

                if self.len() == LEN {
                    unsafe { mem::transmute(self.as_ptr()) }
                } else {
                    panic!();
                }
            }
        }
    };
}

// Call array_impl!(i) for i in 0..256. "2 0 0" means 0o200 (octal 200).
map_range!(array_impl @ 2 0 0);

Gazetta

2015-07-13T00:00:00+00:00

Gazetta is a static site generator written in rust (currently powering this website). You can find more details on the project page.

Platter

2014-01-31T00:00:00+00:00

Announcing platter, a file server for direct file transfers. See the project page for details.

January 2014 Screenshots

2014-01-31T00:00:00+00:00

Yet another screenshot. This time with bspwm and bar (rendered with overkill).

Overkill Initial Release

2013-11-09T00:00:00+00:00

I have been working on a project I call overkill for the past few months or so. It’s is a publish-subscribe framework (or a functional-reactive programming framework if you want to use the latest buzz word) for collecting and distributing information on a local machine. Personally, I use it to generate my status bar (hence the name, overkill). See the project page for more information.

May 2013 Screenshots

2013-06-02T00:00:00+00:00

New blog, new month, new screenshots.

New GPG Key

2013-05-07T00:00:00+00:00

It’s been a while but I figured I should probably make a new GPG key with increase security (1024 to 4096 bits) and expiring subkeys.

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

As of 'Tue, 07 May 2013 00:50:01 -0400', I have transitioned from my old key
to a new one in order to increase the security and sign with expiering
subkeys instead of my secure master key.

My old key fingerprint was:

    8F12 8D02 2B69 004E 8CF3  1890 D854 9F57 252B A385

My new key fingerprint is:

    327B 20CE 21EA 68CF A774  8675 7C92 3221 5899 410C

And the full new key:

    -----BEGIN PGP PUBLIC KEY BLOCK-----
    Version: GnuPG v2.0.19 (GNU/Linux)

    mQINBFGIaNIBEADbgEpvt4xVYSmvsIjcsmij7ds1Mt1Xe8dClPJ8iZu+E/MZYq/r
    Fnu5FJ1Hz09fGNwnwEhP06LfQ2cNWQiabiTqa9jqqu9/ulb1ElZvEhM9G5NedHR4
    9iIP5A75OzbywXIqYGBB6tbHLOBjLoIgSe8vJeFe/iTVy+52N0I+eiMCoq5Fcpql
    Liip/sHUYJx/wcnD7SoV8KbbfM2Oqcyan7AEAlHNeV4OXyKNNtufO0ZGaem+7vn8
    dl0Gv6jJkXAKGtL5V8eEljx6KOBO5ehvnu2KMvBHjJxPvW3gtby7m53yIqS74SFZ
    SK0wggMrCl0Lnwf3+YAYL2ycYxDcfcPjtQe8+X6kZcYKdnhAKvlhrFAIAaNXvM1I
    U6Oecw74jaRFlVkz3vlQ9FZLB0Am11OZ81EuihDFyMvB+lGYzCvrXbIPlvXC9uwT
    wUAcs4y47AzvUwMrvRhF7CFMAONWD60+eC9mzRc2/PGVPI5LsFpjgv2zlfZ8V9JQ
    T3/iST6FSwkmKyntW85ChTjpIGNgfBQzvRCD+8+he3TjvHaG5NN0TfjoBdZ4esYw
    b6r0AJgfP/EveXqojEz1UMWesf2WuYf/l9G5HstWJtrqB/EAcurX5WVNcIqE3QfF
    qVf2Rh/4/lO9oPC5g2M7k30/OSOl8uWNbXExxZyC18JDA1C5qn9wEEbt8wARAQAB
    tCNTdGV2ZW4gQWxsZW4gPHN0ZXZlbkBzdGViYWxpZW4uY29tPokCPAQTAQIAJgIb
    AwcLCQgHAwIBBhUIAgkKCwQWAgMBAh4BAheAAhkBBQJRiGxQAAoJEHySMiFYmUEM
    gr8QAMO2Jc0F4mSqef2OxDzo2tcRcQ4vC+h08Nxljgp9mcpnZLvWdEhff0b9dyEo
    bBGlaISzcteGGRhJ1OyiLHPbjLnfCLCeZvQ7hCff/1YjVy170zDku4FIVBiwcbv4
    wMvdVVJX3iXC92R0G5tPuPJ5rw+41PRNLA3h9XT+K6Ns0PJsq4We1bNLeq0XSl7/
    chgID0g/AqjcxPT/8gZlLi3TytUi9MTN2XZUbTFPgChuMuKAZigeoPClCyu4p2t5
    IMp6qVGcnuNIww1+QUCi8pGdnsT/isU2gLcC9EGLAovyKipdqbS7IkPAAs1u0UAu
    zRJKVGYbTZrBeXr4wPUMFbyTbcM5cjXwC6rbJcyWfbp3FSWHSbHI9wgwg+JY2bB1
    fqTVaiZpTxmjKC3X4Y39K++f6Nr5oP4bxCPUg3h4i6VChiRpM+NZok5rZZKsBxfb
    QK/pXVnC3BesEEQtyoa+1fwg0mWGsbTsVdqz5T8cHUUgfUJM74Q+6Z9Jql8e3FR4
    IuRkWxsmeq4J9GgfxiddfhHZ9gp7txGOBx/pPft46t/9PdBxhoMPIPrK1eWUZnVm
    x0YRCvv4YTS3CEkoRHHEdmDfn5cyM2NNNWcM36pasfg6WLglrlfCyZFG6IgJBntU
    ZiTS0OakT1TFenheR8a1VAqN1DoQxecsCOGkkvlTQPv623sbiEYEEBECAAYFAlGI
    bd4ACgkQ2FSfVyUro4UXeACcCy/odWhokz4bnZOYLhio9gq1UOwAn0w/mM6DjeNg
    HOfa4+a8XyvyQ626tCFTdGV2ZW4gQWxsZW4gKE1JVCkgPHN0ZWJAbWl0LmVkdT6J
    AjkEEwECACMCGwMHCwkIBwMCAQYVCAIJCgsEFgIDAQIeAQIXgAUCUYhsUAAKCRB8
    kjIhWJlBDBkjEAC0wDHuLaRkk+LZLcC9iaxQEVkvgmtI1z39+TFhUbT8MEzAiQAj
    NKqsCpNG9H9zs9ZuEawPt67Nu/aKNEXg6T4Hfb9s1IjqYZCMGeGGogGanRaIc4Xq
    Qvfdj6OP/Js7Mw7jAHM/ffdPSVp7qGRK0VtCWi1rU+T1NIn1HKGdteW3xWe6iLpQ
    X30h5RZVKfx8fU1ayXxc1i+UQpKpW2c8xpsbOsKM60iEnbYPD1Al66VwGRRN7xhN
    HOZmzvcS5x1gJ5UoUyfXucUlll8Lhy50blRmSnhS3TItsL6pQELxran4jWsd3aXx
    une9YFcsx2eENTmLnVxVam1OQBjyJP64sjpkldqUOQAAE5Nr2GpVYOhCkSi9ZIEh
    IA/NPLC1ZsfGa57zVFlBK3qpOIpiCQ9VHUuNyXcG/0UxQ9Qs58CwUvDNEQE2gDgw
    1N3XOeY3CoCrzJyROqFQl2rS29Oo/7jxJnieeUPYafu516QsuXh374z1MZ4Hvw19
    YApYtNtytyzc6G1hlAhr9ow6TNFEkZHbX972LLriXGI4k3tqHUcvPrzbV4BaYelI
    9T3KTbO9hzs81muzc0IRKNAQAoe5ikeybLIE+/3pzhK3MADbo7kWJpMh3auy1mm0
    yy+aYCLMzRZyk1e2ohT98gRi7X33j5+84PFmk7s6H0bxVXmbznfLSxYD/IhGBBAR
    AgAGBQJRiG3eAAoJENhUn1clK6OFApoAnAgc+GJmXWSKD8cgMyCcM5qWGtarAJwJ
    jcpxQxyz0A4+8G5i0r4SYP/KprQpU3RldmVuIEFsbGVuIChDU0FJTCkgPHN0ZWJA
    Y3NhaWwubWl0LmVkdT6JAjkEEwECACMCGwMHCwkIBwMCAQYVCAIJCgsEFgIDAQIe
    AQIXgAUCUYhsUAAKCRB8kjIhWJlBDLj9D/4uTRLRgjaBCagcrtgCY1NCG3DmfWWF
    0WVqqCK5FCrbiTANJI09HIohpa0ZqSU4fw42loVrOOgRIn7HS6dhv5FVVeQXSl70
    06jvq42CiJvJ1Q9PY79Qa87oeX9lC4QKYrBhSTZkC1Q7uXtkPd2fJCIrNurp5+BI
    7JJp7IwARCk5mLXeR1qi6M+aluGdF7v6lp4O9w/KhIYzfV7pl9HLZM9/81Umrphb
    /gF8w+ErwUtdxKg2tkt+DitlUcojrtKwxdJJIp2N46IuV3zz68x7Ud8oOfgCUJNp
    AODkH/6zlzHZ8fHqPx3FNNGh2BUHrp4MF7953GFJZDHkmCRHNXVh1YuU77EVWU8y
    udlcCLNKTofIHQiBwuNcLzV2Fd2f6sdChLT2Xhq/YKZX6N9Q/ae6Bq7Q1QoQ2r0u
    w7kM4LripWUH91CHQPzOFLPS+T2GUZ5hUcI1fEw2udijymUHA7pbYxeCJhKGsvBM
    oSfs6awM5DfZpmxj+3TRVQHp7XG+YqZDGTymuZ7V7rEs3U17n5M9ebMMF1/EObTw
    x2yfM75kEj2Kz3Oti09LxIu+s42inVZTaB08hNUBHPKHVSWwwebUDebBNGUQ6PI7
    oStwX7KDx/1+xrxOdh8M96rSrwyPbiUCE9zXh7Drn4vL9yZeSnJ3NI0D9cTK1xOM
    6ZGqyUss2YElsYhGBBARAgAGBQJRiG3eAAoJENhUn1clK6OFyzUAoJouyBzJCay8
    9i/LkZME456qByKlAJ9O6VB9tOTxIDS/oPsl7rHpgvAm6bQqU3RldmVuIEFsbGVu
    IChHTWFpbCkgPHN0ZWJhbGllbkBnbWFpbC5jb20+iQI5BBMBAgAjAhsDBwsJCAcD
    AgEGFQgCCQoLBBYCAwECHgECF4AFAlGIbFAACgkQfJIyIViZQQz9Cg//VkDQ33m+
    2JumNddaNCONZZNqAvtS5+Pwu5FGkkrj2IYn45lU9jog2hG2ZyKlEZf1/ZDfM+hP
    qtxha6Tgpx3VWytN0aKzKUhav7S/58fhw46gmQvimIFBWS7RcMZskMl234hErvhd
    3LyjL6uJx93roJSlwCeARggn8LQbQgBcxcAAHh2Wlb74p/Le3CA/xYbkacyoCex2
    QuDF7lMCYTD1qDGkHiniiUDHXZYSNkfyT2XOkORZv3JoU0eNhO2RRP3FI5hsztOm
    BVOfjvOvfWQDRJDczVvhraLoRenTsnI/nDI+T5kAQrSDJ0xc44DjRpxx5vu2sasY
    Zggd/9mbJkYC2hA7dRZRIP1/YZPFw8ekvTFR0FM7LkSvFh9GJhwnv/4xK+/bRv5r
    6SVOc47kH/gTfZSjusu4feWRIeaEvuwC90ORmLujM77bR0o0hkZekYVPdF+m6tEy
    0b4LxNt6dtiqEXewSEwnfFHcXLc+Y1M2bUspREo7yz5krplJgXhkeDLvLmTUURhN
    2Tgkc4ksB1NVaNRtDr6Ry5zIbYZB3AMcsNvV1mOeNYeqYmUTB7yaTEpNQsndQD9i
    YK9hA5vsaHLPJj7drLKfgHT7l7v0O90dVL6S7JoboEshaEgcEp+jXBl9crz5xLqx
    u124DrLKqsqmDyr83VIdMuPOTL32oG2dKwGIRgQQEQIABgUCUYht3gAKCRDYVJ9X
    JSujhZusAJ0Rdvv++yKLuwL7KNQGP6cNsu+3DACcDqEOP1VNT/ke4LpwdL6sHdoi
    Xaq5Ag0EUYho0gEQAMq8FLqp2zHs8ORlk5qDS5y8Fdi9RsttWEybLGMzx6Ka2A73
    SaWm0+oLtpLehuAAWF0iTAj9+TztzbmUWfPFr4Zj/i4L73XOeAgz2cCFHOEjjgTF
    Y804Hk99WVhQdZMikwyTPk2s6ccf6TTxHqdtut5EqTKEU1yWf2CU4Aq2uidWxnI6
    5TSE4HPCW4bHhZxZF1YX9HfR3oE3S7PXa3ojNQ+5pXyXTiw+nrcGnIlN0GOIZUYj
    z7R+HjczjuLngG3jFjHIXyplLbezZUxwXaseqHgrPwFZaAOXPwjkzbKRE/PaLU4l
    b8IbZWJ05Ho8lgsci0CILaMjclC0WVdLf+uXfo09oOwIUz34nQqoDSSvIW+gMe+P
    Skf6slSwdsQhi5idWLa17TbnvL6+jSr+MMPp3GvcK+Jo+AlqE/Ryx5aY1IybYCLn
    RXLKhc4GNYPZD+9UwClF5pPvl/PfIxnu7Eri6Iw2DLJ1zFJiM6+5xGjTN+pO8Q9x
    UXqb/StYq1SwehjtHpl1hVEsTX6YG35kv02zzd7NrKEnvia3fzBhy/2chh/VWHEk
    Zs3dhW4rOHa+Y+NO4CHUfNtbCFl9dreDb1Upvqav/OeMKSarPzHU2Xly9EeXDk/L
    +s5fRTsy6mR9M36gZclTqpWniTEk2PGm2LbJt47j4qup2FplE0WxSkGLR14rABEB
    AAGJAiUEGAECAA8CGwwFAlGIbGkFCQHhNxcACgkQfJIyIViZQQyWSg/+LWq9J7il
    JOPMdgHKOkVsYRpU+OnEevnmfqs+THFlJY/hpMPHDiOJ5pAnoIF3sUnEIN5CrcOz
    YXxMoszsFTiL22WWPaF1v2go9KFpFpe2YJrp6fFMs9W+rD2K1GfAtY3wlfRK9mhn
    n0IHO9Y2qY/D1/jgmz4735AwgNLu7z5G9QU1AA9/2CzgJioCnFv59FJuks5hac3E
    r1HhS15sAvNnLBHjIlXZsRSui2bCL2sYFLNcf2A1AW/wEE0RPEvoP/xMh6EhvM9u
    Biwi8n7EkbAFptp6fW9yGmmWytcsGHxwfhG0wBy4gMg6FNl5skf19NdtSrzn081N
    uLK3Av3GQAp7AaSUYnhQS7sO1/klRiBoQXN97W9wn+N+wCG9LfdZQnUVS28qW4Ar
    5BNjeN1PW3HI+bbi/ElsQTUlMpLoGhPUE9niOadJqY4TOZKVunLppuEjaPBWbFK9
    ZRFQWmm4pMGu19o2ywYVVVhhdM9wGfXFMxbIyZp8YfTcSIHmPuoTq9dqUregC0sk
    oxSHQw8eoLgOIrkOsvnRDiVZsjMKaKg4I8GhqOPK+vD/2/nDre/ytv5Q9+GI5+wL
    JhTQwIMYITWT3OsXkttowYpIqAqzPdGX+0EiTcod3IhEN9XdM9ZatYpBBbsS/A/Z
    xShFmpTNIo1z99ARqe8JQuUYQ6Y4KNblNwm5Ag0EUYhrzgEQAOvRfIF3bN6uRSuu
    jib06s5JKcPpBDmjkfZPwgr7A5G0hfk17umfDD4YyDEKiFmP6IJ4YBabbm0iI1FA
    erETYGKg9nK1cSYen/sIV1BQf38cTYKmBKHefTD/XB45umcLV7TryqGjmW/jbgKP
    D1TjBpnkz5brfrt8KGHoUcFRDkQ7Bm/ufwPxp+bRYu25+MIRHdigQdxvm4vbgIfy
    iG0ENs9e4B1cuk4GKtAr1J3U0q3NufOCnk/gTNNSPh1uaHCH0EZTUJBV+mwyqe4i
    2/ksQg2Ufpy3wz0Jczd58XLc4c0JYJ1ir0fBRobqMJWlYuiXjYzXj8y4se5IDojm
    +ljudRK1nveoOB+tHygLoMIiKOOuL+VmLmcOHqySzObFfRbpbvp7wKcJunCcVF9i
    J6aYfK0XG7eK15u83QaKw/jGIdTh9Z2Ic4gl1YdkpLzK33nlzk/bM2SIUDhK3vIP
    jctXe4bF8OZ+YIrc1XtlGhJ6c3bqSmOiEO7tVkr6vwmJQWnVfedxt9qJqTxwnE9J
    WQGpbijio3xommhFomTalpZ+NtuN3SYFMSSSiVkVRXmcbpxkaObHJvY1g50Fqh7e
    7/KN4lpyJ/k7J1DWuMaBX5jHT9PrsnbaXli8rw5ylivSghs92Lgqw/gfoIU8JiRd
    1iqxA/j/Ps+wuQwZLJcpOOU9zU65ABEBAAGJBEQEGAECAA8FAlGIa84CGwIFCQHh
    M4ACKQkQfJIyIViZQQzBXSAEGQECAAYFAlGIa84ACgkQmVTTNRXa64SChw//W/Gx
    crHkgHtFjns0clDCqmmakS2HRRaAJ53Q62ntr/9nKifPUATNqdtiv+vRCPeuz8oM
    WgWQYVb+hBi3hbEOXISdOT4PZFAjg66LvdMA9ocKFa8RbXYwL8ThR9uEh89REIEf
    aTdZgSJGLxiafTNJ2KPS3FJerJAFqtbPMojLb9Oui5659ySDloXC+Owd8a+D2F+V
    IbMrO6UOJ/JlajmDLkwsI3ypjiGgNIdhipSpOBY2jBsA8kOoqhLrWPFVpCxvH9Ba
    jJKaK3N81ytSQGqsReRTJAJATGGvcX53u416NByWDssxWyWteKK2xIAHhcl8g3X9
    ItBGuHcddrkTHlLDSFkYKglEPY6PQsCpBlHsBBjBkRYznFCw+PkbNDc4FkANCtGR
    WgBqfzE+0sjAy//xjbu4M1+lcYizYoyO8xI+cdy9TGmNIoevhHxEZiGlv99PXGkc
    1kSYbBBOABXHOLGlV0mOP6pK8Ve8AJk6qSGphmpGbDVwC1pl5Am61vPFXjAErGaJ
    lfFhq5s9iXtDecJVmTHaepDLL+fC5DwVsNL99oqf/coXIweSWbnOQzR5rabjis1p
    fOb/+qpaMRX5liBpUpMxBeIDmb41EOopuVeW37QD1bYp+q4/i0alDN/F0Ev6rqxX
    1A7ntUPq1Nmmfl/2kJmFapg+4QpAwIRgZfyrSFKn4Q/8CciaRYHAgLNJoc9cYgzB
    hLHSnM6kyF1UmcK9yb/SAjThPQcg4zeRDI4/WPsE4R8qZHCq4tH47kgTMPNRTak6
    b6KPYaKCgaGP81I8ndSlMcmvhROmQCVuWueWoMn1laoqups4nSW+vr6qH19bHqEc
    D7jQiUrTcRCVGEJS6tkH/PPwyBRmWTARY3Rd6Y/D/jSkJTOYT/e4DKHBrLyabXzy
    9v6E+e6eExJsPV3P5f8zngU/L/RFS3oqykj96WEN4Tx0OyyvGDx2MIxJKujNCbxj
    6+TMcmgLbm+PSP0zMUu3R07VUnuzE8nhi8GBx5LW7ONim70UUKFQp5p5jZq0lgkQ
    xB4q+kWI7speobt3osgmFDNEzWU8PZfl9smeFOxDF5ja/myC1KRhFecwtZQvPJ99
    PH43VIfl41MrC39lhA5DfeO+FLLUa1KDa1sXRLVdAtme6z1wVbYrc7/X5E69d+Po
    DyknudabLdW+LxcHXAIP6z1wpWflCVIRziaefilXvY5eq8h/jwU3AfdgygBSJty+
    wmhmuOHAWWaURwxuU77w32e2lHyXhNIm0aDPiYISOPo1x3yRYMtVDWzcfG6Gc6HM
    T7gbnzPXt2CrSm+Noineb4TFGQZLgtgRLut+PjEkSCHjc6RRGFy39VZChgJzkEFN
    MXJjnYZCKLva+UJATvt09dQ=
    =hRIT
    -----END PGP PUBLIC KEY BLOCK-----
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.19 (GNU/Linux)

iQIcBAEBAgAGBQJRiI01AAoJEHySMiFYmUEMZzIP/Asu/YJ6QloHkLso3rT4ihFP
suVLXWouks6IyiCLr96Erf/+50D36KXd07/aMD54rNrvIPiq7RNhcQasyH7zAQtq
bGJIQqZATLfp3EjVvHx3H4szHyA+pW+HU1uzh6HigAfQMGTpOsZsvf8SLmB8sohj
HzMyJdQCzDKXQLotGaSQ4n79Xr2K7lQATz10aOc0qGZBENHkFvYJ7MNEFv+LuWio
vVwduuStvBOYRts6z8pHv7M3ZgzOiqSx7vtRCXRwuRLAzisc09ogNRp9CXKWkO9F
bkiMKOhHvRWMpthPcgVxbA9151n8LNDL02hdSJ2LhJm10I6XKX1dhzqVtaVLXkbd
pLRvkyNg4PbFD5bd5TPmsDoVI3mW/CsNgDlCHDeMf8aS1fGxhBQVO6+X/YmiUc9o
lqSdOnt2Kf1gTWSFFjJ32GgpLD6ajAkvxqcDZTCXbdaqr83jBbAaZ4EiHIKruOqT
slIEI8KbY9LItMVZk55435H2MzDvazPOPrW0uRrWExnE5A4n6szcLrkEIaG99AS3
YVC+ycEHWNtaDyvyXb2mbJICtIs8y/Nhrz2WT52fDYFJLakVp04Zgvdbn732ISpg
AW+sJ6Sg/sHpX4V2SV290W4wDCJ6LBqxPzb0zs/2JvGR+J/ByIQpoD5W6XdaHJn5
tTcsGtiQ0e7BNC/poqLViEYEARECAAYFAlGIjTUACgkQ2FSfVyUro4W2wwCcCEEf
kUu9EqFYq0Vdrhqsd5bOIp0An237odqQt2MFZVNM7YtsH6cPwk2z
=/NJg
-----END PGP SIGNATURE-----

My Configuration Files

2010-08-22T00:00:00+00:00

I have finally got around to making a git repository for my configuration files.

Here they are: http://github.com/Stebalien/dotfiles

Turn the Zim Desktop Wiki into a calendar

2010-05-18T00:00:00+00:00

Why

I recently switched to Arch Linux and decided to ditch evolution (a good but bloated program). Claws Mail works perfectly as an email manager but I couldn’t get its calendar plugin to work properly. I have been using Zim for a while and noticed that it had a very basic calendar plugin; this was exactly what I needed. The plugin allows users to create pages in their wikis for individual days: no complex forms to fill out, just a simple page to keep track of what you are doing on a given day.

What

As Zim lacks desktop integration so I wrote two python scripts for conky integration:

zim-conky_cal.py
Prints a calendar (like the cal command) with the current date and appointments highlighted.
zim-conky_events.py
Lists the next 5 events or all of the events in the current month and the next, whichever comes first.

I also wrote a program for adding events to the calendar (zim-cal.py and zim-cal.ui). Select some text, run the program and double click the date to add your text to calendar. You can also input your own text by clicking the edit button (the big button on the right).

How

First: Enable the calendar plugin (Edit->Preferences->Plugins->Calendar).

Download: zimcal.tar.bz2

Conky scripts

Edit CAL_PATH to point to the folder that stores your Zim calendar.
Add ${execpi 300 /path/to/zim-conky_cal.py} and ${execpi 300 /path/to/zim-conky_events.py} to your conkyrc

Zim-Cal program

Edit CAL_PATH to point to the folder that stores your Zim calendar.
Make PROG_PATH point to the directory where you put “zim-cal.ui”
If you intend to use this program regularly, you should probably assign a global hotkey to it in your window manager.

Make Gksu and Policykit red

2010-04-29T00:00:00+00:00

I was bored one day and decided to make my gksu(do) and policykit dialogs red. The results are actually quite nice.

Add this to the bottom of your gtkrc file:

style "gksu" {
    bg[NORMAL] = "#770000"
    bg[ACTIVE] = "#550000"
    bg[PRELIGHT] = "#990000"
    bg[SELECTED] = "#550000"
    bg[INSENSITIVE] = "#220000"
}

widget "GksuuiDialog*" style "gksu"widget "PolkitGnomeAuthenticationDialog*" style "gksu"

Packagekit with apturl

2010-04-28T00:00:00+00:00

Although I no longer use packagekit, I still have my apturl script so I thought I would post it. This script will allow you to open apt:// scripts with packagekit. (Just save this to a file, mark it executable, and tell your browser to open apt scripts with it).

#!/bin/bash
/usr/bin/gpk-install-package-name $(echo $* | sed -e 's/apt:\/\?\/\?//')

Useful Bash functions

2010-04-27T00:00:00+00:00

cdd: cd and list the files.

function cdd(){ cd $*  ls --color}

changelog: get the change log for a program

changelog() {
    log=/usr/share/doc/"$*"/changelog*
    if [ -r $log ]; then
        less $log
        unset log
    else
        log=/usr/share/doc/"$*"/CHANGELOG*
        if [ -r $log ]; then
            less $log
        fi
    fi
}

mkdircd: make a directory and move in.

function mkdircd() {
  mkdir $* cd ${!#}
}

Screenshot of Arch

2010-04-25T00:00:00+00:00

I have been trying Arch Linux in VirtualBox and will probably switch when I get around to it (or at least duel boot along with Ubuntu).

Here is what it looks like so far; if you have any questions about tools, configs, etc., ask and I will post.

Kupfer Plugins

2010-04-25T00:00:00+00:00

After getting frustrated with GNOME-Do’s memory hogging, I switched to Kupfer. Kupfer is a lightweight, extensible application launcher like Do (as it is now called) but much more powerful and easier to extend (it is written in python).

My Plugins

So far, I’ve written the following plugins:

gwibber\_plugin.py: This plugin allows you to send messages from Kupfer through Gwibber (with no configuration).
exaile\_plugin.py: This plugin allows you to pause, play, skip, and go backwards in Exaile. It is based on the Rhytmbox plugin.

+1: evolution\_plugin.py: I did not write this plugin (although I did do a fair bit of editing). The Evolution plugin adds an evolution contact source (and works with the built in email plugin).

Download: kupfer-plugins.tar.gz

Start conky only after the root window loads

2010-01-02T00:00:00+00:00

Every time I logged in, conky would start up before nautilus loaded the desktop. This caused conky to load as a floating window that stayed on top of all other windows. I have finally gotten around to fixing this problem.

~~Here~~ (gone, email if found) is a simple python script that waits for nautilus to load the desktop before starting conky.

This script is probably very inefficient but it gets the job done.

Humanity Icon for Caffeine

2009-11-15T00:00:00+00:00

For those who don’t know, Caffeine is a small program for Linux that lets a user prevent his or her computer from entering a power save state. If a user wishes, he or she can even configure caffeine to automatically inhibit power-saving when watching a flash movie, or running VLC, Totem etc. For more information, visit its website here.

As a user of both Caffeine and the new Humanity icon theme (the default icon theme in karmic), I made a very basic gray-scale version of the Caffeine icon. You can download it here.

Service Manager for Karmic

2009-11-01T00:00:00+00:00

Annoyingly, as karmic has mostly switched to Upstart, it does not include a service manager. While I hope that the gnome service-manager will be updated to include support for upstart soon I have, for the interim, written a very simple service manager.

Be warned: When I say “very simple” I mean “very simple, noob unfriendly, and potentially dangerous”. While it should not harm your computer, I make no guarantees because it is my first PyGTK program and was written in my spare time over a couple of days. A word of warning, the code is very messy and inefficient (understatement).

Link

New Desktop Theme

2009-09-24T00:00:00+00:00

Just in case anyone is interested, here is my new desktop layout.

This theme works with 1280x800 screens. (If you have a different size screen, you will have to modify it)

Download: theme.tar.gz

Font: Droid Sans

Panel: tint2

Install from this PPA
The tint2rc file (from my theme package) to “~/.config/tint2/”

Background: custom (includes panel and conky backgrounds)

Either use my background (background.png) or replace the background layer in background.xcf with your own image and save it as a png.

Conky:

System Information and Calendar.

You can find them in the theme package.

To install:

Create a new folder “~/.conky/”
Copy “cal.conkyrc”, “cal.py” and “system.conkyrc” to “~/.conky/”
Add a new startup item sh -c "conky -d -c ~/.conky/system.conkyrc; conky -d -c ~/.conky/cal.conkyrc"

Theme:

Metacity: Nooto
GTK2: Ghostship
Icons: Elementary

Write a file as root from a non-root vim.

2009-08-14T00:00:00+00:00

Problem

I often edit config files in vim, try to save them, and then realize that I ran vim as a normal user and the config file is in /etc. In the past I would close vim and redo all of my changes as root (using sudo). This is a real pain especially if I had made a lot of changes.

Solution

Add the following to your ~/.vimrc:

cmap w!! w !sudo tee % >/dev/null<CR>:e!<CR><CR>

A while ago I came across this post that describes how to save a file as root from a non-root vim by adding cmap w!! w !sudo tee % >/dev/null to my .vimrc.

The problem is that, after running this command, vim will notice that the file has changed on disk and ask the user if he or she wants to reload it. After a while this got annoying, therefore the multiple CRs (enters) and the :e! (reloads the file).

Apt Repository Permissions

2009-08-06T00:00:00+00:00

I just posted a solution to this idea but thought that I should share it here.

Here is the problem: In order to get the latest features on Ubuntu, people are adding a lot of PPAs. For now there hasn’t, as far as I know, been a case in which a PPA owner has uploaded a malicious package but this is a possibility. Uploading an end user application, such as shutter, with malicious code would be problematic but not devastating. On the other hand, uploading a malicious sudo package would be devastating. Here is my solution.

Different repositories would “own” packages:

Ownership would be set in a file such as /etc/apt/ownership/.list
A special system packages file would be created that would designate system packages (sudo, pam etc…).

Apt repositories would have permissions:

Ultimate Trust: Update and Install packages from this repository regardless of ownership including system packages.
All: Update and Install new packages from this repository regardless of ownership (except system owned packages).
Owned only: Update and install only owned packages.
No Updates: Install owned packages from this repository but do not download updates from it.

Flags:

Warning: There would be a warning flag that a user could set on a repository that would warn when packages are updated or installed from that repository.
System: There would be a system flag that could be set on security related packages (sudo, bash etc…) that would prevent all but “Ultimate Trust” repositories from installing/updating them.

Dark-Minimal Lock Dialog

2009-07-27T00:00:00+00:00

I finally uploaded my first contribution to gnome-look.org: Dark-Minimal Lock Dialog.

Screenshot

Download

Gnome-Look.org

Navigate text with vi(m) keys on linux

2009-06-05T00:00:00+00:00

Intro

Lifehacker recently posted a AutoHotkey script for windows that allows text navigation using letters instead of the arrow keys. In response to @wersdaluv’s post, I wrote a very simple script that allows users to navigate text using the standard vim keys (hjkl) when the caps-lock key is toggled. Feel free and add to my very basic script.

Steps

Download my script (via copy and paste) from ~~here~~. Lost (email if found).
Save the script somewhere where you will not delete it and mark it as executable (chmod u+x /path/to/script.sh)
Add the script to the startup programs with the argument init (i.e. /path/to/script.sh init). If you don’t know how to add startup programs in your Desktop Environment, Google it.
Assign F13 (the now remapped capslock key), as a hotkey in your window manager. Set the command to '/path/to/script.sh toggle'. Again, if you don’t know how to add a hotkey, Google it.
Now either log out and then in or run ’/path/to/script.sh init' in order to remap the capslock key.
Pressing the capslock key should now toggle navigation mode.

Bash completion with aptitude aliases

2009-05-24T00:00:00+00:00

Problem

If I used my alias for installing an application (inst application), I would have to know the full application name because I would not have bash completion. This was very annoying when installing libraries because they often have weird version strings tacked on to their ends.
If I used the full command (sudo aptitude install application), I would have bash completion and would therefore not have to know the whole application name. I could simply type libxul and get libxul0d.

On one hand, I would type a short command plus a complected application name, on the other I would type a long command and a simple application name. I wanted to be able to type a short command with a simple application name.

Solution

I wrote my own bash completion rules. They are based on the default aptitude bash completion rules but customized for aliases.

# Install Completion
#
_aptitude_all()
{
        local cur dashoptions

        COMPREPLY=()
        cur=`_get_cword`

        dashoptions='-S -u -i -h --help --version -s --simulate -d \
                     --download-only -P --prompt -y --assume-yes -F \
                     --display-format -O --sort -w --width -f -r -g \
                     --with-recommends --with-suggests -R -G \
                     --without-recommends --without-suggests -t \
                     --target-release -V --show-versions -D --show-deps\
                     -Z -v --verbose --purge-unused'

        if [[ "$cur" == -* ]]; then
            COMPREPLY=( $( compgen -W "$dashoptions" -- $cur ) )
        else
                COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
        fi
        return 0
}
_aptitude_installed()
{
        local cur dashoptions

        COMPREPLY=()
        cur=`_get_cword`

        dashoptions='-S -u -i -h --help --version -s --simulate -d \
                     --download-only -P --prompt -y --assume-yes -F \
                     --display-format -O --sort -w --width -f -r -g \
                     --with-recommends --with-suggests -R -G \
                     --without-recommends --without-suggests -t \
                     --target-release -V --show-versions -D --show-deps\
                     -Z -v --verbose --purge-unused'

        if [[ "$cur" == -* ]]; then
            COMPREPLY=( $( compgen -W "$dashoptions" -- $cur ) )
        else
                COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
        fi
        return 0
}
complete -F _aptitude_all $default inst
complete -F _aptitude_all $default upgrade
complete -F _aptitude_all $default apt-info
complete -F _aptitude_all $default apt-changes
complete -F _aptitude_all $default apt-download
complete -F _aptitude_installed $default uninst
complete -F _aptitude_installed $default reinst
complete -F _aptitude_installed $default purge

Just copy it into a file such as ~/.bash_completion and source the file in your ~/.bashrc by adding “. ~/.bash_completion”.

Change/Add/Remove the aliases at the end of the file. The lines that start with complete -F _aptitude_all complete any available or installed package and lines that start with complete -F _aptitude_installed complete only installed packages.

inst, upgrade, apt-info, apt-changes…. are my aliases. You must use YOUR ALIASES for this to work. To add aliases, read this.

How to invite someone to Ubuntu One

2009-05-24T00:00:00+00:00

For anyone with an Ubuntu One account, the following are instructions for sending invites:

Go to My Files in the web interface.
Create a new folder (to be shared) with the person that you will be inviting
Go to the sharing tab (on the right).
Share the folder with the person that you want to invite (The trick is that someone does not have to have an Ubuntu One account to accept a share).

http://ubuntuone.com

For anyone looking for an invite, just ask @bugabundo at Identi.ca.

Grdc - A very good graphical VNC viewer for the average linux user

2009-05-20T00:00:00+00:00

Overview

After finding myself frustrated with Vinagre’s (GNOME’s standard VNC viewer) lack of ssh tunneling support I began looking for an alternative. I finally found it: Grdc.

Grdc supports both VNC and RDP. Grdc can tunnel both connections over ssh for security. The ssh tunneling supports key based or password based authentication and allows the user to select a custom server and port (if they differ from the defaults).

Grdc’s user interface is much simpler than that of Vinagre. It allows the user to create and save custom connections and organize them by groups. Its connection quality settings are, unlike many remote desktop programs, quite simple. The user simply chooses the quality and the number of colors. Grdc also has a panel applet for the gnome-panel that lets users connect to their saved connections through a simple menu.

Another interesting feature is the “VNC Incoming Connection” protocol. This protocol lets users create new VNC servers with custom ports and passwords on the fly. This is especially useful if a user wants to let a remote user temporarily control their desktop.

Grdc does not support everything. It does not support tabbed connections like Vinagre but, in my opinion, tabbed connections are overkill for most users. It also does not support browsing a network for VNC connections with avahi as Vinagre does. This feature would be useful for administrators but is somewhat useless for the average user because most users will access the computer from the internet, not the LAN, and thus avahi support would be pointless.

Overall, Grdc is good for remote, internet traversing connections because of its ssh support and is useful to the average user because of its simplicity. Vinagre is still a better VNC client for administrators that have to manage many computers over a LAN because, on a LAN, encryption is usually unnecessary while avahi support is helpful and, when managing multiple computers, tabs are very helpful.

For screenshots see the SourceForge Screenshot Page

Installation

As of the writing of this post, the version of Grdc in the ubuntu repositories is woefully out of date and does not support ssh tunneling. Therefore one should use the deb provided by the project maintainers on sourceforge. Simply download the grdc deb (link below) and install (usually just double click). The grdc-gnome package is the gnome-panel applet and the grdc package is the main program.

Downloads: http://sourceforge.net/project/showfiles.php?group_id=248852

Homepage: http://grdc.sourceforge.net/

– Edit: I have packaged a 64bit version. Download here.

– Edit 2: The 64bit version of grdc-gnome (the panel applet) for karmic seems to work in jaunty. Download here.

How to record one's linux computer with pulseaudio

2009-03-21T00:00:00+00:00

I posted a simple tip to an Identi.ca user (mxc) explaining how to record a skype conversation and felt that others might find the information useful. Here is an elaborated explanation of how to record the sound from a linux computer.

Install pavucontrol and the gnome-sound-recorder (in the gnome-media package).
Open the gnome-sound-recorder and start recording
Open the pulseaudio volume control and switch to the recording tab
Click on the down arrow of the “gnome-sound-recorder” Record Stream, Select “Move Stream” and move the stream to the “Monitor” stream for your sound card.

This should record all sound from your computer if you are using pulseaudio. I have not tested this with skype but it should work.

Identi.ca feed fetcher script

2009-03-11T00:00:00+00:00

Attached is a simple Identi.ca feed fetcher script written in python. It is a console program and has no gui. It will display the same content as would appear on a users Identi.ca homepage for a given user. Edit the configuration at the head of the script before use.

It works well with conky; simply add ${exec python /path/to/script.py} to your conky file and it will update whenever your conky refreshes. If your conky config is set to update very frequently, please use ${execi interval /path/to/script.py} so that you are not constantly polling identi.ca’s server.

Edit 1: Updated script to correctly encode text and to include replies.
Edit 2: Inline script to fix broken link.

Script:

#!/usr/bin/python
# -*- coding: utf-8 -*-

# Copyright (C) 2008 Steven
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# Blog: http://blog.stebalien.com

import feedparser
import textwrap
import unicodedata
### SETTINGS ###
# Username (lowercase)
USER = "stebalien"
# Width in charictars of output
WIDTH = 50
# Number of posts to display
POSTS = 10

# Indent of posts
INDENT_FIRST = 3
INDENT_REST = 5

################

def formatPost(string):
    #string = string..replace(unicode("“", "utf-8"), '"').replace(unicode("”", "utf-8"), '"').replace(unicode("…", "utf-8"), '...').replace(unicode("’", "utf-8"), "'")
    string = unicodedata.normalize('NFKD', string).encode('ascii','ignore')
    parts = string.partition(':')
    return parts[0] + parts[1] \
    + "\n" + wrapper.fill('\n' \
    + parts[2]) \
    + "\n\n"

wrapper = textwrap.TextWrapper()
wrapper.subsequent_indent = ' '*INDENT_FIRST
wrapper.initial_indent = ' '*INDENT_REST
wrapper.width = WIDTH
# Get and display feed
all_feed = feedparser.parse("http://identi.ca/" + USER + "/all/rss")
reply_feed = feedparser.parse("http://identi.ca/" + USER + "/replies/rss")

n = 0
i = 0

while ((i+n) < POSTS):
    while (reply_feed.entries[n].updated_parsed > all_feed.entries[i].updated_parsed):
        print "> " + formatPost(reply_feed.entries[n].title)
        n=n+1
    print "  " + formatPost(all_feed.entries[i].title)
    i=i+1

Mumbles screenshot

2008-11-20T00:00:00+00:00

Here is a screenshot of mumbles.

Banshee Plugin for mumbles

2008-11-20T00:00:00+00:00

I Just wrote a banshee plugin for mumbles. It works much better than banshee’s default notification daemon integration. Clicking on the notification brings banshee to the front. Install it like you would any other mumbles plugin (see two posts back or look for instructions on the mumbles homepage).

Plugin (python 2.5) + Source: banshee-plugin_mumbles.tar.gz

Change the notification icon in Mumbles without creating a plugin.

2008-11-17T00:00:00+00:00

I have noticed that several people have asked how to change the notification icon on mumbles without creating a new plugin.This is actually very simple: use the generic DBus plugin with dbus-send. I believe that this tutorial requires the SVN version but I may be mistaken. First add a new section to your DBus plugin configuration file. If you do not have this configuration file, copy the sample one from the mumbles source tarball (found on the project’s homepage). The file is called dbus.conf.sample. Copy this file to ~/.mumbles/dbus.conf. The new section is as follows:

[program-or-script-name]
enabled = true
interface = org.program-or-script-name.DBus
path = /org/program-or-script-name/DBus
signal = your-signal
icon = your-icon.png

Put your-icon.png in the ~/.mumbles/plugins/icons/ folder.your-signal is your name for the alert. None of these variables are important but they must be consistent.

After doing the previous and restarting mumbles, run this command:

dbus-send /org/program-or-script-name/DBus org.`*program-or-script-name*`.DBus.your-signal string:"Title" string:"Message"

Make sure that you replace all necessary variables. This will display a mumbles popup with your custom icon, title, and message. You can also specify a click action using launch = action.

Mumbles with gmail

2008-11-16T00:00:00+00:00

I have been playing around with mumbles lately and have written a gmail plugin for anyone interested. Mumbles is a notification system that works very much like growl for the mac. The latest SVN version can even replace the gnome notification daemon (but not very well). While still in its infancy, this project shows a lot of promise. I based the plugin on the evolution tutorial on project’s homepage. I based the script on this script (with many modifications). When you click on the notification popup, evolution will launch (you can edit the source to change the program). The script requires python-feedparser.

Plugin, Source, and Script package: gmail-plugin_mumbles.tar.gz

Installing the precompiled plugin:

Installing the plugin from source (adapted from dot_j’s ~~tutorial~~ (gone)):

Installing the script:

BTW: This script does not safely store the username and password. I may, in the distant future, make this script work with gnome-keyring but this is not likely. I hope that mumbles will soon get better notification-daemon support so that I can go back to using mail-notification.

OpenID: More accepters, less providers.

2008-10-29T00:00:00+00:00

I am noticing a very annoying and self-defeating trend with OpenIDs. The main purpose of OpenID is to allow people to have one login for multiple sites. OpenID is pointless if few sites accept it. This problem will correct itself eventually as more sites adopt OpenID. The biggest problem is the number of sites providing and not accepting OpenID. This defeats the whole purpose of OpenID. It is pointless to have a myriad of choices for OpenIDs if you can’t use them anywhere. Multiple OpenIDs for multiple sites just means multiple logins which is the very thing that OpenID is supposed to fix. I hope that many sites *ahem blogger* will soon start accepting OpenIDs as login credentials instead of just providing them.

General bug reporting rant

2008-09-19T00:00:00+00:00

I am starting to see this very often and find it very annoying: people report a bug, later they find a preexisting report for the same bug, they then mark that preexisting bug as a duplicate of their bug. I end up getting lots of “this bug has been marked as a duplicate of bug x” emails and this is VERY annoying. To prevent this people need to rigorously check for a preexisting report. Second, when you find two duplicate bugs, search the bug tracker for any more duplicates and mark all of the newest duplicates as duplicates of the oldest bug. This prevents chains of duplicates which in turn maximizes the efficiency of the bug reporting and fixing process.

Example:

Chained:

 report 1     ->    report 2     ->     report 3     ->     report 4
    |                  |                   |                   |
Commenters         Commenters           Commenters         All commenters
from report 1      from reports 1-2     from report 1-3

Non-chained:

report 1 ----\
 commenters 1 \
report 2 ------> report 4
 commenters 2 /   all commenters
report 3 ----/
 commenters 3

In the chained version commenters move from report to report wasting comments on bugs that will probably never be seen again after being marked a duplicate. In the non-chained version commenters move directly from the duplicate to the final (and oldest) bug report wasting as few as comments possible on the duplicates.

Linux + Razer Lycosa = WTF

2008-09-06T00:00:00+00:00

I broke my previous keyboard and went shopping for a new one (FYI: water + G15 == not good). I wanted another back-lit keyboard (like my previous G15). When I went to Best Buy (not my favorite store) I saw the slick Raser Lycosa Keyboard I decided to try it. My advice: don’t. While the keyboard itself is great (I like the low, rubber covered keys) the neither the the USB port nor the headphone jack worked on either of the keyboards that I tried (I returned the first one and tried the second one in the store). The problem: Interference. My computer refused to mount my USB flash drive while plugged into the Lycosa and the headphones buzzed (like a radio). I ended up getting the latest (annoyingly orange) G15 keyboard which works but I HATE ORANGE.

Inline Comments

2008-08-18T00:00:00+00:00

I Finaly got around to enabling inline comments. For help on this, follow this tutorial.

vCard viewer perl script

2008-06-27T00:00:00+00:00

I needed a simple way to view vCards in mutt and found a few Perl scripts that could parse and display vCards but none of them worked very well. I searched the ubuntu repository, found libtext-vcard-perl, and wrote a simple Perl script using this library.

Past this in vcard-view.pl:

#!/usr/bin/perl
# Copyright (C) 2008, Steven Allen
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see //www.gnu.org/licenses/>.

# This program parses vCards and displays their contents in a
# human readable form.

# Import libtext-vcard-perl library
use Text::vCard::Addressbook;
use Text::vCard::Node;
use Text::vCard;

# Get card name
my $card_file = $ARGV[0];

# Create Addressbook
my $address_book = Text::vCard::Addressbook->new({
 'source_file' => $card_file,
});

#Loop through Addressbook
foreach my $vcard ($address_book->vcards()) {
 print "=" . ( "=" x 59 ) . "\n";

 # Name/Email
 print "Name:\n " . $vcard->fullname();
 $count = 0;
 my $emails = $vcard->get({ 'node_type' => 'EMAIL' });
 foreach my $email (@{$emails}) {
  if ($count == 0) {
   $space = " ";
  } else {
   $space = "  " . ( " " x length ($vcard->fullname()) );
  }
  if($email->is_type('home')) {
   print $space . "" . $email->value() . "> (Home)\n";
  } elsif ($email->is_type('work')) {
   print $space . "" . $email->value() . "> (Work)\n";
  } else {
   print $space . "" . $email->value() . ">\n";
  }
  $count++;
 }

 # Address
 my $addresses = $vcard->get({ 'node_type' => 'addresses' });
 print "\nAddresses:\n";
 foreach my $address (@{$addresses}) {
  if($address->is_type('home')) {
   print " --------------------------------\n";
   print "\t" . $address->street() . "\n";
   print " Home:\t" . $address->city() . ", " . $address->region() . "\n";
   print "\t" . $address->post_code() . ", " . $address->country() . "\n";
   print " --------------------------------\n";
  } elsif ($address->is_type('work')) {
   print " --------------------------------\n";
   print "\t" . $address->street() . "\n";
   print " Work:\t" . $address->city() . ", " . $address->region() . "\n";
   print "\t" . $address->post_code() . ", " . $address->country() . "\n";
   print " --------------------------------\n";
  } else {
   print " --------------------------------\n";
   print "\t" . $address->street() . "\n";
   print " Other:\t" . $address->city() . ", " . $address->region() . "\n";
   print "\t" . $address->post_code() . ", " . $address->country() . "\n";
   print " --------------------------------\n";
  }
 }
 # Phones
 print "Phones:\n";
 my $tels = $vcard->get({ 'node_type' => 'tel' });
 foreach my $tel (@{$tels}) {
  if($tel->is_type('home')) {
   print " Home:\t" . $tel->value() . "\n";
  } elsif ($tel->is_type('cell')) {
   print " Cell:\t" . $tel->value() . "\n";
  } elsif ($tel->is_type('work')) {
   print " Work:\t" . $tel->value() . "\n";
  } else {
   print " Other:\t" . $tel->value() . "\n";
  }
 }
 # URL
 my $urls = $vcard->get({ 'node_type' => 'URL' });
 foreach my $url (@{$urls}) {
  print "Web:\t" . $url->value() . "\n";
 }
 print "=" . ( "=" x 59 ) . "\n";
}

Running the "Ubunu System Panel" on a 64 bit machine.

2008-06-19T00:00:00+00:00

After installing the 64 bit version of Ubuntu on my Dell Inspiron 1420n I found that the USP (Ubuntu System Panel) keybindings do not work. This is because the /usr/lib/python2.4/site-packages/usp/plugins/_keybinder.so is compiled for a 32 bit system. After a little searching I found out that Glipper includes a _keybinder.so file. After replacing USP’s _keybinder.so with Glipper’s version, the keybindings worked fine.

Download glipper aptitude download glipper.
Extract the glipper deb with dpkg-deb -x glipper_1.0-1ubuntu1_amd64.deb glipper (change glipper_1.0-1ubuntu1_amd64.deb to the name of your file).
Copy in the new _keybinder.so with sudo cp ./glipper/usr/lib/python-support/glipper/python2.5/glipper/keybinder/_keybinder.so /usr/lib/python2.4/site-packages/usp/plugins/_keybinder.so.
Restart USP with killall gnome-panel and your USP shortcut keys should now work.

Edit: This is no longer necessary.

Latte rant

2008-06-19T00:00:00+00:00

I religiously drink decaf lattes (by “religiously” I mean every Sunday) and am becoming very annoyed with the common misconception that lattes are just coffee and milk. True lattes are not made with standard coffee beans, they are made with espresso beans. Espresso beans are roasted longer and thus are much richer but less bitter. Many so called coffee shops claim to sell lattes but use regular coffee beans in their espresso machine. The resulting drink is not a café latte. It is called a café au lait.

Here’s my plea: Coffee shops, please correctly label your drinks.

PS: If you go to Canada, bring your own espresso. I can’t find a decent Latte in all of Nova Scotia.

New Compiz transparency

2008-06-07T00:00:00+00:00

This may not be new but, after upgrading compiz from git today, I noticed that certain windows (gnome-system-monitor and the AWN manager) were semi-transparent. See the screenshot:

Edit: As far as I can tell, the Murrine engine, not compiz, is not causing the transparency.

Conky: The simple system monitor

2008-06-02T00:00:00+00:00

Conky is a simple system monitor that uses very little ram.

I have 2 conky-rc files: a system monitor and a weather display.

I wrote my system monitor from scratch and my weather display is based on this tutorial.

System Monitor conkyrc

# System Monitor
# Stebalien.com
# set to yes if you want Conky to be forked in the background
background no

# Use Xft?
use_xft yes

# Xft font when Xft is enabled
xftfont Bitstream Vera Sans Mono:size=8

# Text alpha when using Xft
xftalpha 0.8

# Update interval in seconds
update_interval 5.0

# This is the number of times Conky will update before quitting.
# Set to zero to run forever.
total_run_times 0

# Create own window instead of using desktop (required in nautilus)
own_window yes

# If own_window is yes, you may use type normal, desktop or override
own_window_type override

# Use pseudo transparency with own_window?
own_window_transparent yes

# If own_window_transparent is set to no, you can set the background colour here
own_window_colour black

# If own_window is yes, these window manager hints may be used
#own_window_hints undecorated,below,sticky,skip_taskbar,skip_pager

# Use double buffering (reduces flicker, may not work for everyone)
double_buffer yes

# Minimum size of text area
minimum_size 280 5

# Draw shades?
draw_shades yes

# Draw outlines?
draw_outline no

# Draw borders around text
draw_borders no

# Draw borders around graphs
draw_graph_borders yes

# Stippled borders?
stippled_borders 8

# border margins
border_margin 4

# border width
border_width 1

# Default colors and also border colors
default_color white
default_shade_color black
default_outline_color black

# Text alignment, other possible values are commented
#alignment top_left
#alignment top_right
alignment bottom_left
#alignment bottom_right
#alignment none

# Gap between borders of screen and text
# same thing as passing -x at command line
gap_x 12
gap_y 12

# Subtract file system buffers from used memory?
no_buffers yes

# set to yes if you want all text to be in uppercase
uppercase no

# number of cpu samples to average
# set to 1 to disable averaging
cpu_avg_samples 2

# number of net samples to average
# set to 1 to disable averaging
net_avg_samples 2

# Force UTF8? note that UTF8 support required XFT
override_utf8_locale no

# Add spaces to keep things from moving about?  This only affects certain objects.
use_spacer no

color1 SteelBlue4
TEXT
${color1}${tcp_portmon 50005 50005 lservice 0}          ${color green}${tcp_portmon 50005 50005 rip 0}
${color1}Drives:      ${color lightgrey}Lin:${color}${fs_used_perc /}% | ${color lightgrey}Home:${color}${fs_used_perc /home}% | ${color lightgrey}Ext:${color}${fs_used_perc /media/ext}%
${color1}Network:     ${color lightgrey}Down:$color${downspeed ath0} k/s | ${color lightgrey}Up:$color${upspeed ath0} k/s
${color1}System:      ${color lightgrey}CPU:$color$cpu% | ${color lightgrey}RAM:$color$memperc% | ${color lightgrey}SWAP:$color$swapperc%

Replace ath0 with the name of your network interface.

Weather Display conkyrc

# Weather display
# Stebalien.com
# set to yes if you want Conky to be forked in the background
background no

# Use Xft?
use_xft yes

# Xft font when Xft is enabled
#xftfont Bitstream Vera Sans Mono:size=8
#xftfont Terminus:size=8
xftfont Liberation Sans:size=8

# Text alpha when using Xft
xftalpha 0.8

# Print everything to console?
# out_to_console no

# mail spool
#mail_spool $MAIL

# Update interval in seconds
update_interval 5.0

# This is the number of times Conky will update before quitting.
# Set to zero to run forever.
total_run_times 0

# Create own window instead of using desktop (required in nautilus)
own_window no

# Use double buffering (reduces flicker, may not work for everyone)
double_buffer yes

# Minimum size of text area
minimum_size 100 5
maximum_width 600

# Draw shades?
draw_shades no

# Draw outlines?
draw_outline no

# Draw borders around text
draw_borders no
draw_graph_borders yes

# Stippled borders?
stippled_borders 8

# border margins
border_margin 4

# border width
border_width 1

# Default colors and also border colors
default_color white
default_shade_color black
default_outline_color white

# own window options
own_window  yes
own_window_transparent yes
own_window_type  override
own_window_hints undecorated,below,sticky,skip_taskbar,skip_pager

# Text alignment, other possible values are commented
#alignment top_left
#alignment top_right
#alignment bottom_left
alignment bottom_right

# Gap between borders of screen and text
# same thing as passing -x at command line
gap_x 10
gap_y -10

# Subtract file system buffers from used memory?
no_buffers yes

# set to yes if you want all text to be in uppercase
uppercase no

# number of cpu samples to average
# set to 1 to disable averaging
cpu_avg_samples 2

# number of net samples to average
# set to 1 to disable averaging
net_avg_samples 2

# Force UTF8? note that UTF8 support required XFT
override_utf8_locale yes

# Add spaces to keep things from moving about?  This only affects certain objects.
use_spacer yes

# colors
color1 white
# light blue
color2 6892C6
# orange
color3 E77320
# green
color4 78BF39
# red
color5 CC0000
# Steel blue
color6 SteelBlue4

# variable is given either in format $variable or in ${variable}. Latter
# allows characters right after the variable and must be used in network
# stuff because of an argument

# stuff after 'TEXT' will be formatted on screen

TEXT
$color6${hr 1}
 ${voffset -2}Now:
${voffset -6}${hr 1}
   ${voffset -8}$color${font weather:size=64}${execi 3600 python ~/.conky/conkyForecast.py --location=USCA0638 --datatype=WF}${font}
                     ${voffset -66}Conditions: ${execi 3600 python ~/.conky/conkyForecast.py --location=USCA0638 --datatype=CC}
                     Temp: ${execi 3600 python ~/.conky/conkyForecast.py -i --location=USCA0638 --datatype=HT}
                     Wind: ${execi 3600 python ~/.conky/conkyForecast.py -i --location=USCA0638 --datatype=WS} ${execi 3600 python ~/.conky/conkyForecast.py --location=USCA0638 --datatype=WD}
                     Humidity: ${execi 3600 python ~/.conky/conkyForecast.py --location=USCA0638 --datatype=HM}
${voffset -4}$color6${hr 1}
  ${voffset -2}${execi 3600 python ~/.conky/conkyForecast.py --location=USCA0638 --datatype=DW --shortweekday --startday=0 --spaces=9 --endday=4}
${voffset -6}${hr 1}
$color${voffset 4}${font weather:size=24}${execi 3600 python ~/.conky/conkyForecast.py --location=USCA0638 --datatype=WF --startday=0 --endday=4 --spaces=1}${font}
          ${font Liberation Sans:size=6}${voffset -36}${execi 3600 python ~/.conky/conkyForecast.py -i --location=USCA0638 --datatype=HT --startday=0 --endday=4 --spaces=18}
               ${execi 3600 python ~/.conky/conkyForecast.py -i --location=USCA0638 --datatype=LT --startday=0 --endday=4 --spaces=17}
               ${execi 3600 python ~/.conky/conkyForecast.py --location=USCA0638 --datatype=PC --startday=0 --endday=4 --spaces=19}

Replace ~/.conky/conkyForecast.py with the location of your weather script. Replace USCA0638 with your city code (see the tutorial link at the beginning of this post).

Conky weather script

#!/usr/bin/python
# -*- coding: utf-8 -*-
###############################################################################
# conkyForecast.py is a (not so) simple (anymore) python script to gather
# details of the current weather for use in conky.
#
#  Author: Kaivalagi
# Created: 13/04/2008
# Modifications:
# 14/04/2008 Allow day ranges for forecast data
# 14/04/2008 Check for connectivity to xoap service
# 18/04/2008 Allow the setting of spaces for ranged output
# 18/04/2008 Allow Night and Day forecast output
# 18/04/2008 Support locale for condition code text "CC" option, awaiting spanish language translation
# 18/04/2008 Use pickling for class data rather than opening xml, this bypasses the need to interrogate cached data
# 19/04/2008 Added spanish condition text - Thanks Bruce M
# 19/04/2008 Added isnumeric check on all numeric output with units suffix
# 19/04/2008 Altered pickle file naming to include location code
# 19/04/2008 Added spanish week days conversion via locale
# 20/04/2008 Added decent command argument parser
# 20/04/2008 Added --shortweekday option, if given the day of week data type is shortened to 3 characters
# 21/04/2008 Fixed locale options for forecast output
# 21/04/2008 Added --template option to allow custom output using a single exec call :)
# 21/04/2008 Added --hideunits option to remove, for example, mph and C from output
# 23/04/2008 Removed --imperial option from template, this MUST be set as a standard option on the script call and not used in the template file.
# 23/04/2008 Readded --imperial option to template, enabling metric or imperial values per datatype. Note when using templates command line option will not work.
# 23/04/2008 Added output notifying user if the location given is bad
# 24/04/2008 Added handling for no connectivity, will revert to cached data now (erroring if no cache exists). Tests by trying to open xoap.weather.com
# 24/04/2008 Fixed Celsius to fahrenheit conversion
# 06/05/2008 Updated url used after webservice was updated
# 09/05/2008 Consolidated current condition and forecast data fetch into one call
# 09/05/2008 Added Sunrise and sunset to datatypes, these are specific to both current conditions and forecast data
# 09/05/2008 Added moon phase, barometer reading and barometer description to datatypes, these are only specific to current conditions and so are N/A in forecasted output
# 09/05/2008 Added unit conversions for barometer from mb to inches (imperial)
#   09/05/2008  Updated spanish condition text - Thanks Bruce M
#   10/05/2008  Added french locale data - Thanks benpaka
#   12/05/2008  Added new BF (bearing font) datatype to provide an arrow character (use with Arrow.ttf font) instead of NSEW output from WD (wind direction)
#   12/05/2008  Updated WD output to be locale specific, currently supports default english and spanish - Thanks Bruce M
# 18/05/2008 Added new MF (moon font) datatype to provide a moon font character (characters incorrect and no dedicated font yet).
# 21/05/2008 For current conditions the --datatype=LT option now displays "feels like" temperature rather than the current temperature
#
# TODO:
# Consolidate pkl files into one file/class
# Add a weather font based moon phase output based on moon icon data
# ??? Any more requirements out there?

import sys, os, socket, urllib2, datetime, time
from xml.dom import minidom
from stat import *
from optparse import OptionParser
import locale
import gettext
import pickle
from math import *

APP="conkyForecast.py"
DIR=os.path.dirname (__file__) + '/locale'
gettext.bindtextdomain(APP, DIR)
gettext.textdomain(APP)
_ = gettext.gettext

class CommandLineParser:

    parser = None

    def __init__(self):

        self.parser = OptionParser()
        self.parser.add_option("-l","--location", dest="location", default="UKXX0103", type="string", metavar="CODE", help=u"location code for weather data [default: %default],Use the following url to determine your location code by city name: http://xoap.weather.com/search/search?where=Norwich")
        self.parser.add_option("-d","--datatype",dest="datatype", default="HT", type="string", metavar="DATATYPE", help=u"[default: %default] The data type options are: DW (Day Of Week), WF (Weather Font Output), LT (Forecast:Low Temp,Current:Feels Like Temp), HT (Forecast:High Temp,Current:Current Temp), CC (Current Conditions), CT (Conditions Text), PC (Precipitation Chance), HM (Humidity), WD (Wind Direction), WS (Wind Speed), WG (Wind Gusts), CN (City Name), SR (sunrise), SS (sunset), MP (moon phase), MF (moon font), BR (barometer reading), BD (barometer description). Not applicable at command line when using templates.")
        self.parser.add_option("-s","--startday",dest="startday", type="int", metavar="NUMBER", help=u"define the starting day number, if omitted current conditions are output. Not applicable at command line when using templates.")
        self.parser.add_option("-e","--endday",dest="endday", type="int", metavar="NUMBER", help=u"define the ending day number, if omitted only starting day data is output. Not applicable at command line when using templates.")
        self.parser.add_option("-S","--spaces",dest="spaces", type="int", default=1, metavar="NUMBER", help=u"[default: %default] Define the number of spaces between ranged output. Not applicable at command line when using templates.")
        self.parser.add_option("-t","--template",dest="template", type="string", metavar="FILE", help=u"define a template file to generate output in one call. A displayable item in the file is in the form {--datatype=HT --startday=1}. The following are possible options within each item: --datatype,--startday,--endday,--night,--shortweekday,--imperial,--hideunits,--spaces . Note that the short forms of the options are not currently supported! None of these options are applicable at command line when using templates.")
        self.parser.add_option("-L","--locale",dest="locale", type="string", help=u"override the system locale for language output (en=english, es=spanish, fr=french, more to come)")
        self.parser.add_option("-i","--imperial",dest="imperial", default=False, action="store_true", help=u"request imperial units, if omitted output is in metric. Not applicable at command line when using templates.")
        self.parser.add_option("-n","--night",dest="night", default=False, action="store_true", help=u"switch output to night data, if omitted day output will be output. Not applicable at command line when using templates.")
        self.parser.add_option("-w","--shortweekday",dest="shortweekday", default=False, action="store_true", help=u"Shorten the day of week data type to 3 characters. Not applicable at command line when using templates.")
        self.parser.add_option("-u","--hideunits",dest="hideunits", default=False, action="store_true", help=u"Hide units such as mph or C, degree symbols (°) are still shown. Not applicable at command line when using templates.")
        self.parser.add_option("-v","--verbose",dest="verbose", default=False, action="store_true", help=u"request verbose output, no a good idea when running through conky!")
        self.parser.add_option("-r","--refetch",dest="refetch", default=False, action="store_true", help=u"fetch data regardless of data expiry")

    def parse_args(self):
        (options, args) = self.parser.parse_args()
        return (options, args)

    def print_help(self):
        return self.parser.print_help()

class WeatherData:
    def __init__(self, day_of_week, low, high, condition_code, condition_text, precip, humidity, wind_dir, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc):
        self.day_of_week = u""+day_of_week
        self.low = u""+low
        self.high = u""+high
        self.condition_code = u""+condition_code
        self.condition_text = u""+condition_text
        self.precip = u""+precip
        self.humidity = u""+humidity
        self.wind_dir = u""+wind_dir
        self.wind_speed = u""+wind_speed
        self.wind_gusts = u""+wind_gusts
        self.city = u""+city
        self.sunrise = u""+sunrise
        self.sunset = u""+sunset
        self.moon_phase = u""+moon_phase
        self.moon_icon = u""+moon_icon
        self.bar_read = u""+bar_read
        self.bar_desc = u""+bar_desc


class WeatherText:

    conditions_text = {
        "0": _(u"Tornado"),
        "1": _(u"Tropical Storm"),
        "2": _(u"Hurricane"),
        "3": _(u"Severe Thunderstorms"),
        "4": _(u"Thunderstorms"),
        "5": _(u"Mixed Rain and Snow"),
        "6": _(u"Mixed Rain and Sleet"),
        "7": _(u"Mixed Precipitation"),
        "8": _(u"Freezing Drizzle"),
        "9": _(u"Drizzle"),
        "10": _(u"Freezing Rain"),
        "11": _(u"Showers"),
        "12": _(u"Showers"),
        "13": _(u"Snow Flurries"),
        "14": _(u"Light Snow Showers"),
        "15": _(u"Blowing Snow"),
        "16": _(u"Snow"),
        "17": _(u"Hail"),
        "18": _(u"Sleet"),
        "19": _(u"Dust"),
        "20": _(u"Fog"),
        "21": _(u"Haze"),
        "22": _(u"Smoke"),
        "23": _(u"Blustery"),
        "24": _(u"Windy"),
        "25": _(u"Cold"),
        "26": _(u"Cloudy"),
        "27": _(u"Mostly Cloudy"),
        "28": _(u"Mostly Cloudy"),
        "29": _(u"Partly Cloudy"),
        "30": _(u"Partly Cloudy"),
        "31": _(u"Clear"),
        "32": _(u"Clear"),
        "33": _(u"Fair"),
        "34": _(u"Fair"),
        "35": _(u"Mixed Rain and Hail"),
        "36": _(u"Hot"),
        "37": _(u"Isolated Thunderstorms"),
        "38": _(u"Scattered Thunderstorms"),
        "39": _(u"Scattered Thunderstorms"),
        "40": _(u"Scattered Showers"),
        "41": _(u"Heavy Snow"),
        "42": _(u"Scattered Snow Showers"),
        "43": _(u"Heavy Snow"),
        "44": _(u"Partly Cloudy"),
        "45": _(u"Thunder Showers"),
        "46": _(u"Snow Showers"),
        "47": _(u"Isolated Thunderstorms"),
        "na": _(u"N/A"),
        "-": _(u"N/A")
    }

    conditions_text_es = {
        "0": _(u"Tornado"),
        "1": _(u"Tormenta Tropical"),
        "2": _(u"Huracá¡n"),
        "3": _(u"Tormentas Fuertes"),
        "4": _(u"Tormentas"),
        "5": _(u"Lluvia y Nieve Mezclada"),
        "6": _(u"Lluvia y Aguanieve Mezclada"),
        "7": _(u"Aguanieve"),
        "8": _(u"Llovizna Helada"),
        "9": _(u"Llovizna"),
        "10": _(u"Lluvia Engelante"), # o lluvia helada
        "11": _(u"Chaparrones"),
        "12": _(u"Chaparrones"),
        "13": _(u"Nieve Ligera"),
        "14": _(u"Nieve Ligera"),
        "15": _(u"Ventisca de Nieve"),
        "16": _(u"Nieve"),
        "17": _(u"Granizo"),
        "18": _(u"Aguanieve"),
        "19": _(u"Polvo"),
        "20": _(u"Niebla"),
        "21": _(u"Bruma"),
        "22": _(u"Humo"),
        "23": _(u"Tempestad"),
        "24": _(u"Ventoso"),
        "25": _(u"Fráo"),
        "26": _(u"Muy Nublado"),
        "27": _(u"Principalmente Nublado"),
        "28": _(u"Principalmente Nublado"),
        "29": _(u"Parcialmente Nublado"),
        "30": _(u"Parcialmente Nublado"),
        "31": _(u"Despejado"),
        "32": _(u"Despejado"),
        "33": _(u"Algo Nublado"),
        "34": _(u"Algo Nublado"),
        "35": _(u"Lluvia con Granizo"),
        "36": _(u"Calor"),
        "37": _(u"Tormentas Aisladas"),
        "38": _(u"Tormentas Dispersas"),
        "39": _(u"Tormentas Dispersas"),
        "40": _(u"Chubascos Dispersos"),
        "41": _(u"Nieve Pesada"),
        "42": _(u"Nevadas Débiles y Dispersas"),
        "43": _(u"Nevada Intensa"),
        "44": _(u"Nubes Dispersas"),
        "45": _(u"Tormentas"),
        "46": _(u"Nevadas Dispersas"),
        "47": _(u"Tormentas Aisladas"),
        "na": _(u"N/A"),
        "-": _(u"N/A")
    }

    conditions_text_fr = {
        "0": _(u"Tornade"),
        "1": _(u"Tempête Tropicale"),
        "2": _(u"Ouragan"),
        "3": _(u"Orages Violents"),
        "4": _(u"Orageux"),
        "5": _(u"Pluie et Neige"),
        "6": _(u"Pluie et Neige Mouillée"),
        "7": _(u"Variable avec averses"),
        "8": _(u"Bruine Givrante"),
        "9": _(u"Bruine"),
        "10": _(u"Pluie Glacante"),
        "11": _(u"Averses"),
        "12": _(u"Averses"),
        "13": _(u"Légère Neige"),
        "14": _(u"Forte Neige"),
        "15": _(u"Tempête de Neige"),
        "16": _(u"Neige"),
        "17": _(u"Grêle"),
        "18": _(u"Pluie/Neige"),
        "19": _(u"Nuage de poussière"),
        "20": _(u"Brouillard"),
        "21": _(u"Brume"),
        "22": _(u"Fumée"),
        "23": _(u"Tres Venteux"),
        "24": _(u"Venteux"),
        "25": _(u"Froid"),
        "26": _(u"Nuageux"),
        "27": _(u"Tres Nuageux"),
        "28": _(u"Tres Nuageux"),
        "29": _(u"Nuages Disséminés"),
        "30": _(u"Nuages Disséminés"),
        "31": _(u"Beau"),
        "32": _(u"Beau"),
        "33": _(u"Belles Éclaircies"),
        "34": _(u"Belles Éclaircies"),
        "35": _(u"Pluie avec Grêle"),
        "36": _(u"Chaleur"),
        "37": _(u"Orages Isolés"),
        "38": _(u"Orages Localisés"),
        "39": _(u"Orages Localisés"),
        "40": _(u"Averses Localisées"),
        "41": _(u"Neige Lourde"),
        "42": _(u"Tempête de Neige Localisées"),
        "43": _(u"Neige Lourde"),
        "44": _(u"Nuages Disséminés"),
        "45": _(u"Orages"),
        "46": _(u"Tempête de Neige"),
        "47": _(u"Orages Isolés"),
        "na": _(u"N/A"),
        "-": _(u"N/A")
    }

    conditions_weather_font = {
        "0": _(u"W"),
        "1": _(u"V"),
        "2": _(u"W"),
        "3": _(u"s"),
        "4": _(u"p"),
        "5": _(u"k"),
        "6": _(u"k"),
        "7": _(u"g"),
        "8": _(u"g"),
        "9": _(u"g"),
        "10": _(u"h"),
        "11": _(u"g"),
        "12": _(u"g"),
        "13": _(u"k"),
        "14": _(u"k"),
        "15": _(u"k"),
        "16": _(u"k"),
        "17": _(u"k"),
        "18": _(u"k"),
        "19": _(u"e"),
        "20": _(u"e"),
        "21": _(u"a"),
        "22": _(u"d"),
        "23": _(u"d"),
        "24": _(u"d"),
        "25": _(u"d"),
        "26": _(u"e"),
        "27": _(u"e"),
        "28": _(u"e"),
        "29": _(u"c"),
        "30": _(u"c"),
        "31": _(u"a"),
        "32": _(u"a"),
        "33": _(u"b"),
        "34": _(u"b"),
        "35": _(u"k"),
        "36": _(u"a"),
        "37": _(u"f"),
        "38": _(u"f"),
        "39": _(u"f"),
        "40": _(u"g"),
        "41": _(u"k"),
        "42": _(u"k"),
        "43": _(u"k"),
        "44": _(u"b"),
        "45": _(u"g"),
        "46": _(u"k"),
        "47": _(u"f"),
        "na": _(u""),
        "-": _(u"")
    }

    conditions_moon_font = {
        "0": _(u"0"),
        "1": _(u"1"),
        "2": _(u"2"),
        "3": _(u"3"),
        "4": _(u"4"),
        "5": _(u"5"),
        "6": _(u"6"),
        "7": _(u"7"),
        "8": _(u"8"),
        "9": _(u"9"),
        "10": _(u"10"),
        "11": _(u"11"),
        "12": _(u"12"),
        "13": _(u"13"),
        "14": _(u"14"),
        "15": _(u"15"),
        "16": _(u"16"),
        "17": _(u"17"),
        "18": _(u"18"),
        "19": _(u"19"),
        "20": _(u"20"),
        "21": _(u"21"),
        "22": _(u"22"),
        "23": _(u"23"),
        "24": _(u"24"),
        "25": _(u"25"),
        "na": _(u""),
        "-": _(u"")
    }

    day_of_week = {
        "Today": _(u"Today"),
        "Monday": _(u"Monday"),
        "Tuesday": _(u"Tuesday"),
        "Wednesday": _(u"Wednesday"),
        "Thursday": _(u"Thursday"),
        "Friday": _(u"Friday"),
        "Saturday": _(u"Saturday"),
        "Sunday": _(u"Sunday")
    }

    day_of_week_short = {
        "Today": _(u"Now"),
        "Monday": _(u"Mon"),
        "Tuesday": _(u"Tue"),
        "Wednesday": _(u"Wed"),
        "Thursday": _(u"Thu"),
        "Friday": _(u"Fri"),
        "Saturday": _(u"Sat"),
        "Sunday": _(u"Sun")
    }

    day_of_week_es = {
        "Today": _(u"hoy"),
        "Monday": _(u"lunes"),
        "Tuesday": _(u"martes"),
        "Wednesday": _(u"miércoles"),
        "Thursday": _(u"jueves"),
        "Friday": _(u"viernes"),
        "Saturday": _(u"sábado"),
        "Sunday": _(u"domingo")
    }

    day_of_week_short_es = {
        "Today": _(u"hoy"),
        "Monday": _(u"lun"),
        "Tuesday": _(u"mar"),
        "Wednesday": _(u"mié"),
        "Thursday": _(u"jue"),
        "Friday": _(u"vie"),
        "Saturday": _(u"sáb"),
        "Sunday": _(u"dom")
    }

    day_of_week_fr = {
        "Today": _(u"Aujourd'hui"),
        "Monday": _(u"Lundi"),
        "Tuesday": _(u"Mardi"),
        "Wednesday": _(u"Mercredi"),
        "Thursday": _(u"Jeudi"),
        "Friday": _(u"Vendredi"),
        "Saturday": _(u"Samedi"),
        "Sunday": _(u"Dimanche")
    }

    day_of_week_short_fr = {
        "Today": _(u"Auj"),
        "Monday": _(u"Lun"),
        "Tuesday": _(u"Mar"),
        "Wednesday": _(u"Mer"),
        "Thursday": _(u"Jeu"),
        "Friday": _(u"Ven"),
        "Saturday": _(u"Sam"),
        "Sunday": _(u"Dim")
    }

    bearing_arrow_font = {
        "N": _(u"i"),
        "NNE": _(u"j"),
        "NE": _(u"k"),
        "ENE": _(u"l"),
        "E": _(u"m"),
        "ESE": _(u"n"),
        "SE": _(u"o"),
        "SSE": _(u"p"),
        "S": _(u"a"),
        "SSW": _(u"b"),
        "SW": _(u"c"),
        "WSW": _(u"d"),
        "W": _(u"e"),
        "WNW": _(u"f"),
        "NW": _(u"g"),
        "NNW": _(u"h"),
        "N/A": _(u" ")
    }

    bearing_text_es = {
        "N": _(u"N"),
        "NNE": _(u"NNE"),
        "NE": _(u"NE"),
        "ENE": _(u"ENE"),
        "E": _(u"E"),
        "ESE": _(u"ESE"),
        "SE": _(u"SE"),
        "SSE": _(u"SSE"),
        "S": _(u"S"),
        "SSW": _(u"SSO"),
        "SW": _(u"SO"),
        "WSW": _(u"WOW"),
        "W": _(u"O"),
        "WNW": _(u"ONO"),
        "NW": _(u"NO"),
        "NNW": _(u"NNO"),
        "N/A": _(u"N\A")
    }

    bearing_text_fr = {
        "N": _(u"N"),
        "NNE": _(u"NNE"),
        "NE": _(u"NE"),
        "ENE": _(u"ENE"),
        "E": _(u"E"),
        "ESE": _(u"ESE"),
        "SE": _(u"SE"),
        "SSE": _(u"SSE"),
        "S": _(u"S"),
        "SSW": _(u"SSO"),
        "SW": _(u"SO"),
        "WSW": _(u"WOW"),
        "W": _(u"O"),
        "WNW": _(u"ONO"),
        "NW": _(u"NO"),
        "NNW": _(u"NNO"),
        "N/A": _(u"N\A")
    }

class GlobalWeather:

    current_conditions = []
    day_forecast = []
    night_forecast = []

    locale = "en"

    options = None
    weatherxmldoc = ""

        TEMP_FILEPATH_CURRENT = "/tmp/conkyForecast-c-LOCATION.pkl"
    TEMP_FILEPATH_DAYFORECAST = "/tmp/conkyForecast-df-LOCATION.pkl"
    TEMP_FILEPATH_NIGHTFORECAST = "/tmp/conkyForecast-nf-LOCATION.pkl"
        EXPIRY_MINUTES = 30
    DEFAULT_SPACING = u" "


    def __init__(self,options):

        self.options = options

        if self.options.locale == None:
            try:
                self.locale = locale.getdefaultlocale()[0][0:2]
                #self.locale = "es" #uncomment this line to force Spanish locale
                #self.locale = "fr" #uncomment this line to force French locale
            except:
                print "locale not set"
        else:
            self.locale = self.options.locale
            #self.locale = "es" #uncomment this line to force Spanish locale
            #self.locale = "fr" #uncomment this line to force French locale

        if self.options.verbose == True:
            print >> sys.stdout, "locale set to ",self.locale

    def getText(self,nodelist):
        rc = ""
        for node in nodelist:
            if node.nodeType == node.TEXT_NODE:
                rc = rc + node.data
        return rc


    def getSpaces(self,spaces):
        string = u""
        if spaces == None:
            string = self.DEFAULT_SPACING
        else:
            for i in range(0, spaces+1):
                string = string + u" "
        return string


    def isNumeric(self,string):
        try:
            dummy = float(string)
            return True
        except:
            return False

    def isConnectionAvailable(self):
        # ensure we can access weather.com's server by opening the url
        try:
            usock = urllib2.urlopen('http://xoap.weather.com')
            usock.close()
            return True
        except:
            return False

    def getBearingText(self,bearing):
        bearing = float(bearing)
        if bearing  11.25:
            return u"N"
        elif bearing  33.75:
            return u"NNE"
        elif bearing  56.25:
            return u"NE"
        elif bearing  78.75:
            return u"ENE"
        elif bearing  101.25:
            return u"E"
        elif bearing  123.75:
            return u"ESE"
        elif bearing  146.25:
            return u"SE"
        elif bearing  168.75:
            return u"SSE"
        elif bearing  191.25:
            return u"S"
        elif bearing  213.75:
            return u"SSW"
        elif bearing  236.25:
            return u"SW"
        elif bearing  258.75:
            return u"WSW"
        elif bearing  281.25:
            return u"W"
        elif bearing  303.75:
            return u"WNW"
        elif bearing  326.25:
            return u"NW"
        elif bearing  348.75:
            return u"NNW"
        else:
            return "N/A"

    def convertCelsiusToFahrenheit(self,temp):
        return str(int(floor(((float(temp)*9.0)/5.0)+32)))

    def convertKilometresToMiles(self,dist):
        return str(int(floor(float(dist)*0.621371192)))

    def convertMillibarsToInches(self,mb):
        return str(int(floor(float(mb)/33.8582)))

    def getTemplateList(self,template):

    templatelist = []

    for template_part in template.split("{"):
            if template_part != "":
                for template_part in template_part.split("}"):
                    if template_part != "":
                        templatelist.append(u""+template_part)

        return templatelist


    def getOutputText(self,datatype,startday,endday,night,shortweekday,imperial,hideunits,spaces):
        #try:
            output = u""

            # define current units for output
            if hideunits == False:
                if imperial == False:
                    tempunit = u"°C"
                    speedunit = u"kph"
                    pressureunit = u"mb"
                else:
                    tempunit = u"°F"
                    speedunit = u"mph"
                    pressureunit = u"in"
            else:
                tempunit = u"°"
                speedunit = u""
                pressureunit = u""

            if startday == None: # current conditions

                if datatype == "DW":
                    if self.locale == "es":
                        if shortweekday == True:
                            output = WeatherText.day_of_week_short_es[self.current_conditions[0].day_of_week]
                        else:
                            output = WeatherText.day_of_week_es[self.current_conditions[0].day_of_week]
                    elif self.locale == "fr":
                        if shortweekday == True:
                            output = WeatherText.day_of_week_short_fr[self.current_conditions[0].day_of_week]
                        else:
                            output = WeatherText.day_of_week_fr[self.current_conditions[0].day_of_week]
                    else:
                        if shortweekday == True:
                            output = WeatherText.day_of_week_short[self.current_conditions[0].day_of_week]
                        else:
                            output = WeatherText.day_of_week[self.current_conditions[0].day_of_week]
                elif datatype == "WF": # weather font
                    output = WeatherText.conditions_weather_font[self.current_conditions[0].condition_code]
                elif datatype == "LT":
                    string = self.current_conditions[0].low
                    if self.isNumeric(string) == True:
                        if imperial == True:
                            string = self.convertCelsiusToFahrenheit(string)
                        string = string + tempunit
                    output = string
                elif datatype == "HT":
                    string = self.current_conditions[0].high
                    if self.isNumeric(string) == True:
                        if imperial == True:
                            string = self.convertCelsiusToFahrenheit(string)
                        string = string + tempunit
                    output = string
                elif datatype == "CC":
                    if self.locale == "es":
                        output = WeatherText.conditions_text_es[self.current_conditions[0].condition_code]
                    elif self.locale == "fr":
                        output = WeatherText.conditions_text_fr[self.current_conditions[0].condition_code]
                    else:
                        output = WeatherText.conditions_text[self.current_conditions[0].condition_code]
                elif datatype == "CT":
                    output = self.current_conditions[0].condition_text
                elif datatype == "PC":
                    string = self.current_conditions[0].precip
                    if self.isNumeric(string) == True:
                        string = string + u"%"
                    output = string
                elif datatype == "HM":
                    string = self.current_conditions[0].humidity
                    if self.isNumeric(string) == True:
                        string = string + u"%"
                    output = string
                elif datatype == "WD":
                    string = self.current_conditions[0].wind_dir
                    if self.isNumeric(string) == True:
                        string = self.getBearingText(string)

                    if self.locale == "es":
                        output = WeatherText.bearing_text_es[string]
                    elif self.locale == "fr":
                        output = WeatherText.bearing_text_fr[string]
                    else:
                        output = string

                elif datatype == "BF":
                    string = self.current_conditions[0].wind_dir
                    if self.isNumeric(string) == True:
                        string = WeatherText.bearing_arrow_font[self.getBearingText(string)]
                    output = string
                elif datatype == "WS":
                    string = self.current_conditions[0].wind_speed
                    if self.isNumeric(string) == True:
                        if imperial == True:
                            string = self.convertKilometresToMiles(string)
                        string = string + speedunit
                    output = string
                elif datatype == "WG":
                    string = self.current_conditions[0].wind_gusts
                    if self.isNumeric(string) == True:
                        if imperial == True:
                            string = self.convertKilometresToMiles(string)
                        string = string + speedunit
                    output = string
                elif datatype == "CN":
                    output = self.current_conditions[0].city
                elif datatype == "SR":
                    output = self.current_conditions[0].sunrise
                elif datatype == "SS":
                    output = self.current_conditions[0].sunset
                elif datatype == "MP":
                    output = self.current_conditions[0].moon_phase
                elif datatype == "MF":
                    output = WeatherText.conditions_moon_font[self.current_conditions[0].moon_icon]
                elif datatype == "BR":
                    string = self.current_conditions[0].bar_read
                    if self.isNumeric(string) == True:
                        if imperial == True:
                            string = self.convertMillibarsToInches(string)
                        string = string + pressureunit
                    output = string
                elif datatype == "BD":
                    output = self.current_conditions[0].bar_desc
                else:
                    output = "\nERROR:Unknown data type requested"

            else: # forecast data

                if endday == None: # if no endday was set use startday
                    endday = startday

                if night == True: # night forecast required

                    for day_number in range(startday, endday+1):

                        if datatype == "DW":
                            if self.locale == "es":
                                if shortweekday == True:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_short_es[self.night_forecast[day_number].day_of_week]
                                else:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_es[self.night_forecast[day_number].day_of_week]
                            elif self.locale == "fr":
                                if shortweekday == True:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_short_fr[self.night_forecast[day_number].day_of_week]
                                else:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_fr[self.night_forecast[day_number].day_of_week]
                            else:
                                if shortweekday == True:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_short[self.night_forecast[day_number].day_of_week]
                                else:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week[self.night_forecast[day_number].day_of_week]
                        elif datatype == "WF": # weather font
                            output = output + self.getSpaces(spaces) + WeatherText.conditions_weather_font[self.night_forecast[day_number].condition_code]
                        elif datatype == "LT":
                            string = self.night_forecast[day_number].low
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertCelsiusToFahrenheit(string)
                                string = string + tempunit
                            output = output + self.getSpaces(spaces) + string

                        elif datatype == "HT":
                            string = self.night_forecast[day_number].high
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertCelsiusToFahrenheit(string)
                                string = string + tempunit
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "CC":
                            if self.locale == "es":
                                output = output + self.getSpaces(spaces) + WeatherText.conditions_text_es[self.night_forecast[day_number].condition_code]
                            elif self.locale == "fr":
                                output = output + self.getSpaces(spaces) + WeatherText.conditions_text_fr[self.night_forecast[day_number].condition_code]
                            else:
                                output = output + self.getSpaces(spaces) + WeatherText.conditions_text[self.night_forecast[day_number].condition_code]
                        elif datatype == "CT":
                            output = output + self.getSpaces(spaces) + self.night_forecast[day_number].condition_text
                        elif datatype == "PC":
                            string = self.night_forecast[day_number].precip
                            if self.isNumeric(string) == True:
                                string = string + u"%"
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "HM":
                            string = self.night_forecast[day_number].humidity
                            if self.isNumeric(string) == True:
                                string = string + u"%"
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "WD":
                            string = self.night_forecast[day_number].wind_dir
                            if self.locale == "es":
                                output = output + self.getSpaces(spaces) + WeatherText.bearing_text_es[string]
                            elif self.locale == "fr":
                                output = output + self.getSpaces(spaces) + WeatherText.bearing_text_fr[string]
                            else:
                                output = output + self.getSpaces(spaces) + string

                        elif datatype == "BF":
                            output = output + self.getSpaces(spaces) + WeatherText.bearing_arrow_font[self.night_forecast[day_number].wind_dir]
                        elif datatype == "WS":
                            string = self.night_forecast[day_number].wind_speed
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertKilometresToMiles(string)
                                string = string + speedunit
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "WG":
                            string = self.night_forecast[day_number].wind_gusts
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertKilometresToMiles(string)
                                string = string + speedunit
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "CN":
                            output = output + self.getSpaces(spaces) + self.night_forecast[day_number].city
                        elif datatype == "SR":
                            output = output + self.getSpaces(spaces) + self.night_forecast[day_number].sunrise
                        elif datatype == "SS":
                            output = output + self.getSpaces(spaces) + self.night_forecast[day_number].sunset
                        elif datatype == "MP":
                            output = output + self.getSpaces(spaces) + self.night_forecast[day_number].moon_phase
                        elif datatype == "MF":
                            output = output + self.getSpaces(spaces) + WeatherText.conditions_moon_font[self.night_forecast[day_number].moon_icon]
                        elif datatype == "BR":
                            output = output + self.getSpaces(spaces) + self.night_forecast[day_number].bar_read
                        elif datatype == "BD":
                            output = output + self.getSpaces(spaces) + self.night_forecast[day_number].bar_desc
                        else:
                            output = "\nERROR:Unknown data type requested"
                            break

                else: # day forecast wanted

                    for day_number in range(startday, endday+1):

                        if datatype == "DW":
                            if self.locale == "es":
                                if shortweekday == True:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_short_es[self.day_forecast[day_number].day_of_week]
                                else:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_es[self.day_forecast[day_number].day_of_week]
                            elif self.locale == "fr":
                                if shortweekday == True:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_short_fr[self.day_forecast[day_number].day_of_week]
                                else:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_fr[self.day_forecast[day_number].day_of_week]
                            else:
                                if shortweekday == True:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week_short[self.day_forecast[day_number].day_of_week]
                                else:
                                    output = output + self.getSpaces(spaces) + WeatherText.day_of_week[self.day_forecast[day_number].day_of_week]
                        elif datatype == "WF": # weather font
                            output = output + self.getSpaces(spaces) + WeatherText.conditions_weather_font[self.day_forecast[day_number].condition_code]
                        elif datatype == "LT":
                            string = self.day_forecast[day_number].low
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertCelsiusToFahrenheit(string)
                                string = string + tempunit
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "HT":
                            string = self.day_forecast[day_number].high
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertCelsiusToFahrenheit(string)
                                string = string + tempunit
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "CC":
                            if self.locale == "es":
                                output = output + self.getSpaces(spaces) + WeatherText.conditions_text_es[self.day_forecast[day_number].condition_code]
                            elif self.locale == "fr":
                                output = output + self.getSpaces(spaces) + WeatherText.conditions_text_fr[self.day_forecast[day_number].condition_code]
                            else:
                                output = output + self.getSpaces(spaces) + WeatherText.conditions_text[self.day_forecast[day_number].condition_code]
                        elif datatype == "CT":
                            output = output + self.getSpaces(spaces) + self.day_forecast[day_number].condition_text
                        elif datatype == "PC":
                            string = self.day_forecast[day_number].precip
                            if self.isNumeric(string) == True:
                                string = string + u"%"
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "HM":
                            string = self.day_forecast[day_number].humidity
                            if self.isNumeric(string) == True:
                                string = string + u"%"
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "WD":
                            string = self.day_forecast[day_number].wind_dir

                            if self.locale == "es":
                                output = output + self.getSpaces(spaces) + WeatherText.bearing_text_es[string]
                            elif self.locale == "fr":
                                output = output + self.getSpaces(spaces) + WeatherText.bearing_text_fr[string]
                            else:
                                output = output + self.getSpaces(spaces) + string

                        elif datatype == "BF":
                            output = output + self.getSpaces(spaces) + WeatherText.bearing_arrow_font[self.day_forecast[day_number].wind_dir]
                        elif datatype == "WS":
                            string = self.day_forecast[day_number].wind_speed
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertKilometresToMiles(string)
                                string = string + speedunit
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "WG":
                            string = self.day_forecast[day_number].wind_gusts
                            if self.isNumeric(string) == True:
                                if imperial == True:
                                    string = self.convertKilometresToMiles(string)
                                string = string + speedunit
                            output = output + self.getSpaces(spaces) + string
                        elif datatype == "CN":
                            output = output + self.getSpaces(spaces) + self.day_forecast[day_number].city
                        elif datatype == "SR":
                            output = output + self.getSpaces(spaces) + self.day_forecast[day_number].sunrise
                        elif datatype == "SS":
                            output = output + self.getSpaces(spaces) + self.day_forecast[day_number].sunset
                        elif datatype == "MP":
                            output = output + self.getSpaces(spaces) + self.day_forecast[day_number].moon_phase
                        elif datatype == "MF":
                            output = output + self.getSpaces(spaces) + WeatherText.conditions_moon_font[self.day_forecast[day_number].moon_icon]
                        elif datatype == "BR":
                            output = output + self.getSpaces(spaces) + self.day_forecast[day_number].bar_read
                        elif datatype == "BD":
                            output = output + self.getSpaces(spaces) + self.day_forecast[day_number].bar_desc
                        else:
                            output = u"\nERROR:Unknown data type requested"
                            break

            output = u""+output.strip(u" ") # lose leading/trailing spaces
            return output

        #except:
            #print "getOutputText:Unexpected error: ", sys.exc_info()[0]


    def getOutputTextFromTemplate(self,template):
        #try:

            # keys to template data
            DATATYPE_KEY = "--datatype="
            STARTDAY_KEY = "--startday="
            ENDDAY_KEY = "--endday="
            NIGHT_KEY = "--night"
            SHORTWEEKDAY_KEY = "--shortweekday"
            IMPERIAL_KEY = "--imperial"
            HIDEUNITS_KEY = "--hideunits"
            SPACES_KEY = "--spaces="

            output = u""

            optionfound = False

            #load the file
            try:
                fileinput = open(self.options.template)
                template = fileinput.read()
                fileinput.close()
            except:
                output = u"Template file no found!"

            templatelist = self.getTemplateList(template)

            # lets walk through the template list and determine the output for each item found
            for i in range(0,len(templatelist)-1):

                pos = templatelist[i].find(DATATYPE_KEY)
                if pos != -1:
                    optionfound = True
                    pos = pos + len(DATATYPE_KEY)
                    datatype = templatelist[i][pos:pos+4].strip("}").strip("{").strip("-").strip(" ")
                else:
                    datatype = None

                pos = templatelist[i].find(STARTDAY_KEY)
                if pos != -1:
                    optionfound = True
                    pos = pos + len(STARTDAY_KEY)
                    startday = int(templatelist[i][pos:pos+4].strip("}").strip("{").strip("-").strip(" "))
                else:
                    startday = None

                pos = templatelist[i].find(ENDDAY_KEY)
                if pos != -1:
                    optionfound = True
                    pos = pos + len(ENDDAY_KEY)
                    endday = int(templatelist[i][pos:pos+4].strip("}").strip("{").strip("-").strip(" "))
                else:
                    endday = None

                pos = templatelist[i].find(NIGHT_KEY)
                if pos != -1:
                    optionfound = True
                    night = True
                else:
                    night = False

                pos = templatelist[i].find(SHORTWEEKDAY_KEY)
                if pos != -1:
                    optionfound = True
                    shortweekday = True
                else:
                    shortweekday = False

                pos = templatelist[i].find(IMPERIAL_KEY)
                if pos != -1:
                    optionfound = True
                    imperial = True
                else:
                    imperial = False

                pos = templatelist[i].find(HIDEUNITS_KEY)
                if pos != -1:
                    optionfound = True
                    hideunits = True
                else:
                    hideunits = False

                pos = templatelist[i].find(SPACES_KEY)
                if pos != -1:
                    optionfound = True
                    pos = pos + len(SPACES_KEY)
                    spaces = int(templatelist[i][pos:pos+4].strip("}").strip("{").strip("-").strip(" "))
                else:
                    spaces = 1

                if optionfound == True:
                    templatelist[i] = self.getOutputText(datatype,startday,endday,night,shortweekday,imperial,hideunits,spaces)
                    optionfound = False

            # go through the list concatenating the output now that it's been populated
            for item in templatelist:
                output = output + item

            return output

        #except:
            #print "getOutputTextFromTemplate:Unexpected error: ", sys.exc_info()[0]


    def fetchData(self):

        # always fetch metric data, use conversation functions on this data
        file_path_current = self.TEMP_FILEPATH_CURRENT.replace("LOCATION",self.options.location)
        file_path_dayforecast = self.TEMP_FILEPATH_DAYFORECAST.replace("LOCATION",self.options.location)
        file_path_nightforecast = self.TEMP_FILEPATH_NIGHTFORECAST.replace("LOCATION",self.options.location)

        if self.isConnectionAvailable() == False:
            if os.path.exists(file_path_current):
                RefetchData = False
            else: # no connection, no cache, bang!
                print "No internet connection is available and no cached weather data exists."
        elif self.options.refetch == True:
            RefetchData = True
        else:
                # does the data need retrieving again?
                if os.path.exists(file_path_current):
                    lastmodDate = time.localtime(os.stat(file_path_current)[ST_MTIME])
                expiryDate = (datetime.datetime.today() - datetime.timedelta(minutes=self.EXPIRY_MINUTES)).timetuple()

                if expiryDate > lastmodDate:
                    RefetchData = True
                else:
                    RefetchData = False
            else:
                RefetchData = True


                                                                # fetch the current conditions data, either from the website or by 'unpickling'
            if RefetchData == True:

            # obtain current conditions data from xoap service
            try:

                # http://xoap.weather.com/weather/local/UKXX0103?cc=*=5=xoap=xoap=1061785028=e374effbfd74930b

                url = 'http://xoap.weather.com/weather/local/' + self.options.location + '?cc=*=8=xoap=xoap=1061785028=e374effbfd74930b=m'
                if self.options.verbose == True:
                    print >> sys.stdout, "fetching weather data from ",url

                usock = urllib2.urlopen(url)
                xml = usock.read()
                usock.close()
                self.weatherxmldoc = minidom.parseString(xml)
            except:
                print "fetchData:Unexpected error: ", sys.exc_info()[0]
                print "Unable to contact weather source for current conditions"

            # tell the user if the location is bad...
            found = xml.find("Invalid location provided")
            if found != -1:
                print "Invalid location provided"

            # interrogate weather data, load into class structure and pickle it
            try:

                # prepare weather data lists
                self.current_conditions = []
                self.day_forecast = []
                self.night_forecast = []

                # collect general data
                weather_n = self.weatherxmldoc.documentElement
                location_n = weather_n.getElementsByTagName('loc')[0]
                city_n = location_n.getElementsByTagName('dnam')[0]
                city = self.getText(city_n.childNodes)

                # collect current conditions data
                day_of_week = u"Today"
                precip = u"N/A"
                sunrise_n = location_n.getElementsByTagName('sunr')[0]
                sunrise = self.getText(sunrise_n.childNodes)
                sunset_n = location_n.getElementsByTagName('suns')[0]
                sunset = self.getText(sunset_n.childNodes)
                current_condition_n = weather_n.getElementsByTagName('cc')[0]
                current_desc_n = current_condition_n.getElementsByTagName('t')[0]
                current_desc = self.getText(current_desc_n.childNodes)
                current_code_n = current_condition_n.getElementsByTagName('icon')[0]
                current_code = self.getText(current_code_n.childNodes)
                current_temp_n = current_condition_n.getElementsByTagName('tmp')[0]
                current_temp = self.getText(current_temp_n.childNodes)
                current_temp_feels_n = current_condition_n.getElementsByTagName('flik')[0]
                current_temp_feels = self.getText(current_temp_feels_n.childNodes)
                bar_n = current_condition_n.getElementsByTagName('bar')[0]
                bar_read_n = bar_n.getElementsByTagName('r')[0]
                bar_read = self.getText(bar_read_n.childNodes)
                bar_desc_n = bar_n.getElementsByTagName('d')[0]
                bar_desc = self.getText(bar_desc_n.childNodes)
                wind_n = current_condition_n.getElementsByTagName('wind')[0]
                wind_speed_n = wind_n.getElementsByTagName('s')[0]
                wind_speed = self.getText(wind_speed_n.childNodes)
                wind_gust_n = wind_n.getElementsByTagName('gust')[0]
                wind_gusts = self.getText(wind_gust_n.childNodes)
                wind_dir_n = wind_n.getElementsByTagName('d')[0]
                wind_direction = self.getText(wind_dir_n.childNodes)
                humidity_n = current_condition_n.getElementsByTagName('hmid')[0]
                humidity = self.getText(humidity_n.childNodes)
                moon_n = current_condition_n.getElementsByTagName('moon')[0]
                moon_icon_n = moon_n.getElementsByTagName('icon')[0]
                moon_icon = self.getText(moon_icon_n.childNodes)
                moon_phase_n = moon_n.getElementsByTagName('t')[0]
                moon_phase = self.getText(moon_phase_n.childNodes)
                current_conditions_data = WeatherData(day_of_week, current_temp_feels, current_temp, current_code, current_desc, precip, humidity, wind_direction, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc)
                self.current_conditions.append(current_conditions_data)

                # collect forecast data
                bar_read = u"N/A"
                bar_desc = u"N/A"
                moon_phase = u"N/A"
                moon_icon = u"na"
                forecast_n = weather_n.getElementsByTagName('dayf')[0]
                day_nodes = forecast_n.getElementsByTagName('day')

                for day in day_nodes:
                    day_of_week = day.getAttribute('t')
                    day_of_year = day.getAttribute('dt')
                    high_temp_n = day.getElementsByTagName('hi')[0]
                    high_temp = self.getText(high_temp_n.childNodes)
                    low_temp_n = day.getElementsByTagName('low')[0]
                    low_temp = self.getText(low_temp_n.childNodes)

                    sunrise_n = day.getElementsByTagName('sunr')[0]
                    sunrise = self.getText(sunrise_n.childNodes)
                    sunset_n = day.getElementsByTagName('suns')[0]
                    sunset = self.getText(sunset_n.childNodes)

                    # day forecast specific data
                    daytime_n = day.getElementsByTagName('part')[0] # day
                    condition_code_n = daytime_n.getElementsByTagName('icon')[0]
                    condition_code = self.getText(condition_code_n.childNodes)
                    condition_n = daytime_n.getElementsByTagName('t')[0]
                    condition = self.getText(condition_n.childNodes)
                    precip_n = daytime_n.getElementsByTagName('ppcp')[0]
                    precip = self.getText(precip_n.childNodes)
                    humidity_n = daytime_n.getElementsByTagName('hmid')[0]
                    humidity = self.getText(humidity_n.childNodes)
                    wind_n = daytime_n.getElementsByTagName('wind')[0]
                    wind_speed_n = wind_n.getElementsByTagName('s')[0]
                    wind_speed = self.getText(wind_speed_n.childNodes)
                    wind_direction_n = wind_n.getElementsByTagName('t')[0]
                    wind_direction = self.getText(wind_direction_n.childNodes)
                    wind_gusts_n = wind_n.getElementsByTagName('gust')[0]
                    wind_gusts = self.getText(wind_gusts_n.childNodes)
                    day_forecast_data = WeatherData(day_of_week, low_temp, high_temp, condition_code, condition, precip, humidity, wind_direction, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc)
                    self.day_forecast.append(day_forecast_data)

                    # night forecast specific data
                    daytime_n = day.getElementsByTagName('part')[1] # night
                    condition_code_n = daytime_n.getElementsByTagName('icon')[0]
                    condition_code = self.getText(condition_code_n.childNodes)
                    condition_n = daytime_n.getElementsByTagName('t')[0]
                    condition = self.getText(condition_n.childNodes)
                    precip_n = daytime_n.getElementsByTagName('ppcp')[0]
                    precip = self.getText(precip_n.childNodes)
                    humidity_n = daytime_n.getElementsByTagName('hmid')[0]
                    humidity = self.getText(humidity_n.childNodes)
                    wind_n = daytime_n.getElementsByTagName('wind')[0]
                    wind_speed_n = wind_n.getElementsByTagName('s')[0]
                    wind_speed = self.getText(wind_speed_n.childNodes)
                    wind_direction_n = wind_n.getElementsByTagName('t')[0]
                    wind_direction = self.getText(wind_direction_n.childNodes)
                    wind_gusts_n = wind_n.getElementsByTagName('gust')[0]
                    wind_gusts = self.getText(wind_gusts_n.childNodes)
                    night_forecast_data = WeatherData(day_of_week, low_temp, high_temp, condition_code, condition, precip, humidity, wind_direction, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc)
                    self.night_forecast.append(night_forecast_data)


                # pickle the data for next time!
                fileoutput = open(file_path_current, 'w')
                    pickle.dump(self.current_conditions,fileoutput)
                    fileoutput.close()

                fileoutput = open(file_path_dayforecast, 'w')
                    pickle.dump(self.day_forecast,fileoutput)
                    fileoutput.close()

                fileoutput = open(file_path_nightforecast, 'w')
                    pickle.dump(self.night_forecast,fileoutput)
                    fileoutput.close()

            except:
                print "fetchData:Unexpected error: ", sys.exc_info()[0]
                print "Unable to interrogate the weather data"

        else: # fetch weather data from pickled class files
            if self.options.verbose == True:
                print >> sys.stdout, "fetching weather data from file: ",file_path_current

                fileinput = open(file_path_current, 'r')
            self.current_conditions = pickle.load(fileinput)
            fileinput.close()

            if self.options.verbose == True:
                print >> sys.stdout, "fetching day forecast data from files: ",file_path_dayforecast, file_path_nightforecast

                fileinput = open(file_path_dayforecast, 'r')
            self.day_forecast = pickle.load(fileinput)
            fileinput.close()

            if self.options.verbose == True:
                print >> sys.stdout, "fetching day forecast data from files: ",file_path_nightforecast, file_path_nightforecast

                fileinput = open(file_path_nightforecast, 'r')
            self.night_forecast = pickle.load(fileinput)
            fileinput.close()

    def outputData(self):
        #try:

            if self.options.template != None:

                output = self.getOutputTextFromTemplate(self.options.template)

            else:

                output = self.getOutputText(self.options.datatype,self.options.startday,self.options.endday,self.options.night,self.options.shortweekday,self.options.imperial,self.options.hideunits,self.options.spaces)


            print output.encode("utf-8")

        #except:
            #print "outputData:Unexpected error: ", sys.exc_info()[0]

if __name__ == "__main__":

    parser = CommandLineParser()
    (options, args) = parser.parse_args()

    if options.verbose == True:
        print >> sys.stdout, "location:",options.location
        print >> sys.stdout, "imperial:",options.imperial
        print >> sys.stdout, "datatype:",options.datatype
        print >> sys.stdout, "night:",options.night
        print >> sys.stdout, "start day:",options.startday
        print >> sys.stdout, "end day:",options.endday
        print >> sys.stdout, "spaces:",options.spaces
        print >> sys.stdout, "verbose:",options.verbose
        print >> sys.stdout, "refetch:",options.refetch

    # create new global weather object
    weather = GlobalWeather(options)
    weather.fetchData()
    weather.outputData()

Save this script as conkyForecast.py and make it executable.

Install fonts using nautilus-actions

2008-05-31T00:00:00+00:00

Nautilus-Actions installs custom entries in the context menu in nautilus. I needed a simple way to install fonts so I wrote a command for nautilus-actions.

Set “Path:” to bash

Set Parameters to -c "if zenity --question --text=\"Would you like to install the font system wide?\" --title=\"Install to System\"; then gksudo cp %M /usr/share/fonts/truetype/local/%m; else cp %M ~/.fonts/%m; fi; exit 0;".

If you do not want to install nautilus actions you can simply create a Nautilus script.

The contents of the script should be:

#!/bin/bash
if zenity --question --text="Would you like to install the font system wide?" --title="Install to System"; then
     for $i in $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS; do
          gksudo cp $i /usr/share/fonts/truetype/local/$(basename $i)
     done
else
     for $i in $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS; do
          cp $i ~/.fonts/$(basename $i)
     done
fi
exit 0

Save this script in ‘~/.gnome2/nautilus-scripts’ and make it executable (chmod u+x).

Qalculate: The best calculator program

2008-05-25T00:00:00+00:00

I finaly found the (almost) perfect calculator program, qalculate. It can solve/factor equations, work with significant figures, work with trigonometry, and much more.

Screenshots:

PCMan File Manager: 7z and rar archives

2008-05-25T00:00:00+00:00

By default, pcmanfm will not extract/create 7zip and Rar archives. Extracting rar archives is already implemented but not enabled by default while the ability to extract 7z archives is not implemented at all. To enable the extraction of rar and 7zip archives and the creation of 7zip archives open src/ptk/ptk-file-archiver.c:

Uncomment:

       {
           "application/x-rar",
           NULL,
           "unrar -o- e",
           ".rar", TRUE
       }

And add this below:

       {
           "application/x-7z-compressed",
           "7zr a -bd -y",
           "7zr x -bd -y",
           ".7z", TRUE
       }

Next, insert a comma, after the end bracket of the rar section.

The archive handlers section should endup looking like this:

const ArchiveHandler handlers[]=
   {
       {
           "application/x-bzip-compressed-tar",
           "tar --bzip2 -cvf",
           "tar --bzip2 -xvf",
           ".tar.bz2", TRUE
       },
       {
           "application/x-compressed-tar",
           "tar -czvf",
           "tar -xzvf",
           ".tar.gz", TRUE
       },
       {
           "application/zip",
           "zip -r",
           "unzip",
           ".zip", TRUE
       },
       {
           "application/x-tar",
           "tar -cvf",
           "tar -xvf",
           ".tar", TRUE
       },
       {
           "application/x-rar",
           NULL,
           "unrar -o- e",
           ".rar", TRUE
       },
       {
           "application/x-7z-compressed",
           "7zr a -bd -y",
           "7zr x -bd -y",
           ".7z", TRUE
       }
   };

Compile with a standard ./configure; make; make install or ./configure; make; checkinstall.

Install Flash Player 10 in liferea

2008-05-21T00:00:00+00:00

Installing flash player 10 in Ubuntu does not install it for Liferea.

The fix for this is very simple:

First install Flash Player 10 using this Tutorial

Next execute this command in the terminal:

 sudo ln -s /usr/lib/firefox-addons/plugins/libflashplayer.so \
            /usr/lib/xulrunner-addons/plugins/libflashplayer.so

Flash Player 10 should now work in Liferea.

Tip: Purge Auto-installed packages with Aptitude

2008-05-16T00:00:00+00:00

When switching from apt-get to aptitude, I discovered that aptitude, unlike apt-get, does not purge configuration files of auto-removed packages when given the command aptitude purge package. The fix for this is very simple.

In order to purge configuration files only when the purge command is given you must either specify the --purge-unused option in the command or create an alias. To create an alias add this alias command='sudo aptitude purge --purge-unused' to ~/.bashrc. Command is the command that you would like to assign for purging the packages.

To always purge configuration files for auto-removed packages add Aptitude::Purge-Unused=true to /etc/apt/apt.conf.d/05aptitude. This will cause aptitude to always purge configuration files for all auto-removed packages regardless of weather or not the command was aptitude purge or aptitude remove.

Rarcrack: Crack zip, rar, and 7z files

2008-05-13T00:00:00+00:00

I have just tested rarcrack and love it. Rarcrack cracks password protected rar, 7z, and zip archives. Sadly, it’s not in the Ubuntu repository. I have therefor compiled a deb: rarcrack.deb. I have not included this deb in my PPA because I compiled it with debianpackagemaker.

Make Firefox 3's autocomplete bar work with a dark theme

2008-05-03T00:00:00+00:00

I use MurrinaAngustifolium as my gtk theme but, because it is a dark theme, it does not always play nicely with other applications. One problem that I have finally fixed is the drop-down auto-complete menu for the location bar. Put the following code in your userChrome.css file (or use stylish).

@namespace url(http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul);
.ac-comment {
  font-size: 100% !important;
  color: #dddddd !important;
}
.ac-comment[selected="true"] {
  color: #56aaff !important;
}

.ac-url-text {
  font-size: 100% !important;
  color: #555555 !important;
}

.ac-url-text[selected="true"] {
  color: #666666 !important;
}
.autocomplete-richlistbox {
  background: #1a1a1a !important;
}
.autocomplete-richlistitem[selected="true"] {
  background: #000000 !important;
}
tooltip {
  background-color: #1a1a1a !important;
  color: #ffffff !important;
}

This code also makes some of the tooltips black.

Tip: Pause a program not started from the command line

2008-04-29T00:00:00+00:00

This tip is a follow-up from the last one. To pause a program that was not started from a terminal, simply go to the gnome-system-manager, right click, and select stop. Select continue to resume a paused process.

Tip: Pause a command line program

2008-04-28T00:00:00+00:00

This trick is known by many but it can’t hurt to mention it once more. I sometimes find myself in the middle of running a program in the command line but would like to check on something before I continue. The easiest way to pause a program in the command line is to hit Control+Z. To restart the command simply type fg. Do not close the terminal window or restart your computer because the paused program will close.

Ubuntu hardy upgrade status: Buggy but working

2008-04-25T00:00:00+00:00

I ran into a few problems during the upgrade but all of them were fixable.

Partial Upgrade fix: Downgrade non-ubuntu packages to their ubuntu versions if an ubuntu version exists. My system refused to complete the upgrade (and I had to upgrade it through aptitude) because of a few package conflicts (mostly from the schmidtke repository).

Numpad Fix: My computers numpad stopped working after upgrading. Somehow an acceptability option had been turned on. To fix this go to System > Preferences > Keyboard and go to the mouse keys tab and uncheck the checkbox.

Remove custom G15 drivers: A while back I had installed the G15 drivers based on a tutorial posted on the ubuntu wiki. These drivers should now be uninstalled as Ubuntu Hardy comes with its own drivers.

Everything appears to be working fine now.

Tip: Faster Ubuntu upgrade

2008-04-24T00:00:00+00:00

I am currently upgrading to Ubuntu 8.04 and so far so good. For the past releases I have upgraded from the standard server but that was very slow (8 hour download).

Fix: Use another server.

My current download is almost complete and my download speed is currently at 164kb/s (my max, thanks AT). To change the download server, simply open System > Administration > Software Sources and select download from other. Pick a random server in your country and hope for the best (the pick the best server button does not find the least bogged down server, it finds the closest server). The Ubuntu teem should make this happen automatically. The System Updater should find the mirror with the greatest download speed and use that server for its upgrade.

'Pause' command in linux

2008-04-24T00:00:00+00:00

Windows comes with a very useful pause command. Linux does not. This can be problematic when running programs in the terminal from the GUI. If a program runs in a terminal but did not originated in the terminal (i.e. you double click on a file in nautilus and select run in terminal) the terminal window closes immediately when the program finishes. This makes it impossible to read the output from the terminal.

This function can be added to your ~/.bashrc file:

function pause() {
   test $*  read -p "$*" || read -p "Press enter to continue..."
}

I found this code on www.cyberciti.biz but edited it to allow for no arguments.

Imageshack: Media hosting for the web

2008-04-23T00:00:00+00:00

I have seen imageshack used a lot but have never tried it myself until now.

Problem

Bloggers image hosting is limited (100mb) and does not work with lightbox.

Solution

Imageshack works great with blogger and lightbox. It allows for easy posting of small thumbnails that link to the bigger image. Normally the thumbnail would link to a web page containing the full version of the image but this is not compatible with lightbox (lightbox needs the actual image). The fix is very easy: Simply change the image link to the thumbnail link but remove the .th from in front of the extension.

My ~~main~~ complaint is that the thumbnails are too small. I could get around this by using the full image and scaling it down with css but this would wast some of my 300mb per image per hour bandwidth (not really a problem now but may become problematic with more readers).

Edit: My main complaint is that they lose images. Imageshack (along with pretty much every other media hosting site) is great for forum posts, but not for semi-permanent blogs.

HOWTO: Create a floating sidebar on the left (Minima)

2008-04-22T00:00:00+00:00

It took me a while to get the floating sidebar on the left of this page working well so I decided to write this post in order to save others time and frustration. I made this tutorial for the Minima template but you could modify it in order to work with any template.

Add this:

/* Floating sidebar on left */
#fixedsidebar-wrapper {
  position: fixed;
  top: 75px;
  left: 10px;
  width: 100px;
  float: left;
  word-wrap: break-word; /* fix for long text breaking sidebar float in IE */
  overflow: hidden; /* fix for long non-text content breaking IE sidebar float */
}
#big-wrapper {
  margin: 0 150px 0 100px;
}

Below this:

#sidebar-wrapper {
  width: 220px;
  float: $endSide;
  word-wrap: break-word; /* fix for long text breaking sidebar float in IE */
  overflow: hidden;     /* fix for long non-text content breaking IE sidebar float */
}

Then, to fix the page elements tab…

Add this:

/** Page structure tweaks for layout editor wireframe for floating sidebar on left **/

body#layout #outer-wrapper,
body#layout #header-wrapper,
body#layout #footer {
  width: 500px;
  padding: 0px;
}
body#layout #main-wrapper {
  width: 300px;
}
body#layout #sidebar-wrapper {
  width: 200px;
}
body#layout #newsidebar-wrapper {
  width: 150px;
}

…below the previous code.

To remove the dotted line under widgets…

Add this:

#fixedsidebar.sidebar .widget {
  border-bottom-width: 0 !important;
}

Below this:

.sidebar .widget, .main .widget {
  border-bottom:1px dotted $bordercolor;
  margin:0 0 1.5em;
  padding:0 0 1.5em;
}

Then add <div id="big-wrapper"> just under <body>. This will make sure that the floating sidebar will not overlap the other content.

Now in order to actually place the sidebar…

Add this:

      <div id="fixedsidebar-wrapper">
   <b:section class="sidebar" id="fixedsidebar" preferred="yes">
      <b:widget id="NewProfile" locked="false" title="'About" type="Profile" />
    </b:widget>
  </b:section>
</div>

Below this:

    <div id="content-wrapper">
 <div id="crosscol-wrapper" style="">
   <b:section class="crosscol" id="crosscol" showaddelement="no" />
 </b:section>
</div>

Finally, add a </div> tag before the </body> tag to close the “big-wrapper”

This post is heavily based on this tutorial but creates a fixed (floating) sidebar instead of a sidebar that scrolls with the rest of the page.

For advertisement free browsing: apply Adblock Plus

2008-04-22T00:00:00+00:00

Adblock Plus is a great Firefox extension that blocks advertisements. Advertisements hog bandwidth and are distracting. It is easy to use (right click and select block element).

Here is my adblock plus filter list (save it as a text document and import it).

(Adblock Plus 0.7 or higher required) [Adblock]
@@netstream
@@http://www.microsoft.com/
@@http://www.windowsmarketplace.com/
@@|http://www.kiisfm.com/
@@|http://www.apple.com/
@@|https://www.windwardschool.org/
@@|http://iwonderdesigns.com/
@@|http://news.bbc.co.uk/
@@|http://wow.weather.com/
@@|http://www.defensedevices.com/
@@http://www2.gawker.com/assets/minify.php?files=*
@@http://syndication.mmismm.com/
@@http://tags.gawker.com/
*.2o7.net/*
*/shopping_deals*
*/tacoda/*
*_fromoursponsors_*
/(\W|_)(ad(s)?(vert(is(ement|ing|er)?)?)?)(s)?(view|log|image(s)?|Links|counter|serve(r)?|sys|brite|sonar|lengend|side|files)?(\W|_|1)/
/[\W_](blog|get|online)ad(s)?[\W_]/
/[\W_](double|fast)click[\W_]/
/\.geocities.com/js_source/(ygNSLib9|pu5geo).js/
/\D(728|588|468|234|160|120)x(600?|90)\D/
http://*.sageanalyst.net/*
http://*.centrport.net/*
http://*.falkag.net/*
http://*.industrybrains.com/*
http://*.itnation.com/*
http://*.questionmarket.com/*
http://*.spinbox.net/*
http://*.tiser.com.*/
http://*.tribalfusion.com/*
http://*.valueclick.com/*
http://*theglobeandmail.com/adsv3/*
http://ehg*.hitbox.com/*
http://graphics8.nytimes.com/marketing/
http://images.pcworld.com/shared/graphics/bevel_*.gif
http://images.stardock.com/store/*
http://images.usatoday.com/kk/classified/*
http://infospace.abcnews.com/*/adinsert.js
http://media.nyadmcncserve*.com/
http://media.washingtonpost.com/wp-srv/popjs/popup*
http://msnbc.msn.com/#DIV(p2)
http://msnbc.msn.com/#DIV(textSmallGrey)
http://msnbc.msn.com/*#DIV(clr)
http://msnbc.msn.com/*#DIV(w779)
http://pagead2.googlesyndication.com/*
http://rcm.amazon.com/e/cm?t=*
http://servedby.*
http://server.*.liveperson.net/*
http://www.goodsforyou.com/*
http://www.humaxusa.com/*
http://www.insanely-great.com/*/adsb.cgi*
http://www.kiisfm.com/cc-common/CCAS_media/ccas_creative_81152.gif
/.*(-|_|/)promo(-|_).*\.(gif|png|jpg)/
http://www.qksrv.net/*
intellitxt
*/promotions/*
http://us.a1.yimg.com/*
http://download-search.search.com/search?v=og&q=*
http://i.d.com.com/*/*_sponsors_*.gif
http://www.ftjcfx.com/*
|http://*.addfreestats.com/*
/http://feeds\.(\w|\W)+\.com/~[a]/(\w|\W)+\?.=(\w|\W)+/
http://*.casalemedia.com/*
http://www.lduhtrp.net/*
http://www.afcyhf.com/*
http://www.shareasale.com/*
http://3ps.go.com/DynamicAd?*
/[\W|_](((p|P)romo)(tional)?)?(_)?(promo(s)?|banner)(s)?(_)?(up|down|standard|right|left|top|bottom)?([0-9])?\.(gif|png|jpg|bmp)/
http://*.atwola.com/*
http://ccas.clearchannel.com/*&affiliate=*
http://network.business.com/*
http://affiliates.digitalriver.com/*
http://clk.atdmt.com/*
http://www.awltovhc.com/image-*
http://*.adland.ru/*
http://www.macdailynews.com/adpeeps/*
http://rss.sourceforge.net/~a/*
http://cgi.insecure.org/cgi-bin/pro/*
http://affiliates.babylon.com/*
http://view.atdmt.com/*
/.*(_|/)sponsor(s)?((\.(gif|jpg|png))|(/))/
http://bs.serving-sys.com/BurstingPipe/BannerSource.asp?*
*/web_banners/*
*/bin/ad
http://*.google.com/pagead/*
*/images/banner*.png
http://s1.amazon.com/exec/varzea/tipbox/*
*_sweeps*
http://www.conduit.com/banners/*
*adpartner*
http://digg.com/img/feature-*.gif
http://*.freesoftwaremagazine.com/openads/*
http://regmedia.co.uk/*
http://www.siteground.com/img/banners_cust/2*
http://ubuntulinuxhelp.com/hic300250.gif
http://www.tqlkg.com/*
http://groups.google.com/groups/adfetch?*
http://banner.casinotropez.com/*
http://www.speedsuccess.net/*
#*(sponsored_links_article)
#*(ad_bottom)
#*(ad_top)
#*(launchpad-ads-3)
#*(sponsorship)
#*(sponsorshiphack)
#*(promo2)
#*(ad_300)
#*(ad_180)
#*(adbannerblock)
#*(ad34)
#*(googlesyndication)
##div.banner ad + *
google.com#TABLE(cellpadding=9)(border=0)
openssh.com#BLINK
google.com#a(href^=https://www.google.com/ads)
babelfish.yahoo.com#DIV(ovt)
cnet.com#DIV(class=asl_margin)
cnet.com#DIV(class=rb_pft_ad)
#DIV(id=spons_links)
#DIV(class=columnGroup advertisementColumnGroup)
#A(href^=http://www.servage.net/?coupon=)
flickr.com#DIV(id=AdBlock)
youtube.com#DIV(id=leaderboardAd)
google.com#TD(rowspan=5)
google.com##TD[onmouseover="return ss()"]
google.com#H2(class=sl f)
#DIV(class=sponsor)
youtube.com#NOSCRIPT(class=noscript-show)
google.com#DIV(id=tpa1)
linuxforums.org#DIV(id=topbanner)
linuxforums.org#NOSCRIPT(class=noscript-show)
linuxquestions.org#NOSCRIPT(class=noscript-show)
#DIV(id=rightad)
#DIV(id=topad)(class=ad)
#A(class=sponsoredlink)
#DIV(id=ad-top)
#DIV(class=banner ad)
opendns.com#UL(class=adkeywords)
google.com##TABLE.contentitem[cellspacing="0"][cellpadding="5"][border="0"][bgcolor="#ffffff"][style]
google.com##TD[nowrap][onmouseover="return true"]
google.com#*(href^=http://www.google.com/sponsoredlinks?)
builtwith.com#DIV(class=featuredTechnology)
flashlinux.org.uk#DIV(id=portlet-dtm)
#*(id=sponsors)
#DIV(id=ads)
techcrunch.com#A(href=/advertise/)
#A(href^=http://www.google.com/pagead)
dictionary.reference.com#A(href^=http://www.google.com/url?sa=L&ai=)
#IMG(src^=http://ad.uk.doubleclick.net)
#IMG(src^=http://ad.doubleclick.net)
yahoo.com#A(href=http://us.ard.yahoo.com/SIG=12lt27gkl/M=570179.11705344.12177319.9641256/D=yahoo_top/S=2716149:HDLN/_ylt=AvsqK7FgUbxkrtlnjbKs1lP1cSkA/Y=YAHOO/EXP=1193800089/A=5005233/R=0/SIG=14m0dtrqi/*https://www.getsmart.com/refi/qform.asp?bp=ltquickmatch&esourceid=1271910&promo=00221&num=1-866-262-6895&AdType=2&version=45&disable_popups=1&init=1)
howstuffworks.com#A(class=reify-linkifier)
#DIV(class=topbanners)
#DIV(id=holidayad)
#DIV(class=doubleClickAd)
#*(class=doubleClick)
#DIV(class=adText)
guide.opendns.com#DIV(id=noresultsads)
#DIV(class=ad_itext_bar)
search.com#UL(class=sponsored)
experts-exchange.com#DIV(class=ontopBanner)
guide.opendns.com#DIV(id=adbox)
us.f812.mail.yahoo.com#TABLE(id=welcomeAdsContainer)
books.google.com#DIV(class=ad)
weather.yahoo.com#DIV(class=yw-ad)
lifehacker.com#DIV(id=sitemeter)
#DIV(class=advertContainer)

Taboo: Can't read it now? Save it for later.

2008-04-21T00:00:00+00:00

Taboo is basically a temporary bookmarks manager. If you have found an article that you find interesting but it is too long you would normally have 3 options.

Bookmark it.
Leave the tab open and move on.
Close the tab and find it in your history.

All of these options have one major problem: Clutter. Bookmarks can either be stored in a menu or the bookmarks toolbar. This is fine for sites that are frequented often or are permanent references but temporary bookmarks make the perminant bookmarks harder to find. A separate temporary bookmarks folder is fine but it can be very hard to find a specific bookmark mixed in with all of the other temporary bookmarks. Leaving the bookmark in your tabbar makes sorting through your tabs frustrating. The history is normaly erased after a set period of time ind is a pain to look through.

Taboo solves these problems. If you can’t remember the sites name, you can look for the thumbnail of the site. If you can only remember when you looked at the site you can view your taboos in calendar mode. If you know that you added your taboo recently (within the last 10 or so) you can use the menu attached to the “View Taboos” button as the list is sorted by most recently added. Taboo is a beta so more features should appear as time goes on.

Screenshots:

Scribefire: Cool but not perfect

2008-04-20T00:00:00+00:00

Scribefire is a very useful extension and can even upload images to blogger but has a few annoying “bugs” for lack of a better word.

Scribefire pre-release and dark-themes (gtk) don’t mix well (it looks very ugly). Scribefire current release works better with dark themes but not perfectly.

Scribefire can upload images but does not upload them to the standard server (it uploads them to “Picasa web albums”) and, unlike the default editor, it simply places a shrunken version of the image on the webpage and does not link it to its bigger version. This is easily fixable but annoying (especially when using lightbox).

Too many features and few options to trim down the UI.

Verdict: Fun but not for me (yet).

Gnome-Blog debs (no repository)

2008-04-19T00:01:00+00:00

Here is the link to the debs from the Gnome-Blog debs post if you don’t want to add my repository.

gnome-blog

Gnome-Blog debs

2008-04-19T00:00:00+00:00

I have just uploaded the patched gnome-blog deb and an updated python-gdata deb (gnome-blog requires python-gdata 1.0.1 or up but gutsy only includes 1.0). The python-gdata is unnecessary if you use hardy but is a later version than the one provided by hardy.

My PPA:

deb http://ppa.launchpad.net/stebalien/ubuntu gutsy main
deb-src http://ppa.launchpad.net/stebalien/ubuntu gutsy main

Edit: I got the patch from http://bugzilla.gnome.org/show_bug.cgi?id=151291 (thanks to Richard Schwarting)

PDF tools

2008-04-19T00:00:00+00:00

A while back I wrote a script that can convert PDFs into several other formats. It can also print information about PDFs. I recommend you use this script in conjunction with nautilus-actions.

Usage

./PDFtools.sh [pdf document]

Screenshots

Main Window:

Info:

Font Info:

This script requires poppler-tools and zenity

Copy Script From: PDFTools.sh

Gnome-Blog (patched)

2008-04-18T00:00:00+00:00

I have just patched gnome-blog (and spent hours tweaking it) and it now correctly posts titles with blogger. I will post the install instructions along with the gutsy packages required tomorrow.

P.S.

I am posting this from gnome-blog.

BloGTK + tomboy-blogposter + gnome-blog

2008-04-17T00:00:00+00:00

I have tested BloGTK + tomboy-blogposter + gnome-blog and all of them have problems with blogger. Gnome-blog is the simplest. It is a panel applet for the gnome-panel and has a very clean, simple, and fast interface. On the other hand, BloGTK is a standalone app that is a little bulky. Neither of these programs will post titles of posts correctly (BloGTK refuses to allow a title at all and gnome-blog posts the title as part of the body of the post). Tomboy-Blogposter does post the title correctly (because it uses the new API) but does not allow for HTML (links etc…). I am therefore resigned to look for another program (I will try Scribfire next).

Edit: Gnome-Blog cannot post pictures to blogger.

Moving Day

2008-04-17T00:00:00+00:00

I just moved to blogger (obviously) because it has comments and many more features than Tumblr. (This move was recommended by Josh Stroud)

2wire+iwl3945=Crash

2008-04-06T00:00:00+00:00

It turns out that my wireless problem is in my router not my computer. My 2wire router crashes when I try to connect to it using the iwl3945 driver. Ubuntu Gutsy used the ipw3945 driver (now deprecated). That driver worked. Otherwise, Hardy is cool.

Installing Ubuntu beta

2008-04-03T00:00:00+00:00

The wireless card continues to not work but I am installing anyway (nothing to loose). I am hoping that the fix on launchpad will work.

Edit: The battery monitor applet does work in GNOME.

Xubuntu 8.04 Beta 1

2008-04-03T00:00:00+00:00

I just tried out Xubuntu hardy beta with full disk encryption.

Verdict: Broken.

Xubuntu would not properly display my battery percentage (the panel applet would display 28%, 100%, or 0%).
The wireless worked fine and then suddenly stopped working (I had not updated or otherwise messed with my system). When I conncted to a wireless network said network would go down (tested with 2wire only).

I am now trying ubuntu 8.04 beta x86_64 (the 64 bit version) on my dual core, 64bit Intel laptop. I will post the results.

Turn on keyboard led when receiving mail

2008-03-25T00:00:00+00:00

After a lot of fruitless searching I finally figured out the command to turn the scroll lock led on and off in X. I first tried setleds +scroll and setleds -scroll but that only works in a Virtual Terminal. I then tried xset led on and xset led off. That one messes up the num pad. I finally came up with the following:

On:

xset led 3

Off:

xset -led 3

I use mail-notification and set the scroll lock led to go on when I have new mail and set it to go off when I have read the mail.

My Desktop

2008-03-18T00:00:00+00:00

After a lot of tweaking, my desktop is beginning to look how I would like it to look.

Plugging a friend's blog

2008-03-13T00:00:00+00:00

This is my friend Josh’s blog. Random but interesting.

Xname.org

2008-03-12T00:00:00+00:00

I just signed up with 1and1.com and found that they do not offer marginally advanced DNS settings and allow only five subdomains. To work around these limitations I signed up with Xname.org. They allow unfettered customization of the DNS record and are free. I very much recommend them (and thank them).

10 Hour Fix

2008-03-09T00:00:00+00:00

Today I spent 10 hrs fixing my hostname.

I had just bought the domain stebalien.com and was fiddling around with my network settings with network-admin and found the domain box. I typed in my new domain to see what the setting did. Nothing happened for a while so I erased the setting and changed the hosts file back to its original state (without the domain name). Later, while I was using Firefox, my session crashed. I logged back in and received this error:

(process:6725): Gtk-WARNING **: This process is currently running setuid or setgid.
This is not a supported use of GTK+. You must create a helper
program instead. For further details, see:

    http://www.gtk.org/setuid.html

Refusing to initialize GTK+.

(process:6729): Gtk-WARNING **: This process is currently running setuid or setgid.
This is not a supported use of GTK+. You must create a helper
program instead. For further details, see:

    http://www.gtk.org/setuid.html

Refusing to initialize GTK+.

I was consequently logged out. This error had nothing to do with the hostname so I assumed that one of my files had been corrupted. After reinstalling half of my system (sudo aptitude reinstall packages) and looking through all of my configuration files I finally logged in using startx. I was immediately logged back out with a hostname internal error. I spent another hour going over my host configuration files (/etc/hosts, /etc/hostname, …) and all of my DNS configuration files. I finally logged back in using the Failsafe Terminal, typed in sudo network-admin and re-added my domain name, logged back out and in, and my session did not crash. I then proceeded to launch firefox. The page did not load. I could ping, tracerout, and use elinks (a text based web browser for the console) but I Firefox would not load any website. I tinkered with my network-admin settings for 15 minuets before I finally realized that I had a backup of my network-admin settings. I restored my settings and proceeded to write this blog post. I am still clueless as to what my problem was but am happy that it was at least fixed.