Viet vietlq

To remove a submodule you need to:

Delete the relevant section from the .gitmodules file.
Stage the .gitmodules changes git add .gitmodules
Delete the relevant section from .git/config.
Run git rm --cached path_to_submodule (no trailing slash).
Run rm -rf .git/modules/path_to_submodule (no trailing slash).
Commit git commit -m "Removed submodule "
Delete the now untracked submodule files rm -rf path_to_submodule

Build a scalable Twitter clone with Django and GetStream.io

In this tutorial we are going to build a Twitter clone using Django and GetStream.io, a hosted API for newsfeed development.

We will show you how easy is to power your newsfeeds with GetStream.io. For brevity we leave out some basic Django-specific code and recommend you refer you to the Github project for the complete runnable source code. At the end of this tutorial we will have a Django app with a profile feed, a timeline feed, support for following users, hashtags and mentions.

I assume that you are familiar with Django. If you're new to Django the [official tutorial] (https://docs.djangoproject.com/en/2.0/intro/) explains it very well.

SchemaSpy is a neat tool to produce visual diagrams for most relational databases.

Here's how to use it to generate schema relationship diagrams for PostgreSQL databases:

Download the jar file from here (the current version is v6.1.0)
Get the PostgreSQL JDBC driver (unless your installed version of java is really old, use the latest JDBC4 jar file)
Run the command against an existing database. For most databases, the schema (-s option) we are interested in is the public one:

How to build a notification feed using Stream

Introduction

In this tutorial we are going to show how easy it is to build a notification feed using GetStream.io. First of all, let's quickly introduce you to our fictional example app. It's called bug-your-friends.com and allows you interact with your friends, ping them, follow them or poke them. Here's a quick list of example interactions:

poke another user (eg. Thierry pokes Alessandra)
follow a user (eg. Tommaso follows Iris)
ping a user (eg. Josie pings Carolina)

Whenever a user is part of one of these interactions, we want to update his notification feed, update the number of unseen and unread

How to solve the curl port 443: Network is unreachable problem:

joridos@localhost:~/Documents/github$ opam init
default    Downloading https://opam.ocaml.org/urls.txt
'opam init' failed.
# opam-version    1.1.1
# os              linux
Cannot download https://opam.ocaml.org/urls.txt, please check your connection settings.
joridos@localhost:~/Documents/github$ curl https://opam.ocaml.org/urls.txt

Table Of Content

Skip to the relevant sections if needed.

2-min tutorial to do it the quick-and-dirty-way
Concepts for resolving Git conflicts
Setting up different editors / tool for using git mergetool
- Finding out what mergetool editors are supported
mergetool simple code example for vimdiff
- Resolving conflict from a Git pull
Other great references and tutorials

Let's Encrypt on Ubuntu 14.04, nginx with webroot auth

This document details how I setup LE on my server. Firstly, install the client as described on http://letsencrypt.readthedocs.org/en/latest/using.html and make sure you can execute it. I put it in /root/letsencrypt.

As it is not possible to change the ports used for the standalone authenticator and I already have a nginx running on port 80/443, I opted to use the webroot method for each of my domains (note that LE does not issue wildcard certificates by design, so you probably want to get a cert for www.example.com and example.com).

Configuration

For this, I placed config files into etc/letsencrypt/configs, named after <domain>.conf. The files are simple:

	import base64
	import hashlib
	import hmac
	from Crypto.Cipher import AES


	key = base64.decodebytes(b'v4QC6l4ttEogiBYvjLyvbA==')
	nonce = base64.decodebytes(b'3iNVHJXuCfYoU9QP49DGqw==')
	ct = base64.decodebytes(b'x9WM3Qy15Xw/2Z6pGVKXVA==')

	/*
	In Ethereum, a contract can be written so that it returns a value for eth_call.
	A Dapp can then check for success or error value of eth_call, before calling eth_sendTransaction,
	to take advantage of eth_call effectively being a "preview" of the code flow that the transaction
	will take. In traditional client-server, clients can't ask servers beforehand what's going to
	happen when the client makes a call; with Dapps contracts can be written so that clients can ask
	for a "preview" of what is going to happen, before any funds/ethers are actually utilized
	(eth_call does not cost any ethers).

	Note: it is possible that in between eth_call and when eth_sendTransaction is actually mined,

	module type CELL = sig
	type 'a cell
	type 'a exp

	val return : 'a -> 'a exp
	val (>>=) : 'a exp -> ('a -> 'b exp) -> 'b exp

	val cell : 'a exp -> 'a cell exp
	val get : 'a cell -> 'a exp