Felipe Oliveira Carvalho felipecrv

It’s common these day when React & React Native developers use State management library (like Redux). I’ve been using React & React Native for a while now and found out that Pure React is actually not bad. In this article I will share my way of doing things with React & React Native purely, without State management library (represented by Redux).

For those of you who are struggling learning Redux, because of the overwhelming of the whole React/JSX/Babel/Webpack/Native Component/Native Module/.. and have to add Redux to the list just to solve some of React problems, or because of the high learning curve of Redux, I hope you find this article helpful.

Some of React problems with State Management

Assuming you have some knowledge of React, I will jump right in the problems that most of us encoutered at the beginning of time learning React:

Flow pass data down, pass event up makes us to pass data & function via props and it's hard to manage when amount of props gets huge. (Comunication between component

Run the following commands as root or user with sudo access to update the packages list and install the prerequisites: To install the Development Tools packages, run the following command as root or user with sudo privileges :

$ sudo apt update
$ sudo apt-get upgrade -y
$ sudo apt-get dist-upgrade -y
$ sudo apt-get install build-essential software-properties-common manpages-dev -y
$ sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
$ sudo apt-get update -y

	// Package winfolder returns the path to known folders on Windows.
	// This package will only build on Windows, so make sure that any
	// Go file using it is guarded to only build on Windows.
	package winfolder

	import (
	"fmt"
	"syscall"
	"unsafe"
	)

	#define BINKGL_LIST \
	/* ret, name, params */ \
	GLE(void, LinkProgram, GLuint program) \
	GLE(void, GetProgramiv, GLuint program, GLenum pname, GLint *params) \
	GLE(GLuint, CreateShader, GLenum type) \
	GLE(void, ShaderSource, GLuint shader, GLsizei count, const GLchar* const string, const GLint length) \
	GLE(void, CompileShader, GLuint shader) \
	GLE(void, GetShaderiv, GLuint shader, GLenum pname, GLint *params) \
	GLE(void, GetShaderInfoLog, GLuint shader, GLsizei bufSize, GLsizei length, GLchar infoLog) \
	GLE(void, DeleteShader, GLuint shader) \

	/* Copyright (c) 2018 Arvid Gerstmann. */
	/* This code is licensed under MIT license. */
	#ifndef AG_RANDOM_H
	#define AG_RANDOM_H

	class splitmix
	{
	public:
	using result_type = uint32_t;
	static constexpr result_type (min)() { return 0; }

	Latency Comparison Numbers Simplified (~2012)
	---------------------------------- log2 log10
	L1 cache reference 0 0 ~ 1 ns
	Branch mispredict 3 1
	L2 cache reference 4 1
	Mutex lock/unlock 6 2
	Main memory reference 8 2
	Compress 1K bytes with Zippy 13 4
	Send 1K bytes over 1 Gbps network 14 4
	Read 4K randomly from SSD* 18 5

	// Baseline version without prefetch
	static const LRMEntry * lrm_search_one_basic(const LRM * lrm, const U8 * ptr)
	{
	LRM_hash_t hash = lrm_hash8(ptr);

	// Jump-in: narrow down the search interval using the jump table
	LRM_hash_t ji = hash >> lrm->jumpInShift;
	S32 jump1 = lrm->jumpIn[ji];
	S32 jump2 = lrm->jumpIn[ji + 1];

	# Hash, displace, and compress: http://cmph.sourceforge.net/papers/esa09.pdf
	# This is expected linear time for any seeded hash function that acts like a random hash function (universality isn't enough).
	# (Actually, the code as written is O(n log n) when targeting 100% load. It's O(n) when targeting any smaller load factor.)
	# You can make keys_per_bucket higher than the default of 4 but construction time will start to increase dramatically.
	# The paper this is based on compresses the seeds (so the fact that the algorithm tries seeds in increasing order is important)
	# which brings the representation size close to the information-theoretical minimum. I don't do any of that here, but it could
	# be done as a postprocess.
	def make_perfect_hash(keys, load_factor=1.0, keys_per_bucket=4, rhash=murmurhash, max_seed=1000000):
	m = int(len(keys) / load_factor)
	r = int(len(keys) / keys_per_bucket)

	// The two sweetspots are 8-bit and 4-bit tags. In the latter case you can fit 14 32-bit keys in
	// a cacheline-sized bucket and still have one leftover byte for metadata.

	// As for how to choose tags for particular problems, Google's Swiss table and Facebook's F14 table
	// both use hash bits that weren't used for the bucket indexing. This is ideal from an entropy perspective
	// but it can be better to use some particular feature of the key that you'd otherwise check against anyway.
	// For example, for 32-bit keys (with a usable sentinel value) you could use the 8 low bits as the tag
	// while storing the remaining 24 bits in the rest of the bucket; that fits 16 keys per bucket. Or if the keys
	// are strings you could store the length as the discriminator: with an 8-bit tag, 0 means an empty slot,
	// 1..254 means a string of that length, and 255 means a string of length 255 or longer. With a 4-bit tag

	(lldb) settings show target.process.thread.step-avoid-regexp
	target.process.thread.step-avoid-regexp (regex) = ^std::
	(lldb) settings set target.process.thread.step-avoid-regexp ""

	http://stackoverflow.com/questions/19413181/step-into-stl-sources-in-xcode-5