cybai (Haku) CYBAI

Update: See https://github.com/muan/details-on-details instead.

I did a talk at Brooklyn JS called Details on <details> on 2018/07/19. I have way more details prepared than the ones that fit in the slides, so here's the real details on <details>. ❤️

– @muan

Spec

【譯】Rust vs. Go

本文譯自 Julio Merino 2018 年七月撰寫的 Rust vs. Go 一文。Julio Merino 是 G 社僱員，在 G 社工作超過 8 年，無論工作內外，都接觸開發不少 Go 語言，並撰寫 [Rust 點評][rust-review]系列文，來聽聽他對 Rust 與 Go 的想法吧。

Thanks Julio Merino for this awesome article!

Moved to Shopify/graphql-design-tutorial

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.

Pinafore browser bugs

Chrome

sticky element hit detection fails occasionally (nolanlawson/pinafore#1)
video fullscreen in modal on Android forces landscape resize on entire document (no repro in iOS Safari, Firefox Android)
modal with transform is blurry (nolanlawson/pinafore#71)

Edge

In this tutorial we're going to build a set of parser combinators.

What is a parser combinator?

We'll answer the above question in 2 steps.

What is a parser?
and, what is a parser combinator?

So first question: What is parser?

⚠️ 多年未更新，訊息已過時，請直接閱讀官網 https://tokio.rs/ ⚠️

本文譯自 [Tokio internals: Understanding Rust's asynchronous I/O framework from the bottom up][tokio-internals]。
Thanks [David Simmons][david-simmons] for this awesome article!

[Tokio][tokio] 是 Rust 的開發框架，用於開發非同步 I/O 程式（asynchronous I/O，一種事件驅動的作法，可實現比傳統同步 I/O 更好的延伸性、效能與資源利用）。可惜的是，Tokio 過於精密的抽象設計，招致難以學習的惡名。即使我讀完教程後，依然不認為自己充分內化這些抽象層，以便推斷實際發生的事情。

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.

	-- programming

	data Nat : Set where
	zero : Nat
	suc : Nat → Nat

	_+_ : Nat → Nat → Nat
	zero + n = n
	suc m + n = suc (m + n)

	import React from 'react';

	function onlyChild(children) {
	return Array.isArray(children) ? children[0] : children;
	}

	export function combineContext(contexts) {
	class Provider extends React.Component {
	render() {
	const init = this.props.children;