Issue 1:
Starting with this SO question, I arrived at take() to a in-place array permutation, however when the call is made with the "clip" argument (to avoid creation of a backup in case of exception) the function can be seen to duplicate rows/columns.

Exact test code demonstrating this issue was provided by Stefano M from the SO post comment stream, and appears below.

import numpy as np
print np.version.version

N = 10

# gen ref matrix and permutation
ref = np.arange(N*N)
ref.resize(N,N)
rr = range(N)
np.random.shuffle(rr)

arr = ref.copy()
res = (arr.take(rr,axis=0) == ref[rr,:]).all()
print "test take, not overwriting:", res

arr = ref.copy()
arr.take(rr,axis=0,out=arr,mode="raise")
print "test not-in-place take:", (arr == ref[rr,:]).all()

arr = ref.copy()
arr.take(rr,axis=0,out=arr,mode="clip")
res = (arr == ref[rr,:]).all()
print "test in-place take:", res
if not res:
print "rr", rr
print "arr", arr[:,0]
print "ref", ref[rr,0]

The output is:

1.8.0
test take, not overwriting: True
test not-in-place take: True
test in-place take: False
rr [7, 8, 6, 3, 9, 0, 5, 1, 2, 4]
arr [70 80 60 30 90 70 70 80 60 90]
ref [70 80 60 30 90 0 50 10 20 40]

Also tested in numpy 1.6.2. and 1.7.1, where it seems broken as well.

Issue 2:
EDITED to update with items from @eric-wieser and @shoyer. Feel free to edit to add other items.

A reminder of clean-up after #8247 that could most usefully be done:

Currently, arguments in ufuncs are normalized in get_ufunc_arguments (in ufunc_object.c), well after a check for an override is done; the latter code separately normalized arguments in override.c. Obviously, it would be better if only one of those was done (to the extend possible). As part of this, the type of exception raised should also be made consistent with python, i.e., TypeError for too many/too few arguments, things occurring both as positional and keyword arguments, etc.)

BUG: __array_ufunc__ on arguments like axis would also override the ufunc (#9107).

np.dot and np.matmul are no longer overridden, but it would be good to override np.matmul in particular (as it implements a binop). This would need (1) turn np.matmul into a generalized ufunc (or have it use a new gufunc, after prepending/appending of axes as appropriate); (2) use the same generalized ufunc where feasible inside np.dot (and ndarray.dot), so that the most common cases can be overridden (for other cases, we might want to error on the presence of __array_ufunc__).

(@eric-wieser) Set the __name__ field of the generated NDArrayOperatorsMixin methods (#9012)

(@shoyer) Need to switch ufunc overrides to always raise TypeError if any arguments set __array_ufunc__ = None (#9011)

(@shoyer) Choose the recommended way of implementing binary ops (calling the ufunc directly, or calling __array_ufunc__), and clarify guidance in the NEP (#9027)

(@shoyer) Backwards compatible mixin like NDArrayOperatorsMixin as a separate project (#9016).

(@shoyer) BUG: no way to override matmul/@ if __array_ufunc__ is set (#9028)

(@mhvk) BUG: no way to override __eq__ for structured ndarray (#9153)

ENH/MAINT: let ndarray.__array_ufunc__ be the overall gateway to applying ufuncs on ndarray; that way, this function can just participate in the different trials of objects to see if they can handle the ufunc. As part of that, should they just turn subclasses into regular arrays (since those have had a chance anyway? see discussion in #9079)

(@shoyer) Document the table of ndarray arithmetic special methods and corresponding ufuncs in the proper docs (e.g., reference/array.classes.rst, not the NEP).