<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
     xmlns:content="http://purl.org/rss/1.0/modules/content/"
     xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
     xmlns:atom="http://www.w3.org/2005/Atom"
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:wfw="http://wellformedweb.org/CommentAPI/"
     >
  <channel>
    <title>Empty Thoughts</title>
    <link>http://michaeltrier.com/</link>
    <description>Living on the Edge</description>
    <pubDate>Mon, 16 Jan 2012 05:12:55 GMT</pubDate>
    <generator>Blogofile</generator>
    <sy:updatePeriod>hourly</sy:updatePeriod>
    <sy:updateFrequency>1</sy:updateFrequency>
    <item>
      <title>Smart Money</title>
      <link>http://michaeltrier.com/2012/01/14/smart-money</link>
      <pubDate>Sat, 14 Jan 2012 20:00:00 EST</pubDate>
      <category><![CDATA[Forex]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2012/01/14/smart-money</guid>
      <description>Smart Money</description>
      <content:encoded><![CDATA[<div class="document">
<p>This week a trading partner and I (I'll talk more about that down the road) had
an interesting discussion. We instituted a new directional bias in a strategy
and with it there's a lot of down time.  Although we're not watching charts in
a discretionary way, there's still a lot of chart watching that goes on.
Honestly we can't help ourselves. Although the down time of the bias is a good
thing, the bias is keeping us out of the whipsawing market, there's a lot of
time where nothing is going on. The whole process makes you anxious and bored.</p>
<p>In response to this additional downtime we wondered whether or not it would
make sense to pick up more pairs outside of the normal set of pairs we were
using. We both discussed it at length. The end result for me was a real
teachable moment, because you see the smart money is not interested in &quot;how
much I can make&quot; but instead &quot;how much will I risk.&quot; We concurred that
often when trades are going on they are going on with multiple pairs at the
same time. The point being that just because you might like to extract more
money from the market, you would be forced to take on risk that is outside of
your established trading plan in order to get these trades on. For me this was
just a clear reminder of the mindset difference between the smart money and
everyone else.</p>
<p>Ed Ponsi's book <a class="reference external" href="http://www.amazon.com/gp/product/0470097299">Forex Patterns &amp; Probabilities</a> hits home this point very
well. Near the end of the book he discusses the potential for hedge fund
trading. Ponsi lays out the scenario of two traders. One trader sees 100%
returns but also experiences significant drawdown in the process. The other
trader sees a consistent 10% return but drawdown is kept to a minimum.  The
hedge fund is going to pick the second trader to manage his money because the
question for the investor is not, &quot;How much money are you going to make me?&quot;, but instead, &quot;How
much of my money are you willing to risk?&quot;</p>
<p>It's easy to get greedy in the trading business. It's easy to think about the
freedom, the endless opportunities, and rewards that come from winning big. But
if I'm going to be part of that 5%, that is winning, then I need to start
thinking like the smart money.</p>
<p>This week I'll be making my way through Mark Douglas' excellent book <a class="reference external" href="http://www.amazon.com/gp/product/0735201447">Trading
in the Zone</a>. It's the second time I'm reading through it. Although it's a bit
heavy on the psychology, it is helping to reinforce the ideas presented here.</p>
<p>Happy trading!</p>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>A Little about Currency Trading</title>
      <link>http://michaeltrier.com/2012/01/13/a-little-about-currency-trading</link>
      <pubDate>Fri, 13 Jan 2012 20:14:00 EST</pubDate>
      <category><![CDATA[Forex]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2012/01/13/a-little-about-currency-trading</guid>
      <description>A Little about Currency Trading</description>
      <content:encoded><![CDATA[<div class="document">
<p>I've begun talking more and more about Foreign Currency trading (Forex) on my
twitter account and elsewhere. Part of the reason is because it's huge part of
my focus these days. As I've <a class="reference external" href="/2011/01/15/a-trading-journey/">said previously</a> I've have always been
interested in the financial markets. What's exciting and challenging is that
I can combine my love of programming with my passion for the markets. I'll be
writing more about the programming aspects of trading, but in this post I want
to provide a general introduction to Forex for some of my friends that might be
interested in learning more themselves.</p>
<p>There's lots of great resources out there on foreign exchange currency trading.
This post is not meant to be an exhaustive explanation of Forex, but just
a summary of what it's all about, some things that make it attractive, and some
resources for finding out more information.</p>
<p>There are a ton of resources on the internet, in books, podcasts, and elsewhere
with people eager to teach you about currency trading. Frankly there's a lot of
money to be made on the backs of people being sold a dream down easy street.
It's unfortunate that this is the case but it's true. Given this fact you have
to be pretty good at being discerning as well as getting information from
multiple sources. At then end of the day if you decide you want to trade
currencies, it's your money you'll be putting at risk, so if you go that route
you need to treat it as a profession.</p>
<div class="section" id="what-is-currency-trading">
<h1>What is Currency Trading?</h1>
<p>When you're trading currencies your pitting one currency against another.  So
with something like EUR/USD, if you buy this pair you're betting that the Euro
will rise against the US Dollar. If you sell this pair you're betting the
opposite, that the US Dollar is going to rise against the Euro. With Forex
there's no distinction between buying and selling, unlike the stock market
where there is a tendency to buy and hold stocks.</p>
</div>
<div class="section" id="the-market">
<h1>The Market</h1>
<p>The Forex markets are a 24 hour market. It starts in New Zealand, goes to the
Asian session, the London session, the US session and then back again. From
Friday night until Sunday night the market is closed.  Liquidity is another
important thing. With the stock market it does about $58 Billion a day. Major
players can really move that market.  With Forex it does about $4 Trillion
a day. It's the closest thing we have to a perfect market.  No big players can
really move the price with the exception of central banks.  If there's Japanese
intervention or Swiss intervention then it can easily move the market a hundred
points.  But still in the scheme of things that's very minor.</p>
</div>
<div class="section" id="price-movements">
<h1>Price Movements</h1>
<p>One hundred points is a move of 1 cent in the price of the currency.
Everything in Forex is measured in Pips. A pip is generally 1/100 of a cent.
So in the case of EUR/USD if it's trading at 1.3546 and price goes up to
1.3556 then that represents a 10 pip move.  Most brokers will display price
out to a 1/10th of a pip (also called a pipette) or a total of 5 decimals.
Some pairs, such as the Yen pairs, are displayed out to 3 decimals.</p>
</div>
<div class="section" id="leverage-and-risk-management">
<h1>Leverage and Risk Management</h1>
<p>One other interesting thing about Forex is the use of leverage. Since the
Dodd-Frank legislation passed U.S. traders are limited to 50 to
1 leverage on a trade. (They are also pretty much forbidden from opening
accounts overseas.) This means that with $10,000 you could potentially
trade $500,000 worth of currency. Now if you do that you're a moron, but
some use of leverage that is managed appropriately with risk management can
be beneficial. I'll talk more about risk management in follow up posts
because it's one of the most important things in trading yet it's often not
discussed.  The key is to know how much you're risking on each trade.
A standard lot in Forex is $100,000 worth of currency.  You can also trade
mini lots ($10,000), and micro lots ($1,000).  At a standard lot each pip
movement is worth roughly $10 per pip.  So if I set a stop loss in a trade of
30 pips then I'm risking $300 on that trade at a standard lot, or $30 on that
trade with a mini.</p>
</div>
<div class="section" id="brokers">
<h1>Brokers</h1>
<p>As &quot;retail&quot; traders we are not allowed to buy and sell directly with the
central banks. Retail brokers are who we deal with. There are different kinds
of brokers and different ways they do business. Most of the larger well known
brokers are pretty reliable. Brokers tend to fall into two categories but these
often get blurred.  There are dealing desk brokers that are taking the other
side of the trade from you and there are Electronic Communications Networks
(ECN) brokers which are generally just batching up your trades and passing them
on to the Interbank (central banks, partner banks, other brokers, etc...).
Some folks don't like dealing desk brokers because in a sense the broker makes
money if you lose. Brokers make their money mostly on the spread (the price
difference between bid and ask).</p>
<p>Some brokers offer lower spreads but then
charge a commission to make their money.  If you search on the internet you'll
find someone complaining about every one of them. A lot of the complaints can
be distilled down to morons trying to blame the broker for their own bad
decisions. Occasionally it's over an issue of slippage (fill price differences
from your order price). Slippage can be a real problem in high market
volitility situations. There are various ways to prevent slippage: trade when
there is high liquidity, don't trade on banking holidays, don't trade 30
minutes prior to major news items such as Non-Farm Payroll announcements.</p>
<p>I don't want to make it all sound like it's not the brokers fault, because
there have been <a class="reference external" href="http://www.nfa.futures.org/news/newsRel.asp?ArticleID=3851">NFA fines</a> against brokerages over slippage and other
nefarious trading practices.</p>
</div>
<div class="section" id="no-central-exchange">
<h1>No Central Exchange</h1>
<p>Forex has no centralized exchange.  It's all distributed. That means if I'm
trading with <a class="reference external" href="http://www.fxdd.com/">FXDD</a> and you're trading with <a class="reference external" href="https://www.tradestation.com/">Tradestation</a> your data is always
going to be a bit off from mine. Retail Forex trading is only a little over 10
years old. So it's a very infant market.</p>
<p>Some people have pushed for the creation of a centralized exchange. Personally
I like the distributed nature of it. As a technical trader (mostly) all I can
base my trades on is my data. As long as you are working with an ECN that has
good liquidity, it shouldn't be a concern.</p>
</div>
<div class="section" id="demo-trading">
<h1>Demo Trading</h1>
<p>The tools are starting to get really good. One great thing about Forex is that
with any broker you can sign up for a demo account and start &quot;paper&quot; trading
right away.  Their value add is in the tools they provide, so it's pretty
amazing what you can do for no commitment.  As an example, you can go to
<a class="reference external" href="http://www.oanda.com/">Oanda</a>, <a class="reference external" href="http://www.dukascopy.com/">Dukascopy</a> or <a class="reference external" href="http://www.alpari-us.com/">Alpari</a> today and sign up for a demo account,
download a platform and start getting a feel for what it's like to trade the
markets without risking any money. The demo platforms are exactly the same as
the live platforms in terms of features. Data reliability and execution time of
orders is not guaranteed to be the same, so it's always a good idea to take
a new strategy live with very minimal exposure. Personally I'll trade in micro
lots for a couple of weeks to be sure I'm seeing live what I saw in my own
back testing.</p>
<p><strong>Note</strong> that any reference to brokers in the above paragraphs does not represent
and endorsement and they are not &quot;introducing broker&quot; links. I'm a trader, not
a salesman. Do you own homework.</p>
</div>
<div class="section" id="what-kind-of-trader-are-you">
<h1>What Kind of Trader are You?</h1>
<p>Different traders use different trading methodologies.  There's fundamental
traders which like to trade off longer time frames and base it on the overall
fundamentals of the economies in play, and there are technical traders that
simple trade off the technicals of the price.</p>
<p>A fundamental trader for
instance might short EUR/GBP betting that the Eurozone countries are going to
suffer ratings downgrades, due to lack of a sustainable plan to address the
Greek debt crisis, and the
British Pound is going to continue to strengthen.</p>
<p>A technical trader may just
have a technical strategy that says if price reaches a prior point of support
it's likely to bounce off of it and head higher.  I think the best traders
combine the two methodologies and consider both in a trade. Most of my trading
is purely technical, but I don't ignore the fundamentals.  If nothing else
I don't trade on bank holidays for instance because of the low liquidity.
Things like that.</p>
<p>For technical traders they tend to fall into two main camps,
those that trade based on indicators and those that trade based on price
action. This is not a hard defined rule, but I'm just trying to generalize
things.  Indicator traders tend to use things like Fibonacci levels,
stochastics, exponential moving averages, etc... to build a trading strategy.
Price action traders tend to look at support / resistance, candlestick patterns, and
just general price movement between the bears and bulls.</p>
<p>Some traders like to go after small wins, such as a 10 pip move, and other traders like to have
a trade open for several days and go after 100 - 300 pip moves.  I'd caution
about trying to scalp trade for very small pips because as a retail trader you
would get eaten alive by execution speeds and the spread.  When you carry
a currency over a day there's interest to be paid, so some folks make sure they
close their trades by end of day or in other cases end of week.
In fact sometimes it's to be paid and sometimes it's to be received. There is
a trading methodology that is just based on this interest called the Carry
Trade.  It's not such a good thing today since all economies are in the toilet
but there was a time when it was a great way to trade.  With the carry trade
you would find a currency paying 6% interest and
another that is paying .5% interest. You would sell the higher interest
currency.The buyer of the currency would pay you that 6% over the .5% you'd
pay out and you would make a relatively low risk 5.5%.</p>
</div>
<div class="section" id="automated-trading">
<h1>Automated Trading</h1>
<p>The up and coming thing these days is automated trading. That's what I'm most
interested in. I'll have a lot more to say about this in future posts. The
tools are finally good enough that most brokers offer an API
that you can code to.  This means you can back test a strategy for about 10
years, fine tune it, and then automate it.  If you balance a good strategy with
good Risk Management you can live to trade another day.</p>
<p>Automated trading also takes a lot of the psychology out of it, which is huge.
In my opinion psychology is the number one reason why most traders lose money.
In fact it is said that 90% of Forex traders lose money. That's huge!
Discretionary traders tend to not follow their rules.  So
although they may have developed a great strategy when they get into the trade
the psychology eats them alive.</p>
</div>
<div class="section" id="final-thoughts">
<h1>Final Thoughts</h1>
<p>I could go on and on but I'm sure I'll have future posts on the subject. I will
wrap it up with just one more item.  You shouldn't be trading Forex with money you
cannot afford to lose. That's critical.  Because as much as you can back test
and use risk management the high degree of leverage offered in Forex means
price can work in your favor just as much as it can work against you.</p>
<p>Here's a couple of helpful resources to get you started in the right direction:</p>
<p><a class="reference external" href="http://www.babypips.com/school/">Baby Pips</a> - excellent resource to get started. They make
it fun and do a good responsible job of presenting the fundamental aspects of
trading.</p>
<p><a class="reference external" href="http://reviewpips.com/">Review Pips</a> - by the same folks that do Baby Pips. This is a review site by
users of products and services they have used. Be careful about any review
sites. Some &quot;salesman&quot; are clearly stuffing the ballot. I'd get the opinion of
people you trust and combine it with reviews from multiple sites.</p>
<p><a class="reference external" href="http://www.amazon.com/s/ref=nb_sb_ss_i_5_13?url=search-alias%3Ddigital-text&amp;field-keywords=stock+market+wizards&amp;x=0&amp;y=0&amp;sprefix=stock+market+%2Cdigital-text%2C169">Market Wizards Books</a> - very inspirational series of books by Jack D. Schwager that are
interviews with traders that have done exceptional. These books help to understand the
mindset of a succesful trader.</p>
</div>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Crazy Hair</title>
      <link>http://michaeltrier.com/2011/01/19/crazy-hair</link>
      <pubDate>Wed, 19 Jan 2011 20:14:00 EST</pubDate>
      <category><![CDATA[Personal]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2011/01/19/crazy-hair</guid>
      <description>Crazy Hair</description>
      <content:encoded><![CDATA[<div class="document">
<p>I'm a bit biased, but his crazy hair is awesome!</p>
<img alt="/media/assets/crazy-hair.png" src="/media/assets/crazy-hair.png" />
</div>
]]></content:encoded>
    </item>
    <item>
      <title>A Trading Journey</title>
      <link>http://michaeltrier.com/2011/01/15/a-trading-journey</link>
      <pubDate>Sat, 15 Jan 2011 20:14:00 EST</pubDate>
      <category><![CDATA[Forex]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2011/01/15/a-trading-journey</guid>
      <description>A Trading Journey</description>
      <content:encoded><![CDATA[<div class="document">
<p>I've contemplated for some time on when and how much I would talk about my
trading journey on my blog. After giving it some thought, I've decided it would
be fun to chronicle my progression in trading education and ultimately
trading and analysis.</p>
<div class="section" id="how-i-got-here">
<h1>How I Got Here</h1>
<p>First a little background on me, at least in how it relates to trading. I've
always been interested in the markets. I can remember that the first time
I really had some sort of understanding about stocks and financial markets was
around the time of the breakup of the Bell System in 1984. I recall asking my
step-father to explain what it meant. It was only a year later that I found
myself attending conferences with a childhood friend in San Francisco on
investments and investment opportunities. (As an interesting aside, at one such
conference a company called Motorola trying to raise investment money for it's
newish mobile phone division. They phoned me twice the following week and I had
to tell them that it would take quite a bit of allowance money for me to be
able to pony up the $2,000 minimum they were asking. What a missed opportunity
that was.)</p>
<p>Although I remained interested in investments and markets I only flirted with
the idea off and on over the years. Even though I was quite proficient with
computers and software development, I was a finance major and attended school
at <a class="reference external" href="http://www.ggu.edu/">Golden Gate University</a> in the financial district in San Francisco.
I studied for my <a class="reference external" href="http://www.sec.gov/answers/series7.htm">Series 7</a> with a relatively small brokerage house in
Cupertino in the evenings, but decided it wasn't anything I wanted to go
through with. (The idea of selling something to someone because it's what I had
to offer instead of what was best for their situation didn't appeal to me.)</p>
<p>About 5 years ago I became aware of the retail foreign exchange (forex)
currency markets. I read lots of interesting pieces on it, entertained
exploring it further, but never did move on it. Somehow, about a year ago, the
foreign currency markets crossed my path once again. I don't even recall how it
happened, but when it did I knew it was an itch I wanted to scratch.</p>
</div>
<div class="section" id="ninety-percent-of-traders-lose-money">
<h1>Ninety Percent of Traders Lose Money</h1>
<p>From then until now I've been reading, watching, and studying as much as I can.
I've read countless numbers of books, spent hours in forums, and continued to
educate myself on economic affects on the forex markets. What I discovered is
there is a ton of misinformation in the marketplace. Most of what folks are
selling or even giving away is pure bullshit. Like so many financial experts
you see on TV, most are just regurgitating what they've heard others say.
There's many approaches to being successful in the financial markets. Some
prefer to trade on fundamentals, others on technicals, and some just on pure
price action. But if it was as easy as trading a 20 day EMA breakout, or some
such horseshit, why would any of us work for a living.  There's this huge herd
mentality and not many are stopping to do their own analysis or homework. It
seems that everyone is looking to get rich quick, and yet most are getting
broke even faster. There's a sobering statistic in trading: 90% of all traders
lose money.</p>
<p>I knew that if I was going to do some trading of my own I didn't want to be
part of that 90% and I knew that my best chance for success would involve doing
the hard work, testing ideas, and finding someone that was where I wanted to be
and getting that person to mentor me. About six months ago a friend introduced me
to Phil Newton and his <a class="reference external" href="http://trading-strategies.info/">Trading Strategies</a> site. After talking to Phil and
reviewing others' personal experiences with Phil, I decided that it would be
worthwhile to hook up with someone like Phil, in order to get some guidance in
the markets. Phil is the real deal.</p>
</div>
<div class="section" id="the-journey">
<h1>The Journey</h1>
<p>For the past six months I've been demo trading, developing a trading plan, and
continuing to learn as much as I can. I'm not sure where any of this will go,
but I always enjoy learning something new, and right now trading is satisfying
that desire for me. Maybe at some point I'll be posting charts, making
predictions and all the rest of that crap, but until then I'll keep watching,
learning, studying, and documenting my journey. For me the journey is really
the best part.</p>
</div>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Debugging Emails in Django</title>
      <link>http://michaeltrier.com/2010/12/12/debugging-emails-in-django</link>
      <pubDate>Sun, 12 Dec 2010 20:14:00 EST</pubDate>
      <category><![CDATA[Python]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2010/12/12/debugging-emails-in-django</guid>
      <description>Debugging Emails in Django</description>
      <content:encoded><![CDATA[<div class="document">
<p>In many applications you need some way to debug / test the sending of emails
without actually sending them out. For instance, you may be working on a
political action based application and part of the functionality of the app
is to automatically email your congressional representatives about a particular
issue. While testing an application like this you want to be able to verify that the
appropriate emails are setup to be delivered, but you don't want them to actually
get delivered. This sort of testing does not replace any integration
level tests you would write, but it serves a different purpose. Often, client
signoff on an application requires end-user testing. These debug emails could
be used to verify the application is working correctly to obtain a signoff.</p>
<div class="section" id="wrapping-django-s-send-mail">
<h1>Wrapping Django's send_mail</h1>
<p>In every Django project I have an app called <tt class="docutils literal">core</tt>. Core is something I've built
up over time to include common things I want in every project. Core contains
things like admin screens for <tt class="docutils literal">LogEntry</tt>, <tt class="docutils literal">ContentType</tt>, and others. It
also includes a wrapped version of Django's <tt class="docutils literal">send_mail</tt> that I use whenever
I need to send email messages.</p>


<div class="pygments_colorful"><pre><span class="kn">from</span> <span class="nn">django.conf</span> <span class="kn">import</span> <span class="n">settings</span>
<span class="kn">from</span> <span class="nn">django.core.mail</span> <span class="kn">import</span> <span class="n">send_mail</span> <span class="k">as</span> <span class="n">send_mail_original</span>

<span class="k">def</span> <span class="nf">send_mail</span><span class="p">(</span><span class="n">subject</span><span class="p">,</span> <span class="n">message</span><span class="p">,</span> <span class="n">from_email</span><span class="p">,</span> <span class="n">recipient_list</span><span class="p">,</span>
              <span class="n">fail_silently</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span> <span class="n">auth_user</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">auth_password</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span>
              <span class="n">connection</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">recipient_list</span><span class="p">,</span> <span class="nb">basestring</span><span class="p">):</span>
        <span class="n">recipient_list</span> <span class="o">=</span> <span class="p">[</span><span class="n">recipient_list</span><span class="p">]</span>

    <span class="k">if</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">settings</span><span class="p">,</span> <span class="s">&#39;EMAIL_DEBUG_ON&#39;</span><span class="p">,</span> <span class="bp">True</span><span class="p">):</span>
        <span class="c"># wrap the email message</span>
        <span class="n">wrapper</span> <span class="o">=</span> <span class="s">&quot;-------------------------------------------------</span><span class="se">\n</span><span class="s">&quot;</span> \
                  <span class="s">&quot;- DEBUG EMAIL                                   -</span><span class="se">\n</span><span class="s">&quot;</span> \
                  <span class="s">&quot;-------------------------------------------------</span><span class="se">\n</span><span class="s">&quot;</span> \
                  <span class="s">&quot;- To: </span><span class="si">%(to)s</span><span class="s">                                    -</span><span class="se">\n</span><span class="s">&quot;</span> \
                  <span class="s">&quot;- From: </span><span class="si">%(from)s</span><span class="s">                                -</span><span class="se">\n</span><span class="s">&quot;</span> \
                  <span class="s">&quot;- Subject: </span><span class="si">%(subject)s</span><span class="s">                          -</span><span class="se">\n</span><span class="s">&quot;</span> \
                  <span class="s">&quot;-------------------------------------------------</span><span class="se">\n\n</span><span class="s">&quot;</span> \
                  <span class="o">%</span> <span class="p">{</span>
                        <span class="s">&#39;to&#39;</span><span class="p">:</span> <span class="s">&quot;, &quot;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">recipient_list</span><span class="p">),</span>
                        <span class="s">&#39;from&#39;</span><span class="p">:</span> <span class="n">from_email</span><span class="p">,</span>
                        <span class="s">&#39;subject&#39;</span><span class="p">:</span> <span class="n">subject</span>
                    <span class="p">}</span>

        <span class="n">message</span> <span class="o">=</span> <span class="n">wrapper</span> <span class="o">+</span> <span class="n">message</span>
        <span class="n">subject</span> <span class="o">=</span> <span class="s">&quot;DEBUG: </span><span class="si">%s</span><span class="s">&quot;</span> <span class="o">%</span> <span class="n">subject</span>
        <span class="n">recipient_list</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">settings</span><span class="p">,</span> <span class="s">&#39;DEBUG_EMAILS&#39;</span><span class="p">,</span>
                                <span class="p">(</span><span class="n">k</span> <span class="k">for</span> <span class="n">k</span><span class="p">,</span><span class="n">v</span> <span class="ow">in</span> <span class="n">settings</span><span class="o">.</span><span class="n">ADMINS</span><span class="o">.</span><span class="n">items</span><span class="p">()))</span>

    <span class="n">send_mail_original</span><span class="p">(</span><span class="n">subject</span><span class="p">,</span> <span class="n">message</span><span class="p">,</span> <span class="n">from_email</span><span class="p">,</span> <span class="n">recipient_list</span><span class="p">,</span>
                       <span class="n">fail_silently</span><span class="o">=</span><span class="n">fail_silently</span><span class="p">,</span> <span class="n">auth_user</span><span class="o">=</span><span class="n">auth_user</span><span class="p">,</span>
                       <span class="n">auth_password</span><span class="o">=</span><span class="n">auth_password</span><span class="p">,</span> <span class="n">connection</span><span class="o">=</span><span class="n">connection</span><span class="p">)</span>
</pre></div>



<p>The code is pretty self explanatory. This simple method allows you to send
email messages, but wrap them so they are actually only delivered to the
<tt class="docutils literal">ADMINS</tt>, or <tt class="docutils literal">DEBUG_EMAILS</tt> if you have specified that setting.
<tt class="docutils literal">DEBUG_EMAILS</tt> is a list of email addresses to send to.</p>
</div>
<div class="section" id="using-django-mailer-2">
<h1>Using django-mailer-2</h1>
<p>Another method that can be used to verify the contents of sent emails is to
use the <a class="reference external" href="https://github.com/SmileyChris/django-mailer-2">django-mailer-2</a> application. I prefer this one by SmileyChris over
<a class="reference external" href="https://github.com/jtauber/django-mailer">the original</a> by James Tauber, but both fundamentally do the same thing.
django-mailer-2 captures, queues, and sends out emails via a <tt class="docutils literal">cron</tt> job, in
place of the standard &quot;fire and forget&quot; method. django-mailer-2 provides
a method to monkey-patch the Django version of <tt class="docutils literal">send_mail</tt> so that its
specialized version is used instead.</p>
<p>This simple addition to my <tt class="docutils literal">urls.py</tt> module means I don't have to modify any
of my application code.</p>


<div class="pygments_colorful"><pre><span class="c"># queue all email</span>
<span class="kn">from</span> <span class="nn">django_mailer</span> <span class="kn">import</span> <span class="n">queue_django_mail</span>
<span class="n">queue_django_mail</span><span class="p">()</span>
</pre></div>



<p>Once you have django-mailer-2 wired into your project any emails will
automatically be queued up into the django-mailer-2 tables. As long as the
django-mailer-2 cron job entries are not running on your test server, the messages
will never be sent out. Incidentally, I have my own <a class="reference external" href="https://github.com/empty/django-mailer-2">forked version</a> of
django-mailer-2 that only makes modifications to the admin in order to make
it simpler to find mail messages.</p>
<p>This application is also very useful when working in a development environment,
especially if you are not running a mail server on your local development
system.</p>
<p>Hopefully these couple of tips will help you test and debug Django emails more
simply in the future.</p>
</div>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Why I Use Vim</title>
      <link>http://michaeltrier.com/2010/12/05/why-i-use-vim</link>
      <pubDate>Sun, 05 Dec 2010 19:57:00 EST</pubDate>
      <category><![CDATA[Programming]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2010/12/05/why-i-use-vim</guid>
      <description>Why I Use Vim</description>
      <content:encoded><![CDATA[<div class="document">
<img alt="/media/assets/2010/Vimlogo.png" src="/media/assets/2010/Vimlogo.png" />
<p>I've been using <a class="reference external" href="http://code.google.com/p/macvim/">MacVIM</a> as my editor of choice for a couple of years now, yet
in many ways I still feel like a beginner. Every day I am learning
more and more about my editor, but it takes a conscious effort to become proficient with
an editor like Vim. Here's why I make that effort.</p>
<p>Editors are something that are very personal; they have to fit with your own
work flow approach to programming. If you have ever stopped to think about it,
the way each person goes about editing text is quite different. I frequently
pair program with colleagues and I find it amazing, and sometimes frustrating,
to see how others go about editing. For instance some people are delete and
insert kind of people, others prefer to insert and then delete, some are poor
typists and prefer to do copy and paste editing, and others are overwrite folks.</p>
<p>It's also not just a general difference in approach; the differences are
contextual. For instance, your editing approach
when deleting multiple whole lines is very different from your approach to
just editing a single line. It's also different if you're editing content in
the middle of the line versus editing at the beginning or the end of the line.
Approaches to find and replace are also widely varied. I point all this out
because at the end of the day you are best served by having an editor that is
able to be customized to work best with your natural approach to editing. For
me Vim is that editor, yet there are many <a class="reference external" href="http://www.gnu.org/software/emacs/">other great</a> <a class="reference external" href="http://www.xemacs.org/">alternatives</a>.</p>
<p>The downside to something like Vim, and other highly configurable editors, is
that it does require an investment of time to see the real benefits of it.
I have several friends that desire to learn Vim but aren't willing to make the
investment to switch from something like <a class="reference external" href="http://macromates.com/">TextMate</a>. Thankfully there are
quite a few resources out there to help you get up to speed quickly.</p>
<ul class="simple">
<li><a class="reference external" href="http://peepcode.com/">PeepCode Screencasts</a> - Their offerings of <a class="reference external" href="http://peepcode.com/products/smash-into-vim-i">Smash into Vim</a> and <a class="reference external" href="http://peepcode.com/products/smash-into-vim-ii">Smash into
Vim 2</a> are great videos to help you get started with Vim. I learned some
fundamental things about Vim in these screencasts that I wasn't aware of
previously. I also find them real gems to visit again and again. Well worth
the money.</li>
<li><a class="reference external" href="http://vimcasts.org/">VimCasts</a> - Free short videos highlighting features of Vim. VimCasts is
produced by Drew Neil. These are high quality professionally done trainings.
A highly recommended addition to your podcast reader.</li>
<li><a class="reference external" href="http://www.vim.org/scripts/index.php">Vim Scripts</a> - Part of the Vim site that is devoted to third-party plugins
to expand the capabilities of Vim. It's well worth your time to find plugins
that make things easier. For instance, I have a plugin that highlights errors
in my Python code as I type, such as finding unused imports or making sure
my code is <a class="reference external" href="http://python.org/dev/peps/pep-0008/">PEP8</a> compliant. I have a plugin that makes commenting painless.</li>
<li><a class="reference external" href="http://showmedo.com/videotutorials/video?name=3160030;fromSeriesID=316">Justin Lilly's Vim Screencasts</a> - My good friend Justin Lilly has a number
of great screencasts on Vim. Additionally, his post titled <a class="reference external" href="http://justinlilly.com/vim/my_new_ide.html">Vim: My New IDE</a>
is an excellent introduction to some of the plugins available on Vim.</li>
</ul>
<p>One other thing that will get you up to speed on Vim is to start with
someone else's Vim configuration. Mine is <a class="reference external" href="https://github.com/empty/vimrc">available on GitHub</a>. I caution you
to not adopt a complex Vim configuration until you have the basics down. The
main reason being is that some configurations alter basic builtin behavior.
For instance in my configuration I disable navigation using the arrow keys. If
you're not aware of this it could impact your understanding of what are Vim
defaults and what things are modifications.</p>
<p>One of the big advantages for me in using Vim is that it's available on every
platform that I work with. This means I don't have to context shift when I'm
editing configuration files on the server, or writing .NET code.</p>
<p>I hope you take some time to check out the above resources and consider using
an editor like Vim. It's an ongoing investment but certainly worthwhile.</p>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>New Blog Platform</title>
      <link>http://michaeltrier.com/2010/12/04/new-blog-platform</link>
      <pubDate>Sat, 04 Dec 2010 18:07:00 EST</pubDate>
      <category><![CDATA[Python]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2010/12/04/new-blog-platform</guid>
      <description>New Blog Platform</description>
      <content:encoded><![CDATA[<div class="document">
<p>Like <a class="reference external" href="http://techspot.zzzeek.org/2010/11/21/how-coders-blog/">several</a> <a class="reference external" href="http://lucumr.pocoo.org/2010/11/23/new-blog/">others</a> I've decided to switch my blog to a
non-blog platform. I did this mainly because the whole blog
platform web interface approach is not something that works well
for me. Often when I think about writing something I want to
focus on the writing and not on the whole process of creating a
post. Instead, what usually happens is that I log into my <a class="reference external" href="http://zine.pocoo.org/">blog
platform</a> see 1,400 spam comments, feel compelled to delete them
all, and then give up on the whole idea. Dealing with media was
always another hassle to deal with. In the end I knew I wanted
to streamline the process.</p>
<p>Luckily, while I was rolling this around in my head others were
doing the same thing. It turns out there's quite a few options
out there in the Python world for using static blog generators
to deliver up content. In the end I went with <a class="reference external" href="http://blogofile.com/">blogofile</a>, but
customized it a bit for my needs. With blogofile I'm able to
write up a post in <a class="reference external" href="http://docutils.sourceforge.net/rst.html">ReStructuredText</a> format, commit it to Git,
and push the repository to my server. From there a Git post-receive
hook handles the process of rebuilding my blog. It's a
simplified process that allows me to focus on writing content
and not the process of getting a blog post out there.</p>
<p>One thing you'll notice is that my blog no longer has comment
support. I'm on the fence on this one. Comments can often be
helpful to further clarify, distill, or correct things that are
written. But, dealing with spam is a hassle and not something I
have the energy for. If I do enable comments it will be done
by using <a class="reference external" href="http://disqus.com/">Disqus</a> as others have done. Until then, just contact
me through <a class="reference external" href="http://twitter.com/mtrier/">twitter</a>.</p>
<div class="section" id="converting-my-content">
<h1>Converting My Content</h1>
<p>One of the challenges when moving from one blog platform to another
is getting your content converted. In my case I was going from HTML
to ReStructuredText for the posts. I was also pulling data out of a
PostgreSQL database. To simplify the process I wrote a script that uses
<a class="reference external" href="http://www.sqlalchemy.org/">SQLAlchemy</a> and that made the process pretty straight forward. I've
included an excerpt of the script below, but if you'd like the whole thing
let me know.</p>


<div class="pygments_colorful"><pre><span class="k">def</span> <span class="nf">from_html_to_rst</span><span class="p">(</span><span class="n">content</span><span class="p">):</span>
    <span class="n">p1</span> <span class="o">=</span> <span class="n">Popen</span><span class="p">([</span><span class="s">&quot;/Users/mtrier/.cabal/bin/pandoc&quot;</span><span class="p">,</span>
                <span class="s">&quot;--reference-links&quot;</span><span class="p">,</span>
                <span class="s">&quot;-r&quot;</span><span class="p">,</span>
                <span class="s">&quot;html&quot;</span><span class="p">,</span>
                <span class="s">&quot;-t&quot;</span><span class="p">,</span>
                <span class="s">&quot;rst&quot;</span><span class="p">],</span> <span class="n">stdin</span><span class="o">=</span><span class="n">PIPE</span><span class="p">,</span> <span class="n">stdout</span><span class="o">=</span><span class="n">PIPE</span><span class="p">)</span>
    <span class="n">p1</span><span class="o">.</span><span class="n">stdin</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">content</span><span class="p">)</span>
    <span class="n">p1</span><span class="o">.</span><span class="n">stdin</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
    <span class="k">return</span> <span class="n">p1</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>

<span class="n">posts</span> <span class="o">=</span> <span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Post</span><span class="p">)</span><span class="o">.</span><span class="n">filter</span><span class="p">(</span><span class="n">Post</span><span class="o">.</span><span class="n">status</span><span class="o">==</span><span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">order_by</span><span class="p">(</span><span class="n">desc</span><span class="p">(</span><span class="n">Post</span><span class="o">.</span><span class="n">pub_date</span><span class="p">))</span>

<span class="k">for</span> <span class="n">post</span> <span class="ow">in</span> <span class="n">posts</span><span class="p">:</span>
    <span class="n">year_directory</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">post_directory</span><span class="p">,</span> <span class="nb">str</span><span class="p">(</span><span class="n">post</span><span class="o">.</span><span class="n">pub_date</span><span class="o">.</span><span class="n">year</span><span class="p">))</span>
    <span class="n">mkdir_p</span><span class="p">(</span><span class="n">year_directory</span><span class="p">)</span>
    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s">&quot;</span><span class="si">%s</span><span class="s">/</span><span class="si">%s</span><span class="s">-</span><span class="si">%s</span><span class="s">.rst&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">year_directory</span><span class="p">,</span>
                                <span class="nb">str</span><span class="p">(</span><span class="n">post</span><span class="o">.</span><span class="n">post_id</span><span class="p">)</span><span class="o">.</span><span class="n">zfill</span><span class="p">(</span><span class="mi">4</span><span class="p">),</span>
                                <span class="n">post</span><span class="o">.</span><span class="n">slug</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s">&#39;/&#39;</span><span class="p">)[</span><span class="o">-</span><span class="mi">1</span><span class="p">]),</span> <span class="s">&#39;w&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
        <span class="c"># write out YAML</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">&#39;---</span><span class="se">\n</span><span class="s">&#39;</span><span class="p">)</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">&quot;title: </span><span class="si">%s</span><span class="se">\n</span><span class="s">&quot;</span> <span class="o">%</span> <span class="n">post</span><span class="o">.</span><span class="n">title</span><span class="p">)</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">&quot;date: </span><span class="si">%s</span><span class="se">\n</span><span class="s">&quot;</span> <span class="o">%</span> <span class="n">post</span><span class="o">.</span><span class="n">pub_date</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="s">&quot;%Y/%m/</span><span class="si">%d</span><span class="s"> %H:%M:%S&quot;</span><span class="p">))</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">&quot;tags: </span><span class="si">%s</span><span class="se">\n</span><span class="s">&quot;</span> <span class="o">%</span> <span class="s">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">([</span><span class="n">p</span><span class="o">.</span><span class="n">name</span> <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">post</span><span class="o">.</span><span class="n">tags</span><span class="p">]))</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">&quot;categories: </span><span class="si">%s</span><span class="se">\n</span><span class="s">&quot;</span> <span class="o">%</span> <span class="s">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">([</span><span class="n">c</span><span class="o">.</span><span class="n">name</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">post</span><span class="o">.</span><span class="n">categories</span><span class="p">]))</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">&quot;author: Michael Trier</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">)</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">&#39;---</span><span class="se">\n</span><span class="s">&#39;</span><span class="p">)</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">from_html_to_rst</span><span class="p">(</span><span class="n">post</span><span class="o">.</span><span class="n">text</span><span class="p">))</span>
        <span class="k">except</span> <span class="ne">Exception</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
            <span class="k">print</span> <span class="s">&quot;Post </span><span class="si">%s</span><span class="s"> can&#39;t be decoded.&quot;</span> <span class="o">%</span> <span class="n">post</span><span class="o">.</span><span class="n">post_id</span>
</pre></div>



<p>To convert from HTML to ReStructuredText I used a Haskell tool called
<a class="reference external" href="http://johnmacfarlane.net/pandoc/">Pandoc</a>. It worked quite well, requiring very little cleanup after
the fact. Pandoc was easily installable on my Mac by using <a class="reference external" href="https://github.com/mxcl/homebrew">homebrew</a>
to bring in the Haskell platform and then using cabal to install Pandoc.</p>


<div class="pygments_colorful"><pre><span class="nv">$ </span>brew install haskell-platform
<span class="nv">$ </span>cabal update
<span class="nv">$ </span>cabal install pandoc
</pre></div>



<p>Hopefully all of these changes will mean that I'll be more inclined to
post more often, but that remains to be seen. At least when I do post
it will be a much simpler process. Special thanks to <a class="reference external" href="http://techspot.zzzeek.org/">Mike Bayer</a> for
his help on some Blogofile issues.</p>
</div>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Django 1.1 Testing and Debugging</title>
      <link>http://michaeltrier.com/2010/07/07/django-1.1-testing-and-debugging</link>
      <pubDate>Wed, 07 Jul 2010 01:39:00 EDT</pubDate>
      <category><![CDATA[Python]]></category>
      <category><![CDATA[Testing]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2010/07/07/django-1.1-testing-and-debugging</guid>
      <description>Django 1.1 Testing and Debugging</description>
      <content:encoded><![CDATA[<div class="document">
<p>I've been wanting to write this post for about four weeks now, and
finally I have a chance to follow through on it. A little over a
month ago I picked up Karen M. Tracey's new book,
<a class="reference external" href="http://www.amazon.com/Django-Testing-Debugging-Karen-Tracey/dp/1847197566/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1278466694&amp;sr=8-1">Django 1.1 Testing and Debugging</a> by <a class="reference external" href="http://www.PacktPub.com">Packt Publishing</a>. It's
been surprising to me that I've heard little in Django circles
about this book because it fills a very nice space that has been a
huge void in the Django world for some time. Testing within Django
has always been something I've struggled with. The platform has
never really &quot;encouraged&quot; testing in a way that I was used to in
the Ruby on Rails or Pylons world. Likely this was more of an
internal personal struggle of trying to figuring out how to fit
testing within my workflow within the Django world than an actual
shortcoming in the framework. For me, Ms. Tracey's book was exactly
what I needed to put things into perspective and to get clarity on
an appropriate testing workflow in Django.</p>
<p>The book is very well written and quite readable. I found only a
few minor code problems, and likely the result of chasing an ever
evolving framework than actual oversight. I was able to digest the
book over three days and began to put some of the teachings in the
book into practice immediately.</p>
<p>The book starts off with some basic testing setup items and
discusses testing approaches. Quickly Ms. Tracey moves into talking
about doctests. Although I'm not a huge fan of doctests, I found
the discussion easy to follow and Tracey does a great job of
presenting the advantages and disadvantages of doctests. In chapter
three Unit Tests using TestCase are covered and again Ms. Tracey
does a very thorough job of covering the pros and cons of this
approach. There were two areas of the book that probably helped
fill in gaps for me the most, the chapter on using Client to do
integration tests and the chapter on integrating third-party test
tools. I still haven't had a chance to dig into Twill but I
definitely want to experiment in using Twill for my integration
tests. The last half of the book is spent talking about debugging
approaches and figuring out how to find and solve problems with
your code. Although I personally didn't get a lot of new
information out of this section of the book, programmers new to
Django / Python will find it to be an excellent resource in
outlining the options that are available when things go wrong. The
book finishes up with a chapter on moving your applications to
production, debugging production problems, and load testing your
applications.</p>
<p>I really only have two criticisms of the book and they are both
minor. In chapter 5 where Ms. Tracey discusses integrating Django
testing with third-party tools, I thought the book should have gone
a little deeper. <a class="reference external" href="http://nedbatchelder.com/code/coverage/">Coverage</a> and <a class="reference external" href="http://twill.idyll.org/">Twill</a> are covered in depth but
not a lot of time is spent on using <a class="reference external" href="http://somethingaboutorange.com/mrl/projects/nose/0.11.3/">Nose</a> as a test runner other
than to provide the basic approach. I understand the book is not
about extending Nose but it would have been nice to have a bit more
to work with there. The only other criticism of the book was with
the final chapter. Although there's useful information in the
&quot;moving your app to production&quot; chapter, it seemed out of scope for
this book and a subject matter that is really deserving of an
entire book itself. That said, I did enjoy the discussion on load
testing and found it very helpful.</p>
<p>In summary, if you're developing with Django this is another &quot;must
have&quot; book in my opinion. There's so much good information in this
book, and it is presented in a very readable and easy to understand
way. I'm planning to order a copy for each member of my team.</p>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>I'm Alive!</title>
      <link>http://michaeltrier.com/2010/07/06/i'm-alive!</link>
      <pubDate>Tue, 06 Jul 2010 03:14:00 EDT</pubDate>
      <category><![CDATA[Personal]]></category>
      <category><![CDATA[Python]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2010/07/06/i'm-alive!</guid>
      <description>I'm Alive!</description>
      <content:encoded><![CDATA[<div class="document">
<p>Yes, I'm alive! The past six months have been grueling and a ton of
hard work but definitely worth it. I've ignored pretty much every
aspect of life except for coding. And I'm talking about heads down,
all night, coding. It's what I love; it's who I am, but still after
a certain amount of time you feel like you need to come up for
air.</p>
<p>Well I'm coming up for air. I'll be posting more to my blog, I'll
be contributing more to open source projects like SQLAlchemy, I'll
be working on some of my own stuff, and I'll be entertaining my
brain in whatever interests me at the moment. If that's all you
care about then know that I'm back. If you want to know more about
what I've been doing then read on.</p>
<p>For the past year I've been involved in a very large project at
work. The project involved the redesign of our websites at
Presbyterian Church (U.S.A.). The first two sites went live this
past week. They are:</p>
<p><a class="reference external" href="http://www.pcusa.org/">http://www.pcusa.org/</a></p>
<p><a class="reference external" href="http://gamc.pcusa.org/">http://gamc.pcusa.org/</a></p>
<p>Both sites are built on Python. So in addition to building out
these sites, I've also been training and transitioning my
development team to Python programming. That means a lot of Python
101 / 102 classes, pair programming, code reviews, and unit
testing. To say we're transitioning is a bit of an overstatement.
In one sense we're transitioning from .NET development, but in
another we're not. We're supplementing the current architecture
with Python. Most upcoming projects will make more sense if written
in Python, but not all. Regardless, we'll always use the right tool
for the job.</p>
<p>Things have been going quite well and I'm very pleased with where
we are at the moment. Hopefully I'll have an opportunity to talk
about some of the interesting technological and architectural
decisions we've made along the way. Until then I'm happy to be back
in the game.</p>
</div>
]]></content:encoded>
    </item>
    <item>
      <title>Bowling Buddies</title>
      <link>http://michaeltrier.com/2010/02/25/bowling-buddies</link>
      <pubDate>Thu, 25 Feb 2010 21:26:00 EST</pubDate>
      <category><![CDATA[Personal]]></category>
      <guid isPermaLink="true">http://michaeltrier.com/2010/02/25/bowling-buddies</guid>
      <description>Bowling Buddies</description>
      <content:encoded><![CDATA[<div class="document">
<img alt="/media/assets/photo.jpg" src="/media/assets/photo.jpg" />
</div>
]]></content:encoded>
    </item>
  </channel>
</rss>


