<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Don&#39;t expect much on A Place for Poor Examples</title>
    <link>https://blog.mattblair.co/blog/</link>
    <description>Recent content in Don&#39;t expect much on A Place for Poor Examples</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Tue, 13 Jan 2026 12:00:00 -0400</lastBuildDate>
    
	<atom:link href="https://blog.mattblair.co/blog/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>Why AI Won’t Replace the Human Touch in Performance Reviews</title>
      <link>https://blog.mattblair.co/blog/20260113-performance-reviews-using-llms/</link>
      <pubDate>Tue, 13 Jan 2026 12:00:00 -0400</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20260113-performance-reviews-using-llms/</guid>
      <description>Why AI Won’t Replace the Human Touch in Performance Reviews Performance reviews are a perennial headache in many organizations – often seen as bureaucratic, time‐consuming, and stressful for managers and employees alike. With the rise of AI tools, some argue we might automate or even eliminate traditional reviews. Is it realistic (or wise) to have AI do our performance reviews? I believe the answer is no: while AI can assist, it cannot replace the thoughtful human effort that makes reviews valuable.</description>
    </item>
    
    <item>
      <title>A Framework for Engineering Career Development</title>
      <link>https://blog.mattblair.co/blog/20250903-creating-a-career-development-plan/</link>
      <pubDate>Wed, 03 Sep 2025 12:00:00 -0400</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20250903-creating-a-career-development-plan/</guid>
      <description>A career development plan is a structured approach to professional growth. It&amp;rsquo;s a tool for both individuals and managers to align on expectations, identify opportunities, and measure progress. A well-crafted plan can be the difference between a reactive career and a proactive one.
The &amp;ldquo;Why&amp;rdquo;: Aligning on a North Star The first step in creating a career development plan is to define a &amp;ldquo;north star.&amp;rdquo; This is the individual&amp;rsquo;s long-term career goal.</description>
    </item>
    
    <item>
      <title>Onboarding Engineers with Mentorship Pods</title>
      <link>https://blog.mattblair.co/blog/20250503-mentorship-pods/</link>
      <pubDate>Mon, 09 Jun 2025 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20250503-mentorship-pods/</guid>
      <description>Onboarding Engineers with Mentorship Pods When you’re a small team, pairing each new hire 1:1 works great—but as you grow, that model becomes overwhelming. Mentorship pods solve this by pairing a single mentor with a small cohort of new engineers. They learn together, share questions, and ramp up faster than going it alone.
Why Pods? Pods create a community feel. Mentees learn from each other’s questions, and mentors can standardize core topics while still giving personalized attention.</description>
    </item>
    
    <item>
      <title>A Pragmatic Framework for Technical Debt</title>
      <link>https://blog.mattblair.co/blog/20250216-technical-debt-framework/</link>
      <pubDate>Sun, 16 Feb 2025 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20250216-technical-debt-framework/</guid>
      <description>A Pragmatic Framework for Technical Debt We’ve all faced the dilemma: should we rush a quick feature out the door, or spend extra time refactoring code? That choice often creates technical debt—shortcuts in code, architecture, or process that make future work harder. Left unaddressed, debt piles up and slows your entire team down.
What Is Technical Debt? Think of technical debt like a credit card balance: you gain speed early on by “borrowing” simplicity, but interest mounts in the form of bugs, longer build times, and confusing code.</description>
    </item>
    
    <item>
      <title>Blameless Postmortems: Turning Failures into Learning</title>
      <link>https://blog.mattblair.co/blog/20241225-blameless-post-mortems/</link>
      <pubDate>Wed, 25 Dec 2024 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20241225-blameless-post-mortems/</guid>
      <description>Blameless Postmortems: Turning Failures into Learning When something breaks in production—maybe a server crashes or a deployment goes sideways—it’s tempting to point fingers and hunt for the person “at fault.” But that only breeds fear and discourages honest discussion. A blameless postmortem flips the script: it treats every outage as a chance to learn how our systems and processes can improve, rather than a moment for shame.
Why “Blameless” Matters In a blameless culture, people feel safe admitting mistakes, asking questions, and sharing every detail of what happened without worrying about repercussions.</description>
    </item>
    
    <item>
      <title>Setting up an on-call roll</title>
      <link>https://blog.mattblair.co/blog/20240921-on-call-triage-role/</link>
      <pubDate>Sat, 21 Sep 2024 12:25:15 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20240921-on-call-triage-role/</guid>
      <description>Structuring an On-Call Rotation: A Guide for Engineering Managers On-call rotations are more than “who picks up the phone”—they’re a critical way to balance incident response, customer support, and operational health without burning out your team. Below is a template you can adapt, illustrated with examples from my time leading a device-management on-call rotation at a fast-growing tech company.
 1. Define a Clear Primary On-Call Role Rather than vague “points,” be explicit about the time commitment you expect each engineer to spend on-call:</description>
    </item>
    
    <item>
      <title>Build vs. Buy</title>
      <link>https://blog.mattblair.co/blog/20240619-build-vs-buy/</link>
      <pubDate>Wed, 19 Jun 2024 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20240619-build-vs-buy/</guid>
      <description>In the software development world, teams often face the dilemma of whether to build a tool in-house or purchase an existing solution. This “build vs. buy” debate can significantly impact a company’s efficiency, budget, and focus. A quintessential example of this debate is the implementation of feature flags.
Understanding Feature Flags Feature flags, or toggles, are a powerful technique that allows developers to enable or disable features in a production environment without deploying new code.</description>
    </item>
    
    <item>
      <title>Establishing 1-1s that Work</title>
      <link>https://blog.mattblair.co/blog/20240414-establishing-1-1s-that-work/</link>
      <pubDate>Sun, 14 Apr 2024 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20240414-establishing-1-1s-that-work/</guid>
      <description>Purpose The primary purpose of one-on-one meetings is to give your reports a chance to discuss issues and topics that they find important. It’s an opportunity for them to bring up concerns, challenges, and ideas that might not surface during regular team meetings. This is not a meeting to get status updates on projects! Schedule other time for that.
Frequency and Duration These meetings should be held regularly, ideally once a week, and should last anywhere from 30 minutes to an hour.</description>
    </item>
    
    <item>
      <title>Refactoring a Legacy Codebase</title>
      <link>https://blog.mattblair.co/blog/20240305-refactoring-a-legacy-codebase/</link>
      <pubDate>Tue, 05 Mar 2024 11:52:59 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20240305-refactoring-a-legacy-codebase/</guid>
      <description>Background In my current role, I inherited an older codebase where best practices were often overlooked. As I reviewed the code and the surrounding processes, I found numerous areas for improvement in both code quality and operational practices.
Where to Start? When tackling a project like this, I find it best to break down the necessary changes into four categories:
 Immediate Changes Short-Term Changes Medium-Term Changes Long-Term Changes  Immediate Changes Stack Overflow used to offer a list of concrete practices that engineering companies should follow.</description>
    </item>
    
    <item>
      <title>Decoding the Origins of CAN Reports</title>
      <link>https://blog.mattblair.co/blog/20230907-can-reports/</link>
      <pubDate>Thu, 07 Sep 2023 15:22:57 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230907-can-reports/</guid>
      <description>In the realm of incident management, accurate and swift communication is vital. Different organizations adopt various strategies to ensure efficient communication during emergencies. One such strategy that has been gaining traction is the utilization of CAN reports, a mnemonic that stands for “Conditions, Actions, Needs.” Let us delve deeper into the intricacies and origins of this unique reporting format.
What is a CAN Report? A CAN report, fundamentally, serves as a structure to relay critical information succinctly during an incident.</description>
    </item>
    
    <item>
      <title>Strategic Approaches for Technical Improvement</title>
      <link>https://blog.mattblair.co/blog/20230508-tech-improvement-roadmap/</link>
      <pubDate>Sun, 07 May 2023 12:19:57 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230508-tech-improvement-roadmap/</guid>
      <description>Introduction Technical debt is a common challenge faced by engineering teams, requiring deliberate efforts to manage and pay it down. In this blog post, we will explore different approaches to tackling technical debt and building a long-term technical strategy. We will also highlight the importance of involving senior individual contributors (ICs) and engineering managers (EMs) in shaping the strategy, while considering the alignment with business and product goals.
 Engaging Senior ICs and EMs in Technical Strategy  To ensure a comprehensive technical strategy, it is essential to involve experienced ICs and EMs in the decision-making process.</description>
    </item>
    
    <item>
      <title>Crunch Time</title>
      <link>https://blog.mattblair.co/blog/20230404-crunch-time/</link>
      <pubDate>Tue, 04 Apr 2023 03:10:07 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230404-crunch-time/</guid>
      <description>Crunch periods are a reality in many industries, and sometimes they are necessary to meet an immovable deadline. However, working under high-pressure situations for an extended period can lead to burnout, and it&amp;rsquo;s essential to provide support for the team after the crunch is over. In this blog post, we will discuss different approaches for formalized recovery time after a crunch period.
Ask team members what would make them feel valued One approach is to ask team members what would make them feel valued after the crunch period.</description>
    </item>
    
    <item>
      <title>Improving Software Quality</title>
      <link>https://blog.mattblair.co/blog/20230327-code-quality/</link>
      <pubDate>Mon, 27 Mar 2023 10:54:47 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230327-code-quality/</guid>
      <description>As a manager, you&amp;rsquo;re responsible for ensuring that the software your team creates is of the highest quality possible. This means reducing the number of bugs and improving code quality. But how do you measure these improvements? And what strategies can you implement to achieve them?
Measuring Quality One traditional way of measuring quality is by the number of bugs that are found and fixed. However, this is a lagging metric, meaning that you can only measure it after the damage has been done.</description>
    </item>
    
    <item>
      <title>Moving Between Tech Stacks</title>
      <link>https://blog.mattblair.co/blog/20230302-changing-stacks/</link>
      <pubDate>Thu, 02 Mar 2023 17:31:07 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230302-changing-stacks/</guid>
      <description>When it comes to software engineering roles, experience in the tech stack you&amp;rsquo;re going to be working in is valuable but not specifically required. A good engineer can ramp up and learn new stacks. However, someone experienced in the tech stack can contribute quickly to key development initiatives, while also bringing outside experience using the stack.
But which tech stacks are easier to move between, and which ones are the hardest?</description>
    </item>
    
    <item>
      <title>Promoting Technical Excellence in your Organization</title>
      <link>https://blog.mattblair.co/blog/20230221-technical-excellence/</link>
      <pubDate>Tue, 21 Feb 2023 17:31:07 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230221-technical-excellence/</guid>
      <description>I was speaking to a friend who works at a startup with a team of around 14 engineers. 80% of them are mid level engineers with 3-4 years of experience. They all work in product squads covering specific areas.
These have lost momentum in the development and they are seeing 2 key problems:
 The teams lacks direction on where to focus their energy and prefer tackling small issues as they don&amp;rsquo;t have a vision as to what impactful engineering initiatives to do.</description>
    </item>
    
    <item>
      <title>Interesting Articles for Engineering Managers</title>
      <link>https://blog.mattblair.co/blog/20230201-link-dump/</link>
      <pubDate>Wed, 01 Feb 2023 12:53:42 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230201-link-dump/</guid>
      <description>Engineering Leadership Principles The article &amp;ldquo;Engineering Leadership Principles&amp;rdquo; by Hugo Dias outlines six principles that he believes are crucial for effective engineering leadership:
 Build trust through transparency and communication Foster a culture of learning and growth Prioritize quality and reliability Lead with empathy and emotional intelligence Build strong, diverse teams Empower your team to take ownership and make decisions  Dias provides examples and anecdotes to illustrate each principle and explains why they are important.</description>
    </item>
    
    <item>
      <title>Mentorship Proposal</title>
      <link>https://blog.mattblair.co/blog/20230131-mentorship-proposal/</link>
      <pubDate>Tue, 31 Jan 2023 15:30:12 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20230131-mentorship-proposal/</guid>
      <description>Note: This is a proposal I put together with one of the engineers in my organization for a peer-directed mentorship program. I&amp;rsquo;ve removed names and fudged numbers but I hope it will serve as a valuable template. All other numbers quoted here are from outside studies, with links to the studies provided.
Peer Mentorship Proposal The most valuable asset of a company are its employees.
Among top reasons for millennials wanting to quit their jobs are &amp;lsquo;Not enough opportunities to advance&amp;rsquo; at 35% and &amp;lsquo;Lack of learning and development opportunities&amp;rsquo; at 28%.</description>
    </item>
    
    <item>
      <title>Technical State of the Team - Expanded</title>
      <link>https://blog.mattblair.co/blog/20221212-technical-state-of-team-expanded/</link>
      <pubDate>Mon, 12 Dec 2022 12:12:12 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20221212-technical-state-of-team-expanded/</guid>
      <description>Note: This is a compliment to the previous article I wrote about the Technical state of a Team, and explains the concepts in depth.
Technical State of the Team There’s a saying that people don’t leave companies, they leave managers. Management is a key part of any organization, yet the discipline is often self-taught and unstructured. Getting to the good solutions for complex management challenges can make the difference between fulfillment and frustration for teams, and, ultimately, between the success and failure of companies.</description>
    </item>
    
    <item>
      <title>Project Planning Checklist</title>
      <link>https://blog.mattblair.co/blog/20221110-project-planning-checklist/</link>
      <pubDate>Thu, 10 Nov 2022 05:17:17 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20221110-project-planning-checklist/</guid>
      <description>All the previous project planning articles summarized into a checklist.
Project Planning Checklist Pre-Planning  Identity your stakeholders Identity the goal you’re trying to accomplish Get familiar with the code Set up a local environment to try things out  Beginning to Plan  Identify the rough scope of the work Identify the milestones of the project  Project Kickoff  High-Level Timelines  Call out timelines you haven’t figured out yet, and when you will figure them out   Identify Roles and Responsibilities of people involved with the project Identify Dependencies on other teams  Lay out the requirements for what you need from others to be successful   Identify Goals and Outcomes for the project Identify how you want people to work together on the project Identify next steps after the kickoff is complete  Overall Technical Design  An overview of the problem A breakdown of the individual milestones and how they’re related High-level process / workflow diagrams / designs / etc Any other notes that might be relevant to folks who will be working on the project  Breaking Down the Project into Milestones  Are the milestones clear on what they’re delivering?</description>
    </item>
    
    <item>
      <title>Running Your Projects</title>
      <link>https://blog.mattblair.co/blog/20221008-running-your-project/</link>
      <pubDate>Sat, 08 Oct 2022 05:17:17 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20221008-running-your-project/</guid>
      <description>Note: This is a series of project planning talks I gave my team.
Running your project Writing A Technical Design Document At this point, you’re ready to start designing your system.
A good technical design document should contain:
 An overview of the problem A breakdown of the individual milestones and how they’re related High-level process / workflow diagrams / designs / etc Any other notes that might be relevant to folks who will be working on the project  You should also consider if certain steps can be done in parallel, and what steps block other aspects of the work.</description>
    </item>
    
    <item>
      <title>Kickoff Doc Expanded</title>
      <link>https://blog.mattblair.co/blog/20220907-kickoff-docs-expanded/</link>
      <pubDate>Wed, 07 Sep 2022 05:17:17 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20220907-kickoff-docs-expanded/</guid>
      <description>Note: this is an expansion on a previous article I wrote around kickoff docs.
Project Kickoff! At this point, you should have a good idea of what your overall goal is. You should have a rough sketch of what your milestones are for the project and what you want to include in each one. You should not have the specific details of the projects worked out yet.
It’s time for a project kickoff.</description>
    </item>
    
    <item>
      <title>So you’ve got yourself a project</title>
      <link>https://blog.mattblair.co/blog/20220806-so-you-have-project/</link>
      <pubDate>Sat, 06 Aug 2022 05:17:17 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20220806-so-you-have-project/</guid>
      <description>Note: This is a series of project planning talks I gave my team.
So you’ve got yourself a project A project (and a ticket) is a placeholder for a conversation. No matter if a ticket is super detailed or vague on what it wants, the best way to do good work is to figure out a few things about the work you’ve been given.
Get Comfortable Pre-planning for any project should begin FAR before the actual work.</description>
    </item>
    
    <item>
      <title>When to plan a project</title>
      <link>https://blog.mattblair.co/blog/20220705-project-planning-overview/</link>
      <pubDate>Tue, 05 Jul 2022 05:17:17 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20220705-project-planning-overview/</guid>
      <description>Note: This is a series of project planning talks I gave my team.
When to plan a project What is a project plan? Project planning is the process of defining your objectives and scope, your goals and milestones (deliverables), and assigning tasks and resources for each step. A good plan is easily shareable with everyone involved, and it’s most useful when it’s revisited regularly. Simply outlining a plan and never discussing it with your team again is a good recipe for wasted time and effort.</description>
    </item>
    
    <item>
      <title>Define your team&#39;s stragetic intent</title>
      <link>https://blog.mattblair.co/blog/20220628-strategic-intent/</link>
      <pubDate>Tue, 28 Jun 2022 21:30:12 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20220628-strategic-intent/</guid>
      <description>Note: This was a series of talks I gave to leadership in my organization, so some of the comments here might not make sense in the context of a blog post.
This is not original work: I pulled heavilty from these four books to put together these talks:
References:
 High Output Management The First 90 Days An Elegant Puzzle A Manager’s Path  If I did not site some of these works here, or pulled quotes directly from them, forgive me.</description>
    </item>
    
    <item>
      <title>Getting Started with your Team: Organize to Learn</title>
      <link>https://blog.mattblair.co/blog/20220325-organize-to-learn/</link>
      <pubDate>Fri, 25 Mar 2022 18:37:09 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20220325-organize-to-learn/</guid>
      <description>Note: This was a series of talks I gave to leadership in my organization, so some of the comments here might not make sense in the context of a blog post.
This is not original work: I pulled heavilty from these four books to put together these talks:
References:
 High Output Management The First 90 Days An Elegant Puzzle A Manager’s Path  If I did not site some of these works here, or pulled quotes directly from them, forgive me.</description>
    </item>
    
    <item>
      <title>Managerial Meddling</title>
      <link>https://blog.mattblair.co/blog/20211222-managerial-meddling/</link>
      <pubDate>Wed, 22 Dec 2021 15:34:06 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20211222-managerial-meddling/</guid>
      <description>Note: This was a series of talks I gave to leadership in my organization, so some of the comments here might not make sense in the context of a blog post.
This is not original work: I pulled heavilty from these four books to put together these talks:
References:
 High Output Management The First 90 Days An Elegant Puzzle A Manager’s Path  If I did not site some of these works here, or pulled quotes directly from them, forgive me.</description>
    </item>
    
    <item>
      <title>What is a manager?</title>
      <link>https://blog.mattblair.co/blog/20210919-what-is-a-manager/</link>
      <pubDate>Sun, 19 Sep 2021 12:31:03 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20210919-what-is-a-manager/</guid>
      <description>Note: This was a series of talks I gave to leadership in my organization, so some of the comments here might not make sense in the context of a blog post.
This is not original work: I pulled heavilty from these four books to put together these talks:
References:
 High Output Management The First 90 Days An Elegant Puzzle A Manager’s Path  If I did not site some of these works here, or pulled quotes directly from them, forgive me.</description>
    </item>
    
    <item>
      <title>SMART vs CLEAR goals</title>
      <link>https://blog.mattblair.co/blog/20210627-smart-vs-clear/</link>
      <pubDate>Sun, 27 Jun 2021 09:39:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20210627-smart-vs-clear/</guid>
      <description>Setting Goals Two of the more popular methods for setting goals are SMART and CLEAR:
SMART Goals This method helps ensure that the goals have been thoroughly vetted. It also provides a way to clearly understand the implications of the goal-setting process.
Specific – To set specific goals, answer the following questions: who, what, where, when, which, and why.
Measurable – Create criteria that you can use to measure the success of a goal.</description>
    </item>
    
    <item>
      <title>The schedule of an engineering manager</title>
      <link>https://blog.mattblair.co/blog/20210516-weekly-tasks/</link>
      <pubDate>Sun, 16 May 2021 09:39:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20210516-weekly-tasks/</guid>
      <description>Overview In re-reading High Output Management recently, I was particularly interested in reading over Andy Grove&amp;rsquo;s schedule and seeing how he spent his time. I thought it might be interesting to post something similar to how I allocate my time throughout the year.
Regular Occurring Events: Weekly 1:1’s with all direct reports Weekly 1:1’s with PM, Design, etc Weekly 1:1&amp;rsquo;s with my manager Weekly leadership meeting with pillar leadership Bi-weekly 1:1’s with peers Monthly Career Conversations with direct reports</description>
    </item>
    
    <item>
      <title>Breakdown; post-mortem of a process failure</title>
      <link>https://blog.mattblair.co/blog/20210217-incident-remediation/</link>
      <pubDate>Wed, 17 Feb 2021 18:49:50 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20210217-incident-remediation/</guid>
      <description>I was reviewing an old incident review doc where I wrote up some of the high level learnings from the incident. Thought it was worth sharing, with the details omitted to protect the innocent.
Some backstory; we were trying to load test a component and ended up getting the load testing done at the last minute right before customer launch. The team had to work into the weekend to meet the customer deadline.</description>
    </item>
    
    <item>
      <title>Measure the Technical State of your Team</title>
      <link>https://blog.mattblair.co/blog/20210110-measurable-technical-state-of-the-team/</link>
      <pubDate>Sun, 10 Jan 2021 21:40:42 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20210110-measurable-technical-state-of-the-team/</guid>
      <description>Some thoughts on how you could evaluate the state of the systems your team owns.
One way to use this:
 Put some of these criteria on the Y axis Put the name of the components you own on the X. Give everything a score from 1 to 0. Either average the scores or sum them to figure out which components need the most love.  If all of these are the same for everything you own, it might make sense to skip that section.</description>
    </item>
    
    <item>
      <title>Understanding Velocity in Development Teams</title>
      <link>https://blog.mattblair.co/blog/20201102-understanding-velocity-in-development-teams/</link>
      <pubDate>Mon, 02 Nov 2020 17:31:07 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20201102-understanding-velocity-in-development-teams/</guid>
      <description>Velocity is a commonly used metric in development teams to measure how much work they can fit into a sprint. However, using velocity for any other purpose can be problematic as it might not reflect the real progress of the project and can be a flawed planning mechanism.
It&amp;rsquo;s crucial to understand that each team defines what a point means for them, making velocity not useful for comparing teams with each other.</description>
    </item>
    
    <item>
      <title>The importance of clear communication</title>
      <link>https://blog.mattblair.co/blog/20200909-pyramid-principle-inaction/</link>
      <pubDate>Wed, 09 Sep 2020 15:20:08 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20200909-pyramid-principle-inaction/</guid>
      <description>This is based off a talk I gave on improving communications.
There is a lot of communication right now With everyone working remotely, the importance of communication has increased. We&amp;rsquo;re communicating more often without meeting, and making your message clear when everyone is deluged with correspondance is the only way to have impact in your organization.
To succeed in any organization, you need to be able to tell your story. Whether it’s a status update, an RFC, or an escal question, you need to be able to quickly tell people the state of the world.</description>
    </item>
    
    <item>
      <title>1:1&#39;s aren&#39;t enough in a SIP world</title>
      <link>https://blog.mattblair.co/blog/20200606-remote-management-lessons-learned/</link>
      <pubDate>Mon, 08 Jun 2020 13:40:42 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20200606-remote-management-lessons-learned/</guid>
      <description>Back when we were all the office together, it was pretty easy as a manager to get a feel for how the team was doing. Are folks getting along? Are folks stressed? Does everyone have the right balance of work? With folks all around you, it was pretty easy to drop in on a conversation, take someone to lunch, or grab a coffee and talk.
These small encounters gave you a chance to make sure your team was running efficiency, it also gave your team a chance to speak to you as a human being outside of formal settings.</description>
    </item>
    
    <item>
      <title>Kickoff Docs</title>
      <link>https://blog.mattblair.co/blog/20200404-kickoff-docs/</link>
      <pubDate>Tue, 03 Mar 2020 14:07:39 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20200404-kickoff-docs/</guid>
      <description>What is a Project Kickoff?  What is a project kick-off? A project kick-off meeting is the first meeting with the project team and the client of the project where applicable. This meeting is the time to establish common goals and the purpose of the project.
 Taken from the Atlassian Project Kickoff reference.
Why a Project Kickoff? A project kickoff sets a clear outline of project goals and milestones.</description>
    </item>
    
    <item>
      <title>Measuring Backlog Health</title>
      <link>https://blog.mattblair.co/blog/20200101-measuring-backlog-health/</link>
      <pubDate>Wed, 01 Jan 2020 21:40:42 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20200101-measuring-backlog-health/</guid>
      <description>Backlog Grooming Some thoughts on how you could evaluate the state of your backlog.
Small, well groomed backlog
 Are the tickets in the backlog going to be actioned in the near term? If you deleted the tickets that aren&amp;rsquo;t in your near-term roadmap, how long would it take you to recreate it? Is the Backlog consistently growing or shrinking? Are the tickets all in a state to be actioned immediately, or do they need additional work?</description>
    </item>
    
    <item>
      <title>Pyramid Principle Examples</title>
      <link>https://blog.mattblair.co/blog/20191111-pyramid-principle-examples/</link>
      <pubDate>Mon, 11 Nov 2019 15:57:32 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20191111-pyramid-principle-examples/</guid>
      <description>I use SCQA all the time in my communications both up to leadership and down to my teams.
This TED talk from Derek Sivers is a great example of someone using SCQA to communicating a problem and a suggested solution in a short amount of time. Worth watching if you&amp;rsquo;re looking to use SCQA in your own communications.
Another example of an SCQA structured communication is something I received at work:</description>
    </item>
    
    <item>
      <title>Further Engineering Management Classes</title>
      <link>https://blog.mattblair.co/blog/20190607-further-engineering-management-classes/</link>
      <pubDate>Fri, 07 Jun 2019 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20190607-further-engineering-management-classes/</guid>
      <description>Some further classes I recommend for potential new engineering managers.
https://www.harrisonmetal.com/library/objectives-key-results
So many companies want to set up goals in the OKR (Objective-Key Result) format. This shows some great examples how to format yours.
https://www.harrisonmetal.com/library/storytelling-amp-presenting-1-thank-you-barbara-minto
I use SCQA all the time in my communications both up to leadership and down to my teams. Highly recommend taking this class or reading The Pyramid Principle.
https://www.harrisonmetal.com/classes/gm2-setting-goals-measuring-performance
If you&amp;rsquo;re a manager, you&amp;rsquo;re going to have to figure out a way to set goals for your teams and measure the performance of those goals.</description>
    </item>
    
    <item>
      <title>Project Planning Notes</title>
      <link>https://blog.mattblair.co/blog/20190202-project-planning-notes/</link>
      <pubDate>Fri, 08 Feb 2019 16:29:13 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20190202-project-planning-notes/</guid>
      <description>More Shared Knowledge on Projects  Include more people in code reviews even if they&amp;rsquo;re not actively picking up development tasks &amp;ndash; this shares out knowledge of the changes and gets another set of eyes that can ask good questions Break team silos, share knowledge Do Team PR&amp;rsquo;s for big PR&amp;rsquo;s  Ideally break work into small pieces though   Do team share of projects for tech projects, share knowledge Team Collab!</description>
    </item>
    
    <item>
      <title>Manager Conference Links</title>
      <link>https://blog.mattblair.co/blog/20180115-manager-conference-links/</link>
      <pubDate>Tue, 15 Jan 2019 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20180115-manager-conference-links/</guid>
      <description>A couple of EM conferences folks might find useful:
SFELC Summit
An annual celebration for engineering leaders.
A wide range of topics. One day, multiple tracks. Great speaker lineup. A refresher on management fundamentals. Workshops and Breakouts.
Calibrate
You’re a great engineer. Become a great leader. Calibrate is aimed at practicing engineering managers, responsible for the people on their team.
You can find videos of previous years here.
TEMSCON
Research-focused engineering management conference.</description>
    </item>
    
    <item>
      <title>ElasticSearch Perf - Highlighter Edition</title>
      <link>https://blog.mattblair.co/blog/20181121-elasticsearch-perf-work/</link>
      <pubDate>Wed, 21 Nov 2018 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20181121-elasticsearch-perf-work/</guid>
      <description>Wanted to share the results of the work we&amp;rsquo;ve been doing to improve performance and stabilize our ES cluster.
Short Version: Changing sharding and &amp;ldquo;highlighting&amp;rdquo; strategies when doing FreeText searches dramatically impacts performance.
Long Version: We&amp;rsquo;ve been load testing various aspects of search to pinpoint features we use that create large amounts of load on the system. Our initial research pointed at normal searches and freetext searches as being problematic.</description>
    </item>
    
    <item>
      <title>Moment.js alternatives</title>
      <link>https://blog.mattblair.co/blog/20180908-moment-js-alternatives/</link>
      <pubDate>Sat, 08 Sep 2018 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20180908-moment-js-alternatives/</guid>
      <description>If you&amp;rsquo;re looking for moment.js alternatives, I&amp;rsquo;d recommend reading this article about smaller, lighter-weight moment.js alternatives.</description>
    </item>
    
    <item>
      <title>Manager READMEs</title>
      <link>https://blog.mattblair.co/blog/20180601-manager-readme/</link>
      <pubDate>Fri, 01 Jun 2018 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20180601-manager-readme/</guid>
      <description>A friend recently introduced me to the ideas of creating a Manager README.
The idea is that for coworkers and new team members, you give a rundown of how you like to work and what they can expect.
Some of the canonical READMEs that are frequently used as templates can be found here.
A list of the current READMEs out in the wild (including mine), as well as some links to guides to help write them, can be found here.</description>
    </item>
    
    <item>
      <title>ElasticSearch sharding work</title>
      <link>https://blog.mattblair.co/blog/20180305-elasticsearch-sharding-work/</link>
      <pubDate>Mon, 05 Mar 2018 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20180305-elasticsearch-sharding-work/</guid>
      <description>Wanted to share some insights my team has found with changing sharding strategies for ElasticSearch (ES).
Today we moved 100% of my work&amp;rsquo;s search and autocomplete queries from a mutli-sharded index to a single-sharded index.
Short version: Reducing shard count reduces system load, CPU usage, mostly positive results on performance.
Medium version: In moving 100% of our searches and autocomplete queries from a mutli-sharded index to a single-sharded index, we saw drops in cluster load, queries generated by ES, and overall ES CPU usage.</description>
    </item>
    
    <item>
      <title>Engineering Management Classes</title>
      <link>https://blog.mattblair.co/blog/20171229-engineering-management-classes/</link>
      <pubDate>Fri, 29 Dec 2017 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20171229-engineering-management-classes/</guid>
      <description>Two classes I recommend for potential new engineering managers.
https://www.harrisonmetal.com/classes/foundations-general-management
The course is designed to help new managers develop foundational skills in management and leadership.
The course covers several key topics, including:
 Understanding the role of a manager and developing a management philosophy Building effective teams and managing team dynamics Developing and executing strategy Managing operations and projects Building and managing relationships with stakeholders Leading change and managing transitions  The course is divided into several modules, with each module covering a specific topic.</description>
    </item>
    
    <item>
      <title>ElasticSearch Garbage Collection issues?</title>
      <link>https://blog.mattblair.co/blog/20170813-elasticsearch-garbage-collection/</link>
      <pubDate>Sun, 13 Aug 2017 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20170813-elasticsearch-garbage-collection/</guid>
      <description>Seeing high garbage collection with ElasticSearch? My team was seeing periodic 300ms+ garbage collection pauses. We found out that we had misconfigured our ES instances.
If you&amp;rsquo;re encountering this, make sure you&amp;rsquo;ve disabled memory swapping:
https://www.elastic.co/guide/en/elasticsearch/reference/5.0/setup-configuration-memory.html</description>
    </item>
    
    <item>
      <title>Moment.js instantiation slowness</title>
      <link>https://blog.mattblair.co/blog/20170504-moment-js-instantiation-slowness/</link>
      <pubDate>Thu, 04 May 2017 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20170504-moment-js-instantiation-slowness/</guid>
      <description>Was doing some test speedup/performance improvement work recently on the search API and found out something; the moment.js library takes around 100 microseconds (or .1 milliseconds) to create a new instance.
Why is 100 microseconds a big deal?
If you&amp;rsquo;re processing:
 100 records Where each record has 7 date fields Then you&amp;rsquo;ve created 70,000 microseconds of work Or 70 milliseconds of processing delay.  By doing some memoization of date formatting in our API, we&amp;rsquo;ve seen these performance improvements:</description>
    </item>
    
    <item>
      <title>Performance Improvement via node 4 to node 6</title>
      <link>https://blog.mattblair.co/blog/20161109-performance-improvement-via-babel-tranpilation-removal/</link>
      <pubDate>Wed, 09 Nov 2016 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20161109-performance-improvement-via-babel-tranpilation-removal/</guid>
      <description>My team at work recently upgraded our codebase to use to node 6.9, as node 6 has recently gone to LTS.
In the picture below, the 1st line is the upgrade from node 4 to node 6, and the corresponding flattening of memory usage vs. load.
The 2nd line is our removal of redis connection queueing in the application.
All of all, the memory consumption of our application is now averaging around 150MB, down from a high of 1GB!</description>
    </item>
    
    <item>
      <title>Superagent/Request Memory Leaks</title>
      <link>https://blog.mattblair.co/blog/20161017-superagent-request-memory-leaks/</link>
      <pubDate>Mon, 17 Oct 2016 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20161017-superagent-request-memory-leaks/</guid>
      <description>Superagent/Request Memory Leaks The last several weeks Thomas Hunter and myself have spent some of our nights and weekends trying to track down memory leaks in an API we both work on.
We were seeing a distinct pattern, that when the API was put under a certain amount of load, that we would start slowly bleeding memory.
We&amp;rsquo;ve found three results:
  Superagent, when put under a certain threshold of load and then connections timeout, can leak memory.</description>
    </item>
    
    <item>
      <title>Node 4 and Babel 6 in Harmony</title>
      <link>https://blog.mattblair.co/blog/20160116-node-4-and-babel-6/</link>
      <pubDate>Sat, 16 Jan 2016 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20160116-node-4-and-babel-6/</guid>
      <description>Pun in title intentional I upgraded a heap of projects I was working on to node 4.2.3 and babel 6.
As I did a quick and dirty upgrade, I kept thinking to myself: doesn&amp;rsquo;t node 4/5 have pretty good support for es6/2015?
As I was looking around the internet for Hello Kitty Formalwear babel 6 upgrade tips, I came across this package which read my mind.
So if you&amp;rsquo;re a node 4/5 user, by doing this:</description>
    </item>
    
    <item>
      <title>Guide to upgrading from Babel 5 =&gt; 6</title>
      <link>https://blog.mattblair.co/blog/20151231-for-real-upgrade-babel-5-to-6/</link>
      <pubDate>Thu, 31 Dec 2015 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20151231-for-real-upgrade-babel-5-to-6/</guid>
      <description>Because it&amp;rsquo;s changed since October There have been a bunch of guides on upgrading to babel 5.
Even those written in the last two months are already out of date. Babel moves annoyingly fast.
Please note: this is up to date as of 6.3.13. As I write this, it might also be obsolete.
Skip babel-core and babel-loader. User babel-register. Due to some complaints about the various ways you could bootstrap babel into an app, there is now babel-register.</description>
    </item>
    
    <item>
      <title>Move your Open Source work to Node 4</title>
      <link>https://blog.mattblair.co/blog/20150910-upgrade-travis-and-os-for-node-4/</link>
      <pubDate>Thu, 10 Sep 2015 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20150910-upgrade-travis-and-os-for-node-4/</guid>
      <description>Now that Node 4 has been released, isn&amp;rsquo;t it time you upgraded your OS (Open Source) projects to use it?
Step 1 - package.json If you&amp;rsquo;re not already using it, the engines field in your package.json allows you to specify what version of node you designed your package to run on. The engines field is not strict - you can&amp;rsquo;t force your consumers to use a preferred engine, but you can warn them if your package uses features that aren&amp;rsquo;t available in all version of node.</description>
    </item>
    
    <item>
      <title>The (0, func) operation in transpiled code</title>
      <link>https://blog.mattblair.co/blog/20150420-0-func-operator-and-decoupling/</link>
      <pubDate>Mon, 20 Apr 2015 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20150420-0-func-operator-and-decoupling/</guid>
      <description>Was looking at some decompiled code from ES6 the other day, when I saw a line that looked like this:
var x = (0, anObject.aFunc)(params); WTF? I had never seen syntax like this before in JavaScript. Time to dig into the docs.
Paraphrasing from Mozilla and StackOverflow:
 When you write expressions separated by a comma (,) JavaScript evaluates all the expressions in order and returns the value of the last expression.</description>
    </item>
    
    <item>
      <title>Replaying changes from one git branch onto another</title>
      <link>https://blog.mattblair.co/blog/20150216-git-rebasing-without-rebasing/</link>
      <pubDate>Mon, 16 Feb 2015 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20150216-git-rebasing-without-rebasing/</guid>
      <description>Or rebasing without rebasing Where I work, we use git (like everyone else), and we follow this common pattern for development:
 Create a feature branch off of master Work on your feature in the branch When getting ready to submit a Pull Request, squash your commits Rebase master against your branch Open PR Get feedback After feedback corrected (if present), merge branch into master  Pretty standard practice. 99% of the time, this is a frictionless process.</description>
    </item>
    
    <item>
      <title>Code coverage for CoffeeScript and JavaScript without pre-compiling</title>
      <link>https://blog.mattblair.co/blog/20141204-gulp-coffee-istanbul/</link>
      <pubDate>Thu, 04 Dec 2014 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20141204-gulp-coffee-istanbul/</guid>
      <description>If you&amp;rsquo;re not aware of your code coverage when building a serious application, you&amp;rsquo;re not building a serious app.
So I love istanbul and gulp-istanbul.
One problem - you have to compile your CoffeeScript, then point you tests at the compiled assets to get coverage metrics.
Not anymore. Introducing gulp-coffee-istanbul. This allows in place CoffeeScript test coverage.
Have tests in coffee? Great. Have tests in JS? Great too. Same with your dependencies - it&amp;rsquo;ll take both, in place, and run coverage.</description>
    </item>
    
    <item>
      <title>It took pivotal 3 years to close a pull request</title>
      <link>https://blog.mattblair.co/blog/20141013-jasmine-node-before-all-after-all/</link>
      <pubDate>Mon, 13 Oct 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20141013-jasmine-node-before-all-after-all/</guid>
      <description>On Feb 9, 2011, Fat (Jacob Thornton, one of the creators on Bootstrap) opened a pull request to add beforeAll and afterAll statements to the jasmine library.
Pivotal, at the time, thought that they were just about to implement:
That tweet was from December 2010.
Since then, a couple people have come up with workarounds.
And now, over three years later, pivotal is about to release beforeAll/afterAll.
You can check out the work here.</description>
    </item>
    
    <item>
      <title>express-coffee-react-views</title>
      <link>https://blog.mattblair.co/blog/20141008-express-coffee-react-views/</link>
      <pubDate>Wed, 08 Oct 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20141008-express-coffee-react-views/</guid>
      <description>This is an Express view engine which renders React components written in CoffeeScript on the server. It renders static markup and does not support mounting those views on the client.
This was derived from express-react-views
This is intended to be used as a replacement for existing server-side view solutions, like jade, ejs, or handlebars.
Usage npm install express-coffee-react-views react Note: You must explicitly install react as a dependency. react is a peer dependency here.</description>
    </item>
    
    <item>
      <title>React and the annoyances of JSX</title>
      <link>https://blog.mattblair.co/blog/20140909-react-jsx-class-classname-for-htmlfor/</link>
      <pubDate>Tue, 09 Sep 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140909-react-jsx-class-classname-for-htmlfor/</guid>
      <description>I&amp;rsquo;ve been writing a bunch of React code and a heap of JSX at work.
React (coupled with Flux) has been a joy to work with. The uni-directional data flow makes understanding the state of your application at any point easy to understand. The gradual componentization of our UI codebase is a beautiful thing to witness. That, coupled with a component based CSS system (using BEM guidelines for naming classes) has removed the messy bleed over we were having with some of our old css code.</description>
    </item>
    
    <item>
      <title>Ember.Data Model Issues</title>
      <link>https://blog.mattblair.co/blog/20140708-ember-data-model-issue-boolean/</link>
      <pubDate>Fri, 11 Jul 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140708-ember-data-model-issue-boolean/</guid>
      <description>I was working with some older Ember.Data code, and I came across a model like this:
App.MyFancyModel = DS.Model.extend({ isSelected: false, isSomethingElse: DS.attr(&amp;#39;boolean&amp;#39;, {defaultValue: false}) }); I thought this code was a bit strange, and then went and played with it a bit:
aFancyModel.get(&amp;#39;isSelected&amp;#39;); //returns false aFancyModel.set(&amp;#39;isSelected&amp;#39;, true); aFancyModel.get(&amp;#39;isSelected&amp;#39;); //returns true aFancyModel.get(&amp;#39;isSomethingElse&amp;#39;); //returns false aFancyModel.set(&amp;#39;isSomethingElse&amp;#39;, true); aFancyModel.get(&amp;#39;isSomethingElse&amp;#39;); //returns true I got identical behavior from the two properties. Then, I tried this:</description>
    </item>
    
    <item>
      <title>Ember.Data Promise-Aware Properties (Cheaters Edition)</title>
      <link>https://blog.mattblair.co/blog/20140711-ember-data-promise-aware-properties/</link>
      <pubDate>Fri, 11 Jul 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140711-ember-data-promise-aware-properties/</guid>
      <description>I have models like this:
Models App.Child = DS.Model.extend({ parent: DS.belongsTo(&amp;#39;parent&amp;#39;, {async: true}) }); App.Parent = DS.Model.extend({ children: DS.hasMany(&amp;#39;child&amp;#39;, {async: true}) }); App.Nursery = DS.Model.extend({ children: DS.hasMany(&amp;#39;child&amp;#39;) }); Then a controller like this:
###Controller
App.NurseryController = Ember.Controller.extend({ uniqueParents = function() { return this.get(&amp;#39;children&amp;#39;).mapBy(&amp;#39;parent&amp;#39;).uniq(); }.property(&amp;#39;children&amp;#39;), somethingLikeReliesOnUniqueParents = function() { .... }.property(&amp;#39;uniqueParents&amp;#39;) } The Problem The property somethingLikeReliesOnUniqueParents was never getting unique values. I found two problems here:
 uniq() couldn&amp;rsquo;t figure out uniqueness - much like the problems with filter.</description>
    </item>
    
    <item>
      <title>Stuff to mind when writing ES6 code</title>
      <link>https://blog.mattblair.co/blog/20140701-stuff-to-mind-es6/</link>
      <pubDate>Tue, 01 Jul 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140701-stuff-to-mind-es6/</guid>
      <description>These are some good tips I picked up browsing the ember and ember.data commits. Nice if you&amp;rsquo;re looking for best practices in writing ES6 code.
example: diverging bindings
this is an issue when dealing with cycles.
bad: (diverges bindings)
import { foo } from &amp;#39;bar&amp;#39;; var otherFoo = foo; foo: (if the rename is actually needed) good:
import { foo as otherFoo } from &amp;#39;bar&amp;#39;; example: closure compiler dead code remove friendly:</description>
    </item>
    
    <item>
      <title>Post about Songbird on npmawesome</title>
      <link>https://blog.mattblair.co/blog/20140626-post-about-songbird-on-npmawesome/</link>
      <pubDate>Thu, 26 Jun 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140626-post-about-songbird-on-npmawesome/</guid>
      <description>The folks at npmawesome wrote a blog post about the Songbird library I wrote.
Songbird is a library that mixes in promise helpers in the Function and Object prototypes on JavaScript. This is a technique that not everybody loves, and I think the author made a great observation about Songbird (and this technique in general).
 While I think it&amp;rsquo;s a great idea to mix in the promise property to Object and Function, however with great power comes great responsibility.</description>
    </item>
    
    <item>
      <title>WriteGooder for Sublime Text</title>
      <link>https://blog.mattblair.co/blog/20140622-sublime-text-write-gooder/</link>
      <pubDate>Sun, 22 Jun 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140622-sublime-text-write-gooder/</guid>
      <description>Simple grammar checking for your documentation.
Prerequisites: write-gooder and Sublime Package Control
Mac OS X: Installing node with homebrew or macports is assumed. The path to write-gooder is hardcoded in this plugin as /usr/local/share/npm/bin:/usr/local/bin:/opt/local/bin. You can change the path to the executable in settings.
Linux: Make sure write-gooder is in your environment path.
Windows: Installing node with the Windows Installer from nodejs.org is assumed.
##Install write-gooder with npm
npm install -g duereg/write-gooder</description>
    </item>
    
    <item>
      <title>Ember Model.isDirty - or not</title>
      <link>https://blog.mattblair.co/blog/20140605-ember-model-isdirty-or-not/</link>
      <pubDate>Thu, 05 Jun 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140605-ember-model-isdirty-or-not/</guid>
      <description>In Ember, if you have models like this:
var Tag = DS.Model.extend({ name: DS.attr(&amp;#39;string&amp;#39;), person: DS.belongsTo(&amp;#39;person&amp;#39;) }); var Person = DS.Model.extend({ name: DS.attr(&amp;#39;string&amp;#39;), tags: DS.hasMany(&amp;#39;tag&amp;#39;) }); Then did something like this:
var tag1 = this.store.find(&amp;#39;tag&amp;#39;, 1); tag1.get(&amp;#39;isDirty&amp;#39;); //returns false tag1.get(&amp;#39;name&amp;#39;); //return null tag1.set(&amp;#39;name&amp;#39;, &amp;#39;foo&amp;#39;); tag1.get(&amp;#39;isDirty&amp;#39;); //returns true That would be the obvious outcome, right?
However, if you do this:
var tag1 = this.store.find(&amp;#39;tag&amp;#39;, 1); var thatGuy = this.store.find(&amp;#39;person&amp;#39;, 1); tag1.get(&amp;#39;isDirty&amp;#39;); //returns false tag.</description>
    </item>
    
    <item>
      <title>Ember Data Contributions</title>
      <link>https://blog.mattblair.co/blog/20140518-ember-data-contributor/</link>
      <pubDate>Sun, 18 May 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140518-ember-data-contributor/</guid>
      <description>My contributions to Ember.Data!
Had three pull requests accepted in the last couple of days.
Now only if they&amp;rsquo;d release version 1.0 &amp;hellip;</description>
    </item>
    
    <item>
      <title>Ember Official Contributor!</title>
      <link>https://blog.mattblair.co/blog/20140505-ember-official-contributor/</link>
      <pubDate>Mon, 05 May 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140505-ember-official-contributor/</guid>
      <description>Check Out My Contribution to Ember!
(Not sexy but I&amp;rsquo;m happy to be helping out.)</description>
    </item>
    
    <item>
      <title>Ember FilterBy Fun</title>
      <link>https://blog.mattblair.co/blog/20140429-ember-filterby-fun/</link>
      <pubDate>Tue, 29 Apr 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140429-ember-filterby-fun/</guid>
      <description>If you happen to be writing filterBy statements in Ember against an object, you will want to use this syntax:
skusForStyle: function(style) { return this.get(&amp;#39;mergedSkus&amp;#39;).filterBy(&amp;#39;style.id&amp;#39;, style.get(&amp;#39;id&amp;#39;)); } Instead of this similar looking but exceptionally evil and non-functioning cousin:
skusForStyle: function(style) { return this.get(&amp;#39;mergedSkus&amp;#39;).filterBy(&amp;#39;style&amp;#39;, style); } </description>
    </item>
    
    <item>
      <title>Ember - Test Teardown Error</title>
      <link>https://blog.mattblair.co/blog/20140410-ember-test-teardown-errors/</link>
      <pubDate>Thu, 10 Apr 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140410-ember-test-teardown-errors/</guid>
      <description>Cannot read property &amp;lsquo;addObject&amp;rsquo; of null If you see the following error in Ember.Data 1.0.0-beta.7:
Cannot read property &#39;addObject&#39; of null TypeError: Cannot read property &#39;addObject&#39; of null at Ember.ArrayProxy.extend.addRecord at Ember.Object.extend.updateRecordArray at null.&amp;lt;anonymous&amp;gt; I found this had to do with Test teardown. A monkey patch that solves the issue:
DS.RecordArray.reopen({ addRecord: function(record) { var thing = Ember.get(this, &amp;#39;content&amp;#39;); if(thing) { this._super(record); } } }); </description>
    </item>
    
    <item>
      <title>Ember - The content property of DS.PromiseArray should be set before modifying it</title>
      <link>https://blog.mattblair.co/blog/20140408-ember-the-content-property-of-ds-promise-array/</link>
      <pubDate>Tue, 08 Apr 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140408-ember-the-content-property-of-ds-promise-array/</guid>
      <description>The content property of DS.PromiseArray should be set before modifying it If you see the following error in Ember.Data 1.0.0-beta.7:
The content property of DS.PromiseArray should be set before modifying it
The issue is with changing the contents of an async field.
//program.js Program = DS.Model.extend({ styles: DS.hasMany(&amp;#39;style&amp;#39;, {async: true}), }); Style = DS.Model.extend({}); and then used like so:
program.get(&amp;#39;styles&amp;#39;).pushObject(style); That code will throw the exception listed above. To work around this behavior, do the following:</description>
    </item>
    
    <item>
      <title>Ember vs Knockout - Property Comparison</title>
      <link>https://blog.mattblair.co/blog/20140320-ember-vs-knockout-property-comparison/</link>
      <pubDate>Thu, 20 Mar 2014 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140320-ember-vs-knockout-property-comparison/</guid>
      <description>A small, appropriate comparison At ModCloth, I&amp;rsquo;ve been working on an internal application that uses Ember.js as its front end framework. In learning Ember I&amp;rsquo;ve noticed some interesting architectural decisions they&amp;rsquo;ve made.
This article will concentrate on their Observable Models in comparison with how Knockout built the same functionality.
TANGENT
Ember.js and Knockout are great contrasts in the library vs framework debate in JS development.
Ember is
 A framework for creating ambitious web applications.</description>
    </item>
    
    <item>
      <title>New Blog!</title>
      <link>https://blog.mattblair.co/blog/20140112-new-blog/</link>
      <pubDate>Sun, 12 Jan 2014 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140112-new-blog/</guid>
      <description>I&amp;rsquo;ve just ended a very long relationship that was hideously overdue for some closure. That&amp;rsquo;s right - I&amp;rsquo;ve left wordpress.
It&amp;rsquo;s a great platform if you can&amp;rsquo;t make a website or just don&amp;rsquo;t care about the details. But it&amp;rsquo;s a little less than I was looking for.
So I&amp;rsquo;ve decided to get minorly techy and build a nice static site to hold all my blog entries. A thousand thanks goes to @dreikanter for writing a simple converter of the wordpress XML format to markdown.</description>
    </item>
    
    <item>
      <title>A/B Testing and Random Selection</title>
      <link>https://blog.mattblair.co/blog/20131211-a-b-testing-and-random-selection/</link>
      <pubDate>Wed, 11 Dec 2013 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20131211-a-b-testing-and-random-selection/</guid>
      <description>Are you looking for an A/B framework? Something you can use in the browser to toggle a user experience - do they see marketing promotion #1, or a picture of a cat?
Or are you interested in random selection - you want to send our 5000 emails of differing types, and see how users respond?
Either way, enter laboratory. A simple framework that allows random selection or A/B testing. With the added bonus of being usable anywhere you can load JavaScript.</description>
    </item>
    
    <item>
      <title>Instrumenting Backbone for better error handling</title>
      <link>https://blog.mattblair.co/blog/20131127-instrumenting-backbone-for-better-error-handling/</link>
      <pubDate>Wed, 27 Nov 2013 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20131127-instrumenting-backbone-for-better-error-handling/</guid>
      <description>At work we&amp;rsquo;ve been having some issues tracking down some nasty client side bugs. We know they&amp;rsquo;re happening in our Backbone views, but we&amp;rsquo;ve been unable to locate them with any accuracy due to the errors bubbling all the way to the window.onerror handler.
Enter Stackbone. A simple bit of code to instrument Backbone’s event loops to better locate client side errors.
To use:
Stackbone.start({ Backbone: Backbone jQuery: jQuery onError: function (err) { // .</description>
    </item>
    
    <item>
      <title>Source maps in node.js</title>
      <link>https://blog.mattblair.co/blog/20131019-source-maps-in-node-js/</link>
      <pubDate>Sat, 19 Oct 2013 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20131019-source-maps-in-node-js/</guid>
      <description>One of the projects I&amp;rsquo;m working on deals with source maps.
If you don&amp;rsquo;t know anything about source maps this link is a good introduction to what source maps are and why they&amp;rsquo;re useful.
Looking at the article date (March 21st, 2012), it&amp;rsquo;s not like source maps are some new hot thing. But the tooling around them is still pretty raw as is their use.
So why would you want to use source maps?</description>
    </item>
    
    <item>
      <title>My ongoing relation with CoffeeScript - and a gotcha</title>
      <link>https://blog.mattblair.co/blog/20130502-coffeescript-gotcha/</link>
      <pubDate>Thu, 02 May 2013 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20130502-coffeescript-gotcha/</guid>
      <description>CoffeeScript, what can I tell ya - I didn&amp;rsquo;t want to love it.
I have an unreasonable grudge against significant whitespace.
I couldn&amp;rsquo;t figure out the value of a language that compiles to another reasonable language.
And don&amp;rsquo;t even get me started on the for of/in thing. I still don&amp;rsquo;t understand that.
But the more I use CoffeeScript, the more I love it.
The lambdas are probably my biggest love - how can you not love them, in comparison to what JavaScript makes you do?</description>
    </item>
    
    <item>
      <title>Docco Fork - All JS, all the time</title>
      <link>https://blog.mattblair.co/blog/20130303-docco-fork-all-js-all-the-time/</link>
      <pubDate>Sun, 03 Mar 2013 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20130303-docco-fork-all-js-all-the-time/</guid>
      <description>EDIT: My fork is no longer needed. The folks at docco saw the same thing and recently ported over the library to use highlight.js.
 I love documentation generators for code. You know what I&amp;rsquo;ve talking about to - something which gives you a split screen of the code and the comments, side by side, for easy reading and scrolling. Like jasmine uses for their documentation:
Since I&amp;rsquo;ve mostly been working in JavaScript lately I&amp;rsquo;ve been looking for something to help document the packages I create easily.</description>
    </item>
    
    <item>
      <title>Esvalidate Library - Standalone Validation Library Using Esprima</title>
      <link>https://blog.mattblair.co/blog/20130215-esvalidate-library-standalone-validation-library-using-esprima/</link>
      <pubDate>Fri, 15 Feb 2013 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20130215-esvalidate-library-standalone-validation-library-using-esprima/</guid>
      <description>I spent a good bit of time working on the Esvalidate code that comes with Esprima, trying to get it to work smoothly with my sublime plugin. After submitting a massive pull request to the author of Esprima and our reviewing my code we came to a conclusion - the new code was better served in its own library.
It&amp;rsquo;s still in its early stages but please check out the progress I&amp;rsquo;m making here: Esvalidate Library</description>
    </item>
    
    <item>
      <title>.Net Gotcha - Private Classes With Access To Containing Classes&#39;s Protected Variables (Or Not)</title>
      <link>https://blog.mattblair.co/blog/20130115-net-gotcha-private-classes-with-access-to-containing-classess-protected-variables-or-not/</link>
      <pubDate>Tue, 15 Jan 2013 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20130115-net-gotcha-private-classes-with-access-to-containing-classess-protected-variables-or-not/</guid>
      <description>A friend and I were working on some code together when we found an interesting edge case in .Net that neither of us knew about. This is what we knew: if you have a class with a protected field in it, if you declare a private class inside of that class, the private class can access the protected variable. The example below shows what this looks like.
public class ParentClassWithProtectedField { protected readonly int protectedField; private class PrivateClassInParentClass { public void Method(ParentClassWithProtectedField parent) { Console.</description>
    </item>
    
    <item>
      <title>Portfolio Spotlight on Pathbrite = Cool?</title>
      <link>https://blog.mattblair.co/blog/20121204-portfolio-spotlight-on-pathbrite-cool/</link>
      <pubDate>Tue, 04 Dec 2012 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20121204-portfolio-spotlight-on-pathbrite-cool/</guid>
      <description>I&amp;rsquo;ve recently created a portfolio on Pathbrite. If you haven&amp;rsquo;t heard of Pathbrite, they are a company aiming to:
 Collect, organize and share a lifetime of learning and achievement.
 I think this section of their mission statement sums up how they are relevant to working professionals.
 &amp;hellip; employers rely on our Pathbrite Portfolio Platform to get a holistic view of candidates, and to better evaluate their readiness for and organizational fit to the opportunity at hand.</description>
    </item>
    
    <item>
      <title>Esprima Plugin for Sublime Text</title>
      <link>https://blog.mattblair.co/blog/20121201-esprima-plugin-for-sublime-text/</link>
      <pubDate>Sat, 01 Dec 2012 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20121201-esprima-plugin-for-sublime-text/</guid>
      <description>In relation to my previous posts confessing my love for sublime, and my enjoyment of Esprima, here is some code that showcases both: An Esprima plugin for Sublime Test!
http://github.com/duereg/sublime-jsvalidate
This has been included in the official list of Sublime Plugins. So you can install this from Sublime using Packages Control.</description>
    </item>
    
    <item>
      <title>Added JavaScript syntax checking via Esprima and a Git pre-commit hook</title>
      <link>https://blog.mattblair.co/blog/20121120-added-javascript-syntax-checking-via-esprima-and-a-git-pre-commit-hook/</link>
      <pubDate>Tue, 20 Nov 2012 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20121120-added-javascript-syntax-checking-via-esprima-and-a-git-pre-commit-hook/</guid>
      <description>I came across a brilliant project the other day - Esprima from Ariya Hidayat, the author of PhantomJS. What is Esprima? Esprima is a JavaScript Parser written in JavaScript Syntax Validator. It forms the basis of several different tools - a minifier, a code coverage tool, a syntax validator - just to name a few. I was immediately interested in the syntax validation tool. It&amp;rsquo;s not a linter - it just checks that the JavaScript written is syntactically correct.</description>
    </item>
    
    <item>
      <title>.Net SQL Parsing - Using the TSqlParser library</title>
      <link>https://blog.mattblair.co/blog/20121101-net-sql-parsing-using-the-tsqlparser-library/</link>
      <pubDate>Thu, 01 Nov 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20121101-net-sql-parsing-using-the-tsqlparser-library/</guid>
      <description>A preface to this post: it is hard to find a free SQL Parser for .NET. There is a company that has a terrible library that they charge $150 bucks for. There are a couple of incomplete implementations done for school projects or for narrowly focused tasks. So if you want a no-strings attached free parser for SQL, you&amp;rsquo;re out of luck. However, since most people who want a .NET parser are writing code on a Windows machine, and use Visual Studio, there is (lightly documented) hope: the TSqlParser library that ships with Visual Studio.</description>
    </item>
    
    <item>
      <title>Free Collection of Microsoft E-Books</title>
      <link>https://blog.mattblair.co/blog/20121030-free-collection-of-microsoft-e-books/</link>
      <pubDate>Tue, 30 Oct 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20121030-free-collection-of-microsoft-e-books/</guid>
      <description>If you&amp;rsquo;re a Microsoft Dev, want to learn a bit more about the following products:
 SharePoint 2010 Sql Server 2012 Visual Studio 2010 Windows 8 Windows Phone 7 Office 365 Office 2010 ASP.NET 4.5 Web Forms ASP.NET MVC 4 Microsoft Dynamics CRM 2011 (God Rest Your Soul)  Microsoft has released a bunch of free e-books about these technologies (and more).
The links to the e-books:
 Microsoft Free E-Books - Page 1 Microsoft Free E-Books - Page 2  </description>
    </item>
    
    <item>
      <title>Derby.js - The Ready() Function, and Adding Client-Side Scripts to your App</title>
      <link>https://blog.mattblair.co/blog/20121017-derby-js-the-ready-function-and-client-side-scripts/</link>
      <pubDate>Wed, 17 Oct 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20121017-derby-js-the-ready-function-and-client-side-scripts/</guid>
      <description>I&amp;rsquo;ve found a neat feature of derby dealing with the ready() function. I&amp;rsquo;ve been creating a derby app, and in my application I need to load up a client-side calendar. With a standard HTML web page this is straightforward thing to do. On the page you wanted the calendar, you would include the client js for the calendar, some code to load it, and that would be that. Derby introduced some complexity to this relatively simple task.</description>
    </item>
    
    <item>
      <title>Cracking the Coding Interview - The Tower of Hanoi and Poor Editing</title>
      <link>https://blog.mattblair.co/blog/20120915-cracking-the-coding-interview-the-tower-of-hanoi-and-poor-editing/</link>
      <pubDate>Sat, 15 Sep 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120915-cracking-the-coding-interview-the-tower-of-hanoi-and-poor-editing/</guid>
      <description>I just finished the Stack section of Cracking the Coding Interview and came across an old puzzle - The Tower of Hanoi. I struggled with solving this problem. I wrote this elaborate, strange algorithm to try to solve it (which should have been a dead give-away that I had it wrong). Ironically enough, hidden in the 20-30 lines of code I wrote were the three lines of code I needed to solve the problem.</description>
    </item>
    
    <item>
      <title>Cracking the Coding Interview - Linked Lists - The Runner Technique</title>
      <link>https://blog.mattblair.co/blog/20120913-cracking-the-coding-interview-linked-list-the-runner-technique/</link>
      <pubDate>Thu, 13 Sep 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120913-cracking-the-coding-interview-linked-list-the-runner-technique/</guid>
      <description>I&amp;rsquo;ve been going over the Linked List section of Cracking the Coding Interview and most times I get stumped with a problem the solution is the Runner Technique (or slow/fast pointers).
The idea behind the runner technique is simple; use two pointers that either move at different speeds or are a set distance apart and iterate through a list.
Why is this so useful? In some linked list problems you need to know the position of a certain element or the length of the list.</description>
    </item>
    
    <item>
      <title>How to install Sublime Text 2 on Ubuntu 12.04 (Unity)</title>
      <link>https://blog.mattblair.co/blog/20120911-how-to-install-sublime-text-2-on-ubuntu-12-04-unity/</link>
      <pubDate>Tue, 11 Sep 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120911-how-to-install-sublime-text-2-on-ubuntu-12-04-unity/</guid>
      <description>Sublime Text has rapidly become my favorite text editor. Cross platform, easy to use, great feature set. The Command Palette feature, where you can search for a feature without having to know where it is in the application, is an piece of usability brilliance. Somebody cobbled together a great step-by-step set of directions on how to install sublime on ubuntu. I wanted to give a shout-out to them and their work.</description>
    </item>
    
    <item>
      <title>Setting up MongoDB to work with Derby.js</title>
      <link>https://blog.mattblair.co/blog/20120906-setting-up-mongodb-to-work-with-derby-js/</link>
      <pubDate>Thu, 06 Sep 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120906-setting-up-mongodb-to-work-with-derby-js/</guid>
      <description>This post is going to cover installing and configuring MongoDB to use with Derby. If you&amp;rsquo;re reading this post looking to add model persistence to your Derby application but don&amp;rsquo;t know much about MongoDB, understanding MongoDB will help you understand Derby and the model system it uses.
What&amp;rsquo;s MongoDB? From their website:
 MongoDB (from &amp;ldquo;humongous&amp;rdquo;) is a scalable, high-performance, open source NoSQL database.
 If you&amp;rsquo;ve never used MongoDB before, you should immediately go here.</description>
    </item>
    
    <item>
      <title>Javascript Strings - Using Array Accessor &#39;[]&#39; to set characters</title>
      <link>https://blog.mattblair.co/blog/20120905-javascript-strings-using-array-accessor-to-set-characters/</link>
      <pubDate>Wed, 05 Sep 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120905-javascript-strings-using-array-accessor-to-set-characters/</guid>
      <description>I&amp;rsquo;ve been learning quite a bit about JavaScript in writing algorithms from Cracking the Coding Interview. I learned something new about strings in JavaScript and how they can be accessed. From MDN:
 Character access There are two ways to access an individual character in a string. The first is the charAt method:
 return &amp;#39;cat&amp;#39;.charAt(1); // returns &amp;#34;a&amp;#34; The other way is to treat the string as an array-like object, where individual characters correspond to a numerical index:</description>
    </item>
    
    <item>
      <title>Cracking the Coding Interview - JavaScript Trie</title>
      <link>https://blog.mattblair.co/blog/20120901-cracking-the-coding-interview-javascript-trie/</link>
      <pubDate>Sat, 01 Sep 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120901-cracking-the-coding-interview-javascript-trie/</guid>
      <description>I finished my third algorithm from Cracking the Coding Interview - the Trie.
Tries are a useful algorithm, if not all that well known. They can be used for efficient spell checking, auto suggestion, as well as the sorting of a collection of strings.
This algorithm was more complex to implement than the Linked List, but a little simpler than the Max/Min Binary Heap to implement.
The trie&amp;rsquo;s structure is easy to understand - it&amp;rsquo;s a word tree, where each leaf of the tree is a letter of a word.</description>
    </item>
    
    <item>
      <title>Cracking the Coding Interview - JavaScript Min/Max Binary Heap</title>
      <link>https://blog.mattblair.co/blog/20120829-cracking-the-coding-interview-javascript-minmax-binary-heap/</link>
      <pubDate>Wed, 29 Aug 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120829-cracking-the-coding-interview-javascript-minmax-binary-heap/</guid>
      <description>I finished my second algorithm from Cracking the Coding Interview - the Binary Heap. This algorithm racketed up the complexity from the Linked List.
The heap&amp;rsquo;s structure is easy to understand - it&amp;rsquo;s a binary tree (a tree where each node can have at most two children). In the case of a max heap, the parents have a greater value than their children. The values in a Max Heap decrease as you move down the tree from the parent to children.</description>
    </item>
    
    <item>
      <title>Derby.js - Starting out with Components; Creating a Twitter Bootstrap Input Component</title>
      <link>https://blog.mattblair.co/blog/20120825-derby-js-starting-out-with-components-creating-a-twitter-bootstrap-input-component/</link>
      <pubDate>Sat, 25 Aug 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120825-derby-js-starting-out-with-components-creating-a-twitter-bootstrap-input-component/</guid>
      <description>In working with Twitter Bootstrap Forms, one of my favorite ways to lay out a form is using the Horizontal form layout. The layout requires a bit of css/html to get each of the form elements (the text boxes and what not) to play nicely. To add form elements to the horizontal form layout, you need the following html structure for each field:
&amp;lt;div class=&amp;#34;control-group&amp;#34;&amp;gt;&amp;lt;!-- additional classes here to change state --&amp;gt; &amp;lt;label class=&amp;#34;control-label&amp;#34;&amp;gt;INPUT_LABEL_TEXT_HERE&amp;lt;/label&amp;gt; &amp;lt;div class=&amp;#34;controls&amp;#34;&amp;gt; &amp;lt;input type=&amp;#34;text&amp;#34; /&amp;gt; &amp;lt;!</description>
    </item>
    
    <item>
      <title>Cracking the Coding Interview - JavaScript Singly Linked List</title>
      <link>https://blog.mattblair.co/blog/20120824-cracking-the-coding-interview-javascript-singly-linked-list/</link>
      <pubDate>Fri, 24 Aug 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120824-cracking-the-coding-interview-javascript-singly-linked-list/</guid>
      <description>I finished my first algorithm from Cracking the Coding Interview - the almighty Singly Linked List.
This is the low-hanging fruit of the data structures I mean to tackle. Even implementing this simple structure, I managed to somehow squeeze in a bug that luckily I caught in my testing. An unfortunate case of premature optimization.
The code doesn&amp;rsquo;t look as cool as it did, but at least it does the job.</description>
    </item>
    
    <item>
      <title>Derby.js - Integrating Twitter Bootstrap into your Application</title>
      <link>https://blog.mattblair.co/blog/20120818-derby-js-integrating-twitter-bootstrap-into-your-application/</link>
      <pubDate>Sat, 18 Aug 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120818-derby-js-integrating-twitter-bootstrap-into-your-application/</guid>
      <description>As I&amp;rsquo;ve mentioned in a previous post, I&amp;rsquo;m a big fan of Twitter Bootstrap. Lately I&amp;rsquo;ve been playing been with JavaScript and Derby. I want to integrate bootstrap with the POC site I&amp;rsquo;m building, and the creators of Derby have already figured out a way to do this.
Step 1: Add a dependency to the derby-ui-boot package, which is a Derby component library based on Twitter Bootstrap.
{ .... &amp;#34;dependencies&amp;#34;: { &amp;#34;derby&amp;#34;: &amp;#34;*&amp;#34;, &amp;#34;derby-ui-boot&amp;#34;: &amp;#34;*&amp;#34;, &amp;#34;express&amp;#34;: &amp;#34;3.</description>
    </item>
    
    <item>
      <title>Cracking the Coding Interview: JavaScript Data Structures</title>
      <link>https://blog.mattblair.co/blog/20120817-cracking-the-coding-interview-javascript-data-structures/</link>
      <pubDate>Fri, 17 Aug 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120817-cracking-the-coding-interview-javascript-data-structures/</guid>
      <description>A friend and co-worker of mine (one of the best and brightest I&amp;rsquo;ve worked with) recently left our company to go work for Microsoft. Having gone through the Microsoft interview process myself (hilariously unprepared, to the enjoyment of my interviewer), I wondered what he had done to get ready for the process. He recommended one book - Cracking the Coding Interview - which he said had been recommended to him as the bible for preparation.</description>
    </item>
    
    <item>
      <title>Derby.js - Working with Views, Models, and Bindings</title>
      <link>https://blog.mattblair.co/blog/20120807-derby-js-working-with-view-templates-models-and-bindings/</link>
      <pubDate>Tue, 07 Aug 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120807-derby-js-working-with-view-templates-models-and-bindings/</guid>
      <description>In my previous post about derby, I talked a bit about how to create a model in derby and one rule you need to follow when creating models (the first two path segments should be an object).
I&amp;rsquo;m creating a test application to help me learn derby here. In the process of doing absolutely everything wrong to start I&amp;rsquo;ve learned a bit about how Derby binds to models. Let&amp;rsquo;s say you&amp;rsquo;re got some markup like this that you&amp;rsquo;d like to bind to.</description>
    </item>
    
    <item>
      <title>HTML5 &#39;formaction&#39; attribute - An easy Modernizr test</title>
      <link>https://blog.mattblair.co/blog/20120801-html-input-formaction-attribute-an-easy-modernizr-test/</link>
      <pubDate>Wed, 01 Aug 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120801-html-input-formaction-attribute-an-easy-modernizr-test/</guid>
      <description>EDIT NOTE: This no longer needs to be done outside of Modernizr. This was added to the Modernizr package about a month ago. Link to issue
 I&amp;rsquo;ve been writing some Html Forms, and in playing with submit buttons came across an interesting attribute in the HTML 5 specs: formaction. The definition, from HTML Living Standard Doc
 The action and formaction content attributes, if specified, must have a value that is a valid non-empty URL potentially surrounded by spaces.</description>
    </item>
    
    <item>
      <title>Australian vs US Coffee Terms Comparison</title>
      <link>https://blog.mattblair.co/blog/20120727-australian-vs-us-coffee-terms-comparison/</link>
      <pubDate>Fri, 27 Jul 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120727-australian-vs-us-coffee-terms-comparison/</guid>
      <description>This took me a while to figure out when I first moved to Australia. I still remember the look on the barista&amp;rsquo;s face when I tried to order an Americano, and then the absolute puzzlement over what the hell a flat white vs a long black was. I hope this helps other visitors to Australia from the US order a decent cup of coffee!
   Description Australian Name US Name     A shot of espresso.</description>
    </item>
    
    <item>
      <title>Derby.js - Playing with Models</title>
      <link>https://blog.mattblair.co/blog/20120722-derby-js-playing-with-models/</link>
      <pubDate>Sun, 22 Jul 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120722-derby-js-playing-with-models/</guid>
      <description>Been playing around with Derby in my spare time. The idea behind the platform is smart - using node and express, you write one set of code, and that code automatically syncs data between browsers, servers, and a database.
Derby is still raw. The documentation is comprehensive but puts important information about the same topic in different places.
I&amp;rsquo;ve culled the following eight lines of documentation of defining models from the documentation:</description>
    </item>
    
    <item>
      <title>Some node.js and express.js beginner help</title>
      <link>https://blog.mattblair.co/blog/20120710-some-node-js-and-express-js-beginner-help/</link>
      <pubDate>Tue, 10 Jul 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120710-some-node-js-and-express-js-beginner-help/</guid>
      <description>I&amp;rsquo;ve just started using node.js with express.js on both Windows (with iisnode) and Ubuntu.
I love the stack (one programming language from front to back!), but some of the documentation has been frustrating for me. I wanted to document what I&amp;rsquo;ve learned so far in the hopes that it&amp;rsquo;ll help someone else down the line.
Generate the starter app At first, I wanted to just hack away some of the existing example apps that were out there.</description>
    </item>
    
    <item>
      <title>Using StructureMap to collect and use all instances of a given type</title>
      <link>https://blog.mattblair.co/blog/20120618-using-structuremap-to-collect-and-use-all-instances-of-a-given-type/</link>
      <pubDate>Mon, 18 Jun 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120618-using-structuremap-to-collect-and-use-all-instances-of-a-given-type/</guid>
      <description>Had an issue at work where I wanted to store my rules and handlers for a class outside of the class definition, so I could better test the component. Found an easy way to add all your rules into StructureMap, and then retrieve those rules as a list via constructor injection.
using System.Collections.Generic; using System.Linq; using System.Text; using StructureMap; using StructureMap.Configuration.DSL; public class TravelRegistry : Registry { public TravelRegistry() { For&amp;lt;ITransportHandler&amp;gt;().</description>
    </item>
    
    <item>
      <title>Why use Twitter Bootstrap?</title>
      <link>https://blog.mattblair.co/blog/20120504-why-use-twitter-bootstrap/</link>
      <pubDate>Fri, 04 May 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120504-why-use-twitter-bootstrap/</guid>
      <description>I&amp;rsquo;m a fan of Twitter Bootstrap, the simple and flexible CSS, HTML, and JavaScript user interface framework.
What&amp;rsquo;s not to like? Out of the box, you&amp;rsquo;ll get:
 Cross-Platform Support  IE 7 to IPhone and everything else (sorry IE6)
12-Column Grid  A good grid system takes most of the pain out of laying out your site. Getting labels, inputs, and other pieces of your ui to layout consistently across different browsers at different resolutions can be one of the most painful parts of web development.</description>
    </item>
    
    <item>
      <title>Posting an IEnumerable of Interfaces back from your Views by extending the DefaultModelBinder</title>
      <link>https://blog.mattblair.co/blog/20120426-posting-an-ienumerable-of-interfaces-back-from-your-views-by-extending-the-defaultmodelbinder/</link>
      <pubDate>Thu, 26 Apr 2012 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120426-posting-an-ienumerable-of-interfaces-back-from-your-views-by-extending-the-defaultmodelbinder/</guid>
      <description>Please note I came across a bug in the code, and revised this post on 31/07/2012.
 Came across an interesting problem today. In ASP.Net MVC, you can easily pass an enumerable of interfaces to your views from your controllers. As long as you have DisplayTemplates and EditorTemplates defined for the subclasses, then those classes will be rendered correctly from your enumerable of the parent interfaces.
However, if you then POST to a controller method that accepts an IEnumerable, you&amp;rsquo;ll get the error message:</description>
    </item>
    
    <item>
      <title>Horrible, Slow, Stupid, Scary Build Process</title>
      <link>https://blog.mattblair.co/blog/20120303-horrible-slow-stupid-scary-build-process/</link>
      <pubDate>Sat, 03 Mar 2012 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120303-horrible-slow-stupid-scary-build-process/</guid>
      <description>So we&amp;rsquo;ve rolled out a new build process at work. I&amp;rsquo;ve started working with a new company, and when I arrived, the build process for a new environment consisted of a 20 page manual somebody had written. The process of putting a build on an environment was slow, the manual had steps missing that everyone just &amp;lsquo;knew&amp;rsquo;, the process had multiple failure points, and was more or less a complete disaster.</description>
    </item>
    
    <item>
      <title>Windows 7 - Problem Steps Recorder</title>
      <link>https://blog.mattblair.co/blog/20120216-windows-7-problem-steps-recorder/</link>
      <pubDate>Thu, 16 Feb 2012 00:00:00 -0800</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20120216-windows-7-problem-steps-recorder/</guid>
      <description>Just found out about a good tool that ships with Windows 7.
One of the hardest things about debugging software can be getting the users to document what went wrong so you can test the scenario. Problem Steps Recorder - which ships with Windows 7 - records a user&amp;rsquo;s actions and documents them in an easy to understand format. It even gives the user the option of sending the recording via e-mail right from the program.</description>
    </item>
    
    <item>
      <title>Setting up a .NET build server WITHOUT installing Visual Studio</title>
      <link>https://blog.mattblair.co/blog/20111031-setting-up-a-net-build-server-without-installing-visual-studio/</link>
      <pubDate>Mon, 31 Oct 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20111031-setting-up-a-net-build-server-without-installing-visual-studio/</guid>
      <description>My client tasked me with upgrading their build server. Today, their platform builds VS 2080 solutions in .NET 3.5 - and I&amp;rsquo;ve been pushing to upgrade everyone to Visual Studio (VS) 2010 and eventually .NET 4.0. I want to upgrade the server to build a VS 2010 solution in .NET 3.5.
This will allow everyone to upgrade to VS 2010 while leaving the task of upgrading the production web servers to another day.</description>
    </item>
    
    <item>
      <title>Enable/Disable jQuery buttons in Knockout with a Custom Binding Handler</title>
      <link>https://blog.mattblair.co/blog/20111021-enabledisable-jquery-buttons-in-knockout-with-a-custom-binding-handler/</link>
      <pubDate>Fri, 21 Oct 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20111021-enabledisable-jquery-buttons-in-knockout-with-a-custom-binding-handler/</guid>
      <description>Still working on those jQuery buttons. Trying to update old ASP.Net Webforms using jQuery, Knockout, and Amplify.
New problem today.
I was having problems getting Knockout to enable/disable my jQuery buttons using the Knockout &amp;lsquo;enable&amp;rsquo; bindingHandler. It would enable/disable the underlying element that I had run the .button() method on, but it had no idea about the div that jQuery had wrapped my element in, or how to handle it.</description>
    </item>
    
    <item>
      <title>Auto Creation of jQuery Buttons using Knockout Templates</title>
      <link>https://blog.mattblair.co/blog/20111019-auto-creation-of-jquery-buttons-using-knockout-templates/</link>
      <pubDate>Wed, 19 Oct 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20111019-auto-creation-of-jquery-buttons-using-knockout-templates/</guid>
      <description>While converting ASP.NET Webforms to be more clienty using HTML 5, Knockout, and jQuery, I came across a problem.
I want to use jQuery buttons on my Knockout-rendered rows, but whenever a new row gets added via a template, the buttons were not created as jQuery buttons. The issue was that I was calling a method to create the buttons after the page was fully rendered but never again. All the new rows wouldn&amp;rsquo;t have the .</description>
    </item>
    
    <item>
      <title>Alas, it was not to be</title>
      <link>https://blog.mattblair.co/blog/20111014-alas-it-was-not-to-be/</link>
      <pubDate>Fri, 14 Oct 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20111014-alas-it-was-not-to-be/</guid>
      <description>My jQuery bug was already documented. :(</description>
    </item>
    
    <item>
      <title>Finished the Nike&#43; Importer for www.runningahead.com</title>
      <link>https://blog.mattblair.co/blog/20111010-finished-the-nike-importer-for-www-runningahead-com/</link>
      <pubDate>Mon, 10 Oct 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20111010-finished-the-nike-importer-for-www-runningahead-com/</guid>
      <description>I finished up the Nike+ data importer for www.runningahead.com. You can check out the code for the importer at this Github repository:
https://github.com/duereg/NikePlusImporter
I got a small test project up for this. It walks through everything but doesn&amp;rsquo;t Mock up the calls to the Nike+ service (I couldn&amp;rsquo;t be bothered). Let me know what you think.</description>
    </item>
    
    <item>
      <title>jQuery UI Bug - 1.8.16, buttonset() method</title>
      <link>https://blog.mattblair.co/blog/20111006-jquery-ui-bug-1-8-16-buttonset-method/</link>
      <pubDate>Thu, 06 Oct 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20111006-jquery-ui-bug-1-8-16-buttonset-method/</guid>
      <description>I love to find bugs in good software! Came across a little jQuery UI bug today. It&amp;rsquo;s for one browser, but it always excited to be able to create an easy-to-replicate bug. The bug is small - it deals with the buttonset() method.
The buttons, instead of having the rounded corners on the outside, have the rounded corners on the inside. Not critical but it made the UI I was working on look strange.</description>
    </item>
    
    <item>
      <title>Beautiful LINQ to Xml</title>
      <link>https://blog.mattblair.co/blog/20110924-beautiful-linq-to-xml/</link>
      <pubDate>Sat, 24 Sep 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20110924-beautiful-linq-to-xml/</guid>
      <description>Is there anything better in life than finding a better way to do something? An easier commute, a better night&amp;rsquo;s sleep, a tastier cake recipe? In starting the Nike+ importer for www.runningahead.com, I knew I was going to have to deal with a bit of XML. Which used to mean XPath. Not so much anymore. LINQ to XML, you rock my world. It turns XML like this&amp;hellip;
&amp;lt;extendedDataList&amp;gt; &amp;lt;extendedData dataType=&amp;#34;distance&amp;#34; intervalType=&amp;#34;time&amp;#34; intervalUnit=&amp;#34;s&amp;#34; intervalValue=&amp;#34;10&amp;#34;&amp;gt; 0.</description>
    </item>
    
    <item>
      <title>Working on Nike&#43; Importer for RunningAhead.com</title>
      <link>https://blog.mattblair.co/blog/20110921-working-on-nike-importer-for-runningahead-com/</link>
      <pubDate>Wed, 21 Sep 2011 00:00:00 -0700</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20110921-working-on-nike-importer-for-runningahead-com/</guid>
      <description>I&amp;rsquo;m a fan of the website www.runningahead.com. I use it to track all my sporting life activities. The primary reason I use this site, instead of one of the hundreds like it, is that you can track anything - yoga, rowing, running, P-90x, underwater hockey, tiddlywinks, whatever. Throw in some customizable reporting and some great hardware integration, and it&amp;rsquo;s free, and you&amp;rsquo;ve got a winner.
That doesn&amp;rsquo;t mean there aren&amp;rsquo;t things I don&amp;rsquo;t like about the site, and things I wish could be better.</description>
    </item>
    
    <item>
      <title></title>
      <link>https://blog.mattblair.co/blog/20140209-introducing-songbird/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blog.mattblair.co/blog/20140209-introducing-songbird/</guid>
      <description>title = &amp;quot;Introducing Songbird&amp;quot; description = &amp;quot;How to have promises everywhere, all the time&amp;quot; date = 2014-02-09 post_name = &amp;quot;introducing-songbird&amp;quot; status = &amp;quot;publish&amp;quot; tags = [&amp;quot;development&amp;quot;,&amp;quot;software&amp;quot;,&amp;quot;coding&amp;quot;,&amp;quot;web&amp;quot;,&amp;quot;html&amp;quot;,&amp;quot;JavaScript&amp;quot;,&amp;quot;CoffeeScript&amp;quot;,&amp;quot;EMCAScript&amp;quot;,&amp;quot;Songbird&amp;quot;,&amp;quot;Bluebird&amp;quot;,&amp;quot;Promises&amp;quot;,&amp;quot;Generators&amp;quot;,&amp;quot;EMCAScript&amp;quot;] categories = [&amp;quot;engineering&amp;quot;, &amp;quot;technical&amp;quot;, &amp;quot;javascript&amp;quot;] layout = &amp;quot;post&amp;quot; +++ Would you rather write this: ```javascript var updateUser = function(id, attributes, callback) { User.findOne(id, function (err, user) { if (err) return callback(err); user.set(attributes); user.save(function(err, updated) { if (err) return callback(err); console.log(&amp;quot;Updated&amp;quot;, updated); callback(null, updated); }); }); }); +++ Or this: ```coffeescript User.</description>
    </item>
    
  </channel>
</rss>