Samuel Schuhmacher forgetaboutit

Rich Hickey on becoming a better developer

Rich Hickey • 3 years ago

Sorry, I have to disagree with the entire premise here.

A wide variety of experiences might lead to well-roundedness, but not to greatness, nor even goodness. By constantly switching from one thing to another you are always reaching above your comfort zone, yes, but doing so by resetting your skill and knowledge level to zero.

Mastery comes from a combination of at least several of the following:

Ubuntu Upstart Script for Team City

Install TeamCity.conf and TeamCityAgent.conf in /etc/init/
Create TeamCity in /etc/default/TeamCity
Make sure TEAMCITY_DATA_PATH and TEAMCITY_SERVER_PATH are owned by www-data
Start TeamCity
```
 sudo service TeamCity start
```

The Indexed Continuation Monad in Haskell, Scala, and C#

The indexed state monad is not the only indexed monad out there; it's not even the only useful one. In this tutorial, we will explore another indexed monad, this time one that encapsulates the full power of delimited continuations: the indexed continuation monad.

Motivation

The relationship between the indexed and regular state monads holds true as well for the indexed and regular continuation monads, but while the indexed state monad allows us to keep a state while changing its type in a type-safe way, the indexed continuation monad allows us to manipulate delimited continuations while the return type of the continuation block changes arbitrarily. This, unlike the regular continuation monad, allows us the full power of delimited continuations in a dynamic language like Scheme while still remaining completely statically typed.

	$ErrorActionPreference = "Stop"

	$notificationTitle = "Notification: " + [DateTime]::Now.ToShortTimeString()

	[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null
	$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText01)

	#Convert to .NET type for XML manipuration
	$toastXml = [xml] $template.GetXml()
	$toastXml.GetElementsByTagName("text").AppendChild($toastXml.CreateTextNode($notificationTitle)) > $null

	import static java.lang.System.*;

	import java.util.function.BiFunction;
	import java.util.function.Function;

	// Implementation of a pseudo-GADT in Java, translating the examples from
	// http://www.cs.ox.ac.uk/ralf.hinze/publications/With.pdf
	// The technique presented below is, in fact, just an encoding of a normal Algebraic Data Type
	// using a variation of the visitor pattern + the application of the Yoneda lemma to make it
	// isomorphic to the targeted 'GADT'.

	using System;
	using System.Collections.Immutable;
	using System.Reactive;
	using System.Reactive.Linq;
	using System.Reactive.Subjects;

	namespace Steellworks.Rx.UndoRedo
	{
	/// <summary>
	/// Defines properties for fetching a value and its inverse.

	# Original Rails controller and action
	class EmployeesController < ApplicationController
	def create
	@employee = Employee.new(employee_params)

	if @employee.save
	redirect_to @employee, notice: "Employee #{@employee.name} created"
	else
	render :new
	end

	-- in reply to http://www.reddit.com/r/haskell/comments/21mja6/make_lllegal_state_transitions_unrepresentable/
	--
	-- We implement a tiny language with three commands: Open, Close, and Get.
	-- The first Get after an Open returns 1, the second Get returns 2, and so on.
	--
	-- Get is only valid while the state is open, and
	-- Open must always be matched by a Close.
	-- We enforce both restrictions via the type system.
	--
	-- There are two valid states: Opened and Closed.

	macro $do {
	rule { { $y:expr } } => {
	$y
	}
	rule { { $x:ident <- $y:expr $rest ... } } => {
	λ['>=']($y, function($x) {
	return $do { $rest ... }
	});
	}
	}

	# to generate your dhparam.pem file, run in the terminal
	openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048