After having been coding for 15 years, writing in many languages, and working on many projects (some big ones and also very small ones). I could say that I really love what I’m doing. But one of the things that I enjoy more, is learning the history of each paradigm and the languages were come from (mainly the first ones). For instance, to go in deep into OOP I work with Smalltalk (with their fascinating live environment with Objects, and messages, everywhere). Also keep reviewing the importance of encapsulations, polymorphism, side-effects, dynamic programming, composition over inherits, taxonomy, etc. And then on the other hand, in FP playing with Lisp, Schema, Javascript, Mondas, Lenses, Transducers, Functors, non-side effects, Pure, Lexical, and Dynamic scope. Also at the reading level, one of my favorite topics is DDD (by Eric Evans and Vaughn Vernon), TDD (Kent Beck, Hernan Wilkinson, Kent C. Dodds, Carlos Ble Jurado, etc). Also always following smart people like Martin Fowler (Code Smell, DSL, MicroServices, etc), Uncle Bob (SOLID, Clean Code & Clean Coder), Abramov (React/Redux ecosystem), Douglas Crockford (Good Part of Javascript, and all your videos), Eric Elliot (his amazing book “Composing Software”), Hernan Wilkinson (OOP, Smalltalk/Pharo, TDD, 10Pines) watching tons of conferences from them among others as well.
I was realizing that all that knowledge that we have, including personal experience, It’s starting to connect in different ways in your mind. And if you think about it, you are able to start to separate them by “levels”. Starting from the very high level, like the top of the mountain, rolling down to more concretes and specific levels (in the base of the mountain). That I called “different layers of knowledge”.
In order to simplify and start to categorize in some way that knowledge I can find at least four kinds of levels of abstraction:
High level: It is completely language-agnostic, with methodologies, abstract concepts, and ideas that help us to follow and implement in any language and paradigm that we use.
Medium level: It’s still language-agnostic because are a set of tools, principles, patterns, and approaches that help us in different ways to kraft our solutions.
Low level: Some of them are language agnostic and others not. We could start to identify different responsibilities codes, and suggest ways to organize our code. The suggestion about the right comments, choosing the right naming of variables, classes, functions, etc.
- Design Patterns (Observer, Strategy, Singleton, Builder, Composite, etc)
- Hight-level design patterns like MVC / MVP / MVVM, MV*, etc
- Clean Code
- Code Smell
- OOCSS, SMACSS, BEM
Very low level: It’s full language/tool/library dependency, ordered by more abstract to more concrete.
- Frameworks (AngularJS, VueJS, Spring-Boot, Meteor, Backbone, GWT, etc)
- Libraries (React, Redux/Flux, JQuery, Lodash, RamdaJS, Stamp, etc)
- Specific Language and library code guidelines (eg: Airbnb, React, etc)
- ESLint and Prettier, are tools that use a particular framework and language.
As problem-solvers guy that we are, one of the main responsibilities that we have it’s using the right methodology, principle, concept, pattern, tool, and approach for the specific problem that we are trying to resolve, but for my experience, I would say that we should have always had in mind the principles to guide as a simpler and cleaner solution!
Please give me your thought about this short article, I love to share ideas and learn from others and I hope this article may be helpful for someone out there!
Also, you can follow me on Twitter, or contact me on Linkedin.
NOTE: I have been influenced by the following talk: “On the Spectrum of Abstraction” by Cheng Lou, that talk blows my mind a couple of years ago. It’s about how to achieve more properties with the least power possible, and where we should be at the right level of abstraction to avoid a lot of problems. Please watch it or at least you could take a look at this summary about that talk.
