jstanley0

# list pid, execution time, and query text for running queries
def pg_ps
  now = Time.now
  ActiveRecord::Base.connection.execute("SELECT pid, query, query_start FROM pg_stat_activity WHERE state='active'").to_a.each do |q|
    printf "%8d %10.2f  %s\n", q['pid'], now - DateTime.parse(q['query_start']), q['query']
  end
  nil
end

# cancel the current query for the given process

hopsoft

const hoverTime = 400
const fetchers = {}
const doc = document.implementation.createHTMLDocument('prefetch')

function fetchPage (url, success) {
  const xhr = new XMLHttpRequest()
  xhr.open('GET', url)
  xhr.setRequestHeader('VND.PREFETCH', 'true')
  xhr.setRequestHeader('Accept', 'text/html')
  xhr.onreadystatechange = () => {

SamSaffron

require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'
  gem 'pg'
  gem 'activerecord', '5.2.0'
  gem 'benchmark-ips'
end

require 'active_record'

tylerzey

let re;

//this looks for the string between the slashes. it'll match hello but not HeLlo.
re = /hello/;
//the lower case i means be case insensitive. this will match HellO.
re = /hello/i;


// explaination for common search characters

chadwilken

import { Controller } from 'stimulus';

export default class extends Controller {
  connect() {
    this.select2Mount();

    document.addEventListener('turbolinks:before-cache', this.handleCache);
  }

  disconnect() {

mrmartineau

Stimulus cheatsheet

• Website: https://stimulusjs.org/
• GitHub repo: https://github.com/stimulusjs/stimulus
• Handbook: https://stimulusjs.org/handbook/introduction
• Discourse: https://discourse.stimulusjs.org/

Lifecycle callbacks

• initialize: once, when the controller is first instantiated
• connect: anytime the controller is connected to the DOM

wojtha

# Class FeatureFlag defines and stores feature flags
#
# @example Configuration
#
#    FEATURE = FeatureFlag.new do |feature|
#      feature.define(:new_user_profile) do |user_id:|
#        Admin.where(user_id: user_id).exists?
#      end
#
#      feature.define(:third_party_analytics) do

stuartc

# Replaces repetitive memoization syntax:
# ```
# def foo
#   return @_foo if defined? @_foo
#   @_foo = 'bar'
# end
# ```
#
# Usage:
#

headius

Algorithm

1. A secret byte you want to read is stored at inaccessible memory location priv_mem.
2. The sender triggers an access exception by attempting to read priv_mem.
3. Due to CPU optimization (out-of-order execution), the load of secret from priv_mem and the use of its value in (4) and (5) below may execute before the exception is triggered.
4. Calculate an offset into a known array probe by multiplying secret by the width of a cache line (or whatever block size the CPU typically fetches, like a 4096-byte page). This guarantees each of those 256 possible offsets will cache separately.
5. Load probe[offset], which causes the CPU to cache exactly one chunk of of our array, populating one cache line.
6. The exception finally triggers, clearing the modified registers...but cached data is not excised.
7. Iterate over all 256 offsets into probe to find out which one loads fast. You've determined the value of secret.

osulyanov

# Ruby CircleCI 2.0 configuration file
#
# Check https://circleci.com/docs/2.0/language-ruby/ for more details
#

defaults: &defaults
  working_directory: ~/repo
  docker:
    - image: circleci/ruby:2.4.1-node-browsers
      environment: