Like Ma likema

Moved to git repository: https://github.com/denji/nginx-tuning

NGINX Tuning For Best Performance

For this configuration you can use web server you like, i decided, because i work mostly with it to use nginx.

Generally, properly configured nginx can handle up to 400K to 500K requests per second (clustered), most what i saw is 50K to 80K (non-clustered) requests per second and 30% CPU load, course, this was 2 x Intel Xeon with HyperThreading enabled, but it can work without problem on slower machines.

You must understand that this config is used in testing environment and not in production so you will need to find a way to implement most of those features best possible for your servers.

Setting up a SSL Cert from Comodo

Purchasing a Comodo PositiveSSL cert via gogetssl.com and installing it on an Nginx server.

Purchase the cert

Prior to purchasing a cert, you need to generate a private key, and a CSR file

📂 Persistent "pipes" in Linux

In a project I'm working on I ran into the requirement of having some sort of persistent FIFO buffer or pipe in Linux, i.e. something file-like that could accept writes from a process and persist it to disk until a second process reads (and acknowledges) it. The persistence should be both across process restarts as well as OS restarts.

AFAICT unfortunately in the Linux world such a primitive does not exist (named pipes/FIFOs do not persist

These links no longer work. Springer have pulled the free plug.

Graduate texts in mathematics

duplicates = multiple editions

A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen

Source: man syscall

Architecture calling conventions

Every architecture has its own way of invoking and passing arguments to the kernel. The details for various architectures are listed in the two tables below.

The first table lists the instruction used to transition to kernel mode, (which might not be the fastest or best way to transition to

	#! /bin/bash

	# HEADS UP! Make sure to use '*' or a valid hostname for the FDQN prompt

	echo 01 > ca.srl
	openssl genrsa -des3 -out ca-key.pem
	openssl req -new -x509 -days 365 -key ca-key.pem -out ca.pem

	openssl genrsa -des3 -out server-key.pem
	openssl req -new -key server-key.pem -out server.csr

	# tested on Ubuntu 14.04 Desktop Amd64

	# WARNING By running this script, a `pip` command may be replaced with pypy's one.
	# In such case, to invoke the original CPython's pip, you have to run it explicitly,
	# e.g., `python -m pip`.

	# installation of pypy-dev
	sudo apt-get install pypy-dev

	# installation of distribute_setup/pip

	git config --global https.proxy http://127.0.0.1:1080

	git config --global https.proxy https://127.0.0.1:1080

	git config --global --unset http.proxy

	git config --global --unset https.proxy


	npm config delete proxy

	Why do compilers even bother with exploiting undefinedness signed overflow? And what are those
	mysterious cases where it helps?

	A lot of people (myself included) are against transforms that aggressively exploit undefined behavior, but
	I think it's useful to know what compiler writers are accomplishing by this.

	TL;DR: C doesn't work very well if int!=register width, but (for backwards compat) int is 32-bit on all
	major 64-bit targets, and this causes quite hairy problems for code generation and optimization in some
	fairly common cases. The signed overflow UB exploitation is an attempt to work around this.