<brad-oyler/>

01
September

SnapCard: the business card app you actually want

An alternative to physical business cards. When someone asks for “your card” just show them SnapCard and have them take a pic.

image

Leave some feedback.

Launching to the App Store and Google Play soon. 

23
July

My “Key Management Principles” (KMP)

~~ re-post from Nov 2008 ~~

Below are a few of the main principles I try to practice on a daily basis and also try to pass on to people I work with. The prime reason for this; is that they are based on common sense and haven’t proved to be wrong yet. Some of the principles below may seem solely oriented towards software development, but they also apply to an agile project management style.

YAGNI
YAGNI, short for ‘You Ain’t Gonna Need It’, suggests to that they should not add functionality until it is necessary. Ron Jeffries writes, “Always implement things when you actually need them, never when you just foresee that you need them.”
The temptation to add features that are not necessary at the moment, but might be in the future, has the following disadvantages:
• The time spent is taken from adding, testing or improving necessary functionality.
• The new features must be debugged, documented, and supported.
• Any new feature imposes constraints on what can be done in the future, so an unnecessary feature now may prevent implementing a necessary feature later.
• Until the feature is actually needed, it is difficult to fully define what it should do and to test it. If the new feature is not properly defined and tested, the unnecessary feature may not work right, even if it eventually is needed.
• It leads to code bloat; the software becomes larger and more complicated.
• Unless there are specifications and some kind of revision control, the feature may not be known to programmers who could make use of it.
• Adding the new feature may suggest other new features. If these new features are implemented as well, this may result in a snowball effect towards feature creep.

KISS
The K.I.S.S. principle or “Keep It Simple Stupid”, states that design simplicity should be a key goal and unnecessary complexity avoided. It serves as a useful principle in a wide array of disciplines, such as software development, animation, journalism, photography, engineering, and strategic planning.
"Everything should be made as simple as possible, but no simpler." – Albert Einstein

Occam’s razor
Occam’s razor, often paraphrased as “All other things being equal, the simplest solution is the best.” In other words, when multiple competing theories are equal in other respects, the principle recommends selecting the theory that introduces the fewest assumptions and postulates the fewest entities. It is in this sense that Occam’s razor is usually understood.

Last Responsible Moment
The key is to make decisions as late as you can responsibly wait because that is the point at which you have the most information on which to base the decision. In software design it means you forgo creating generalized solutions or class structures until you know that they’re justified or necessary.
Making decisions at the Last Responsible Moment isn’t procrastination; it’s inspired laziness. It’s a solid, fundamental risk avoidance strategy. Decisions made too early in a project are hugely risky. Early decisions often result in work that has to be thrown away. Even worse, those early decisions can have crippling and unavoidable consequences for the entire future of the project.

Core Principles of Agile
1. Individuals and interactions over processes and tools
2. Working software over comprehensive documentation
3. Customer collaboration over contract negotiation
4. Responding to change over following a plan

(Source: brad.w3portals.com)

;

embedly:

The 13 year old in all of us rejoiced when Twitter started supporting GIFS! Yaayyy, but I’m here to crush your dreams, Twitter’s GIFs are actually displayed as looping videos.

image

Womp, Womp.

We did a little test, here is the original:

image

Here is the Twitter “GIF”.

It appears that…

24
May

"if-equal" Handlebars helper for Ember or Node

Sometimes creating a view/controller + computed property macro is a bit of overkill for some situations where you ‘should’ separate logic from views.

Anyways, here’s a nice Handlebars helper to add some conditional logic to your templates.

 
Ember.Handlebars.helper('if-equal', function(val, test, options) {
    var arrTest = test.split('||');
    for (var i = 0; i < arrTest.length; i++) {
        if (val === arrTest[i]) {
          return options.fn(this);
        }
      }
      return options.inverse(this);
  });
  

So now, in your template, just use:

  
   {{#if-equal story.type 'video||photo'}}
       < h1> Show me if type is video or photo< /h1>
   {{/if-equal}}   
  
28
April

Election Poll builder for Bootstrap

image

Yes way! Well, kinda.

image

See demo @ http://bradoyler.github.io/HTMLPollBuilder/

Github repo @ https://github.com/bradoyler/HTMLPollBuilder 

11
March

DasHub: A dashboard for Github Issues

DasHub is a lightweight (kanban-style) tool to make GitHub Issues more visible and manageable to teams using Github for issue tracking. 

The entire application is written in javascript using Ember.js

Source on Github

image

Uses:

- Ember.js
- Ember App Kit (EAK)
- Github issues API
- Client-side basic auth
- Javascript
- Sass

Upcoming Planned features

Get at me… fur sure. workaholics

07
March

A web component for the Weather

A card-style weather HTML5 web component example using Polymer.js.

<Source on GitHub/>

image

Uses:

- Meteocons: weather condition icon fonts 
- WeatherUnderground API
- HTML5 Geolocation api
- HTML5 localstorage
- Polymer.js

15
February

Photography makes us feel closer to the world than we really are.

Susan Sontag

;
13
February

Creativity is allowing yourself to make mistakes. Art is knowing which ones to keep.

Scott Adams

;
20
December

git reset —hard

&& git push —force

image

16
December

Front-end tools brought to you by Twitter

Twitter has ‘contributed’ a lot to the open web. Here are a few examples.

  • Flight.js - a lightweight, component-based JavaScript framework  (started ~Jan 2013)
  • Flight-generator - a Yeoman generator to Flight.js
  • Jasmine-Flight - a set of Jasmine helpers for testing your Flight.js app
  • Hogan.js - a mustache-based js template compiler 
  • RECESS - a CSS style hinter on top of LESS 
  • Bootstrap - although no longer maintained by Twitter, I had to mention this ubiquitoius CSS framework. 
  • Typeahead.js - a fast and fully-featured autocomplete library

And yes, there’s more back-end stuff too. See the full list of repos @ http://twitter.github.io/ 

07
October

Rise of the Static Site generators

  I’ve seen a serious uptick in new web publishing projects, over the last 6 months. I think a lot of web developers are pretty unsatisfied with the current approach to the creating content on the web. Stuff like Wordpress, Drupal, Tumblr, Movable Type, etc, all have there pain points, shortcomings, and serious baggage. 

image

So… we enter a “old but new” wave of how to publish to the web. Albeit, the new shiny platforms are built for developers, but keep an eye out for Jekyll-inspired static site platforms like Harp, Roots, Punch, DocPad & Wintersmith because they could be a strong indicator of what’s coming down the pike.

The common tools used across all these platforms seem to of course be the trendy ones: Javascript, Node.js, Express, Markdown, Jade, Stylus & Coffeescript.

Cheers!

01
October

Little problem this morning, going to work…

image

13
September

An Agile Approach

I’ve worked on a few Agile\Scrum projects since 2006 and just wanted to share some notes that I think might be helpful.

The Project roadmap

A roadmap is a high-level plan that describes how the product is likely to grow. The Artifacts (below) of the roadmap are not deliverables, since they have no value to the customer. It is key, that the roadmap be owned by the entire team. Therefore, everyone should contribute to creating and modifying these artifacts.

Artifacts

- User Story: a way to describe a piece of functionality that an end-user wants.

- Epic: A large story that most likely be broken down into multiple stories later on.

- Theme: simply a collection of user stories. However, user stories may belong to multiple themes.

- Spike: A technical issue that needs to be figured out or experimented with before tackling an Epic, Story, or Theme.

Meetings

Daily standups

Please take care with these. Don’t make this a place for everyone to rattle off what they’re working on or direct questions to specific team member. All comments/questions should beneficial to the team. In other words, status updates are for your Facebook friends.

Planning meetings (every 2 or 3 iterations)

- Talk about MMFs (minimal marketable features)

- Prioritize into Themes & Epics

- Retrospectives: The team shares what has worked well and was hasn’t. The good, the bad & the ugly

Iteration meetings (weekly or bi-weekly)

- Re-evaluate the top priority items. This is the team’s chance to adjust direction.

- Create the user story drafts (as a team)

- Estimate user stories (difficulty scoring: 1-5)

*Agile also includes many of the Scrum and XP principles, but in the theme of being “Agile”, trying to stay lightweight with this post. 

The most important part is to continuously make adjustments until a process works well for the team. These terms and practices really just serve as an agreed upon language for the team. Which helps foster efficient communication for the team and also other stakeholders.

A great talk from James Shore on "The Art of Agile"