Transferable skills

Here’s a neat way of thinking about tech skills from Addy Osmani, putting them all into two big buckets:

At a macro level, you learn programming concepts that are largely transferable regardless of language. The syntax may differ, but the core ideas are still the same. This can include things like: data-structures (arrays, objects, modules, hashes), algorithms (searching, sorting), architecture (design patterns, state management) and even performance optimizations (e.g. eager vs lazy evaluation, memoization, caching, lazy-loading etc). These are concepts you’ll use so frequently that knowing them backwards can have a lot of value.

At a micro level, you learn the implementation of those concepts. This can include things like: the language you use (JavaScript, Python, Ruby, etc), the frameworks you use (e.g. React, Angular, Vue etc), the backend you use (e.g. Django, Rails, etc), and the tech stack you use (e.g. Google App Engine, Google Cloud Platform, etc). There involve details that can be valuable to gain expertise in to be effective, but are not always transferable.

Software Engineering – The Soft Parts

So the “macro” skills are the transferable ones. I like that. You learn them well, and they move around with you as technology changes. New framework dropped? That’s neat and all, but as Addy says: “the syntax may differ, but the core ideas are still the same.”

I can’t remember when Dave said this, but I know he did, and it stuck with me. We were talking about the general idea of “components” in web development. There are a ton of approaches to them, but they all essentially share the same conceptual model. Scoping, composition, encapsulation, nesting, etc. I made it slide in my last talk:

Components are a macro, and thus transferable concept.