• Read more about Dwolla, An Alternative Payment Processor

At Intridea, we enjoy helping our customers create secure and functional marketplaces. From investigating and research to testing out the product, finding the best payment solution for our client is top priority.

Recently when looking for a replacement ACH payment processor we had an opportunity to do a deep dive into Dwolla and were pleasantly surprised! We worked through an initial integration with one of our Rails apps, and in this post I'll share how you can do the same.

What is Dwolla?

According to their site:

Dwolla is a payment network that allows any business or person to send, request, and accept money. Unlike the big payment companies that rely on plastic cards and charge hefty fees, Dwolla built their own network that securely connects to your bank account and allows you to move money…

We chose to go with their OAuth + REST API method for integration, but this was one of many possible scenarios. Not only does Dwolla have multiple options for connecting and delivering payment requests, but (as is attractive to any developer) their documentation is clear and concise.

One aspect we’ve avoided in the past with systems like Dwolla, is forcing users to create full accounts prior to gaining access. Dwolla’s new “direct” offering allows users to proceed with an email address, password, and their bank’s website credentials only; saving time, effort and eliminating errors. You can see an example of their form builder here.

Connecting Dwolla to your rails app

Hundreds of people are leveraging the advantages of super simple, secure authentication with OmniAuth in their applications. This authentication route helps simplify login and allows you necessary access to Dwolla permissions.

First, let's add the two gems in your Gemfile. Note: If you want to handle payments as well as incoming funds, add dwolla-ruby too.

gem 'omniauth-dwolla' gem 'dwolla-ruby'  

Next, configure omniauth-dwolla by adding the middleware to config/initializers/omniauth.rb and getting a token with scope permissions for full user info access and sending and requesting transactions:

Rails.application.config.middleware.use OmniAuth::Builder do   provider :dwolla, ENV['DWOLLA_KEY'], ENV['DWOLLA_SECRET'],    :scope => 'accountinfofull|send|request',   :client_options => {         :site => 'https://uat.dwolla.com',         :authorize_url => '/oauth/v2/authenticate',         :token_url => '/oauth/v2/token'       } end 

Finally, visit https://uat.dwolla.com (Dwolla's sandbox which mirrors production) to create a testing account. The sandbox is full-featured, with everything you need in testing; transactions, activity logs, adding funds to test accounts, etc. Once you’ve registered for this test account, you’ll be able to retrieve user information from the Dwolla site when users create an account on the marketplace app. See below:

    "raw_info": {         "City": "New York",         "Id": "123-456-7890",         "Latitude": 41.584546,         "Longitude": -93.634167,         "Name": "Test User",         "State": "NY",         "Type": "Personal"     } 

Before we play with some functions, let's set the secret and key for the app, located in your registered application panel. Remember to record your pin (shown below) for your reference. The pin ensures security for purchases both from your application and for individual purchasers.

# Dwolla Secret Stuff @api_key = 'ztRqeAYvw0B6KFezOuw161bbxWdrmEDPbWVWgETN086Mmj809y' @api_secret = 'knZgUVDlmqWLcao2e64xU+X/L+YMMMaeZQz8JjcFyA+aQgtyXt' @token = 'Bx3bmKWClyUZdLi3KnnQwXkAcOtJy7c/qAzV6oNaHdB0nXobCC' @pin = '1234' 

Using the Dwolla API

You should initiate a new Dwolla User client and seed a previously generated access token (see below) every time you want to call the API.

Dwolla::token = @token Dwolla::api_key = @api_key Dwolla::api_secret = @api_secret 

In order to handle transactions (you can try in rails console):

##### Send money ($1.00) to a Dwolla ID transactionId = Dwolla::Transactions.send({:destinationId => '812-626-8794', :amount => 1.00, :pin => @pin})  ##### Send money ($1.00) to an email address, with a note transactionId = Dwolla::Transactions.send({:destinationId => '812-626-8794', :destinationType => 'Email', :amount => 1.00, :pin => @pin, :notes => 'Everyone loves getting money'})  ##### Get details about a certain Transaction pp Dwolla::Transactions.get(transactionId)  

Handle funding sources.

Keep in mind, as the seller you can affect funding sources in Dwolla's admin panel. We've found that you often need this to let the buyer update/add their bank information to Dwolla via your marketplace.

##### Fetch detailed information for the funding source with a specific ID pp Dwolla::FundingSources.get('some_funding_source_id')  ##### Deposit funds from a bank account into the Dwolla account balance. pp Dwolla::FundingSources.deposit('some_funding_source_id', {:amount => 30.05, :pin => @pin})  ##### Withdraw funds from a Dwolla account balance into bank account pp Dwolla::FundingSources.withdraw('some_funding_source_id', {:amount => 30.05, :pin => @pin})  ##### Add a new bank account. Possible values for account_type: "Checking" and "Savings" pp Dwolla::FundingSources.add({:routing_number => 1111111, :account_number => 1111111, :account_type => "Checking", :name => "Owner Name"})  

There are a multitude of ways to interact with the Dwolla API, and their documentation breaks it down for both developers and non-developers. There are tons more samples like I posted above, but what's more important is to apply the functions correctly to your marketplace use case. Additional features can be found in their labs, click here for more surprises.

If you are looking for a payment gateway, I strongly recommend you use Dwolla. From all angles, it's a complete and smoothly implemented choice. Got any questions? Let us know!

• Read more about Dear Maggie Series: Kiddos

Dear Maggie,

As a parent, working from home is such a blessing! Getting to send them off to school, attend midday field trips, and being home when they return is a privilege I'll never take for granted.

The only struggle though, is balancing work and family time when the kids are on vacation. I always seem to spend the entire day trying to placate one of them, and no matter how hard I try, the interruptions always equate to less work during the day and more in my evenings.

And of course, this doesn’t help with the reports of “Dad works all the time!” and only furthers their desire to have more of my time the next day. Any tips for making these days more enjoyable for everyone?

Run Ragged in Reno

Hey Ragged,

While I don’t have any rugrats of my own, I do have a total of 7 make that 8, nieces and nephews. Whenever I work from my brother’s house and the munchkins are around, my productivity is completely shot. I spoke with a few expert Intrideans though, Ben and Jeff, who manage being great dads and productive workers, and we’ve come up with a few surefire tips for gettin’ er done when the kiddos are around:

1. Tell them “bye” in the morning.

You may just be going into your office, but we’d still recommend telling your kids “bye” in the morning. It doesn’t have to be any more grandiose than a quick hug and a kiss for their day. Sure, you’ll probably see them again in five minutes for a coffee refill, but it creates a clean break and lets them know “you’re now at work.”

2. Create boundaries.

The best way to get work done with little ones around is to have your own space. Many people will create a hanging sign for their office door, indicating they are or are not available. Others create a system of their door being open or cracked. Whatever your method is, establish clear boundaries that your children can understand.

3. Ask for quiet when you need it.

Everyone knows kids are GREAT at making noise. Between general mirth or tears and the toys and TV, things can get loud. Usually just a quick “Hey, hoping on a call” is all it takes to keep them happy and quiet for the duration (so long as you’ve explained what that means, and they have engaging quiet activities for them). It’s important to follow up if expectations aren’t met, and you should be ready for it to take a little while to get it just right.

4. Expect the unexpected.

You never know what you might walk into when you leave your office, and trying to plan or expect too much will lead to disappointment. Accept that you’re raising kids (not robots) and it is their house as well. Do your best to come to terms with the ups and downs, and remember they’re only this little once, so don’t let the mess affect the time you have with them.

5. Make time for visits.

All the above might make it sound like you should try to be distant from your kids during the day, but it’s quite the opposite. You should do your best to make time and visit with them for small blocks of time every day. Try having lunch with your family, play a game, or go for a walk with them. It’s the simple things kids remember most and working from home is the perfect opportunity to create those memories.

Got an idea for our next post? Send your burning questions, feedback, or suggestions over to dearmaggie@intridea.com! We'd love to hear from you.

Also, check out Dear Maggie's advice on relationships and working remotely.

• Read more about Goodbye Google Glass

_{Looking dorky and non-utilitarian. Photo by Teresa Bouza, Americas DataFest}

Google Glass failed not because it was dorky (it was), but because it sucked. Utility drives fashion, and had people found Glass useful enough they would have worn it regardless of how they looked.

The best analogy is the transition from the pocket watch to the wrist watch: in the late 1800s soldiers discovered they could coordinate maneuvers more efficiently if their watches were strapped to their wrists instead of buried in their pockets. Only later did technology and miniaturization allow the wrist watch to become fashionable.

Basically: Dorky White European Guys Willing to Look Silly to Get Stuff Done™.

Two centuries later Google Project Glass debuted without much stuff to be done. All of the dork, none of the utility.

I was a Glass Explorer and we had fun at Intridea playing with the technology, but it’s an object lesson in the need to delight—or at least be useful.

• Read more about Polymer Features You May Have Missed

_{This article originally appeared on the Divshot blog. Divshot is a developer-focused platform for deploying modern front-end applications. It was also started with Intridea's support by Michael Bleigh!}

There's so much new ground to cover with Web Components and Polymer that oftentimes some of the smaller conveniences are overlooked. Here are some of the cool things Polymer can do (or does for you) that you might not have noticed.

Built-In Element Methods

You may have used fire() to trigger custom events from a Polymer element, but that's not the only convenient little method that's available.

async(fn, inArgs, inTimeout) allows you to delay the execution of code (similar to setTimeout or requestAnimationFrame) while keeping this bound appropriately. It comes in handy for things like allowing an event to fully propagate before performing a dependent action.

// executes at the next micro-task checkpoint this.async(function() {   this.$.request.go(); }) 

job(jobName, fn, inTimeout) gives you the ability to limit how frequently an action is performed. Jobs are only executed after inTimeout milliseconds have passed without the same job being called again. You might have heard of this pattern as debounce. It's great for handling things like listening for noisy event streams like keystrokes or mouse movements.

// executes when it hasn't been called for 750ms this.job('keyup', function() {   this.fire('save'); }, 750); 

Layout Attributes

If you've browsed through Polymer examples and source, you might have come across attributes like layout, center, or flex sprinkled here and there. Polymer ships with declarative attributes that let you quickly and easily create complex layouts using CSS Flexbox.

Let's say I want to create a mobile-friendly layout with a header, footer, and content area.

<body fullbleed layout vertical>   <header>This will be at the top</header>   <main flex>This will fill available space</main>   <footer>This will be at the bottom</footer> </body> 

There's quite a bit to this, and the official documentation does a great job of laying it out.

Auto-Binding Templates

Polymer's template binding is powerful stuff, but what if you want to use it outside the context of an element's Shadow DOM? Well, then it's auto-binding to the rescue!

The auto-binding template is an extension of the <template> tag that automatically binds the element itself as the model.

{% raw %} <template id="greeter" is="auto-binding" repeat="{{name in names}}">   <p>Hello, {{name}}, how are you today?</p> </template> <script>   document.querySelector('#greeter').names = ["Alice", "Brenda"]; </script> {% endraw %} 

Because auto-binding templates can exist in the Light DOM (anywhere on the page, really) and don't depend on a user-defined custom element, they come in quite handy on occasion.

Attribute Reflection

Polymer makes it dead easy for attributes defined in the source code to configure properties on the DOM node, but did you know it goes both ways? By using a special form of published in your element definition, you can make it so that the attribute values change to match changing properties.

<polymer-element name="two-way">   <script>     Polymer('two-way', {       published: {         name: {           value: 'Bob',           reflect: true         }       }     });   </script> </polymer-element> 

If you were to use the above element in your page and changed the name property in JavaScript, the name attribute in the web inspector would change, too. Cool stuff!

Polymer is a library that keeps surprising me with how deep and well-designed it is (without even mentioning all of the core and paper custom elements!). It's way more than just a set of polyfills.

Have any Polymer hidden gems of your own you'd like to share? Let us know!

• Read more about From jQuery to AngularJS

Working on a project recently, I went through a process where I converted jQuery-style selectors and DOM manipulation to “The Angular Way”, and I thought I’d share my results.

This is one part of AngularJS I feel every web designer should become familiar with, as it shows how much easier it can be to understand JavaScript written by someone else when you use AngularJS. The reason AngularJS can be easier to understand is a result of its declarative nature, meaning you define click handlers right in your HTML, which in a larger project, can make it much easier to understand just what is going on under the hood.

This example will use a few simple buttons to show and hide content, and I’ll first demonstrate how we might accomplish this with jQuery, and then convert it to Angular. Suppose we were creating an app that allows users to create blog posts, and has three associated views. We might have the following buttons, and content sections:

<button id="btnCompose">Compose</button> <button id="btnPreview">Preview</button> <button id="btnPost">Post</button>  <div id="blogCompose">      <h1>Blog Compose</h1> </div> <div id="blogPreview" class="hide">      <h1>Blog Preview</h1> </div> <div id="blogPost" class="hide">      <h1>Blog Post</h1> </div> 

In jQuery, we would typically have to get all our buttons and assign a click handler that manages the display of the content (probably using a class attribute). Given the above HTML markup, our jQuery might look something like this:

$('button').on('click', function() {      var target = $(this).attr('id'); });  if (target == '#btnCompose') {      $('#blogCompose').removeClass('hide');      $('#blogPreview, #blogPost').addClass('hide'); } else if (target == '#btnPreview') {      $('#blogPreview').removeClass('hide');      $('#blogCompose, #blogPost').addClass('hide');  } else if (target == '#btnPost') {      $('#blogPost').removeClass('hide');      $('#blogCompose, #blogPreview').addClass('hide');  } 

We’re getting all the buttons on the page, and finding their id attribute. We then conditionally add or remove classes based on which button we’re clicking. The major drawback here is that it relies heavily on the structure of the HTML. If the HTML structure changes in the future, the jQuery selectors all have to be rewritten. Let’s take a look at how we might convert this to AngularJS.

First, here’s how we would change the markup:

<button id="btnCompose" ng-click="composeBtn()">Compose</button> <button id="btnPreview" ng-click="previewBtn()">Preview</button> <button id="btnPost" ng-click="postBtn()">Post</button>  <div id="blogCompose" ng-show="state.blogCompose">      <h1>Blog Compose</h1> </div> <div id="blogPreview" ng-show="state.blogPreview">      <h1>Blog Preview</h1> </div> <div id="blogPost" ng-show="state.blogPost">      <h1>Blog Post</h1> </div>  

You’ll notice two main changes here. First, we added what looks like an 'ng-click’ attribute to the buttons. ngClick is an Angular directive that calls a function in the associated controller. Next, we removed the classes from the content, and replaced with ngShow. ngShow is another Angular directive that shows or hides content based on its value. In this case, the values are state.sectionName. We’ll see what the state values are when we get to the JavaScript.

For now, take a moment and compare the jQuery and Angular HTML. The Angular markup gives you clues that clicking a button calls a function (and once you know more about Angular, you’ll know instinctively this function will live in the controller associated with this section of the DOM), while the jQuery buttons could have associated click handlers, but we don’t know without looking through the JavaScript, and we don’t have any assumptions about where those click handlers might reside in our JavaScript.

The “hide” classes we use with jQuery do communicate functionality, but can’t actually accomplish anything functionally. They’re more than likely associated with a CSS class with the display property set to “none”. The Angular ngShow directive allows us to define any number of conditions for the display of the content sections, and like ngClick, we know to look for this functionality in our associated controller.

Given this Angular markup, you might find the associated code in our controller for managing the application’s state:

//Defaults, page load $scope.state = {   blogCompose: true,   blogPreview: false,   blogPost: false }; //Manage state per button $scope.composeBtn = function () {   $scope.state.blogCompose = true;   $scope.state.blogPreview = false;   $scope.state.blogPost = false; };  $scope.previewBtn = function () {   $scope.state.blogCompose = false;   $scope.state.blogPreview = true;   $scope.state.blogPost = false; };  $scope.postBtn = function () {   $scope.state.blogCompose = false;   $scope.state.blogPreview = false;   $scope.state.blogPost = true; }; 

Here, we set the default state so the “compose" content is shown. This is what will be displayed when the app initially loads. We then manage the display of the content through functions assigned to the buttons. The “magic” here is that Angular handles assigning the functions to the buttons, and the state of the app. When we set the state property to either true or false, Angular knows to show or hide the associated content, via the ng-show directive in our markup.

The real beauty here is that we as developers aren’t responsible for parsing the DOM and making sure we have the right buttons or content sections based on the DOM structure. There’s no conditional logic in our JavaScript; we define a few variables and functions, and Angular takes care of the rest.

This is a very simple example, but you can imagine how it can make things easier as the size of your app scales and you have multiple developers changing your HTML markup. It not only makes it less error-prone, but its easier to understand what’s going on simply by reading the HTML or JavaScript, without having to actually run the app and interact with it.

I’ve created a functional JSFiddle demonstrating the AngularJS version, if you’re interested in seeing it in action: http://jsfiddle.net/xna5odq7/1/

• Read more about 5 Apps for Sanity this Season!

Paperless Post | For planning.

Paperless Post is an ecommerce company with a focus on design-driven online and printed stationery. E-cards can often feel subpar to the “real thing”, with personality driven options though, Paperless Post makes the digital card world aesthetic and beautiful. In addition, not only are the cards custom and unique, but PP offers a variety of features from tracking and internal updates to community event boards.

Uber | For time.

If you haven’t heard of these guys yet - you’re missing out. Uber is an on-demand taxi service that can be requested at any moment. Got a relative coming into town, but nobody to pick them up? Request an UberX for them via your phone and give your relative minute by minute updates as to the ETA of their car’s arrival.

Airbnb | For space.

Yes, we love our families, but sometimes extended stays can be a bit stressful. This year, why not book an Airbnb in the area? It’s better than a hotel, will give you space after hours with Uncle Arty, and will keep the family in a happy, stress-free state.

Seamless | For the inevitable hangry moments.

Seamless is your personal delivery food site and as the name would suggests - takes the headache out of online orders. With Seamless you can search for restaurants in your area, create an order, pay online, and get updates on your delivery status by the minute.

YogaStudioApp | For your health.

If there’s any time you shouldn’t skip out on health - it’s the holidays. Make time to take care of yourself. YogaStudioApp is a great resource with custom workouts based on the # of minutes you’ve got, your experience level, and the space you’re in. There’s no excuse, take time to refocus and keep yourself healthy!

What's your favorite app for the holidays? We'd love to hear from you!

• Read more about NASA Launches Orion On First Step to Mars

At 7:05am EST today, the world watched as NASA released its unmanned spacecraft, Orion, into the ether. With Captain Kirk (in doll form) at the helm, the massive capsule soared from Cape Canaveral with countless hopes attached. This new spaceship was built with one goal in mind: deep space exploration.

Orion’s 4.5 hour flight test was a critical step toward eventual near-Earth asteroid excursions, trips around the moon, and--most significantly--manned missions to Mars. That's right: with the success of Orion's launch would come “the beginning of the Mars era,” as NASA Administrator, Charles Bolden, remarked before blastoff.

And succeed it did! Completing two orbits and going farther than all rockets designed to carry astronauts have in the past four decades, Orion passed with flying colors, and landed in the Pacific Ocean at 11:29 this morning. Our biggest congratulations to NASA on an incredibly successful flight test! Mobomo is proud to be part of the team supporting NASA.gov.

• Read more about Happy (git) Trees

We all know Bob Ross (above) and his fascination with "Happy Little Trees" (or maybe that's my fascination). In any case, we can all take some advice from Bob and keep our Git trees happy.

If you took a look at your current project's git tree (through a tool maybe like Gitx) I bet it would look something like this:

Now I don't know about you, but that is really hard for me to follow. I can get the general picture, that there are some branches that merged back into master, but then there's some branching off of branches and merges between branches; I can't really tell what story the git tree is trying to tell.

Why do we care about "Happy Trees"?

It is my view of git that all of your commits should tell a story of new functionality. This lets your coworkers or, as in the case of Intridea, clients see very plainly the set of commits that led to a feature being added to the application. It potentially lets less experienced developers see what steps you took to add a feature, and shows your train of thought on how you went from 0 to feature (hero).

Essentially, keeping a happy and clean git tree is about communication.

What does a Happy (git) tree look like?

Great question! Everyone has their own opinions on what a happy and clean git tree looks like (well, some have no opinion at all); this is my opinion on what a happy and clean tree might look like:

I created this by just initializing a blank git repository and making some commits on master and two different branches. As you can see, it's clearly communicated what work occured on the branch and what commits happened directly on master. This makes it very easy to track down a potential bug, and which commit or merge may have caused it. Also, this makes it very easy to revert an entire feature should it no longer be wanted or if it's causing bugs. All you need to do is revert the merge commit and like magic, the feature is gone.

How do 'I' make my own Happy (git) trees?

Another AMAZING question! You too can have happy little (git) trees, just follow the guidelines below:

• If you are working on a feature that takes more than one commit to implement (you are keeping small commits, right?), make a git branch git checkout -b <branch_name> and do all of your coding on there.
• Before you are ready to merge it back into master, rebase it off of master git fetch && git rebase origin/master.
  • Essentially what a rebase does (if you do not already know) is rewrite your branch's git history by removing your commits, updating your branch so that it's the same as master then replaying your commits one at a time on top of the new HEAD. Note: For a more complete visual explanation of git rebase please see this.
• When you are ready to merge your feature branch back into master, you can check out master git checkout master, update master via git rebase origin/master, and merge your branch using the "no fast forward" option git merge --no-ff <branch_name>
  • What the --no-ff option does is not replay your commits back onto master, but instead makes a merge commit of all the changes in your branch (It should be noted that this is what a GitHub Pull-request does)

A bit more about git rebase and conflicts

Often, if you are working on a team, you will have conflicts when you rebase your branch from master. This is fine--do not panic--it just means that another person updated the same code you did and merged it in before you. What will happen then is the rebase will stop in the middle and you will have to manually fix the conflicts. If you type in git status it will show you which files have conflicts, you can simply open them and see which changes you made that are in conflict with the changes on master (which will be denoted with <<<<<< and ========), then add or delete the code necessary to incorporate both changes in the code (if necessary). Once you are done fixing the conflicts (this includes deleting the <<<< and ==== mark up), go back to the command line and type git add . then git rebase --continue to continue along your path to having a happy (git) tree.

It is for this reason that if I am working on a feature branch, I rebase it after almost every commit, just to make sure I am kept up to date with master. I don't like fixing conflicts, and this ensures that I have as few of them as possible at one time.

Now, a bit more about GitHub and rebasing

If you are like me, you use GitHub to store your code, and you use pull requests on GitHub to have someone review your code (you are having someone review your code, right?). In order to take advantage of GitHub and git rebase you will need to rebase your branches before you make a pull request, otherwise you could end up with a spaghetti like tree as shown above.

Keep the conversation going! We'd love to hear from you!

• Read more about Dear Maggie Series: Health + Happiness

Dear Maggie,

When it comes to the winter season, I am all the more grateful I get to skip the commute and work from home! Nothing beats waking up to snow, and knowing you don’t have to leave your cozy house to get work done.

There’s just one thing - it seems there’s a direct correlation with the increase in my waistline and the decrease in my commute. Incorporating exercise into my daily routine has become increasingly difficult as the reasons for leaving the house have continued to diminish. Help! Do you have any tips for staying fit while working from home?

Frustrated in Frisco

Howdy Frustrated,

You are not alone! It’s so easy to develop an unhealthy routine while working from home. Not only do you move less in a day, but you’re also within easy reach of that lovely space called kitchen.

In my experience, the key to staying fit is pinpointing the problem areas and identifying a solution that works for you. Here are a few tactics I’ve found successful throughout the years. Granted, while there’s no “one size fits all” these tips are definitely a step in the right direction.

Track your activity.

There are lots of options out there, the Fitbit Flex, the Misfit Shine, “UP” by Jawbone, and even most newer phones have some sort of built-in step tracker. Utilize these programs to track exactly how much activity you’re getting in a day. You can set daily goals for yourself, and even compete against friends and family in order to increase your accountability.

Track your calories.

You shouldn’t have any trouble finding a calorie tracking app on your favorite smartphone. Weight Watchers has an application to match their very successful program, MyFitness Pal can track your activity as well, and MyPlate by livestrong.com makes entries on the go a breeze. And if all else fails, go old fashion and keep a food diary. Simply forcing yourself to write down what you eat has an amazing effect on your calorie consumption and eating habits.

Get a workout buddy.

Anyone can create a gym schedule, but its all too easy to skip out when no one is expecting you there. Find a friend looking to go to the gym, and coordinate your schedules. Not only does this open up the possibility of ride-sharing, but at many gyms “couple” memberships offer a great discount vs. individual memberships, and you usually don’t have to kiss the other person to get the discount.

Put your desk to work.

This one might seem silly, but you’d be surprised how much exercise you can fit in WHILE you work. Keep a set of free-weights near your desk and take calls while doing a few lunges. Got a yoga mat? Set your computer to alert you every few hours for a 5-10 minute yoga break. Or why not invest in a standing desk? Whatever it is - you’ve got time - you’ve got the resources - you just have to get creative and discipline yourself to do it.

Pre-plan your hanger.

When it comes time to feed yourself, the easiest worm always gets eaten first and it’s usually disguised in sugary-salty goodness. My best advice for overcoming hanger snacking: buying healthy foods and planning your meals and snacks in advance. Apps like ShopWell allow you to scan the barcodes of items you’re considering for purchase so you can see healthier (and sometimes cheaper!) alternatives. If your problem is inspiration, Su Chef provides healthy recipes (by ingredient), or Blue Apron will deliver all the ingredients and recipe you need for an exciting meal. When you spend a little extra time pre-portioning and preparing - you give yourself a fighting chance for picking the healthier option.

Breaking old habits and getting into a healthy routine can be done! Just remember, working from home should enable a healthy work-life balance, not be an excuse for ignoring it. Take advantage of your work situation, find creative ways to stay active, and have fun doing it!

Got an idea for our next post? Send your burning questions, feedback, or suggestions over to dearmaggie@intridea.com! We'd love to hear from you.

Also, check out Dear Maggie's advice on relationships and working remotely.

• Read more about Ezra Zygmuntowicz

Ezra Zygmuntowicz passed away last week. A titan in the Rails community, Ezra co-founded Engine Yard and was the original developer of the Merb framework.

Ezra was crazy smart, scary smart and spoke with equal felicity about code, 3D printing, and glass blowing. In an industry where intelligence positively correlates with arrogance, Ezra was unfailingly humble and always made time to share his knowledge.

It's no secret that Ezra's personal and health issues limited his career after an early promise. After winding down his 3D printing company Trinity Labs, Ezra served as CTO at Intridea before going on to co-found Stuffstr. If he was unable to complete the projects he started late in life, he was still smart enough to ask the right questions at the right time.

Ezra was questing to the end. I last heard from him two weeks ago when he reached out to me with an idea for a mobile app. His death is a loss to the community, and I will miss him.