shrynx shrynx

Optimizing Rust container builds

I'm a Rust newbie, and one of the things that I've found frustrating is that the default docker build experience is extremely slow. As it downloads crates, then dependencies, then finally my app - I often get distracted, start doing something else, then come back several minutes later and forget what I was doing

Recently, I had the idea to make it a little better by combining multistage builds with some of the amazing features from BuildKit. Specifically, cache mounts, which let a build container cache directories for compilers & package managers. Here's a quick annotated before & after from a real app I encountered.

Before

This is a standard enough multistage Dockerfile. Nothing seemingly terrible or great here - just a normal build stage, and a smaller runtime stage.

Note:

When this guide is more complete, the plan is to move it into Prepack documentation.
For now I put it out as a gist to gather initial feedback.

A Gentle Introduction to Prepack (Part 1)

If you're building JavaScript apps, you might already be familiar with some tools that compile JavaScript code to equivalent JavaScript code:

Babel lets you use newer JavaScript language features, and outputs equivalent code that targets older JavaScript engines.

A vision for data interchange in Elm

How do you send information between clients and servers? What format should that information be in? What happens when the server changes the format, but the client has not been updated yet? What happens when the server changes the format, but the database cannot be updated?

These are difficult questions. It is not just about picking a format, but rather picking a format that can evolve as your application evolves.

Literature Review

By now there are many approaches to communicating between client and server. These approaches tend to be known within specific companies and language communities, but the techniques do not cross borders. I will outline JSON, ProtoBuf, and GraphQL here so we can learn from them all.

Factory Loader

This is a tiny webpack loader that invokes a given module with another as an argument.

What's that useful for? Dependency Injection! Maybe this is how we can solve the VDOM fragmentation issue.

Example

Here's a library-agnostic VDOM component. Notice that it doesn't import react/preact/inferno/whatever - instead, it takes the VDOM library as an argument.

RxJS 5 Operators By Example

⚠️ UPDATE: I have moved the contents of this gist plus more to http://www.learnrxjs.io and https://github.com/btroncone/learn-rxjs. For expanded examples, explanations, and resources, please check out this new location!

A complete list of RxJS 5 operators with easy to understand explanations and runnable examples.

	/* Note, this is only for library interop code. This is not a good way to do things in pure Reason code. */

	module type GeneratorType {
	type value('a);
	type t('a);
	type fn('a) = unit => t('a);

	let valueGet: value('a) => option('a);
	let doneGet: value('a) => bool;

	let cache = new Map();
	let pending = new Map();

	function fetchTextSync(url) {
	if (cache.has(url)) {
	return cache.get(url);
	}
	if (pending.has(url)) {
	throw pending.get(url);
	}

	{-# LANGUAGE GeneralizedNewtypeDeriving #-}

	module Language.HigherRank.Main
	( Expr(..)
	, EVar(..)
	, Type(..)
	, TVar(..)
	, TEVar(..)
	, runInfer
	) where

	[class*='col-'] {
	//Aligns the columns next to each other
	width: 100%;
	float:left;
	min-height: 1px;
	}
	// an extend only class for clearfixing
	%clearfix {
	*zoom: 1;
	&:before,

	// Turns out this was not too difficult.
	// By using the event loop as a global mail box ordering is even guaranteed for messages between only two actors.
	// TODO would like to try and put one actor in a web worker to get some real parallism
	// TODO would like to handle errors and have the concept of a deceased actor while a reference to an actor still exists. Probably involves creating an actor system like in Scala. Eurgh.

	var actor = {
	send: function(message) {
	var self = this;
	console.log("sending to:", self);
	setTimeout(function(){