git svn clone -A authors --no-metadata --localtime $URL

The file authors can be initially empty. The process will be interrupted when an unknown author is encountered. The format is:

username = Firstname Lastname <email>

Alternatively, if you want to recover the author information from Unix user accounts:

git filter-branch --env-filter ". ~/filter.sh" HEAD

Where filter.sh is something like:

mail="$(cat /etc/mailname)"
 
user="$GIT_AUTHOR_NAME"
full="$(getent passwd "$user" | cut -d ':' -f 5 | cut -d ',' -f 1)"
if [ -n "$full" ]; then
        GIT_AUTHOR_NAME="$full"
        GIT_AUTHOR_EMAIL="$user@$mail"
fi
 
user="$GIT_COMMITTER_NAME"
full="$(getent passwd "$user" | cut -d ':' -f 5 | cut -d ',' -f 1)"
if [ -n "$full" ]; then
        GIT_COMMITTER_NAME="$full"
        GIT_COMMITTER_EMAIL="$user@$mail"
fi

1. List the conflict status (first column = ours, second column = theirs):

   git status -s

   Or more detailed (stage 1 = ancestor, stage 2 = ours, stage 3 = theirs):

   git ls-files -u

2. In case of a git-merge, you can check the history of both heads:

   git log --graph --left-right --boundary HEAD...MERGE_HEAD

   Or, to list only the commits that contribute to conflicts:

   git log --left-right --merge

   In case of git-rebase, you can investigate the history and the commit that is being applied:

   git log git show $(cat .git/rebase-apply/original-commit)

3. Resolve the conflict:
   1. Manual resolution and mark as resolved:

      vim <file> git diff -c <file> git add <file>

   2. Resolution using a tool:

      git mergetool <file>

   3. Resolve by selecting local/other version:

      git checkout --ours <file> git checkout --theirs <file> git diff -c <file> git add <file>

   Note that git-diff can be used to inspect changes against both parents at the same time. The default is --cc (combined/condensed) which omits those hunks from -c (combined) that are identical to the hunk from either parent (see git-diff-tree(1)).

4. (If the resolution went wrong) You can still redo the merge if it is not yet staged:

   git merge-index git-merge-one-file <file>

5. (If you decide the merge was a bad idea, or want to start over) Abort the merge:

   git merge --abort

   Or the rebase:

   git rebase --abort

Assigning an entire array:

nodes=(a b c d)
nodes=(foo*)

Copying an entire array:

nodes=("$@")
nodes=("${values[@]}")

Getting individual elements (zero-based indexing) or the element count:

echo ${nodes[i]}
echo ${#nodes[@]}

Iterating an array:

for node in "${nodes[@]}"; do ... done
for ((i=0; i<${#nodes[@]}; i++)); do node=${nodes[i]}; ... done

Appending to an array:

nodes[${#nodes[@]}]=foo

If you need the last form regularly, it can be simplified with the following shorthand:

function push_back { eval "$1[\${#$1[@]}]=\"\$2\""; }
 
push_back nodes foo

GNU Make has a number of builtin rules and variables for building programs, for example, for C:

COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
LINK.o = $(CC) $(LDFLAGS) $(TARGET_ARCH)
OUTPUT_OPTION = -o $@
 
%.o: %.c
	$(COMPILE.c) $(OUTPUT_OPTION) $<
 
%: %.o
	$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@

Because of these builtins, a basic Makefile for a C project with gcc can be quite simple:

CC=gcc
LDLIBS=-lm
 
SRC=$(wildcard *.c)
OBJ=$(SRC:.c=.o)
 
.PHONY: clean
 
foo: foo.o bar.o
 
clean:
        rm -f $(OBJ) foo

This will not track dependencies on headers and other include files, so this will not properly rebuild when these files are updated. With not too much modification, we can ask gcc to output a dependency file next to each object file that is produced. We ask make to include these dependency files where available:

CC=gcc
OUTPUT_OPTION=-MMD -MP -o $@
LDLIBS=-lm
 
SRC=$(wildcard *.c)
OBJ=$(SRC:.c=.o)
DEP=$(SRC:.c=.d)
 
.PHONY: clean
 
foo: foo.o bar.o
 
-include $(DEP)
 
clean:
        rm -f $(OBJ) $(DEP) foo

The options will generate dependency files alongside compilation (-MMD instead of -MM), and with phony targets (-MP) for dependencies. The rationale for doing this is described in Autodependencies with GNU make, although this article dates from a time when apparently only -MM was available. The options -MMD -MP are a modern way of implementing what is proposed in the article.

Besides GCC, also Clang 3.0 and ICC 12.1 seem to support these options.

ffmpeg -i in.avi -strict experimental -crf 23 -preset medium out.m4v

Where you can deviate from the above defaults:

-crf [18-28]

perceived output quality (lower crf is better quality)

-preset [ultrafast,superfast,veryfast,faster,fast,medium,slow,slower,veryslow]

compression effort (slower preset is better compression)

Using ffmpeg:

ffmpeg -i 01.m4v -c copy -bsf:v h264_mp4toannexb 01.ts
ffmpeg -i 02.m4v -c copy -bsf:v h264_mp4toannexb 02.ts
ffmpeg -i concat:"01.ts|02.ts" -c copy -bsf:a aac_adtstoasc join.m4v
rm 01.ts 02.ts

The bitstream filters take care of container requirements.

From the output directory, use this invocation:

URL=http://www.emsl.pnl.gov/docs/global/index.shtml
wget -r -l inf -k -N -np -p -E $URL

You can play around with the options:

-r

recursive

-l inf

follow link infinitely

-k

convert links after downloading

-N

time-stamping

-np

no parent

-p

retrieve prerequisites of pages

-E

page extensions according to MIME type

The files will be stored under hostname/path/to/file. If you know up front that the origin of the files is restricted to a particular host or even subpath, you can additionally use:

-nH

no subdir for host

–cut-dirs=N

strip N path components

clang++ -std=c++0x -stdlib=libc++

This will use the new libc++.

Start by defining the root for the filenames:

FN=com.host.my
vim $FN.cnf

Now save the following information in the configuration file:

[ req ]
default_bits = 2048
default_md = sha1
encrypt_key = no
prompt = no
distinguished_name = dn

[ dn ]
C = GB
ST = My State or Province
L = My Locality
O = My Organization
OU = My Organization Unit
CN = my.host.com
emailAddress = admin@my.host.com

Next, to generate a new key and certificate signing request:

openssl req -new -config $FN.cnf -keyout $FN.key -out $FN.csr

Or, to create a certificate signing request for an existing key:

openssl req -new -config $FN.cnf -key $FN.key -out $FN.csr

(Optional) To consult the information in the certificate signing request, or to verify the key fingerprint:

openssl req -in $FN.csr -noout -text
openssl req -verify -in $FN.csr -key $FN.key -noout

1. List the conflict status (U = Unresolved, R = Resolved):

   hg resolve -la

2. Check the parents (first parent = local, second parent = other):

   hg parents

3. Resolve the conflict:
   1. Manual resolution and mark as resolved:

      vim <file> hg resolve -m <file>

   2. Resolution using a tool (such as fmmerge):

      hg resolve -t fmmerge <file>

   3. Resolve by selecting local/other version:

      hg resolve -t internal:local <file> hg resolve -t internal:other <file>

4. (If the resolution went wrong) Marking a file as unresolved, to redo the merge:

   hg resolve -u <file>

5. (If you decide the merge was a bad idea) To abort the merge altogether:

   hg update -C <rev>