What made the hot chocolate even better, though, was drinking it with hot cinnamon buns. Now, in the case of cinnamon buns I will sometimes just use the canned variation from the freezer, but I find that it produces inconsistent results, usually with a lot of burning on the bottom. Instead, I flipped to a recipe I’ve relied on for a while in King Arthur Flour’s Baker’s Companion. Unlike other cinnamon bun recipes which rely on a quick bread method (e.g., leavening with baking powder, baking soda, or both), this recipe relies on yeast, giving it a distinct flavor in the dough itself and an airier texture. Unfortunately, the filling designed by KAF leaves something to be desired, as it does not give the impact that one normally expects from a cinnamon bun. I intend to experiment adding ground clove and ground nutmeg into the mixture in the future to give the taste the radiating warmth that one should feel when biting into a cinnamon bun.

But, what is the functional programming paradigm?

I am not the best person to answer this question in full, but I can explain the basics of it. At the core of functional programming is the idea that the entire body of code is data. What this means practically is that every method in the code returns a value. This is important because, in most functional languages, instances of data structures are immutable.

One of the major advantages of this method is that any programmer can follow the functional flow of a program. Immutable variables (a.k.a. constants) can be passed as parameters to a method, but they cannot be modified inside that function. Therefore, in order to make the method meaningful, it must return data that is meaningful that is then assigned to a new data structure instance.

All of this eliminates the “magic” that often happens in code where methods happen to be modifying a data structure instance passed as a parameter. (It’s much worse when there’s a data structure instance defined at the global level, allowing methods to modify them without being passed the reference explicitly.) This forces the code a programmer writes to be much cleaner.

Why Scala?

There are a number of very stable and well-honed languages implementing the functional programming paradigm; to name a few:

• StandardML of New Jersey (which happens to be my professor’s language of choice)
• Haskell
• OCaml
• PLT Scheme (now Racket)

And of course there’s a wealth of them on Wikipedia’s Functional Programming page. Scala, however, offers two beautiful features: object-oriented programming (OCaml also has this feature), and compilation down to Java Virtual Machine byte-code. I view these as wonderful reasons to choose Scala as a language to learn. In the end though, the real reason is that it’s an up-and-coming language used by Twitter and FourSquare, so I wanted to jump on the bandwagon and see what the fuss was about.

Where to Start

The worst headache in any language is lack of documentation. Some aspects work like other languages. Other aspects seem to exist in an ether-real sense, but ultimately it’s up to the programmer to implement their full functionality. That’s why there’s always a book or two necessary to get up to speed with a new language. At random, I chose Programming in Scala, not realizing at first that one of the authors of the language, Martin Odersky, was also an author of the book.

The beauty of this is immediately apparent when one starts reading. The book starts with the basic creation of Scala scripts and files and advances all the way through GUI programming, XML parsing, and object equality testing. The last topic includes some very rich scholarly work on how the implementation of object equality tests in most other applications is often lackluster due to the programmer’s misunderstanding of the methodology. The authors give enriching tips on how to test non-reference equality such as giving the equals method the correct type signature and overriding the hashCode method for an object.

The book also investigates common syntax in depth, as well. For example, Section 5.3 describes how the compiler translates arithmetic operations into standard methods performed on objects (infixing). This is very useful for programmers to understand how the language is working “under the hood” and how to best utilize such facts to their advantage.

The book itself has really pushed me forward more in Computer Science as a whole than in just Scala. I sincerely encourage anyone with an interest in programming to read it and learn Scala, just because of the beauty of the language and how well designed it is.

First, I use Google Chrome. As the number of open tabs grows (it happens fast), the size of each tab gets smaller. That means that I end up seeing half of the website name and don’t have a clue about the content. Instead of having a contextual clue in the title regarding the the actual content of the page, instead I just have a clue about the name of the site (which is often very unhelpful).

Secondly, I have to search for what I’m looking at after I’ve already searched my bookmarks for something. Like most people that use a left-to-right language, most text is left-justified and I read from the beginning at the left to the end at the right. I use Pinboard for my bookmarking service, and when I search for data in my bookmarks, I scan the left-hand side of my column for contextual clues about the most relevant bookmarks. When sites organize titles such as “Site Name: Page Title”, what I see is the “Site” part in the results column, which sometimes just confuses me more. For example, one of the most popular post on this blog at the time of writing is “GTD = OmniFocus + OmniOutliner + DEVONThink…”. If I was to bookmark that and then search for something related to GTD in my bookmarks later, I would see the following:

GTD = OmniFocus + OmniOutliner + DEVONThink…  « David’s Blog

If my blog was arranged in the “Site Name: Page Title” format, I would see:

David’s Blog » GTD = OmniFocus + OmniOutliner + DEVONThink…

Respectively, I would see the following scanning down a list of search results:

GTD = OmniFocus…
David’s Blog…

And in my personal experience, the first one gives me better contextual clues as to what I’m looking for and what I’m getting when I click the link.

I personally love this system a lot. When I practice GTD on a regular basis my life becomes easier to manage, and things actually happen as I like them to. I fall into this one trap a lot though: I think that simply practicing GTD will make me a more productive person. That’s not true; GTD does not make you a productive person. The appropriate frame of mind is, “GTD allows me to be a more productive person.” I get myself so wrapped around the concept of writing stuff I need to do down that I never actually get around to doing it. I wonder, “Why does this still feel like its burdening me?”

It’s About Trust

When you write stuff down in a GTD system, the only way it works is when you trust the system you are putting your commitments into. By putting your commitments into this system, you are telling yourself that you have dealt with that commitment and that the commitment will be completed in a reasonable amount of time. When you trust your system to work like this, the burden these commitments place on you is alleviated. Knowing this, I realized I didn’t trust my system like I thought I did. So, now the question is “Why don’t I trust my system?”

Reflecting

There are a lot of things that sit around in my system, waiting to be dealt with. For example, writing this post has been sitting in my system for over 2 months now (it was entered April 4, 2011 at 9:33 PM EST). I know that the reason I didn’t want to write it was because I didn’t want to reflect on how broken my system was; I knew it was broken because instead of experiencing “Mind Like Water,” I was experiencing “Mind Like Molasses.” Still, I didn’t want to admit it was broken because I wasn’t sure I knew how to fix it.

The first part of the recovery process, though, is reflection. This is why David Allen and his associates always stress the importance of a Weekly Review. I always promise myself I’m going to do a Weekly Review, especially when my e-mail inbox pings around 2AM on Tuesday mornings with my Weekly Review reminder from GTD Connect. Those e-mails should put me into action instead of making me feel guilty about not having done one in so long. The Weekly Review is what keeps the system from breaking; looking at your system every week keeps the system in pristine shape. With such a short period between each review, any small failings in your system can be corrected in the next review before they cause catastrophe.

Over-committing and Under-defining

Knowing what you have to do isn’t just half the battle, it is the battle. A review of my system shows that I haven’t been fighting that battle. I have failed to define my commitments and my commitments have continually piled up. It has come to the point where things don’t get into my system because my brain knows that its pointless to put it in. A lot of projects in my system are poorly defined, making it impossible for me to expand them into completable tasks. Furthermore, many of these projects need to be broken up into smaller projects to truly qualify as GTD projects.

I continually allow myself to commit to projects without thinking of the consequences to my system. Many of these commitments, for the reasons above, don’t even make it into my system. This renders my inventory of commitments incomplete, putting even more strain on me to keep track of them in my brain.

Forward

In order to move forward, I’m committing to actually doing weekly reviews and rebuilding my system. At the end of the day, I may have to rip my system apart and start afresh. Getting to that point where I’m able to breathe when I look at my system will be an amazing reward, though. I need to breathe again, and the only way to do that is to get rid of the stale air that’s currently in my lungs.

So what’s the moral of this story? People are not productive or unproductive by nature. These are states that we fall into. Everyone is born with the capacity to be productive, but if we do not care for that capacity, we aren’t productive. GTD allows you to be productive by forcing you to reflect on what you need to do. This is how you nurture productivity. By identifying and controlling the source of non-productivity, you are able to free yourself from the bonds of immobility. This alone though does not make you productive. Instead, this only wipes the slate clean. It is up to you to push forward more and

1. Ensure the slate stays clean
2. Progress further forward with doing what you’ve identified

That being said, Drupal is also much better tailored out-of-the-box as a multi-user CMS versus WordPress which is much better out-of-the-box as a single-user blogging platform. I don’t intend to switch my installation of WordPress 3 to Drupal 7 at any point in the future, mostly because of the prevalence of WordPress templates. However, I hope to use Drupal 7 to power future web projects that don’t require a from-scratch approach.

And, last but certainly not least, do these questions sound ridiculous?

Guess what, you’re not the only one who finds them ridiculous. There are hundreds of thousands of people wondering about those questions: why would water be clear? Why would it be safe? Why would it be easy to get to? Aren’t those just myths?

Unfortunately, for a lot of people, access to fresh, clean, safe water seems like a fairy tale. Take a moment to imagine what your life would be like without water. Now think, shouldn’t access to fresh, clean, safe water be a fundamental right?

What if all this water we took for granted suddenly went away? What if when you went to drink a glass of water, you got brown muck instead? What if the toilets stopped working permanently? What if you had to walk a mile to bathe?

If you think that every person on earth should have access to fresh, clean, safe water, just sign the petition below.

The first thing I should note is why I use DEVONThink over other applications that accomplish the same purpose. The main reason is that DEVONThink is designed the way I think. Everything is laid out in a hierarchy with documents that are inter-related but not of the same category. DEVONThink handles a lot of the extra relations between documents on its own and displays them if I ask to see them. Otherwise, it acts like a customizable Finder with built-in editing tools. That’s an oversimplification, but the power is really quite beautiful.

I first realized how much mileage I could get out of combining DEVONThink with my OmniGroup documents when I realized exactly how little I kept project support folders. So, I set up a Productivity database. I started by copying in most of the lists from the GTD book to text files. That means easy look-up for trigger-lists and weekly-review guidelines. As my current set up stands, those exist in a top-level folder called Lists. I then have another top-level folder called Projects which holds four sub-folders: Current, Incubation, Archived, and Someday/Maybe. Each sub-folder holds its own project list which is a OmniOutliner document. These lists are then replicated to the top-level Lists folder for quick-access. The sub-folders also have their own sub-folders which are project support for individual projects.

What makes this setup so great is that during my weekly review, I have everything I need at my finger-tips. Plus, shifting data is simple. Since my project lists are in OmniOutliner, I can have all 4 documents open at once and easily redistribute projects as the review deems necessary. Also, since I have these are digital files, I just drag-and-drop project support from one category to another. Project becomes active? Move from Incubation to Current. Bandwith dead? Shift+click and drag a bunch of projects from Current to Incubation.

What is marvelous as well is that I don’t have to toss old project support to make space. So, when I need information from that project I finished a few weeks ago, I just go to DEVONThink’s global search and start typing. Or, I can see when support for one project may be relevant to support in another project using what I call DEVONThink’s “mad hatter” function. (It’s actually called “See Also & Classify”, but it looks like an upside down top-hat.)

 <?php the_content(''); ?>

to

<?php the_excerpt(); ?>

Now, the template will render an excerpt instead of the actual post on the main page. That will prevent the featured post from extending over the boundary as well as truncate the rest. If you just want to truncate the featured post, change only line 7.