In development, there’s a delicate balance between Not Invented Here, and making sure you’re using the right tool for the job.

# We'll need these variables later
win = $(window)
curScrollPos = 0
winHeight = win.height()

# Cache all the elements we want to parallaxify
parallaxElements = $('.parallax')

# Figure out if we need to add a browser prefix for CSS transforms
styles = window.getComputedStyle(document.documentElement, '')
stylePrefix = (Array.prototype.slice.call(styles).join('').match(/-(moz|webkit|ms)-/) || (styles.OLink == '' && ['', 'o']))[1]

# This function gets called whenever a user scrolls (or `touchmove`s) the page
scrollHandler = ->
  for parallaxElement in parallaxElements
    # Re-jQueryify the element
    # This could be sped up by not using jQuery, but it's already quite performant on desktop and mobile
    parallaxElement = $(parallaxElement)
    pOffset = plaxable.offset()
    pRand = plaxable.data('rand')

    # Add a `bottom` property to the element's offset
    pOffset.bottom = pOffset.top + plaxable.outerHeight()

    # If this element hasn't already been assigned a parallax randomizer, create one for it
    # This makes sure elements scroll at slightly different speeds to enhance the "layered" effect
    if !pRand
      pRand = Math.random() * (1.3 - 0.7) + 0.7
      plaxable.data('rand', pRand)

    #  We only want to adjust elements that are currently on screen
    if pOffset.bottom >= curScrollPos && pOffset.top <= curScrollPos + winHeight + 100
      # Actually calculate and set the transform
      newYOff = Math.min -((curScrollPos + winHeight - pOffset.top) * 0.1) * pRand, 0
      # Directly accessing an element's `style` property is significantly faster than using `jqObject.css(…)`
      plaxable[0].style["#{stylePrefix}Transform"] = "translate3d(0, #{newYOff}px, 0)"

# Kick everything off!
$(document).on 'ready', ->
  win.on 'resize', -> winHeight = win.height()
  win.on 'scroll touchmove touchend', scrollHandler
  scrollHandler()

rails g model global_config singleton_guard:integer

class GlobalConfig < ActiveRecord::Base
  validates :singleton_guard, presence: true, uniqueness: true, numericality: {equal_to: 1}
  before_validation :set_singleton_guard

private
  def set_singleton_guard
    self.singleton_guard = 1
  end
end

Once you’ve got this base, you need a nice way to actually access the config model from your controllers and views. I added this bit to my ApplicationController:

class ApplicationController < ActionController::Base
  …

private
  def global_config
    @global_config ||= GlobalConfig.first || GlobalConfig.new

    return @global_config
  end
  helper_method :global_config
end

From there, you can simply call global_config from any controller or view. By using an instance variable, we ensure that no matter how many times you access the GlobalConfig this way, it will only make one database call per request cycle.

Now that you’ve got the configuration model all set up, you can add whatever you need (e.g., rails g migration add_newsletter_signup_cta_to_global_config newsletter_signup_cta:string). Since it’s just a normal Rails model, you can set up forms and validation the same way you would for anything else. Using this pattern, clients can easily swap text, images, toggle site features, and more.

nvALT is a beautifully simple application that lets you write plain text notes about anything. Its main trick is letting you create or search for notes without having to manually manage creating or saving files; everything happens directly from the search bar at the top. If I need to take down contact information, I can just type "James Hobbs", hit enter, and immediately start typing phone numbers, company names, or any other relevant information.

Since all files are saved as plain text, they can easily be synced via your service of choice, and edited on any platform (right now, I’m using Editorial on iOS). By writing my notes using Markdown syntax, I can also instantly convert them to beautiful HTML or PDF documents using Marked. This gives me an incredible workflow that scales from one-liner code snippets to documentation for clients; all with no barrier to just start writing.

If you’re a Mac user streaming with Twitch, you should check it out: ViewMaster for Twitch.

Splitting your assets up into smaller page- or module-based files makes for more reusable and maintainable code. Grind is a tool I made to help combine these files before serving them to the browser.

Automatically combining these files saves you work. You don’t have to manually include every file in your HTML, and if you’re dealing with SCSS or CoffeeScript, you don’t have to have another build step to compile them. It’s also beneficial for your users, since fewer HTTP requests means the site will load faster.

Assume you’re building a site with the following directory structure:

index.html
about.html
src/
    js/
        home.js
        about.coffee
    css/
        global.scss
        mixins.scss
        home.scss
        about.scss

You can use a Grindfile something like this (placed in your project root, or anywhere relative to the files you want it to process) to process your assets and get them ready for the browser:

{
    "paths": [
        "src/js"
    ],
    "hint": true,
    "uglify": true,
    "out": "site.js",
    "before": "sass src/css/global.scss:css/site.css"
}

This will combine, hint, and uglify all JavaScript and CoffeeScript files inside src/js, and use the sass command line utility to process and output src/css/global.scss as standard CSS.

Inside global.scss, you can simply @import the other files, and easily get a single CSS file to serve to browsers:

@import "mixins.scss";
@import "home.scss";
@import "about.scss";

If you’ve got Node.js installed, you can easily install Grind with NPM: sudo npm install grind -g. Once that’s done, just create a Grindfile in your project and run grind from the command line in that directory.

Good "pixel design" is, of course, very important; it has been one of the main ways to provide the "user delight" that designers strive for ever since the first GUI. Very few companies outside of tired examples like Google and Craigslist can even attract users without good design to help sell the product. But computers are now powerful enough to provide that same sense of delight in other ways, one of which is the use of motion, which provides visual interest and context without drawing attention away from the content. iOS 7 utilizes motion in almost every interaction; the parallax effects throughout the system, elastic trays, and home screen icon zooming just scratch the surface.

As I type this into Vesper, I’m struck by just how much care has gone into what is truly "as little design as possible". Subtle, well-considered animation and gorgeous typography help create the same sense of wonder that the most ornamental apps inspire on first load, but instead of just being nice to look at, they also improve the actual usage of the application. Every decision that the Q Branch team made serves to make writing more enjoyable; all the design is in service of helping me actually write words on the page. The true soul of every application is its user experience.

Until iOS 7, app design on iOS had been becoming progressively more complex and ornamental; nearly fetishistic. The sudden turnaround isn’t a rejection of beautiful design, it’s a return to caring more about the photograph than the frame.

Within four minutes, one kid … found the on/off switch. He’d never seen an on/off switch. He powered it up. Within five days, they were using 47 apps per child per day. Within two weeks, they were singing ABC songs [in English] in the village.

h/t Dion Almaer

Shlok:

They want you to come in, they want you to put on a suit while you do it. … [Because] they don’t have real jobs. … Those guys are in there, they’re in their suits, and they want you in there, in your suit, doing Suit Things that they can make sure you’re doing.

"What, you wrote 40 lines of code today? I don’t care what it does, you wrote forty; I need fifty".

Interested? You should know HTML, CSS, and JavaScript like the back of your hand. Being deeply familiar with things like templating languages, CSS preprocessors, and CoffeeScript is also critical, as is a constant drive to always be improving yourself. If you think you’ve got what it takes, you should get in touch.

Linux is the canonical open source success story. It succeeded for reasons that are now so boring they’re accepted as common sense. There’s still plenty of room for variation and innovation, but now all the significant achievements are shared with the world. If a company improves Linux, it’s not just improving its own products; it’s making Linux better for everyone.

Everyone gets money equal to what the Government claims is the minimum income for subsistence. No questions asked. Want to sit on your ass? The Government [will] cut you a check for $14.5k per year. After that you’re on your own - no WIC, no subsidized rents, and so on.

I have no idea what kind of social and economic effects this would have, but it would be fascinating to compare against the cost of all the social programs and subsidies it would replace.

It’s not a stretch to imagine that you could immediately be identified by [a] Google Glass user who gets on the bus and turns the camera toward you. Anything you say within earshot could be recorded, associated with the text, and tagged to your online identity. And stored in Google’s search index. Permanently.

Interesting thoughts on a possible dystopian future, starting with Google Glass. This isn’t something that concerns me personally (at least not at the moment), but it’s definitely important to keep in mind as wearable computing becomes more prevalent.

h/t Scott Hanselman

I’ve seen the still-in-progress full set; you’ll definitely want to keep your eye on these.