Raul Murciano raul

Nunebot

A recurring pass over my important projects. Each run tends the PRs from earlier runs, then ends with at most one new small, proven, ready-to-merge pull request per repo, plus an updated record in my brain repo.

How to think about the work

Software is not a factory. A factory builds identical widgets to a fixed spec and is done. Software changes every day: customers, scale, and requirements shift, so a perfect up-front spec never exists. Treat each repo like a painting you come back to: make one deliberate improvement per pass, and leave it better than you found it.

ActiveRecord ETL

I created this to help me run benchmarks/comparisons against Universal ID, but it could serve as the foundation for a robust ETL data pipeline... and it's less than 70 LOC right now! 🤯 🚀

It handles the extract and transform parts of an ETL process and supports the following options:

only - specify which attributes to include

Short link to this page: caseywatts.com/quicktime

Scenario: You want to talk with someone over google hangouts (like for a user study), and you want to record BOTH:

the system output audio (from them)
the microphone audio (from you)

(screenshots below in a comment)

General Setup (do this once)

Types

A type is a collection of possible values. An integer can have values 0, 1, 2, 3, etc.; a boolean can have values true and false. We can imagine any type we like: for example, a HighFive type that allows the values "hi" or 5, but nothing else. It's not a string and it's not an integer; it's its own, separate type.

Statically typed languages constrain variables' types: the programming language might know, for example, that x is an Integer. In that case, the programmer isn't allowed to say x = true; that would be an invalid program. The compiler will refuse to compile it, so we can't even run it.

Do wtf you want to.

one
two

Some text...

$ foo bar

How to set up stress-free SSL on an OS X development machine

One of the best ways to reduce complexity (read: stress) in web development is to minimize the differences between your development and production environments. After being frustrated by attempts to unify the approach to SSL on my local machine and in production, I searched for a workflow that would make the protocol invisible to me between all environments.

Most workflows make the following compromises:

Use HTTPS in production but HTTP locally. This is annoying because it makes the environments inconsistent, and the protocol choices leak up into the stack. For example, your web application needs to understand the underlying protocol when using the secure flag for cookies. If you don't get this right, your HTTP development server won't be able to read the cookies it writes, or worse, your HTTPS production server could pass sensitive cookies over an insecure connection.
Use production SSL certificates locally. This is annoying

	# A Pipeline extension to process steps concurrently
	# Example
	# class ConcurrentPipeline < Pipeline
	# include ConcurrentProcessing
	# end
	#
	# MyPipeline = ConcurrentPipeline.new do \|pl\|
	# pl.step ValidateInput
	#
	# # These steps run concurrently

	/*
	In any of the following scenarios, a critical attribute was left off and needs
	to be corrected.
	*/
	abbr[title=''],
	abbr:not([title]),
	a[href=''],
	a[href='#'],
	a:not([href]) {
	color: var(--color-red-500) !important;

	def defer(&block)
	def block.each ; yield call ; end
	block
	end

	app =
	lambda do \|env\|
	status = 200
	headers = { 'Last-Modified' => exec_sql('SELECT MAX(updated_at) FROM foos').httpdate }