I cannot use Rust in production because its abstraction capabilities are not powerful enough to tackle the problems that arise in my domain.
My application domain is, ironically, high performance computing (numerical simulations). The main piece missing is type level values, but there are also others.
I need type level values to abstract algorithms and data structures over the spatial dimensions of whatever problem I am trying to solve, such that I only have to implement them once. Quad/Octrees, BVHs, structured/unstructured meshes of simplices or hexahedras generalize to arbitrary spatial dimensions. Most numerical methods for PDEs (finite differences/volumes/elements, DG, Lattice Boltzmann) do so as well.
Type level values also would allow better fundamental libraries for, e.g., linear algebra.
But with linear algebra we come to the second piece missing: better support for EDSLs. EDSLs make libraries easy to use, but they are extremely hard to implement in Rust (harder than in C++ and not as powerful). Anything that improves Rust EDSL story would help us implement the libraries that we need. From the top of my head, procedural macros, (way) better CTFE, variadics, and maybe HKTs would help.
There are also some issues with FFI integration. HPC code relies heavily on MPI, whose standard define some macros, that might have different types depending on the implementation used. This makes writing a rust wrapper around MPI a bit of a hassle because those macros have to be dealt with at the build system level, instead of within Rust itself.
Finally, most HPC environments don't have direct access to the internet. This means no rustup.rs, no cargo, no nothing. It would be great if there were ways to use these tools from remote systems, e.g., via ssh tunnels, or if there was an easy way to prepare the environment for a crate in some system, and ship it easily to another one (where everything gets recompiled).
So while I would love to use Rust in production for high performance work, the language currently doesn't allows us to abstract at the level that we need to do our job efficiently. IDE integration, better compile times, lower learning curve... all of these are great, but even if all of these are fixed we would still be unable to use Rust in production.
For this reason I would like to see in the vision for 2017 how Rust plans to expand to those system level/low-level programming fields that it currently struggles at. My field cannot be the only one, so it would be nice to hear of others as well.
EDIT: I rephrased the post because its 1:30am here and the points I tried to make were even unclearer than they are now.
EDIT 2: I think it is actually sad, that Rust concurrency is so good for its age, and that we have so many massively parallel problems (as well as access to so many cores), but cannot use it 