| # Synchronize history between bash sessions | |
| # | |
| # Make history from other terminals available to the current one. However, | |
| # don't mix all histories together - make sure that *all* commands from the | |
| # current session are on top of its history, so that pressing up arrow will | |
| # give you most recent command from this session, not from any session. | |
| # | |
| # Since history is saved on each prompt, this additionally protects it from | |
| # terminal crashes. |
| #!/bin/sh | |
| # AUTHOR | |
| # DANIEL E. GILLESPIE (2016) | |
| # https://github.com/dantheman213 | |
| # DESCRIPTION | |
| # Export your app's table schemas and stored functions from a PostgreSQL | |
| # database into individual *.sql files for easy management and source control. |
| #!/bin/sh | |
| # Copyright (C) 2009-2017 Three Nine Consulting | |
| # Always good practice to update packages. However ask user if they would like to do so | |
| # For explanation on how this works and why check out https://garywoodfine.com/use-pbcopy-on-ubuntu/ | |
| read -p "Do you want to update your package repositories before proceeding ? " -n 1 -r | |
| echo #adding new line | |
| if [[ $REPLY =~ ^[Yy]$ ]] | |
| then | |
| sudo apt update | |
| sudo apt upgrade -y |
Functional programming gets a bad wrap about being too hard for mere mortals to comprehend. This is nonsense. The concepts are actually quite simple to grasp.
The jargon is the hardest part. A lot of that vocabulary comes from a specialized field of mathematical study called category theory (with a liberal sprinkling of type theory and abstract algebra). This sounds a lot scarier than it is. You can do this!
All examples using ES6 syntax. wrap (foo) => bar means:
function wrap (foo) {
using mocha/chai/sinon for node.js unit-tests? check out my utility: mocha-stirrer to easily reuse test components and mock require dependencies
| #!/usr/bin/env bash | |
| # Browse Ramda documentation in Terminal | |
| # Requires jq and a tool such as fzf or peco for interactive filtering | |
| LATEST="http://raine.github.io/ramda-json-docs/latest.json" | |
| DOCS_URL="http://ramdajs.com/docs/" | |
| json=$(curl -s $LATEST) | |
| functions=$(echo "$json" | jq -r '.[] | if .sig and (.sig | length > 0) then .name + " :: " + .sig else .name end') |
| @require 'vars'; | |
| @require 'prefixes'; | |
| /* | |
| Provides man mixins for use within the MDN theme. | |
| */ | |
| /* searches expression for the provided string and replaces with provided value */ | |
| replace($expr, $str, $val) { | |
| $expr = clone($expr); |
Max Goldstein | July 30, 2015 | Elm 0.15.1
In Elm, signals always have a data source associated with them. Window.dimensions is exactly what you think it is, and you can't send your own events on it. You can derive your own signals from these primitives using map, filter, and merge, but the timing of events is beyond your control.
This becomes a problem when you try to add UI elements. We want to be able to add checkboxes and dropdown menus, and to receive the current state of these elements as a signal. So how do we do that?
For this tutorial I'm assuming you are already comfortable with CSS, Sass (I'll use the SCSS syntax) and Compass. Please get set up with each one of those before attempting to use Susy. Sass and Compass both have their own setup instructions and tutorials that you can use.
There is also reference documentation in the works.
CSS Systems
(by @andrestaltz)
So you're curious in learning this new thing called Reactive Programming, particularly its variant comprising of Rx, Bacon.js, RAC, and others.
Learning it is hard, even harder by the lack of good material. When I started, I tried looking for tutorials. I found only a handful of practical guides, but they just scratched the surface and never tackled the challenge of building the whole architecture around it. Library documentations often don't help when you're trying to understand some function. I mean, honestly, look at this:
Rx.Observable.prototype.flatMapLatest(selector, [thisArg])
Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.