While I am in agreement that in general having more than one obvious way to do things are is bad.

I am also in agreement that most of these things are things that happen to be identical for those cases,

but are more generally different.

Consider even python has the same things to a rough approximation.

###
String concatenation

```
In [20]: a="one"; b="two"
In [22]: a + b
Out[22]: 'onetwo'
In [23]: "%s%s" % (a,b)
Out[23]: 'onetwo'
```

Those are basically the same operations you highlight for julia.

Except `string`

I kind of think removing the multiple argument version of `string`

would be good.

So that it only does convert this thing to a string representation.

Having it also do concatenation is not great, since that seems unrelated to me.

```
In [24]: a=1; b=2
In [26]: a + b
Out[26]: 3
In [27]: "%s%s" % (a,b)
Out[27]: '12'
```

Python even has the same kinda behavior here.

##
Create a row vector:

(I say row since python is row major).

```
In [30]: np.asanyarray([1,2,3])
Out[30]: array([1, 2, 3])
In [32]: np.block([1,2,3])
Out[32]: array([1, 2, 3])
```

`np.block`

is actually the equivalent of how `[a;b]`

and `[a b; c d]`

work.

So these really are the direct translations.

##
Create an Empty array

```
In [37]: np.empty((0))
Out[37]: array([], dtype=float64)
In [40]: np.ndarray((0))
Out[40]: array([], dtype=float64)
In [38]: np.asanyarray([])
Out[38]: array([], dtype=float64)
```

I think these are about the same.

Though I am not 100% sure with them.

Point is there are multiple ways.