Hi all. I recently joined a team that's in the process of growing from 2 to 10 developers. What I'm wondering is twofold: 1) how do we pick technologies that are accessible to Jr/Mid developers, and 2) how do pick technologies that enable Jr/Mid developers to write code that's mostly indistinguishable from code that Mid/Sr developers write?

Let's take Ruby for example. It's a very expressive and powerful language, but right off the bat you need to understand concepts such as metaprogramming, blocks vs. procs vs. lambdas, class vs instance methods, class inheritance + include/extend, and several other topics that can't be avoided for very long. While these allow Mid/Sr devs to write amazingly terse code, it leaves Jr devs trusting a lot of "magic" until they've had a few years working with it.

On the same hand, let's look at Javascript: in a simple Ember controller, you may need to understand how anonymous functions (and passing them around) work, how map/reduce works, type coercion, this.get vs. Ember.get, the entirety of what "this" is, and how to read "property('events.@each.category.name')" -- that's all before you dig into the more generic Ember concepts, how routing works, how Handlebars works, etc etc.

And this is all before we even start talking about automated testing.

Now, to compound this, (in my experience), all of the flexibility above leads developers to write code that looks idiomatic, but can be very hard to follow, whether it's a matter of overusing observers and events in Javascript, or writing Ruby code that bounces you between several classes for the sake of over-abstracting a simple problem.

Is the solution just a matter of more pairing + stricter code review? Or maybe using different languages like Python that encourage a "right" way of building things?

I'm very interested in hearing how your companies manage to develop maintainable code in a way that still allows Jr/Mid developers to succeed.