slikts

Appreciating the elegant simplicity of Immer

There is an ongoing shift in programming towards a more constrained mindset, recognizing shared mutable state and side effects as significant sources of accidental complexity and concepts like immutability and reactive, unidirectional pipelines as ways to overcome it. Simplicity is less optional than before, based on an understanding about the limited capacity of human working memory and based on programming language theory and practice. The functional programming ideas seeping into the mainstream leave less people to say that they wouldn't need them because of maybe never having used them.

The basic idea of controlling complexity through constraints is not novel at all, though, and it raises a valid question about why this shift has taken so long to develop, despite the overall trends towards automation and productivity. For example, the distincti

sderosiaux

// From haskell "Monoidal Parsing—Edward Kmett"

import cats.implicits._

final case class Balance(l: Int, r: Int)
object Balance {
  val EMPTY = Balance(0, 0)
  val LEFT = Balance(0, 1)
  val RIGHT = Balance(1, 0)
}

suriyadeepan

function Grid(cells, generation, cell_scale){

	this.text = " all work and no play makes jack a dull boy ";
	// cells
	this.cells = cells;
	this.generation = generation;
	// scale
	this.cell_scale = cell_scale;
	// create next generation
	this.next_gen = function(ruleset){

gtors

CREATE FUNCTION key_underscore_to_camel_case(s text)
RETURNS json
IMMUTABLE
LANGUAGE sql
AS $$
    SELECT to_json(substring(s, 1, 1) || substring(replace(initcap(replace(s, '_', ' ')), ' ', ''), 2));
$$;

-- TODO: add recursive processing
CREATE FUNCTION json_underscore_to_camel_case(data json)