Andrei Dziahel develop7

This is a pure-Python script which builds on top of difftastics --display json to provide:

more ergonomic and ready to use JSON output
slightly styled HTML table (mimics side-by-side)

it addresses following shortcomings of current (v0.51.1) JSON output:

line-scoped changes within block-scoped chunks are unordered (different each time), had to be sorted by rhs.line_number then lhs.line_number
there seems to be a lot of conscutive single-character entries of same type (highlight) for some (probably unknown?) languages, those are merged

addresses Wilfred/difftastic#45

PostgreSQL is Enough

Background and Cron Jobs

Red area is a result of the upfront, fixed cost of learning Haskell vs Java.
- The company pays this for each new hire.
Yellow area is the developer's productivity gain once they're "over the hump."
- The company can benefit from this, but it must first reach a break-even point vs the cost of learning.
- If average employee tenure is less than this break-even point, the company is taking an absolute loss on each employee.
- For Haskell to truly be worth it from a business perspective, the average tenure must not just eclipse the break-even point, but it must go further to account for the opportunity cost of better productivity during that learning period.
However, employees always benefit from this regardless of turnover - they get to take the productivity gain with them. This - in my opinion - naturally results in some tension.

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

58 bytes of CSS to look great nearly everywhere

When making this website, i wanted a simple, reasonable way to make it look good on most displays. Not counting any minimization techniques, the following 58 bytes worked well for me:

main {
  max-width: 38rem;
  padding: 2rem;
  margin: auto;
}

Building network actors with Node Framework

Article topics:

What is Node Framework?
Sample nodes
Node Framework languages structure
- Core languages
- Framework languages
Node Framework design and architecture

	import Control.Monad (ap, forM_)
	import qualified Data.Map as M

	-- The Collapse Monad
	-- ------------------
	-- The Collapse Monad allows collapsing a value with labelled superpositions
	-- into a flat list of superposition-free values. It is like the List Monad,
	-- except that, instead of always doing a cartesian product, it will perform
	-- pairwise merges of distant parts of your program that are "entangled"
	-- under the same label. Examples:

	public class TransactionExample {
	public static void main(String[] args) {
	Transactor<IO<?>, Unit, String> transactor = new Transactor<>() {
	@Override
	public <A> IO<Either<String, A>> runTransactional(Transactional<IO<?>, String, Unit, A> transactional) {
	Unit connection = UNIT;
	return IO.io(() -> System.out.println("Starting Transaction"))
	.discardL(transactional.run(connection)
	.<IO<Either<String, A>>>coerce()
	.flatMap(e -> e.match(s -> IO.io(() -> System.err.printf("Rolling back transaction due to %s%n", s)),

	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE TypeApplications #-}
	{-# LANGUAGE ImpredicativeTypes #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	module IOHCC where

	import Unsafe.Coerce

	u = unsafeCoerce

	module Utils.Concurrent (mkPipeline, launchNukes) where

	import Control.Concurrent (threadDelay)
	import Control.Concurrent.Async (Async, async, cancel, wait)
	import Control.Concurrent.STM (TBQueue, atomically, newTBQueueIO,
	readTBQueue, writeTBQueue)
	import Control.Monad (forever, void)
	import Control.Monad.IO.Class (MonadIO, liftIO)
	import GHC.Natural (Natural)