The Twelve-Factor App

The Twelve-Factor App is a set of golden rules for web-based applications:

In the modern era, software is commonly delivered as a service: called web apps, or software-as-a-service. The twelve-factor app is a methodology for building software-as-a-service apps that:

  • Use declarative formats for setup automation, to minimize time and cost for new developers joining the project;
  • Have a clean contract with the underlying operating system, offering maximum portability between execution environments;
  • Are suitable for deployment on modern cloud platforms, obviating the need for servers and systems administration;
  • Minimize divergence between development and production, enabling continuous deployment for maximum agility;
  • And can scale up without significant changes to tooling, architecture, or development practices.

The twelve-factor methodology can be applied to apps written in any programming language, and which use any combination of backing services database, queue, memory cache, etc.

via The Twelve-Factor App.

Google’s AngularJS Style Guide

Google have published their internal AngularJS Style Guide. It contains language and style rules, a basic naming convention (i.e. don’t use $ as a variable prefix), test-driven recommendations (use Jasmine and Karma), a link to newly-published directory structure recommendations, a guide to scope and prototypal inheritance and an ngInject example.

VelocityConf 2013 Videos

Velocity is the must-attend conference for web operations and performance professionals. Engineers and developers gather to explore the latest technologies, techniques, and best practices around resilience, optimization, mobile, cloud, metrics, and more.

This trove of videos contains gems concerning Continuous Delivery, Testing across the stack, Web Performance and more.

High Performance Browser Networking

Google web performance engineer Ilya Grigorik has put together the definitive tome on bleeding-edge, high speed web apps. The book is packed with information on performance optimization best practices for TCP, UDP, and TLS protocols, and explains unique wireless and mobile network optimization requirements:

How prepared are you to build fast and efficient web applications? This eloquent book provides what every web developer should know about the network, from fundamental limitations that affect performance to major innovations for building even more powerful browser applications—including HTTP 2.0 and XHR improvements, Server-Sent Events (SSE), WebSocket, and WebRTC.

It’s free in HTML format via Velocity Conference.

The Words of Martin Fowler

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

Martin Fowler’s Wikiquote page is a diamond mine of aphorisms.

Often designers do complicated things that improve the capacity on a particular hardware platform when it might actually be cheaper to buy more hardware.

Analysis Patterns: Reusable Object Models, 1997

Modeling Principle: Models are not right or wrong; they are more or less useful.

Refactoring: Improving the Design of Existing Code, 1999

When you find you have to add a feature to a program, and the program’s code is not structured in a convenient way to add the feature, first refactor the program to make it easy to add the feature, then add the feature.

When you feel the need to write a comment, first try to refactor the code so that any comment becomes superfluous.

The key is to test the areas that you are most worried about going wrong. That way you get the most benefit for your testing effort. It is better to write and run incomplete tests than not to run complete tests.

UML Distilled: A Brief Guide to the Standard Object Modeling, 2004

Comprehensiveness is the enemy of comprehensibility.

Martin Fowler deserves a knighthood.