I tend to browse a large number of websites, scavenging all the useful bits of information and saving them to my favorites. If a site has some information which I might find remotely useful in some distant future situation, I want to hold on to it. At some point, this approach let to the limits of the browsers' usefulness; it was simply too hard to determine where in the huge file structure to place the bookmarks.

This was the point where I began using perpetually open browser tabs as a sort of bookmark limbo, they were too useful to abandon but not useful enough that I would endure the overhead of finding a spot for them in the dreadful hierarchy. Obviously, this was an unstable situation at best so this predicament led to my quest for a better bookmark management system.

A quick survey with Google image search indicated that there were no alternatives which did not use the same horrible abstraction for managing bookmarks. This suited me well as an idea for a better solution had begun to take root at the back of my mind.

The premise was simple, a small, easily accessible app which would allow you to enter and search for bookmarks based on tags.

"Booky"

As always, naming is tricky. I have really tried to come up with a cooler name, but so far the name has stuck. It does allow for some nifty letter rhymes, though ;) The program is written in C#, using WPF and .NET 3.5 and is currently nearing the completion of the second beta release.

The design principles have remained simple: the program must be browser agnostic, the user interface must do everything in its power to facilitate an efficient user experience (the less time spent in the program, the better), when not in use it must make as little noise as possible and, finally, it must be pretty looking :) For that last part, you can judge my humble design skills for yourself:

For my part, I can say that the program is immensely helpful and I find myself using it more or less daily. It starts with Windows and then patiently sits waiting in the systray until you need its services. Once activated, the UI shown above appears (without the search results, obviously). All the common commands of the program are avaiable through shortcuts which makes the user experience very fluent and painless.

For instance, if you want to create a bookmark, simply paste an url into the search field and press F1. This brings forth the relevant dialog, which politely suggest a title for the bookmark (from the page title - if available). Just fill out the list of associated tags and press Enter (or Escape to cancel). This illustrates the main goal of the program which is to reduce the amount of time spent managing bookmarks and to encourage more aggressive bookmarking.

Get the Program

Booky requires the .NET framework 3.5 to run (on the client profile version is needed). If you're unsure what version you have, you can go here to find out.

The program is free to use and I have no plans for that to change once the program goes out of beta (I'm not planning for this to be one of those perpetual beta apps which seem to flood the web these days).

• Booky Beta 2 Installer

  .msi | 336.38KB

Feedback 

If you have any comments or feedback on the program I would love to hear about it, especially if you found any bugs or have difficulties using the program. Just throw me a mail at withoutprecedence@gmail.com.

Changelog

Beta 2

•  The program now comes packaged in an installer rather than a collection of files.
• Autocomplete for tag searches has been replaced by a dropdown menu with all the matching tags.
• Searching for tags now matches substrings, i.e. searching for patterns will also match design patterns.
• Better parsing of page titles for bookmark title and better handling of special characters.
• The systray icon now has a context menu showing the 5 most recently visited links for quick launching as well as an exit button.
• Set the program to always start in lower right corner.
• Fixed several bugs and inconsistencies with GUI behavior.
• Fixed issues which caused the program to crash when writing tags.
• Fixed a number of miscellaneous bugs and issues. 

The Language

CGL is an interpreted language which is used to describe card games (currently only solitaire type games). The point of the language is to combine it with an interpreter which transforms a code file into a playable game. The language aims to describe a card game as a non-programmer might think about it which means that it closely follows the metaphors of card games. This should make it a comparatively easy language to approach, and not only for programmers.

To make it easier for people to develop card games in CGL I provide a couple of tools for Notepad++. The package contains files to configure the editor with syntax highlighting and auto completion as well as a game template file so you don't have to figure out the overall structure of a game. For instructions on how to install the files, the package includes a readme file. For those who are into language theory, the language grammar is included as well, so you can get the complete picture of the language syntax.

• Notepad++ tools

  .zip | 3.65KB

A Silverlight Interpreter

The reason I write about our old language here is that I've ported the old winforms-based interpreter to one which is hosted in Silverlight. The interpreter allows you to upload your own CGL code to try out your games as well as a number of existing games.

The interpreter is in ongoing development and I have recently released a third version, which you can try out here. The second version, also implemented in Silverlight, can be found here for reference. The second version is currently the only one supporting uploaded games to be played.

Evolving the Language

Working with the CGL has made it apparent that the language is far from perfect and lacks certain capabilities for expressing game concepts and keeping the code concise. The language was designed around the case of the classical Solitaire game which accompanies Windows installations. This means that a lot of game styles can be hard or impossible to represent in a reasonable amount of code. In addition, there are simply a number of quirks and oversights in the language which have yet to be ironed out.

To improve the language and generally make the experience of writing card games better, I'm currently working on a new implementation of the language using a custom compiler rather than the interpreter from the first port. To document the process I'm putting together a series of articles as I go along, which will be linked to below. See the first article for details on the goals and motivations for the project.

• Compiler Series: Introduction
• Compiler Series Part I: An Overview of CGL
• Compiler Series Part II: Compiler Basics

To make order of the chaos I have made something of a framework myself, which makes it quite easy for me to extend the website. I figured that if anyone else would find the code useful they might as well benefit from my work. This calls for a bit of extra work as the framework code has not been my main focus but just sort of appeared over time. Currently, I'm in the process of cleaning up the code, redesigning it and then making it publicly available. As the different parts of the code gets cleaned up I'll be presenting the main design points and usage patterns in a number of blog posts.

Framework Bits and Bobs

This list contains the parts of the framework which have been cleaned up published, each item pointing to a blog post giving an overview of how it works.

• A model for a composable API to interact with the database
• The main dispatcher for page requests
• Page construction

Framework Design

The framework is designed around the MVC pattern, such that the user defines a controller for each url, along with its associated model and view representation(s). I have attempted to automate as much of the process as possible such that you only have to create the proper controllers, models and views, and the framework will handle the dispatching of page requests and instantiations of controllers.

I must admit that my experiences with application design is limited on the area of the stateless web model and are mostly based on experimentation and inspiration from other application types. Thus, I make no claim that this is the best way to develop a web application but it has served me well enough.

Download

As I cover more and more aspects of the code, the cleaned up parts are included in a downloadable package. The content might vary from the versions described in the blog posts as I continually improve the design and refactor the code.

• PHP Framework Source

  .zip | 69.45KB

Programs written in .NET languages are not slow by any means, but they do come up a bit short for the massive task of ray tracing which can bring any computer to its knees. C++ relies on lots of micro optimizations to achieve optimal performance and many of them are simply not available in .NET such as the use of SIMD instructions. For the same reasons, I decided to stay away from real-time ray tracing and focus on creating the most realistic and beautiful images.

Given the performance of Rend and the abundance of faster and more powerful alternatives, I'm not sure if I will find any useful application for the engine, but as long as it remains as rewarding to work on as it has been so far I'll keep expending on it's features (though it seems the work backlog grows quite a bit faster than what I can keep up with). My current goals are to have an engine with which you can create small animated video clips in a reasonably approachable way. It is already capable of loading an IronPython script to produce still images and video, but available effects are lacking and the usability of the engine needs a bit of polishing as well. Once these issues have been ironed out I will upload Rend and I hope you will return and check it out.

Main Features

To give you an idea of the capabilities of Rend, here is a list of the primary features and effects it supports:

• Ambient, diffuse and specular coloring of objects.
• Reflection and refraction of light to create glass-like objects.
• Hard shadows (also soft shadows but with sub-optimal quality).
• Dynamic anti aliasing using edge detection.
• Texture mapping with bilinear filtering.
• Supports spheres, boxes, planes and triangle primitives.
• Kd-tree for spatial division of objects.
• A plugin model with many extension points.
• Imports 3D models from .x and .obj files (currently not very robust implementations).
• Camera animation and video generation.
• An IronPython scripting interface.
• Post-processing effects such as color inversion, grayscaling, gaussian blur, sharpening, edge detection etc.

Showcase

Here is a little preview of what the engine can do so far:

A mixed collection of objects including a textured moon.

A glass sphere demonstrates the refraction of light.

The classic Utah Teapot.

The Utah Teapot made from glass.

A flight of space ships leaving Earth - model courtesy of XNAfusion.com.

Sometimes things go wrong, such as when I first tried to implement spatial division with Kd-Trees (This is supposed to be the same scene as the first image with some additional spheres).

Resources

Rend started out as a port of the principles and code described in a series of C++ tutorials over at DevMaster.net.

I have found additional inspiration in another excellent tutorial series by the Codermind team.