Jeff bitburnerz

Ubuntu Mate 20.04 XRDP setup

Documenting XRDP setup which worked for me on Ubuntu Mate 20.04.

Some parts are taken from: http://c-nergy.be/blog/?p=14093.

Install xrdp

sudo apt install xrdp

Async Operations with `useReducer` Hook

9 March, 2019

We were discussing with @erusev what we can do with async operation when using useReducer() in our application. Our app is simple and we don't want to use a state management library. All our requirements are satisfied with using one root useReducer(). The problem we are facing and don't know how to solve is async operations.

In a discussion with Dan Abramov he recommends Solution 3 but points out that things are fresh with hooks and there could be better ways of handling the problem.

Problem

How to write an awesome-wm config with Fennel

Awesome-WM is a X11 window manager, that is configured via Lua. Fennel is a Lisp for Lua. This shows a general setup of how to write your awesome-wm config using fennel directly without the compilation step (which would also work, but is not needed).

General setup

Fetch a recent Fennel version (the

Monoids in Haskell, an Introduction

Why should programmers care about Monoids? Because Monoids are a common pattern that shows up over and over in programming. And when patterns show up, we can abstract them and leverage work we've done in the past. This allows us to quickly develop solutions on top of proven, stable code.

Add Commutative Property to a Monoid (Commutative Monoid) and you have something that can be executed in parallel. With the end of Moore's Law, parallelism is our only hope to increasing processing speeds.

What follows is what I've learned after studying Monoids. It is hardly complete, but hopefully will prove to be helpful as an introduction for others.

Monoid Lineage

Interesting Things about Prolog

Facts = Axioms
Rules = Relations = Predicates

There are 2 types of knowledge in Prolog: Axiomatic Knowledge and Consequent Inferred Knowledge.

Axiomatic knowledge is the knowledge that you write as facts (and as rule predicates) in Prolog. Prolog cannot retract any of these axioms after being written (you can't do this at compile time nor at run time). This is called non-monotonic logic.

	#lang at-exp racket
	(require urlang urlang/html urlang/react/urx)
	(require net/sendurl syntax/parse)

	;;;
	;;; Urlang Configuration
	;;;

	(current-urlang-run? #f) ; run using Node? No, use browser
	(current-urlang-echo? #t) ; print generated JavaScript?

	#lang at-exp racket/base

	(require racket/runtime-path racket/format racket/file
	urlang urlang/html urlang/extra urlang/react/urx urlang/for
	syntax/parse racket/syntax)

	;;;
	;;; CONFIGURATION
	;;;

	;; Initialize Biwascheme interpreter on frontend(browser) then send and receive expressions with websocket client
	;; INSTALL websocket.el, LOAD this file and RUN interactive function `load-ws` from Emacs
	;; ws-close to close server
	;; send expression (e.g functions) to browser with `C-c C-s` ... Tip# cursor should be on function name

	(defun load-ws ()
	(interactive)
	(load-file "~/.emacs.d/websocket.el")
	(start-ws)
	(start-repl))

	#!/bin/bash
	#
	# DESCRIPTION:
	#
	# Set the bash prompt according to:
	# * the active virtualenv
	# * the branch/status of the current git repository
	# * the return value of the previous command
	# * the fact you just came from Windows and are used to having newlines in
	# your prompts.

	# 0 is too far from ` ;)
	set -g base-index 1

	# Automatically set window title
	set-window-option -g automatic-rename on
	set-option -g set-titles on

	#set -g default-terminal screen-256color
	set -g status-keys vi
	set -g history-limit 10000