Mike Piccolo mfpiccolo

React context vs Redux in 2020

The [React docs][condoc] give some example use cases for context:

Context is designed to share data that can be considered “global” for a tree of React components, such as the current authenticated user, theme, or preferred language.

The common property of these use cases is that data like the current theme doesn't change often and needs to be shared deep down the component tree, which would be cumbersome with "[prop drilling][drill]". Something else that needs to be shared everywhere is the application state when using a "single source of truth" pattern, so it would follow that the context API would help with that as well, but there's a catch: components that use context will rerender every time that the provided value changes, so sharing the whole application state through context would cause excessive render lifecycles.

Ruby to Rust Cheat Sheet

The goal of this is to have an easily-scannable reference for the most common syntax idioms in Ruby and Rust so that programmers most comfortable with Ruby can quickly get through the syntax differences and feel like they could read and write basic Rust programs.

What do you think? Does this meet its goal? If not, why not?

Variables

Ruby:

Converting libraries to Ember CLI addons

In this guide we will cover two main cases:

Ember specific library
vendor library

Ember library

The Ember library will assume that Ember has already ben loaded (higher in the loading order) and thus will assume it has access to the Ember API.

The final result: require() any module on npm in your browser console with browserify

This article is written to explain how the above gif works in the chrome (and other) browser consoles. A quick disclaimer: this whole thing is a huge hack, it shouldn't be used for anything seriously, and there are probably much better ways of accomplishing the same.

Update: There are much better ways of accomplishing the same, and the script has been updated to use a much simpler method pulling directly from browserify-cdn. See this thread for details: mathisonian/requirify#5

	import React, { Component, PropTypes } from 'react';
	import createBrowserHistory from 'history/createBrowserHistory';
	import History from 'react-router/History';
	import StaticRouter from 'react-router/StaticRouter';

	import { LOCATION_CHANGE } from './routerReducer';

	class DispatchingRouter extends Component {
	static propTypes = {
	store: PropTypes.object,

	import Ember from 'ember';

	export default Ember.Component.extend({
	didInitAttrs(options) {
	console.log('didInitAttrs', options);
	},

	didUpdateAttrs(options) {
	console.log('didUpdateAttrs', options);
	},

	#![feature(core_intrinsics)]

	struct Something
	{
	data:u32,
	}

	impl Something
	{
	pub fn name(&self)->String

	virtual_class = (classes...)->
	classes.reduceRight (Parent, Child)->
	class Child_Projection extends Parent
	constructor: ->
	# Temporary replace Child.__super__ and call original `constructor`
	child_super = Child.__super__
	Child.__super__ = Child_Projection.__super__
	Child.apply @, arguments
	Child.__super__ = child_super

	/*
	What happens?
	- `new Type().what` is looked up with a call to `get` on the proxy
	- a function is returned that will look up `METHOD_NAME` when called
	- `METHOD_NAME` is called because of the `()` behind `new Type().what`
	- if `METHOD_NAME` exists on you object, your own function is called
	- if not, because of prototypal inheritance, `get` is called again
	- `name` is now `METHOD_NAME` and we can throw as we know `METHOD_NAME` is not implemented on the type

	credits http://soft.vub.ac.be/~tvcutsem/proxies/