Ermolay Romanov ermik

1. The Layer Tree

Core Animation's original name is Layer Kit

Core Animation is a compositing engine; its job is to compose different pieces of visual content on the screen, and to do so as fast as possible. The content in question is divided into individual layers stored in a hierarchy known as the layer tree. This tree forms the underpinning for all of UIKit, and for everything that you see on the screen in an iOS application.

In UIView, tasks such as rendering, layout and animation are all managed by a Core Animation class called CALayer. The only major feature of UIView that isn’t handled by CALayer is user interaction.

There are four hierarchies, each performing a different role:

raf.js

A simple script with a few niceties that allows for multiple requestAnimationFrame calls, and FPS pinning.

How it works

The script polyfills rAF if required, then overloads requestAnimationFrame and cancelAnimationFrame with a process that allows multiple frames to be queued up for rAF to run.

This is useful if there are multiple animations running on the page, you want all the callbacks to happen at once, and not on multiple rAF calls. This script is meant as a drop-in solution to that problem.

Simple implementation of debounced fetching in GraphQL to allow merging of multiple rest / database requests into one. Although this example uses GraphQL, the debouncedFetch / fetchProgramPlaycount implementations could probably be used in any context to achieve the same result.

This approach was first described by @leebyron at graphql/graphql-js#19 (comment)

For example this allows turning ten requests for playcounts from this GraphQL query into just one:

{
  latestPrograms(first: 10) {
    name,

playcount

Building a Maintainable, Agile Architecture for Realtime, Transactional Apps

A maintainable application architecture requires that the UI only contain the rendering logic and execute queries and mutations against the underlying data model on the server. A maintainable architecture must not contain any logic for composing "app state" on the client as that would necessarily embed business logic in the client. App state should be persisted to the database and the client projection of it should be composed in the mid tier, and refreshed as mutations occur on the server (and after network interruption) for a highly interactive, realtime UX.

With GraphQL we are able to define an easy-to-change application-level data schema on the server that captures the types and relationships in our data, and wiring it to data sources via resolvers that leverage our db's own query language (or data-oriented, uniform service APIs) to resolve client-specified "queries" and "mutations" against the schema.

We use GraphQL to dyn

MicroService Proxy Gateway Solutions

Kong, Traefik, Caddy, Linkerd, Fabio, Vulcand, and Netflix Zuul seem to be the most common in microservice proxy/gateway solutions. Kubernetes Ingress is often a simple Ngnix, which is difficult to separate the popularity from other things.

Github Star Trend:

This is just a picture of this link from March 2, 2019

Originally, I had included some other solution

New Results:

sorted by rerender time

Solution	Use CSS	Use Inline-Styles	Mount Time (ms)	Rerender time (ms)
react (without styles)	-	-	16.11	29.96
styled-jsx-static	+	-	25.27	42.24
emotion-extract-static	+	+	52.29	44.79
react-css	+	+	28.17	46.18
styletron	+	-	53.03	47.36

	/*
	Copyright 2014 Les Stroud

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software

	import Foundation

	// Some interesting observations on block comparing. Apparently swift nor objective c don't allow comparing closures
	// due to the complexity of the process and because of compiler optimisations… bla bla. But it seems to be possible
	// to do this using conventions blocks, aka the objective c ones that can be cast as objects. The interesting part
	// is how swift freely casts SwfBlock to ObjBlock, yet in reality two casted SwfBlock blocks will always be different
	// values, while ObjBlocks won't. When we cast ObjBlock to SwfBlock, the same thing happens to them, they become two
	// different values. So, in order to preserve the reference, this sort of casting should be avoided.

	typealias SwfBlock = () -> ()

	import UIKit

	extension UIImage {

	// colorize image with given tint color
	// this is similar to Photoshop's "Color" layer blend mode
	// this is perfect for non-greyscale source images, and images that have both highlights and shadows that should be preserved
	// white will stay white and black will stay black as the lightness of the image is preserved
	func tint(tintColor: UIColor) -> UIImage {

	public struct TextSize {

	fileprivate struct CacheEntry: Hashable {
	let text: String
	let font: UIFont
	let width: CGFloat
	let insets: UIEdgeInsets

	fileprivate var hashValue: Int {
	return text.hashValue ^ Int(width) ^ Int(insets.top) ^ Int(insets.left) ^ Int(insets.bottom) ^ Int(insets.right)