Absolutely, and without a doubt.<p>* `unique_ptr` as a local variable.  Before C++11, I needed to either (a) define a holder class for anything that should be deleted at the end of a scope or (b) delete it manually and pray that there isn&#x27;t an exception thrown.  Now, I can just declare it, and trust the destructor to clean up after me.<p>* `unique_ptr` as a return value.  Previously, if a function returns a pointer, there was no way on knowing who was responsible for calling `delete`.  Now, I can clearly indicate intent.  `unique_ptr` means that the caller now owns the object, while C-style pointer or reference means that the callee still owns the object.<p>* With lambda statements, I can call `std::sort` in-place, with the sorting criteria immediately visible.  Previously, I would need to define a function elsewhere in the code, obscuring what may be a simple `a.param &lt; b.param`.<p>* With range-based for loops, I can loop over any container without needing the very long `std::vector&lt;MyClassName&gt;::iterator` declaration.<p>* `= delete` to remove an automatically generated method, such as copy constructors.  Previously, you would declare that method to be private, then never make an implementation of it.  `= delete` shows your intent much more clearly.<p>* `static_assert`, so that you can bail out of templates earlier, and with reasonable error messages.<p>* Variadic templates.  These aren&#x27;t needed in 99% of cases, but they are incredibly useful when designing libraries.<p>* `std::thread`  No more messing around with different thread libraries depending on which platform you are on.