&yet blog

people

$ git clone --recursive https://github.com/andyet/blog.andyet.com.git
$ cd blog.andyet.com
$ npm install
$ npm start
const WebRTC = require('react-native-webrtc');
const {
  RTCPeerConnection,
  RTCIceCandidate,
  RTCSessionDescription,
  getUserMedia,
} = WebRTC;
global.window = global.window || {};
global.window.WebSocket = WebSocket;
global.window.RTCPeerConnection = RTCPeerConnection;
global.RTCPeerConnection = RTCPeerConnection;
global.RTCSessionDescription = RTCSessionDescription;
global.RTCIceCandidate = RTCIceCandidate;
<body class='home'>
  <nav class='main-nav'>
    <a class='nav-home' href='/'>Home</a>
    <a class='nav-web' href='/web'>Web</a>
    <a class='nav-art' href='/art'>Art</a>
    <a class='nav-about' href='/about'>About</a>
    <a class='nav-thoughts' href='/thoughts'>Thoughts</a>
  </nav>

  <h1>
    <span class='name'>Lynn Fisher</span>
    <span class='desc'>artist and designer from Phoenix, Arizona</span>
  </h1>

  <p class='intro'>
    <span>I make things for the web and for walls.</span>
    <span>I specialize in light-hearted projects that make people say, “I don’t get it.”</span>
    <span>Yes, I’ve heard of SVG.</span>
  </p>

  <picture class='lynn'>
    <source srcset='/assets/images/lynn-small.png' media='(max-width: 1400px)'>
    <source srcset='/assets/images/lynn.png'>
    <img src='/assets/images/lynn.png', alt='a photo of the artist'>
  </picture>
</body>
📁 _styl
  📁 components
  📁 globals
  📂 pages
    📄 about.styl
    📄 home.styl
    📄 thoughts.styl
    📄 work.styl
  📄 main.styl
📁 _styl
  📂 pages
    📂 home
      📄 fallback.styl
    📄 home.styl
  📄 main.styl
/* home.styl */

@import 'home/fallback'

@supports (display: grid)
  body.home
    [base styles here]
📁 _styl
  📂 pages
    📂 home
      📄 b-and-w-and-gold-all-over.styl
      📄 big-nav.style
      📄 big.styl
      📄 blockhead.styl
      📄 bolt.style
      📄 cutout.styl
      📄 diagonal.styl
      📄 disguise.styl
      📄 fallback.styl
      📄 fifty-fifty.styl
      📄 half.styl
      📄 L-Y-N-N.styl
      📄 landscape.styl
      📄 movie.styl
      📄 pop-out.styl
      📄 rotate.styl
      📄 stranger.styl
      📄 third.styl
      📄 triangle.styl
      📄 white-bars.styl
      📄 white-box.styl
      📄 x.styl
    📄 home.styl
  📄 main.styl
/* home.styl */

@supports (display: grid)
  body.home
    [base styles here]

  @media screen and (max-width: 400px)
    @import 'home/diagonal'

  @media screen and (min-width: 401px) and (max-width: 500px)
    @import 'home/L-Y-N-N'

  @media screen and (min-width: 501px) and (max-width: 600px)
    @import 'home/blockhead'

  + 18 more (2300px being the widest media query)
{
    "meta": {
      "location": "header",
    },
    "routes": {
      "include": ["/cats"]
    }
  }
}
const server = new Hapi.Server(Config.hapi);
const Muckraker = require('muckraker');
const db = new Muckraker({/* put your db config here*/});
server.bind({ db }); //Allows route handlers to access the database through this.db
server.route({ method: 'GET', path: '/cats', config: {
  description: 'Pagination example',
  plugins: {
    pagination: {
      enabled: true
    }
  },
  validate: {
    query: {
      limit: Joi.number().default(10).min(1).max(100), //Set a sensible default and max page size
      page: Joi.number().positive() //Make sure they can't give a page number that would create a negative offset
    }
  },
  handler: function (request, reply) {

    const params = Object.assign({}, request.query);
    params.offset = (params.page - 1) * params.limit;
    const result = this.db.cats.count(params).then((cat_count) => {

      request.totalCount = cat_count.count;
      return this.db.cats.all(params);
    });

    return reply(result);
  }
});
--cats_one_count.sql
select count(*)::integer as count from cats
--cats_all.sql
select * from cats order by name limit ${limit} offset ${offset}
const link = response.headers.link; //Link header from the response, may look different in your framework
const links = {};

if (link) {
  link.replace(/<([^>]*)>;\s*rel="([\w]*)\"/g, function(m, uri, type) {
    links[type] = uri;
  });
}

this.links = links; //Set a links attribute on this collection, may look different in your framework
next: function () {

  if (this.links.next) {
    this.fetch({ url: this.links.next, reset: true }); //Backbone style fetch, may look different in your framework
  }
},
prev: function () {

  if (this.links.prev) {
    this.fetch({ url: this.links.prev, reset: true });  //Backbone style fetch, may look different in your framework
  }
}
{
  "name": "@fritzy/comments",
  "version": "0.1",
  "main": "index.js"
}
'use strict';

const config = require('getconfig');
const Hapi = require('hapi');

const server = new Hapi.Server();
server.connection(config.hapi.connection);

server.register([
  {
    register: require('good'),
    options: {
      reporters: [{
        reporter: require('good-console'),
        events: {
          response: '*',
          log: '*'
        }
      }]
    },
  },
  {
    // here we require our microservice as a controller
    // you'd require('@fritzy/comments') in any other project
    register: require('./index'),
    options: config
  }
], (err) => {

  if (err) {
    throw err; // something bad happened loading the plugin
  }
  server.start((err) => {

    if (err) {
       throw err;
    }
    server.log('info', 'Server running at: ' + server.info.uri);
  });
});
'use strict';

const Comments = require('./handlers/comments');

// options is the config that we passed in server.js
module.exports = function (plugin, options, next) {

  const db = require('pg')(options.db);
  plugin.bind({
    db: db
  });

  plugin.route({
    method: 'get',
    path: '/',
    config: Comments.list
  });
  plugin.route({
    method: 'get',
    path: '/{id}',
    config: Comments.get
  });
  plugin.route({
    method: 'post',
    path: '/',
    config: Comments.create
  });
  plugin.route({
    method: 'put',
    path: '/{id}',
    config: Comments.update
  });
  plugin.route({
    method: 'delete',
    path: '/{id}',
    config: Comments.delete
  });  

};
server.register([
  // ...
  {
    register: require('@fritzy/comments'),
    routes: {
      prefix: '/comments'
    },
    options: config
  }
]);
CREATE EXTENSION IF NOT EXISTS "pgcrypto";
-- Create a trigger function that takes no arguments.
-- Trigger functions automatically have OLD, NEW records
-- and TG_TABLE_NAME as well as others.
CREATE OR REPLACE FUNCTION unique_short_id()
RETURNS TRIGGER AS $$

 -- Declare the variables we'll be using.
DECLARE
  key TEXT;
  qry TEXT;
  found TEXT;
BEGIN

  -- generate the first part of a query as a string with safely
  -- escaped table name, using || to concat the parts
  qry := 'SELECT id FROM ' || quote_ident(TG_TABLE_NAME) || ' WHERE id=';

  -- This loop will probably only run once per call until we've generated
  -- millions of ids.
  LOOP

    -- Generate our string bytes and re-encode as a base64 string.
    key := encode(gen_random_bytes(6), 'base64');

    -- Base64 encoding contains 2 URL unsafe characters by default.
    -- The URL-safe version has these replacements.
    key := replace(key, '/', '_'); -- url safe replacement
    key := replace(key, '+', '-'); -- url safe replacement

    -- Concat the generated key (safely quoted) with the generated query
    -- and run it.
    -- SELECT id FROM "test" WHERE id='blahblah' INTO found
    -- Now "found" will be the duplicated id or NULL.
    EXECUTE qry || quote_literal(key) INTO found;

    -- Check to see if found is NULL.
    -- If we checked to see if found = NULL it would always be FALSE
    -- because (NULL = NULL) is always FALSE.
    IF found IS NULL THEN

      -- If we didn't find a collision then leave the LOOP.
      EXIT;
    END IF;

    -- We haven't EXITed yet, so return to the top of the LOOP
    -- and try again.
  END LOOP;

  -- NEW and OLD are available in TRIGGER PROCEDURES.
  -- NEW is the mutated row that will actually be INSERTed.
  -- We're replacing id, regardless of what it was before
  -- with our key variable.
  NEW.id = key;

  -- The RECORD returned here is what will actually be INSERTed,
  -- or what the next trigger will get if there is one.
  RETURN NEW;
END;
$$ language 'plpgsql';
CREATE TABLE test (id TEXT PRIMARY KEY, name TEXT);

-- We name the trigger "trigger_test_genid" so that we can remove
-- or replace it later.
-- If an INSERT contains multiple RECORDs, each one will call
-- unique_short_id individually.
CREATE TRIGGER trigger_test_genid BEFORE INSERT ON test FOR EACH ROW EXECUTE PROCEDURE unique_short_id();
INSERT INTO test (name) VALUES ('cheese'), ('ham'), ('turkey'), ('chicken');
SELECT * FROM test;
    id    |  name
----------+---------
 Ixw1yIj7 | cheese
 SXq0jZ-q | ham
 KKWXEtBu | turkey
 DRRXFs1U | chicken
(4 rows)
curl -o data.json "https://api.nasa.gov/patents/content?limit=10000&api_key=DEMO_KEY"
{"count": 1324, "results": [
  {
    "category": "materials and coatings",
    "client_record_id": "patent_ARC-14661-3",
    "center": "ARC",
    "eRelations": [],
    "reference_number": "ARC-14661-3",
    "expiration_date": "",
    "abstract": "Method and system for functionalizing a collection ...",
    "title": "Selective functionalization of carbon nanotubes ..."
    "innovator": [
      {
        "lname": "Khare",
        "mname": "N.",
        "company": "SETI Institute"
        "order": "1"
        "fname": "Bishun"
      }, {
        "lname": "Meyyappan",
        "company": "NASA Ames Research Center",
        "order": "2",
        "fname": "Meyya"
      }
    ],
    "contact": {
      "office": "Technology Partnerships Division",
      "facility": "NASA Ames Research Center",
      "email": "Trupti.D.Sanghani@nasa.gov",
      "name": "Trupti D. Sanghani",
      "address": "Mail Stop 202A-3, Moffett Field, CA 94035"
    },
    "publication": null
    "concepts": {
      "1": "Fundamental physics concepts",
      "0": "Metric space",
      "3": "Carbon",
      "2": "Temperature",
      "5": "Carbon nanotube",
      "4": "Gas",
      "7": "Topology",
      "6": "Ionizing radiation"
    },
    "serial_number": "11/387,503",
    "_id": "53f65b3d5904da2c9fc3008f",
    "patent_number": "7767270",
    "id": "patent_ARC-14661-3",
    "trl": "3 - Proof-of-concept"
  },
  ...
]}
CREATE DATABASE nasa_patents;
\connect nasa_patents;

CREATE TABLE patents (
	id TEXT PRIMARY KEY,
	data JSONB,
	created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(),
	updated TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now()
);
CREATE OR REPLACE FUNCTION update_modified_column()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated = now();
    RETURN NEW;
END;
$$ language 'plpgsql';

CREATE TRIGGER trigger_patents_updated BEFORE UPDATE ON patents
  FOR EACH ROW EXECUTE PROCEDURE update_modified_column();
'use strict';

const data = require('./data.json');
const pg = require('pg-promise')({});

const db = pg('postgres://localhost/nasa_patents');
db.tx((tx) => {
  const queries = [];
  for (let row of data.results) {
    queries.push(tx.query(`INSERT INTO patents (id, data)
      VALUES ($1, $2)
      ON CONFLICT (id) DO UPDATE SET data=$2`, [row._id, row]))
  }
  return tx.batch(queries);
}).catch((err) => {
  console.log(err);
  console.log(err.stack);
  pg.end();
}).then(() => {
  console.log('done');
  pg.end();
});
'use strict';

const data = require('./data.json');
const pg = require('pg-promise')({});

const db = pg('postgres://localhost/nasa_patents');
db.tx((tx) => {
  const queries = [
    tx.none('DROP TABLE IF EXISTS _patents_incoming'),
    tx.none(`CREATE TABLE _patents_incoming (
      id TEXT PRIMARY KEY NOT NULL, data JSONB
    )`)
  ];
  for (let entry of data.results) {
    queries.push(tx.none(`INSERT INTO _patents_incoming (id, data)
      VALUES ($1, $2)`,
      [entry._id, entry]));
  }
  queries.push(tx.tx((tx2) => {
    const queries2 = [
      tx.none(`DELETE FROM patents USING patents AS p1
        LEFT OUTER JOIN _patents_incoming AS p2 ON p1.id=p2.id
        WHERE patents.id=p1.id AND p2.id IS NULL`),
      tx.none(`INSERT INTO patents SELECT * FROM _patents_incoming
        ON CONFLICT (id) DO UPDATE SET data=(
        SELECT data FROM _patents_incoming WHERE id=patents.id)`)
    ];
    return tx2.batch(queries2);
  }));
  return tx.batch(queries);
}).catch((err) => {
  console.log(err);
  console.log(err.stack);
  pg.end();
}).then(() => {
  console.log('done');
  pg.end();
});
CREATE OR REPLACE FUNCTION GetPatent(in_id TEXT)
RETURNS SETOF patents AS $$ BEGIN
	RETURN QUERY SELECT * from patents WHERE id=in_id LIMIT 1;
END;
$$ language 'plpgsql';

select data->>'category' category
  FROM getpatent('53f656f85904da2c9fc2fe6b');
--aeronautics

CREATE OR REPLACE FUNCTION PutPatent(in_data JSON)
RETURNS TEXT AS $$
DECLARE
	r_id TEXT;
BEGIN
	INSERT INTO patents (id, data) VALUES (in_data::JSONB->>'_id',
      in_data::JSONB)
    ON CONFLICT (id) DO UPDATE SET data=in_data::JSONB RETURNING id
      INTO r_id;
	RETURN r_id;
END;
$$ language 'plpgsql';

SELECT PutPatent('{"_id": "ham", "test": "value"}'); -- ham
ALTER TABLE patents ADD COLUMN category TEXT;

CREATE OR REPLACE FUNCTION normalize_patents_category()
RETURNS TRIGGER AS $$
BEGIN
	NEW.category := NEW.data->>'category';
	RETURN NEW;
END;
$$ language 'plpgsql';

CREATE TRIGGER trigger_patents_normalize_category
  BEFORE INSERT OR UPDATE ON patents FOR EACH ROW
  EXECUTE PROCEDURE normalize_patents_category();
CREATE TABLE innovators (
	fname TEXT,
	lname TEXT,
	mname TEXT,
	company TEXT,
	CONSTRAINT innovators_pkey
      PRIMARY KEY (fname, lname, mname, company)
);

CREATE OR REPLACE FUNCTION patents_to_innovators()
RETURNS TRIGGER AS $$
DECLARE
	nr innovators%rowtype;
BEGIN
	FOR nr IN
		SELECT (jsonb_populate_recordset(null::innovators,
          NEW.data->'innovator')).*
	LOOP
		nr.fname := COALESCE(nr.fname, '');
		nr.lname := COALESCE(nr.lname, '');
		nr.mname := COALESCE(nr.mname, '');
		nr.company := COALESCE(nr.company, '');
		INSERT INTO innovators (fname, lname, mname, company)
        (SELECT nr.*)
			ON CONFLICT ON CONSTRAINT innovators_pkey DO NOTHING;
	END LOOP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER trigger_patents_to_innovators
  AFTER INSERT OR UPDATE ON patents
  FOR EACH ROW EXECUTE PROCEDURE patents_to_innovators();
WITH RECURSIVE dtree(id, data) AS (
  SELECT id, data FROM objects WHERE id='some_id'
    -- specify the object to start with
UNION ALL
  SELECT modules.id, modules.data FROM modules
  JOIN dtree ON object.id=dtree.id
)
SELECT * FROM dtree;
CREATE TABLE dependencies (
  id INTEGER SERIAL,
  object_id TEXT,
  sub_dependency_id TEXT,
  CONSTRAINT dependencies_dupes
    UNIQUE (object_id, sub_dependency_id)
);

CREATE OR REPLACE FUNCTION objects_to_dependencies()
RETURNS TRIGGER AS $$
DECLARE
	nr dependencies%ROWTYPE;
BEGIN
	FOR object_cte IN
		SELECT jsonb_array_elements_text(NEW.data->'dependencies')
      AS sub_dependency_id,
      NEW.data->>'id' AS object_id
	LOOP
		INSERT INTO depenedencies (object_id, sub_dependency_id)
          (SELECT object_cte.*)
          ON CONFLICT ON CONSTRAINT dependencies_dupes DO NOTHING;
	END LOOP;
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER trigger_patents_to_innovators
  AFTER INSERT OR UPDATE ON patents
  FOR EACH ROW EXECUTE PROCEDURE patents_to_innovators();
WITH RECURSIVE  dtree(object_id, data, sub_dependency_id) AS (
  SELECT dependencies.object_id, objects.data,
    dependencies.sub_depedency_id
    FROM dependencies
    JOIN objects ON object.id=dependencies.object_id
    WHERE dependencies.sub_dependency_id='some_id'
UNION ALL
  SELECT objects.object_id, objects.data,
    dependencies.sub_dependency_id as dependency
    FROM dependencies JOIN dtree parent
      ON parent.object_id=dependencies.sub_dependency_id
    JOIN object ON object.object_id=dependencies.object_id
) SELECT object_id, data FROM dependencies;
CREATE TABLE authors (id INTEGER PRIMARY KEY, data JSONB);
CREATE TABLE books (id INTEGER PRIMARY KEY, data JSONB, author_id
  INTEGER REFERENCES authors (id));

INSERT INTO authors (id, data) VALUES
(1, '{"first_name": "Mike", "last_name": "Speegle",
  "dob": "1979-02-03"}'::JSONB),
(2, '{"first_name": "Patrick", "last_name": "Rothfuss",
  "dob": "1973-06-06"}'::JSONB);

INSERT INTO books (id, author_id, data) VALUES
(1, 2, '{"title": "The Name of the Wind",
  "ISBN": "978-0-7564-0407-9"}'::JSONB),
(2, 2, '{"title": "Wise Man''s Fear",
  "ISBN": "978-0-7564-0473-4"}'::JSONB),
(3, 1, '{"title": "Something Greater Than Artifice",
  "ISBN": "978-0-692-26050-0"}'::JSONB),
(4, 1, '{"title": "Pen and Platen: Short Stories Written the Long Way",
  "ISBN": "978-0615574165"}'::JSONB),
(5, 2, '{"title": "A Slow Regard of Silent Things",
  "ISBN": "978-0-7564-1043-8"}'::JSONB);

WITH author_books_cte AS (
 	SELECT authors.data AS author_data, json_agg(books.data) as books_data
 		FROM authors
 		LEFT JOIN books ON books.author_id=authors.id GROUP BY authors.id
 )
 SELECT jsonb_pretty(author_data || jsonb_build_object('books', books_data))
  AS authors
 	FROM author_books_cte;
                                  authors
---------------------------------------------------------------------
 {                                                                  
     "dob": "1979-02-03",                                           
     "books": [                                                     
         {                                                          
             "ISBN": "978-0-692-26050-0",                           
             "title": "Something Greater Than Artifice"             
         },                                                         
         {                                                          
             "ISBN": "978-0615574165",                              
             "title": "Pen and Platen: Short Stories Written the
                Long Way"
         }                                                          
     ],                                                             
     "last_name": "Speegle",                                        
     "first_name": "Mike"                                           
 }
 {                                                                  
     "dob": "1973-06-06",                                           
     "books": [                                                     
         {                                                          
             "ISBN": "978-0-7564-0407-9",                           
             "title": "The Name of the Wind"                        
         },                                                     
         {                                                      
             "ISBN": "978-0-7564-0473-4",                       
             "title": "Wise Man's Fear"                         
         },                                                 
         {                                                      
             "ISBN": "978-0-7564-1043-8",                       
             "title": "A Slow Regard of Silent Things"          
         }                                                      
     ],                                                         
     "last_name": "Rothfuss",                               
     "first_name": "Patrick"                                
 }
const someObject = {};

const someProxy = new Proxy(someObject, {
  get: function (target, property, reciever) {
    if (property.substr(0, 6) === 'happy_') {
      return Reflect.get(target, property.substr(6), reciever);
    }
    return 'sad';
  },
  set: function (target, property, value, reciever) {
    if (property.substr(0, 6) === 'happy_') {
      return Reflect.set(target, property.substr(6), value, reciever);
    }
    return false;
  }
});

someProxy.happy_x = 'happy';
console.log(`someproxy.happy_x = 'happy';`);
console.log('='.repeat(40));
console.log('someProxy.x:', someProxy.x);
console.log('someObject.x:', someObject.x);
console.log('someProxy.happy_x:', someProxy.happy_x);
console.log('someObject.happy_x:', someObject.happy_x);
someproxy.happy_x = 'happy';
========================================
someProxy.x = sad
someObject.x = happy
someProxy.happy_x = happy
someObject.happy_x = undefined
  navigator.mediaDevices.enumerateDevices()
  .then(function (devices) {
     // look for audio and video devices, call getUserMedia
    return navigator.mediaDevices.getUserMedia({audio: true, video: true})
  })
  .then(function (stream) {
    // attach to video element
    // attach to peerconnection and establish a connection to the peer
  })
  .catch(function (error) {
    // handle any error that occurred in the chain
  });
  navigator.mediaDevices.enumerateDevices(function (devices) {
    // look for audio and video devices, call getUserMedia
   navigator.mediaDevices.getUserMedia({audio: true, video: true},
     function (stream) {
        // attach to video element
        // attach to peerconnection and establish a connection to the peer
     },
     function (error) {
        // handle errors from getUserMedia
     }
  }, function (error) {
    // handle errors from enumerateDevices, often forgotten
  });
    var RTCPeerConnection = mozRTCPeerConnection || webkitRTCPeerConnection;
    var getUserMedia = mozGetUserMedia || webkitGetUserMedia;
     pc.createOffer(constraints)
    .then(successCallback)
    .catch(errorCallback)
    pc.createOffer(successCallback, errorCallback, constraints)
   navigator.mediaDevices.getUserMedia({video: true})
   .then(function (stream) {
     document.getElementById(‘localVideo’).srcObject = stream;
   })
'link_settings': {
  'xcode_settings': {
    'OTHER_LDFLAGS': [
      '-framework CFNetwork',
    ],
  },
  'libraries': [
    '$(SDKROOT)/usr/lib/libicucore.dylib',
  ],
}
'link_settings': {
  'xcode_settings': {
    'OTHER_LDFLAGS': [
      '-framework CFNetwork',
      '-licucore',
    ],
  },
}
'xcode_settings': {
  'DEAD_CODE_STRIPPING': 'YES',  # -Wl,-dead_strip
  'GCC_OPTIMIZATION_LEVEL': '<(mac_release_optimization)',
  'OTHER_CFLAGS': [ '<@(release_extra_cflags)', ],
},
'xcode_settings': {
  'DEAD_CODE_STRIPPING': 'YES',  # -Wl,-dead_strip
  'GCC_OPTIMIZATION_LEVEL': '<(mac_release_optimization)',
  'OTHER_CFLAGS': [ '<@(release_extra_cflags)', '-fembed-bitcode', ],
},
auth: {
    strategy: 'token',
    scope: 'forum_admin'
},
CREATE TABLE forums_access (
    user_id TEXT,
    forum_id INTEGER REFERENCES forum(id),
    read BOOLEAN DEFAULT FALSE,
    write BOOLEAN DEFAULT FALSE,
    post BOOLEAN DEFAULT FALSE,
    PRIMARY KEY (user_id, forum_id)
);
Post.registerFactorySQL({
    name: "get",
    sql: [
    "SELECT posts.id, posts.author, posts.body, posts.parent_id, posts.thread_id, posts.path, posts.created, posts.updated FROM posts",
    "JOIN threads ON posts.thread_id=threads.id",
    "JOIN forums ON threads.forum_id=forums.id",
    "JOIN forums_access ON forums_access.forum_id=forums.id",
    "WHERE posts.id=$post_id AND ((forums_access.user_id=$user_id AND forums_access.read=True) OR forums.owner=$user_id)"
    ].join(' '),
    oneResult: true
});
CREATE OR REPLACE FUNCTION check_write_access(userid TEXT, f_id INTEGER) RETURNS void AS $$
BEGIN
    IF NOT EXISTS (SELECT * FROM forums_access WHERE user_id=userid AND forum_id=f_id AND write=TRUE) THEN
        IF NOT EXISTS (SELECT id FROM forums WHERE owner=userid AND id=f_id) THEN
            RAISE 'User lacks permission to write to forum: %', f_id USING ERRCODE = 'insufficient_privilege';
        END IF;
    END IF;
END;
$$ language 'plpgsql';
PERFORM check_write_access(user_id, (forum->>'parent_id')::integer);
CREATE OR REPLACE FUNCTION log_forums_change() RETURNS trigger AS $$
DECLARE
  id bigint;
BEGIN
  IF TG_OP = 'INSERT' OR TG_OP = 'UPDATE' THEN
    id = NEW.id;
    IF TG_OP = 'INSERT' AND NEW.owner IS NOT NULL THEN
        INSERT INTO forums_access (user_id, forum_id, read, write, post) VALUES (NEW.owner, NEW.id, True, True, True);
    END IF;
  ELSE
    id = OLD.id;
  END IF;
  INSERT INTO forums_log (forum_id, tbl, op) VALUES (id, TG_TABLE_NAME, TG_OP);
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;
server.auth.strategy('token', 'jwt', {
    key: options.jwtKey,
    validateFunc: function (decoded, cb) {
        var error, credentials = decoded;
        if (!credentials) {
            return cb(error, false, credentials);
        }

        return cb(error, true, credentials);
    }
});
// test/index.js
config.jwtKey = require('crypto').randomBytes(48).toString('base64');
var token = jwt.sign({user: 'tester-user', scope: ['forum_admin']}, config.jwtKey, {expiresInMinutes: 15});
var authorization = 'Bearer ' + token;
if ($(element).hasClass('active')) {
    // do something        
}
_.isEqual(object1, object2)
object1 === object2
var obj = {
    something: 'some value'
}

// here we’re just editing `obj` in place
obj.something = 'some other value'
let obj = {
    something: 'some value'
}

// this creates a brand new copy overwriting just that key
obj = {...obj, something: 'some other value'}
var myStuff = [
    {name: 'henrik'}
]

// push modifies the array defined above
myStuff.push({name: 'js lovin fool'})
let myStuff = [
    {name: 'henrik'}
]

myStuff = [...mystuff, {name: 'js lovin fool'}]
shouldComponentUpdate (newProps) {
    return newProps.obj !== this.props.obj
}
'use strict';
var test = require('tape');

// allow `npm run selenium <url>` usage
var baseURL = process.argv.length >= 3 ? process.argv[2] : 'https://talky.io';

// https://code.google.com/p/selenium/wiki/WebDriverJs
var seleniumHelpers = require('./selenium-lib');
var webdriver = require('selenium-webdriver');

function doJoin(driver, room) {
  return driver.get(baseURL + '/' + room)
  .then(function () {
    return driver.findElement(webdriver.By.id('join'));
  })
  .then(function (button) {
    return button.click();
  });
}

function testP2P(browserA, browserB, t) {
  var room = 'testing_' + Math.floor(Math.random()*100000);

  var userA = seleniumHelpers.buildDriver(browserA);
  doJoin(userA, room);

  var userB = seleniumHelpers.buildDriver(browserB);
  doJoin(userB, room);

  userA.wait(function () {
    return userA.executeScript('return (function() {' +
      'var sessions = app.xmpp.jingle.sessions;' +
      'var sessionIds = Object.keys(sessions);' +
      'if (sessionIds.length != 2) return false;' +
      'if (sessions[sessionIds[0]].peer.full !== sessions[sessionIds[1]].peer.full) return false;' +
      'return sessions[sessionIds[0]]._connectionState === \'connected\';' +
      '})()');
  }, 30*1000)
  .then(function () {
    t.pass('P2P connected');
    userA.quit();
    userB.quit().then(function () {
      t.end();
    });
  })
  .then(null, function (err) {
    t.fail(err);
    userA.quit();
    userB.quit();
  });
}

test('P2P, Chrome-Chrome', function (t) {
  testP2P('chrome', 'chrome', t);
});

test('P2P, Firefox-Firefox', function (t) {
  testP2P('firefox', 'firefox', t);
});

test('P2P, Chrome-Firefox', function (t) {
  testP2P('chrome', 'firefox', t);
});

test('P2P, Firefox-Chrome', function (t) {
  testP2P('firefox', 'chrome', t);
});
var animations = require(var animations = require('create-keyframe-animation')

// this creates the animation above
animations.registerAnimation({
  name: 'move',
  // the actual animation changes
  // these are x, y coordinates
	// there are other alternatives
  // for describing these too.	
  animation: [
    [0, 0], 
    [1, 1]
  ]
})
var elements = document.querySelectorAll('.dot')
animations.runAnimation(elements, 'move')
animations.runAnimation(el, 'stop')
  .then(function () {  
    return animations.runAnimation(el, 'drop')
  })
  .then(function () {  
    return animations.runAnimation(el, 'roll')
  })
  .then(function () {  
    console.log("Done!")
    console.log("You’ve stopped, dropped, and rolled.")
    console.log("You’re probably no longer on fire.")
  })
  .catch(function (err) {  
	  console.log("oww! fire’s hot!")
  })
window.addEventListener('device motion', (e) => {
  // iOS and android do opposite values :-/
  let modifier = /iPad|iPhone|iPod/.test( navigator.userAgent ) ? 1 : -1
  d.ax = (e.accelerationIncludingGravity.x * 5) * modifier
  d.ay = (e.accelerationIncludingGravity.y * 5) * modifier
})
server.route({
    method: 'GET',
    path: '/something/adminy',
    config: {
        handler: function (request, reply) {
            return reply('Hello there, admin.');
        },
        auth: {
            scope: 'admin'
        }
    }
})
{
    "username": "jabba",
    "scope": ["admin", "hutt"]
}
{
    "username": "han",
    "scope": ["door-trash-compactor"]
}
server.route({
    method: 'GET',
    route: '/doors/{door_id}',
    config: {
        handler: function (request, reply) {
            reply(request.params.door_id ' door is closed');
        },
        auth: {
            scope: ['door-{params.door_id}']
        }
    }
});
example.com/about
example.com/about.html
example.com/products/widgets/42
route:              file served:
site.com/pic.png -> pic.png
route:           file served:
site.com/page -> page.html
site.com      -> index.html
route:                        file served:
site.com/missing-image.png -> 404
site.com/other-path        -> 200.html
IF EXISTS (SELECT write FROM objecttype_access WHERE userid=$userid AND objectid=$objectid AND write=True) THEN
  UPDATE objecttype SET value=$value WHERE objectid=$objectid;
END IF;
server.route({ method: 'post', path: '/someobject_access', config: {
    auth: { scope: 'api_admin' },
    handler: function (request, result) {
      var pl = request.payload;
      db.query("insert into objectttype_access (userid, objectid, read, write) values ($1, $2, $3, $4)",
        [pl.userid, pl.objectid, pl.read, pl.write], function (err) {
        if (err) throw Boom.badImplementation("Adding permission failed.");
        reply();
      });
    }
}});
wreck.get("https://someapi.yourproject.com/someobjects", 
  {headers: {authorization: token}},
  function (err, response) {
  if (err) throw err;
  async.map(response.payload.results, function (item, mapcb) {
    wreck.get("https://user-info-api.yourproject.com/users/" + item.userid, function (err, userResponse) {
      if (err) return mapcb(err);
      item.user = userResponse.payload;
      mapcb(err, item);
    });
  }, function (err, results) {
    if (err) throw err;
    console.log(results);
  });
});
CREATE OR REPLACE FUNCTION table_update_notify() RETURNS trigger AS $$
DECLARE
  id bigint;
BEGIN
  IF TG_OP = 'INSERT' OR TG_OP = 'UPDATE' THEN
    id = NEW.id;
  ELSE
    id = OLD.id;
  END IF;
  PERFORM pg_notify('table_update', json_build_object('table', TG_TABLE_NAME, 'id', id, 'type', TG_OP)::text);
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

DROP TRIGGER users_notify_update ON users;
CREATE TRIGGER users_notify_update AFTER UPDATE ON users FOR EACH ROW EXECUTE PROCEDURE table_update_notify();

DROP TRIGGER users_notify_insert ON users;
CREATE TRIGGER users_notify_insert AFTER INSERT ON users FOR EACH ROW EXECUTE PROCEDURE table_update_notify();

DROP TRIGGER users_notify_delete ON users;
CREATE TRIGGER users_notify_delete AFTER DELETE ON users FOR EACH ROW EXECUTE PROCEDURE table_update_notify();
var pg = require ('pg');

pg.connect("postgres://localhost/fritzy", function(err, client) {
    if(err) {
        console.log(err);
    }
    client.on('notification', function(msg) {
        if (msg.name === 'notification' && msg.channel === 'table_update') {
            var pl = JSON.parse(msg.payload);
            console.log("*========*");
            Object.keys(pl).forEach(function (key) {
                console.log(key, pl[key]);
            });
            console.log("-========-");
        }
    });
    client.query("LISTEN table_update");
});
> INSERT INTO users (username) values ('fritzy');

*========*
type INSERT
id 1
table users
-========-

> UPDATE users SET email='fritzy@andyet.com' WHERE id=1;

*========*
type UPDATE
id 1
table users
-========-

> DELETE FROM users WHERE id=1;

*========*
type DELETE
id 1
table users
-========-
pg_notify('table_update', row_to_json(NEW)::text);
pg_notify(json_build_object('table', TG_TABLE_NAME, 'id', id, 'type', TG_OP, 'row', row_to_json(NEW))
p(class="some-special-paragraph another-exciting-class") Here's our amazing content.
p.some-special-paragraph.another-exciting class Here's our amazing content.
.
└── node_modules
    ├── lodash._createwrapper
    │   └── node_modules
    │       ├── lodash._basebind
    │       │   └── node_modules
    │       │       ├── lodash._basecreate
    │       │       │   └── node_modules
    │       │       │       ├── lodash._isnative
    │       │       │       └── lodash.noop
    │       │       ├── lodash._setbinddata
    │       │       │   └── node_modules
    │       │       │       ├── lodash._isnative
    │       │       │       └── lodash.noop
    │       │       └── lodash.isobject
    │       │           └── node_modules
    │       │               └── lodash._objecttypes
    │       ├── lodash._basecreatewrapper
    │       │   └── node_modules
    │       │       ├── lodash._basecreate
    │       │       │   └── node_modules
    │       │       │       ├── lodash._isnative
    │       │       │       └── lodash.noop
    │       │       ├── lodash._setbinddata
    │       │       │   └── node_modules
    │       │       │       ├── lodash._isnative
    │       │       │       └── lodash.noop
    │       │       └── lodash.isobject
    │       │           └── node_modules
    │       │               └── lodash._objecttypes
    │       └── lodash.isfunction
    └── lodash._slice
addClass(el, 'class1');
addClass(el, 'class1', 'class2');
addClass(el, [array of classes]);
[Unit]
Description=Node App
Requires=docker.service

[Service]
EnvironmentFile=/etc/environment
TimeoutStartSec=0
ExecStartPre=-/usr/bin/docker kill node-app
ExecStartPre=-/usr/bin/docker rm node-app
ExecStartPre=/usr/bin/docker pull {{docker_registry}}/node-app
ExecStart=/usr/bin/docker run --rm=true --name=node-app -P -e COREOS_PRIVATE_IPV4=${COREOS_PRIVATE_IPV4} registry/node-app
ExecStop=/usr/bin/docker stop node-app
FROM debian:wheezy
MAINTAINER Marcus Stong, marcus@andyet.net
RUN apt-get update && apt-get install -y curl
CMD echo "Etcd Version: $(curl http://${COREOS_PRIVATE_IPV4}:4001/version)"
#!/bin/bash
iptables -A FORWARD -i docker0 -o eth1 -j ACCEPT
iptables -A FORWARD -o docker0 -i eth1 -j ACCEPT

iptables -A INPUT  -i docker0 -p tcp --dport 4001 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o docker0 -p tcp --sport 4001 -m state --state ESTABLISHED -j ACCEPT

iptables -A OUTPUT -o eth1 -p tcp --dport 4001 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT  -i eth1 -p tcp --sport 4001 -m state --state ESTABLISHED -j ACCEPT

iptables -A INPUT  -i eth1 -p tcp --dport 4001 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o eth1 -p tcp --sport 4001 -m state --state ESTABLISHED -j ACCEPT
#!/usr/bin/env python
import sys
import mechanize

br = mechanize.Browser()
r  = br.open("http://example.com")
if r.code != 200:
    print("Unable to load the test page")
    sys.exit(2)
# if your devs are nice and name the form...
#     br.select_form("name")
# if they don't name it, then you have to use...
#     br.form = list(br.forms())[0]
# To discover what the control field names are...
#     for control in br.form.controls:
#         print(control.type, control.name)
br.form    = list(br.forms())[0]
nameField  = br.form.find_control("name")
emailField = br.form.find_control("email")
nameField.value  = "Testing Form"
emailField.value = "tester@example.com"

r = br.submit()
if r.code != 200:
    print("Error submitting form")
    sys.exit(3)
client.sendPresence({
    caps: {
        hash: 'sha-1',
        node: 'http://talky.io/web',
        ver: 'QgayPKawpkPSDYmwT/WM94uAlu0='
    }
});
// The original that both edits are based on
{
    "id": 1,
    "name": "Franco Witherspoon",
    "age": 32,
    "lastModified": "Mon, 10 Nov 2014 14:32:08 GMT",
    "createdBy": 1,
    "car": {"id": 1, "make": "Honda", "model": "CRX", "modelYear": "2006"},
    "pants": [{
        "id": 1, "manufacturer": "Levis", "style": "501",
        "size": "32", "color": "Indigo"
    },
    {
        "id": 2, "manufacturer": "Bonobos", "style": "Washed Chino",
        "size": "32", "color": "Jet Blue"
    },
    {
        "id": 3, "manufacturer": "IZOD", "style": "Cotton Lounge",
        "size": "32", "color": "Navy"   
    }]
}

// Edit #1 (the one that gets saved while #2 is still editing)
[
    {op: "replace", path: "/name", value: "Francis Withings"},
    {op: "replace", path: "/car/model", value: "CRX SiR"},
    {op: "add", path: "/pants/-", value: {
        manufacturer: "Alfani", style: "RED Slim-fit",
        size: "32", color: "Grey Sharkskin"
    }}
]

// Edit #2
[
    {op: "replace", path: "/name", value: "Frank Withers"},
    {op: "replace", path: "/car/model", value: "CRX SiR"},
    {op: "remove", path: "/pants/2"},
    {op: "add", path: "/pants/-, value: {
        manufacturer: "Joe Boxer", style: "Fleece Pajama",
        size: "32", color: "Red Plaid"
    }}
]
person._conflict = {
    conflicts: [{
        client: {op: "replace", path: "/name", value: "Frank Withers"},
        server: {op: "replace", path: "/name", value: "Francis Withings"},
        original: "Franco Witherspoon"
    }],
    serverState: {
        "id": 1,
        "name": "Franco Witherspoon", // <-- conflicting change
        "age": 32,
        "lastModified": "Wed, 12 Nov 2014 04:58:08 GMT",
        "createdBy": 1,
        "car": {
            "id": 1, "make": "Honda", "model": "CRX SiR", // <-- matching change
            "modelYear": "2006"
        },
        "pants": [{
            "id": 1, "manufacturer": "Levis", "style": "501",
            "size": "32", "color": "Indigo"
        },
        {
            "id": 2, "manufacturer": "Bonobos", "style": "Washed Chino",
            "size": "32", "color": "Jet Blue"
        },
        {
            "id": 3, "manufacturer": "IZOD", "style": "Cotton Lounge",
            "size": "32", "color": "Navy"   
        },
        {
            "id": 4, "manufacturer": "Alfani", "style": "RED Slim-fit",
            "size": "32", "color": "Grey Sharkskin"
        }]
    },
    resolved: [],
    unsaved: [
        {op: "replace", path: "/name", value: "Frank Withers", original: "Franco Witherspoon"},
        {op: "remove", path: "/pants/2", original: {
            "id": 3, "manufacturer": "IZOD", "style": "Cotton Lounge",
            "size": "32", "color": "Navy"   
        }},
        {op: "add", path: "/pants/-", value: {
            manufacturer: "Joe Boxer", style: "Fleece Pajama", size: "32",
            color: "Red Plaid"
        }, original: null}
    ]
};
var AMOU = require('ampersand-model-optimistic-update-mixin');
var BaseModel = require('ampersand-model'); // OR require('backbone').Model;

module.exports = AMOU(BaseModel, {
    props: {id: 'number', name: 'string', age: 'number'},
    children: {car: Car},
    collections: {pants: Pants}
});
var AMOU = require('ampersand-model-optimistic-update-mixin');
var BaseModel = require('ampersand-model'); // OR require('backbone').Model;

module.exports = AMOU(BaseModel, {
    props: {id: 'number', name: 'string', age: 'number'},
    children: {car: Car},
    collections: {pants: Pants},
    _optimisticUpdate: {
        patcher: {/* AMP config */},
        optimistic: {/* AOS config */},
        autoResolve: false,
        JSONPatch: true,
        ignoreProps: [],
        collectionSort: {},
        customCompare: {} // prop/child/collection: function (original, current) {} map where the func returns true when considered equal, false when not, or an array of operations to make original match current
    }
});
person._conflict = {
    conflicts: [/* same as above */],
    serverState: {/* same as above */},
    resolved: [{op: "add", path: "/pants/-", value: {
        manufacturer: "Alfani", style: "RED Slim-fit",
        size: "32", color: "Grey Sharkskin"},
        client: undefined, clientDiscarded: undefined
    }],
    unsaved: [/* same as above */]
}
person._conflict = {
    conflicts: [/* none because we've resolved them in the server's favor */],
    serverState: {/* same as above */},
    resolved: [
        {op: "replace", path: "/name", value: "Francis Withings",
            client: "Frank Withers", clientDiscarded: true}
        {op: "add", path: "/pants/-, value: {
            manufacturer: "Alfani", style: "RED Slim-fit",
            size: "32", color: "Grey Sharkskin"},
            client: undefined, clientDiscarded: undefined}
    ],
    unsaved: [
        {op: "remove", path: "/pants/2", original: {
            "id": 3, "manufacturer": "IZOD", "style": "Cotton Lounge",
            "size": "32", "color": "Navy"   
        }},
        {op: "add", path: "/pants/-", value: {
            manufacturer: "Joe Boxer", style: "Fleece Pajama", size: "32",
            color: "Red Plaid"
        }, original: null}
    ]
}
{
    "name": "example app",
    "description": "an example",
    "version": "1.0.0",
    "devDependencies": {
      "retire": "~0.3.2",
      "precommit-hook": "~1.0.7"
    },
    "scripts": {
      "validate": "retire -n -j"
    }
}
var BaseModel = require('ampersand-model');
var AOS = require('ampersand-optimistic-sync');

module.exports = BaseModel.extend(AOS(BaseModel));
var BaseModel = require('backbone').Model;
var AOS = require('ampersand-optimistic-sync');

module.exports = BaseModel.extend(AOS(BaseModel, {
    // [default], 'last-modified' is also supported
    type: 'etag',
    // pre-define a handler for the sync:invalid-version event 
    invalidHandler: function (model, version, response) {
        // make the most of a bad situation
    },
    // pre-define default sync options
    options: {
        all: {
            // any options you'd like to set for all requests
        },
        // you can also set options for particular methods
        create: {
            success: function (data) {
                // do stuff with data
            }
        },
        read: {},
        update: {
            patch: true
        },
        delete: {},
    }
}
}));
var BaseModel = require('backbone').Model;
var Car = require('./car');
var Pants = require('../collections/pants');
var AMP = require('ampersand-model-patch-mixin');

// A simple person model
module.exports = BaseModel.extend(AMP(BaseModel, {
    props: {id: 'number', name: 'string', age: 'number'},
    children: {car: Car},
    collections: {pants: Pants}
}));
var Person = require('../models/person');
var person = new Person({id: 1});

person.fetch();
// Server's response
{
    "id": 1,
    "name": "Franco Witherspoon",
    "age": 32,
    "lastModified": "Mon, 10 Nov 2014 14:32:08 GMT",
    "createdBy": 1,
    "car": {"id": 1, "make": "Honda", "model": "CRX", "modelYear": "2006"},
    "pants": [{
        "id": 1, "manufacturer": "Levis", "style": "501",
        "size": "32", "color": "Indigo"
    },
    {
        "id": 2, "manufacturer": "Bonobos", "style": "Washed Chino",
        "size": "32", "color": "Jet Blue"
    },
    {
        "id": 3, "manufacturer": "IZOD", "style": "Cotton Lounge",
        "size": "32", "color": "Navy"   
    }]
}
// AMP stores the response data at the property specified by its originalProperty config directive (default: _original).

// Identity is so fluid these days!
person.name = "Frank Withers";

// Let's be specific.
person.car.model += " SiR";

// Frank loved those IZOD's, but their time had come.
person.pants.remove(person.pants.at(2))

// Gotta have PJ pants.
person.pants.add({
    manufacturer: "Joe Boxer", style: "Fleece Pajama",
    size: "32", color: "Blue Plaid"
})

// Wait! Not blue, red.
person.pants.at(2).color = "Red Plaid";

console.log(person._ops.length)
// => 4

person.save();

// Sends the following to the server with Content-Type: application/json+patch
[
    {op: "replace", path: "/name", value: "Frank Withers"},
    {op: "replace", path: "/car/model", value: "CRX SiR"},
    {op: "remove", path: "/pants/2"},
    {op: "add", path: "/pants/-", value: {
        manufacturer: "Joe Boxer", style: "Fleece Pajama",
        size: "32", color: "Red Plaid"
    }}
]
module.exports = BaseModel.extend(AMP(BaseModel, {
    _patcherConfig: {
        autoSave: 5
    },
    props: {id: 'number', name: 'string', age: 'number'},
    children: {car: Car},
    collections: {pants: Pants}
}));
module.exports = BaseModel.extend(AMP(BaseModel, {
    _patcherConfig: {
        autoSave: function (model, opCount) {
            // Returns true if 5 total
            if (opCount >= 5) return true;
            var roots = [];
            // Returns true if more than three different root paths in ops
            this._ops.forEach(function (op) {
                var root = op.path.slice(1).split('/').shift();
                if (roots.indexOf(root) === -1) roots.push(root);
            });
            if (roots.length >= 3) return true;
            return false;
        }
    },
    props: {id: 'number', name: 'string', age: 'number'},
    children: {car: Car},
    collections: {pants: Pants}
}));
# domain = 'example.com'
# config['cafile'] = '/etc/ssl/certs/ca-certificates.crt'
socket.getaddrinfo(domain, 443)[0][4][0]
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((domain, 443))
ctx = SSL.Context(SSL.TLSv1_METHOD)
 # prevent fallback to insecure SSLv2
ctx.set_options(SSL.OP_NO_SSLv2 | SSL.OP_NO_SSLv3)
ctx.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
               pyopenssl_check_callback)
ctx.load_verify_locations(config['cafile'])
ssl_sock = SSL.Connection(ctx, sock)
ssl_sock.set_connect_state()
ssl_sock.set_tlsext_host_name(domain)
ssl_sock.do_handshake()
def pyopenssl_check_callback(connection, x509, errnum, errdepth, ok):
    '''callback for pyopenssl ssl check'''
    log.debug('callback: %d %s' % (errdepth, x509.get_issuer().commonName))
    if x509.has_expired():
        raise CertificateError('Certificate %s has expired!' % x509.get_issuer().commonName)
    if not ok:
        return False
    return ok
x509 = ssl_sock.get_peer_certificate()
try:
    match_hostname(x509, domain)
except CertificateError:
    print('Hostname does not match')
expire_date = datetime.datetime.strptime(x509.get_notAfter(), "%Y%m%d%H%M%SZ")
expire_td   = expire_date - datetime.datetime.now()
if expire_td.days < 15:
    print('Expires in %s days' % expire_td.days)
var original = {
  "cars": [
    {id: 1, "model":"De Ville"},
    {id: 2, "model": "Fleetwood"}
  ]
};

var add = {"op": "add", "path": "/cars/2", "value": {"model": "Eldorado"}};
var remove = {"op": "remove", "path": "/cars/1"};
var replace = {"op": "replace", "path": "/cars/0/model", "value": "Coupe De Ville"};

// The result of applying the above would be:

var patched = {
  "cars": [
    {id: 1, "model":"Coupe De Ville"},
    {id: 3, "model": "El Dorado"}
  ]
};
writeToLocalStorage: function () {
  localStorage[STORAGE_KEY] = JSON.stringify(this);
}
readFromLocalStorage: function () {
  var existingData = localStorage[STORAGE_KEY];
  if (existingData) {
    this.set(JSON.parse(existingData));
  }
}
initialize: function () {
  // Attempt to read from localStorage right away
  // this also adds them to the collection
  this.readFromLocalStorage();

  // We put a slight debounce on this since it could possibly
  // be called in rapid succession. We're using a small npm package
  // called 'debounce' for this: 
  // https://www.npmjs.org/package/debounce
  this.writeToLocalStorage = debounce(this.writeToLocalStorage, 100);

  // We listen for changes to the collection
  // and persist on change
  this.on('all', this.writeToLocalStorage, this);
}
window.addEventListener('storage', this.handleStorageEvent.bind(this));
handleStorageEvent: function (event) {
  if (event.key === STORAGE_KEY) {
    this.readFromLocalStorage();
  }
}
var State = require('ampersand-state');

module.exports = State.extend({
  // These properties get persisted to localStorage
  // because they'll be included when serializing
  props: {
    title: {
      type: 'string',
      default: ''
    },
    completed: {
      type: 'boolean',
      default: false
    }
  },

  // session properties are *identical* to `props`
  // *except* that they're not included when serializing.
  session: {
    // here we declare that editing state, just like
    // the properties above.
    editing: {
      type: 'boolean',
      default: false
    }
  },

  // This is just a convenience method that just
  // gives our view a simple method to call when 
  // it wants to trash a todo.
  destroy: function () {
    if (this.collection) {
      this.collection.remove(this);
    }
  }
});
app.Todo = Backbone.Model.extend({
  // Default attributes for the todo
  // and ensure that each todo created has `title` and `completed` keys.
  defaults: {
    title: ',
    completed: false
  },

  // Toggle the `completed` state of this todo item.
  toggle: function () {
    this.save({
      completed: !this.get('completed')
    });
  }
});
Todos.Todo = DS.Model.extend({
  title: DS.attr('string'),
  isCompleted: DS.attr('boolean')
});
var Collection = require('ampersand-collection');
var SubCollection = require('ampersand-subcollection');
var Todo = require('./todo');

module.exports = Collection.extend({
  model: Todo,
  initialize: function () {
    ...
    // This is what we'll actually render
    // it's a subcollection of the whole todo collection
    // that we'll add/remove filters to accordingly.
    this.subset = new SubCollection(this);
    ...
  },
  ...
}
this.renderCollection(app.me.todos.subset, TodoView, this.queryByHook('todo-container'));
setMode: function (mode) {
  if (mode === 'all') {
    this.subset.clearFilters();
  } else {
    this.subset.configure({
      where: {
        completed: mode === 'completed'
      }
    }, true);
  }
}
var State = require('ampersand-state');
var Todos = require('./todos');

module.exports = State.extend({
  ...
  collections: {
    todos: Todos
  },
  ...  
});
app.me.mode = 'all';
mode: {
  type: 'string',
  values: [
    'all',
    'completed',
    'active'
  ],
  default: 'all'
}
...
initialize: function () {
  // Listen to changes to the todos collection that will
  // affect lengths we want to calculate.
  this.listenTo(this.todos, 'change:completed change:title add remove', this.handleTodosUpdate);

  // We also want to calculate these values once on init
  this.handleTodosUpdate();
  ...
},
// Define our session properties
session: {
  activeCount: {
    type: 'number',
    default: 0
  },
  completedCount: {
    type: 'number',
    default: 0
  },
  totalCount:{
    type: 'number',
    default: 0
  },
  allCompleted: {
    type: 'boolean',
    default: false
  },
  mode: {
    type: 'string',
    values: [
      'all',
      'completed',
      'active'
    ],
    default: 'all'
  }
},
// Calculate and set various lengths we're
// tracking. We set them as session properties
// so they're easy to listen to and bind to DOM
// where needed.
handleTodosUpdate: function () {
  var completed = 0;
  var todos = this.todos;
  todos.each(function (todo) {
    if (todo.completed) {
      completed++;
    }
  });
  // Here we set all our session properties
  this.set({
    completedCount: completed,
    activeCount: todos.length - completed,
    totalCount: todos.length,
    allCompleted: todos.length === completed
  });
},
...
var Router = require('ampersand-router');

module.exports = Router.extend({
  routes: {
    // this matches all urls
    '*filter': 'setFilter'
  },
  setFilter: function (arg) {
    // if we passed one, set it
    // if not set it to "all"
    app.me.mode = arg || 'all';
  }
});
var MainView = require('./views/main');
var Me = require('./models/me');
var Router = require('./router');

window.app = {
  init: function () {
    // Model representing state for
    // user using the app. Calling it
    // 'me' is a bit of convention but
    // it's basically 'app state'.
    this.me = new Me();

    // Our main view
    this.view = new MainView({
      el: document.body,
      model: this.me
    });

    // Create and fire up the router
    this.router = new Router();
    this.router.history.start();
  }

};

window.app.init();
...

bindings: {
  // Toggles visibility of main and footer
  // based on truthiness of totalCount.
  // Since zero is falsy it won't show if
  // total is zero.
  'model.totalCount': {
    // this is the binding type
    type: 'toggle',
    // this is just a CSS selector
    selector: '#main, #footer'
  },
  // This is how you do multiple bindings
  // to a single property. Just pass an 
  // array of bindings.
  'model.completedCount': [
    // Hides the clear-completed span
    // when there are no completed items
    {
      type: 'toggle',
      // "hook" here is shortcut for 
      // selector: '[data-hook=clear-completed]'
      hook: 'clear-completed'
    },
    // Inserts completed count as text
    // into the span
    {
      type: 'text',
      hook: 'completed-count'
    }
  ],
  // This is an HTML string that we made
  // as a derived (a.k.a. computed) property
  // of the `me` model. This was done this way
  // for simplicity because the target HTML
  // looks like this: 
  // "<strong>5</strong> items left"
  // where "items" has to be correctly pluralized
  // since it's not just text, but not really
  // a bunch of nested HTML it was easier to just
  // bind this as `innerHTML`.
  'model.itemsLeftHtml': {
    type: 'innerHTML',
    hook: 'todo-count'
  },
  // This adds the 'selected' class to the right
  // element in the footer
  'model.mode': {
    type: 'switchClass',
    name: 'selected',
    cases: {
      'all': '[data-hook=all-mode]',
      'active': '[data-hook=active-mode]',
      'completed': '[data-hook=completed-mode]',
    }
  },
  // Bind 'checked' state of `mark-all`
  // checkbox at the top
  'model.allCompleted': {
    type: 'booleanAttribute',
    name: 'checked',
    hook: 'mark-all'
  }
},
...
apt-get -s dist-upgrade
yum list updates
Reading package lists...
Building dependency tree...
Reading state information...
The following NEW packages will be installed:
  libxfixes-dev
The following packages will be upgraded:
  base-files openssl tzdata
3 upgraded, 1 newly installed, 0 to remove and 0 not upgraded.
Inst base-files [6.5ubuntu6.7] (6.5ubuntu6.8 Ubuntu:12.04/precise-updates [amd64])
Conf base-files (6.5ubuntu6.8 Ubuntu:12.04/precise-updates [amd64])
Inst tzdata [2014c-0ubuntu0.12.04] (2014e-0ubuntu0.12.04 Ubunt
Inst openssl [1.0.1-4ubuntu5.14] (1.0.1-4ubuntu5.17 Ubuntu:12.04/precise-security [amd64])
Updated Packages
audit.x86_64       2.2-4.el6_5       rhel-x86_64-server-6
audit-libs.x86_64  2.2-4.el6_5       rhel-x86_64-server-6
avahi-libs.x86_64  0.6.25-12.el6_5.1 rhel-x86_64-server-6
#!/usr/bin/env python
import json
import datetime
import subprocess
import etcd

hostname = subprocess.check_output(['uname', '-h'])
ec       = etcd.Client(host='127.0.0.1', port=4001)
normal   = {}
security = {}
output   = subprocess.check_output(['apt-get', '-s', 'dist-upgrade'])
for line in output.split('\n'):
    if line.startswith('Inst'):
        items      = line.split()
        pkgName    = items[1]
        oldVersion = items[2][1:-1]
        newVersion = items[3][1:]
        if '-security' in line:
            security[pkgName] = { 'old': oldVersion, 'new': newVersion }
        else:
            normal[pkgName] = { 'old': oldVersion, 'new': newVersion }
data = { 'timestamp': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
         'normal': normal,
         'security': security,
       }
key = '/packages/%s' % hostname
ec.write(key, json.dumps(data))
Step 1 : RUN apt-get update
 ---> Running in 64a37c06d1f4
Err http://http.debian.net wheezy Release.gpg
  Could not resolve 'http.debian.net'
Err http://http.debian.net wheezy-updates Release.gpg
  Could not resolve 'http.debian.net'
Err http://security.debian.org wheezy/updates Release.gpg
  Could not resolve 'security.debian.org'
# Log dropped outbound packets
iptables -N LOGGING
iptables -A OUTPUT -j LOGGING
iptables -A INPUT -j LOGGING
iptables -A FORWARD -j LOGGING
iptables -A LOGGING -m limit --limit 2/min -j LOG --log-prefix "IPTables-Dropped: " --log-level 4
iptables -A LOGGING -j DROP
# Forward chain between docker0 and eth0
iptables -A FORWARD -i docker0 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -o docker0 -j ACCEPT

# IPv6 chain if needed
ip6tables -A FORWARD -i docker0 -o eth0 -j ACCEPT
ip6tables -A FORWARD -i eth0 -o docker0 -j ACCEPT
/opt/sbin
  /checkiptables.sh
  /iptables.sh
  /iptables_conf.d/
    iptables_*.sh
#!/bin/bash
# generate a list of active rules and remove all the cruft
iptables-save | sed -e ’/^[#:]/d’ > /tmp/iptables.check
if [ -e /etc/iptables.rules ]; then
  cat /etc/iptables.rules | sed -e ’/^[#:]/d’ > /tmp/iptables.rules
  diff -q /tmp/iptables.rules /tmp/iptables.check
else
  echo "unable to check, /etc/iptables.rules does not exist"
fi
Files /tmp/iptables.rules and /tmp/iptables.check differ
#!/bin/bash
PUBLICNET=eth2

iptables -F
ip6tables -F
ip6tables -X
ip6tables -t mangle -F
ip6tables -t mangle -X

# Default policy is drop
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT DROP

ip6tables -P INPUT DROP
ip6tables -P OUTPUT DROP
ip6tables -P FORWARD DROP

iptables -A INPUT -p tcp -m multiport --dports 22 -j fail2ban-ssh
iptables -A fail2ban-ssh -j RETURN
# Allow localhost
iptables -A INPUT  -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
ip6tables -A INPUT  -i lo -j ACCEPT
ip6tables -A OUTPUT -o lo -j ACCEPT
# Allow inbound ipv6 ICMP so we can be seen by neighbors
ip6tables -A INPUT  -i ${PUBLICNET} -p ipv6-icmp -j ACCEPT
ip6tables -A OUTPUT -o ${PUBLICNET} -p ipv6-icmp -j ACCEPT
# Allow incoming SSH
iptables -A INPUT  -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
# Allow outbound DNS
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
iptables -A INPUT  -p udp --sport 53 -j ACCEPT
# Only allow NTP if it’s our request
iptables -A INPUT -s 0/0 -d 0/0 -p udp --source-port 123:123 -m state --state ESTABLISHED -j ACCEPT
iptables -A OUTPUT -s 0/0 -d 0/0 -p udp --destination-port 123:123 -m state --state NEW,ESTABLISHED -j ACCEPT

for s in /opt/sbin/iptables_conf.d/iptables_*.sh ; do
  if [ -e "${s}" ]; then
    source ${s}
  fi
done
# Allow outgoing etcd
iptables -A OUTPUT -o eth2 -p tcp --dport 4001 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT  -i eth2 -p tcp --sport 4001 -m state --state ESTABLISHED -j ACCEPT
If you're going to launch a WebRTC powered service for financial 
gain, then you need to have done everything within your power to
ensure it works reliably across as many cases as possible.
if (b==1 && b===2 && b===herpderp) {
   // do stuff here
}
var b = { }; //a something

b.valueOf = function () {
  return 1;
};

if (b==1) {
  console.log("This code is executed"); //yup, this works
}
var b = 2;

b.valueOf = function () {
    return 1;
};

if (b==1) {
    console.log('This aint called');
}
Number.prototype.valueOf = function () {
    return 1;
};

var b = new Number(2);

if (b==1) {
    console.log('This is called'); //Woo!
}
var b = {};
var herpderp = 2;

b.valueOf = function () {
    b = 2;
    return 1;
};

if (b==1 && b===2 && b===herpderp) {
    console.log('This code runs!!!');
}
var n = 1;
var herpderp = 3;

Object.defineProperty(global, 'b', {
    get: function () {
        return n++;
    }
});

if (b===1 && b===2 && b===herpderp) {
    console.log('this runs');
}

	Test	Ops/sec
Code	`console.log("This runs some code.");`	68,499 (±3.00%), 100% slower
No Code	`// This doesn't run any code!`	746,370,478 (±1.32%), fastest

&yet blog

Coders are people, too

More about Wicked Coolkit:

Recommended resources

Give your attendees the wheel

Small actions; huge impact.

It’s not really about the coffee, of course.

How can you give your attendees the wheel?

Have your passports ready

Our task as event organizers is to offer people experiences that they can’t (or are unlikely to) have on their own, in their everyday lives.

Where do you come from? Where have you been?

Sit in the bad seats

Togetherness

We’ve always been 100% sold on the magic of live events. And we also 💜 the good things the web makes possible—especially finding and connecting with your people across any distance.

We’re interested in how we can experience more togetherness across distances.

Flexibility

Transcript:

Groundedness

Transcript:

Spaciousness

Transcript:

The Last Bite

Announcing our new cold read assessment

Transitioning to CEO and sharing as we go

Ch-ch-ch-changes: The formation of Talky, inc. and a new CEO for &yet

The value of an outside perspective

People who get you

People who don’t get you …yet

Swag can be object-free

Stuff we all get?

A technical look at Facecamp

Preact

Browser Support and Byte Shaving

Slack Max Inline Gif Size

PWAs and iOS

Let Us Know What You Think

Introducing Facecamp: Chat your mug!

Why for?

Dig deeper

Make Facecamp better

Project Meh-nagement

How to be unopinionated about process, but still keep things on track.

Start with the basics

Go beyond the basics…or don’t

Get to know your team

Let your team get to know you

Create a process

Vet your process

Live and learn

Why be unopinionated?

A simple, casual approach to blame-free retrospectives

Project Retrospective Template:

Step 1:

Step 2:

The Great Gatsby (Blog Transition)

How’d you manage that?

So how did you fix it?

It sounds easier, but is it better?

Okay, that makes sense. But how hard was it?

Was it worth it?

Assess yourself! Lead generation edition, Part 3

Assessing the sustainability of your lead generation system

Understand your potential customers

Show up in the right place at the right time with a welcome solution to a pressing need

Educate leads and provide resources to help them on their path

Qualify leads into prospects

Help prospects decide whether to become a customer

Help customers be successful on their path

To sum it up

Further reading

Assess yourself! Lead generation edition, Part 2

Applying a deep understanding of your customers

Showing up in the right place at the right time

How are we showing up in the right place at the right time?

Bringing a welcome solution to a pressing need

Assess yourself! Lead generation edition, Part 1

What do we mean by lead generation?

Understanding your customer

Questions to ask yourself

How are we listening?