Nadeem Bitar shinzui

$NAME is a language-agnostic tool for managing your Postgres schema, designed to make downtime-free schema changes as easy as possible to develop and run.

High-level overview

$NAME improves database migration ergonomics in five major ways:

It stores previous versions of your schema in source control and auto-generates scaffolding for new migrations by "diffing" them with the current schema. This ensures that your production schema never drifts out of sync from the schema defined by your application.
It automates many recipes for doing tricky migrations like column renames "online," without requiring downtime or a synchronized application deploy. Naive methods of renaming a column require multiple application deploys and costly table rebuilds. $NAME's recipe doesn't require either.

Programming as Theory Building

Peter Naur

Peter Naur's classic 1985 essay "Programming as Theory Building" argues that a program is not its source code. A program is a shared mental construct (he uses the word theory) that lives in the minds of the people who work on it. If you lose the people, you lose the program. The code is merely a written representation of the program, and it's lossy, so you can't reconstruct

The Problem

Defining records in Haskell causes accessor functions for the record's fields to be defined. There is no seperate namespace for these accessor functions.

The Goal

Be able to

use records in Haskell, which share field names.
use lenses for accessing these fields

Optics By Example Cheat Sheets

The following are appendices from Optics By Example, a comprehensive guide to optics from beginner to advanced! If you like the content below, there's plenty more where that came from; pick up the book!

Operators
Composition Guide
Substitution Guide
Optical Constarints and Types

Operator Cheat Sheet

Modern applications

Most JavaScript developers love making modern applications, with our new language features and latest libraries making our life easier, but has any one ever actually wondered if this ever impacts our users.

We are dealing with abstractions, abstractions are trying to cover a general use case which could not be conforming to yours. Some are over-engineered in ways one can't possibly comprehend, use cases that will never be reached by middle sized applications. Some of these over

	# Manus AI Assistant Capabilities

	## Overview
	I am an AI assistant designed to help users with a wide range of tasks using various tools and capabilities. This document provides a more detailed overview of what I can do while respecting proprietary information boundaries.

	## General Capabilities

	### Information Processing
	- Answering questions on diverse topics using available information
	- Conducting research through web searches and data analysis

	# I found some good resources but they seem to do a bit too much (maybe from a time when there were more bugs).
	# So here's a minimal Gist which worked for me as an install on a new M1 Pro.
	# Inspired by https://github.com/malob/nixpkgs I highly recommend looking at malob's repo for a more thorough configuration
	#
	# Let's get started
	#
	# Let's install nix (at the time of writing this is version 2.5.1
	curl -L https://nixos.org/nix/install \| sh

	# I might not have needed to, but I rebooted

	# nix-env --install --file ./default.nix
	let
	nixpkgs = builtins.fetchTarball {
	url = "https://github.com/NixOS/nixpkgs/archive/c473cc8714710179df205b153f4e9fa007107ff9.tar.gz";
	sha256 = "0q7rnlp1djxc9ikj89c0ifzihl4wfvri3q1bvi75d2wrz844b4lq";
	};

	config = {
	allowUnfree = true;
	};


	{-# LANGUAGE AllowAmbiguousTypes #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE DerivingStrategies #-}
	{-# LANGUAGE FlexibleContexts #-}
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE GADTs #-}
	{-# LANGUAGE GeneralizedNewtypeDeriving #-}
	{-# LANGUAGE InstanceSigs #-}
	{-# LANGUAGE KindSignatures #-}

	#!/usr/bin/env stack
	-- stack --resolver lts-14.20 --install-ghc runghc --package either --package free
	{-# LANGUAGE DeriveFunctor #-}
	module Main
	where

	import Control.Applicative.Free
	import Data.Bifunctor (first)
	import Data.Either.Combinators (maybeToRight)
	import Data.Either.Validation