Forem: Eddie

Launched a new theme for VSCode today

Eddie — Sat, 30 Jan 2021 17:08:23 +0000

Hello everyone! I launched a VSCode theme that my team uses internally. I've had several people ask about it in the past and finally got around to making it available to the public.

I launched it on Product Hunt today and it would be awesome if you checked it out and tried it out yourself! -> Crucial Human Theme for VSCode

Here's some previews and I hope you enjoy it! 😎

JavaScript

CSS

Font used in previews is Fira Code

Create your own State Management solution in one line

Eddie — Mon, 28 Dec 2020 05:33:37 +0000

Not clickbait.

Create a file and name it Store.js. Put the following one line of code in it.

// Store.js
export default {};

Now you can store any data you want and share it across your modules and components without polluting the global namespace.

Example Usage

// main.js
import Store from './Store.js';
import Settings from '../api/Settings.js';

async function init() {
  const response = await Settings.getAll();
  Store.SETTINGS = response.data; // store XHR response in Store module
}

// Module.js
import Store from './Store.js';

function getSetting(key) {
  return Store.SETTINGS[key]; // get a specific setting from the Store
}

// Task.js
import Store from './Store.js';

function loadTask(id) {
  Store.currentTaskId = id; // Store the current id in Store.js
}

Extending the Store

How would extend this simple concept to add options for the following items?

Immutability
Persistence
Transformation

Have dev tools and boilerplate code prevented you from learning how to code?

Eddie — Sat, 25 Jul 2020 17:27:27 +0000

I'm curious to know how many devs here, especially junior devs, have had trouble understanding certain programming syntax and/or concepts and if dev tools and scaffolding scripts like create-react-app have had any part in stunting your growth?

For example, some boilerplate scripts write basic HTML blocks for you, but did that prevent you from fully understanding concepts like:

<meta name="viewport" content="width=device-width, initial-scale=1.0">

<meta charset="UTF-8">

Share your thoughts in the comments!

How to overcome your impostor syndrome

Eddie — Wed, 08 Jul 2020 21:51:02 +0000

When I was in college, my Calculus professor gave me partial credit for a problem that I had solved correctly. He said that I took a few additional unnecessary steps to reach the answer. I was pissed. In my mind, I got the correct answer and he gave me partial credit because I didn't do it the way he wanted. But his point still stood. I could have done it a better way.

Programming is the same; there are multiple ways to solve a problem - some better than others. But unlike the exchange between me and my professor, us programmers can get multiple tries (most of the time).

Let's get into it.

Type every single character of your code

Impostor syndrome could be exacerbated from copy and pasting code snippets and examples and from using boilerplate app starters like create-react-app. As a beginner, you don't know what is going on under the hood and you might nonchalantly say you don't care, but deep down inside, you actually do - or at least if you want to become a good programmer, you should care.

One way to solve this is to practice typing every single character and line of your code. Much like athletes, chess players, and musicians do the same thing over and over again to get better, programmers, especially beginners, should practice repetitive writing.

Even if your code is partially copy and pasted from another source, practice typing that snippet by hand.

Work Backwards

Focus on the intended result. Focus on getting there first. It may be ugly. It may be slow. But that doesn't matter (yet).

Did your button work? Is that modal window displaying? Were you able to fetch the right data set from the API?

Yes, but there are some errors. Who cares? In this exact moment, who freakin' cares? You achieved the result. Now you can focus on making that error disappear, make sure your code is properly tabbed (or is it spaced?), etc.

How do I know if I'm writing bad code?

"In order to write good code, you must first write bad code."

I don't remember who said this, but the answer to knowing if your code is good or bad is: experience. Don't confuse programming best practices for good code. A programming best practice could simply be someone else's opinion, or it could be something that applies to general usage.

Here's a typical best practice for using the viewport meta tag:

<meta name="viewport" content="width=device-width, initial-scale=1">

But if you constantly rely on this as being the best practice, you don't expose yourself to understanding what other parameters and options there are to perhaps handle a situation that is unique to you. Use best practices as a starting point, but don't stop there.

Just start writing code.

It does not have to be perfect. Then ask yourself these simple questions to improve incrementally:

Did I repeat myself too much?
Does my code look messy?
Am I being consistent?

If you have the resource available, ask another person to look it over.

Follow the carrot

The best part about programming is that feeling when you get a win. The cool thing is that these are typically visual and we as humans respond tremendously to visual cues. It's those incremental wins that keep us going.

There's more than one way to solve a problem

This is the key right here. You may have solved the problem, but you might have this looming thought or feeling that the path you took to get there is wrong or not the best way. You might feel self-conscious leading up to a code review. Guess what? That's normal and it's absolutely OK as long as you strive for continuous improvement.

And you know the best part? You can have another crack at it.

You can find me on the Twitter - https://twitter.com/eddieaich

6 essential tools you should know before launching your website

Eddie — Fri, 03 Jul 2020 13:45:56 +0000

Before you launch your shiny new website, use these tools to make sure that your site is compliant, secure, high performing, and can be easily discovered by your audience.

HTML Validators

These tools look for invalid HTML on your site and show you the actual code and line numbers that you need to correct.

W3C Markup Validator

FreeFormatter

Social Media Card Testing

Tests to see how your site will look on social media feeds when someone shares or posts it. Just enter your website address and they will show you the results.

Twitter Card Validator

. How to Create a Twitter Card

LinkedIn Post Tester

Facebook Sharing Debugger

Security Scanning

Mozilla Observatory

Scans your site's infrastructure configuration to ensure that your site is safe and secure. You can also allow third-party tests to be run from Observatory. For example, a scan from ImmuniWeb will check if your site has SSL vulnerabilities.

SSL Labs

Scans your site for SSL/TLS misconfigurations and compliance.

Webmaster Search Console

These tools allow you to directly submit your website for search engine indexing. They also provide tools to measure the mobile-friendliness of your site. If you opt-in, they will periodically send you e-mail notifications if they detect an error on your site that would reduce search engine optimization.

Below are the three most popular options. Note that you will have to prove that you own your domain or are the owner of the website either by providing a specific DNS entry in your configuration or by adding a temporary meta tag to your site.

Google Search Console

Bing Webmaster Tools

Yandex Webmaster

Performance + Speed

Tests your site for speed and performance.

Google PageSpeed Insights

This is basically a web-based Lighthouse.

WebPageTest

Mobile Friendliness / Responsive

Tests to see if your site is mobile-friendly, shows you screenshots and provides suggestions on what you need to fix if your site is not mobile-friendly.

Google Mobile-Friendly Test

Bing Mobile-Friendliness Tool

Summary

Once you've launched your website, you can continuously use the above tools to make sure that your site remains secure, mobile-friendly, and delivers to your audience at blazing speeds.

Happy websiting!

You can find me on the Twitter - https://twitter.com/eddieaich

What is your routine to snap out of a dev funk?

Eddie — Tue, 05 May 2020 14:31:18 +0000

Lately, I've been hitting a wall more often than I would like while I'm programming. No matter how much coffee I drink, I just can't seem to snap out of it. Sometimes, it gets to a point where I'm doing more damage than good. I write sloppy, lazy code. Take shortcuts.

I can't really pinpoint the root cause either. Lack of sleep, stress, kids, distractions.

I've tried all sorts of things but the one thing that has seemed to help me is to exercise vigorously. Do jumping jacks until exhaustion.

What's your routine? How do you identify the root cause? How often do you get into a mental funk?

How to detect when the user stops typing

Eddie — Tue, 07 Apr 2020 14:21:34 +0000

Background

It is common to add keystroke events to input elements to detect when a user is typing such as keypress, keydown, and keyup. But sometimes, these alone are too granular for your needs. Imagine sending a Fetch request to your server to update a DB record after every keystroke!

With just a little bit of code, we can make handling user keystrokes more practical and more performant.

Practical applications

Implement an auto-save feature
Keep your local data store up-to-date
Synchronize the view with real-time collaborators

Here's what you're going to build

Let's define some basic variables

let timer,
    timeoutVal = 1000; // time it takes to wait for user to stop typing in ms

// pointers to our simple DOM elements
const status = document.getElementById('status');
const typer = document.getElementById('typer');

Add two separate event listeners on keypress and keyup

// detects when the user is actively typing
typer.addEventListener('keypress', handleKeyPress);
// triggers a check to see if the user is actually done typing
typer.addEventListener('keyup', handleKeyUp);

Create a timeout on keyup event

// when the user has stopped pressing on keys, set the timeout
// if the user presses on keys before the timeout is reached, then this timeout should be canceled via the keypress event
function handleKeyUp(e) {
  window.clearTimeout(timer); // prevent errant multiple timeouts from being generated
  timer = window.setTimeout(() => {
  status.innerHTML = 'All done typing! Do stuff like save content to DB, send WebSocket message to server, etc.';
  }, timeoutVal);
}

Clear the timeout object on keypress

// when user is pressing down on keys, clear the timeout
// a keyup event always follows a keypress event so the timeout will be re-initiated there
function handleKeyPress(e) {
  window.clearTimeout(timer);
  status.innerHTML = 'Typing...';
}

That's it!

See how simple that was? Now you can make a more accurate determination on when the user has stopped typing and process data more intelligently.

Make it better - other things to think about!

How would you handle Backspace events?
How would you handle version control?

Follow me on Twitter https://twitter.com/eddieaich

How to structure API for creating content with parent/child relationship?

Eddie — Wed, 20 Nov 2019 21:30:20 +0000

I need some advice on deciding which endpoint to use in order to create an article and have that article be assigned to a publication.

Say I have two API endpoints:

/v1/publications
/v1/articles

If I want to create a new article and have it automatically assigned to a publication, should I:

Make the call to POST /v1/publications/article and have that endpoint create the new article as well as its assignment to the specified publication or
Make the call to POST /v1/articles to create the new article and have that endpoint assign the new article to the publication

Ex:

Publications.createArticle(publicationId);
// creates a new article
// publication id is required and auto assigns the new article to publication id

vs.

Articles.create(publicationId);
// Creates a new article
// publication id is optional. If it exists, assign it to the publication
// If it does not exist, just create the article

CSS - Keep it simple! 3 core concepts for a professional look

Eddie — Mon, 11 Nov 2019 15:35:15 +0000

You don't need much to create a professional, clean looking web application. Just follow these three principles and basic techniques in each category and you'll be well on your way to making professional looking user interfaces. Today, we will be looking at the following core concepts:

Spacing
Contrast
Subtlety

Spacing

Spacing covers things like padding, margin, line-height, and letter-spacing. Giving your elements breathing room and space increases readability and cleanliness.

Padding

The amount of padding works hand-in-hand with your chosen font size and line spacing. In this example, I am using padding: 30px;, but as you can see, each line of text seems a bit crowded.

Line Height

The next example includes line-height: 1.5em. Notice how much more readable it is? If I used a smaller font size, then I would probably also reduce the line height, and possibly the padding.

Contrast

Contrast is important for legibility and accessibility. It covers things like difference in color between text and background. It also covers differences in font weight: bold, semi-bold, thin.

Color Contrast

Let's see what happens if we reduce the contrast between the text and background color.

Now let's meet in the middle between black (#000) and medium gray (#999). Below, I am using color: #333;, which reduces the contrast just slightly enough to help reduce eye strain.

Font weight contrast

The headline h2 element provides a contrast between itself and the text below using font weighting.

Notice that there is extra space above the h2? It is there because by default, h2 adds additional margins above and below it. Since we have padding: 30px; all around out box, the extra margin above the h2 is no longer necessary. Let's follow our spacing concept and remove that.

Subtlety

Any complementary styles should be subtle. Let's use border as an example.

Subtle borders

Below, we added a black border, but the contrast between the border and the box's background color seems a bit too strong. We want the focus to be on the content and the black border is taking some of the focus away.

Let's go for a lighter color for the border.

Smoothness

In some cases, you may want your user inteface to be a bit smoother. Let's smooth out the corners of our box a bit using border-radius.

Add subtle interactions

Let's say that we want to indicate to the user that the box is clickable. Let's change the mouse cursor and add a shadow effect to our box when a user hovers the mouse over it, but make sure we are subtle about it!

...and let's add some smoothness to it by adding a transition time between states. We will add transition: 0.3s; to our container style.

Universal Applicability

The three concepts are universal. Here's a dark version.

...and here's an alternative light version.

Summary

See? It doesn't take much to completely change the look and feel of our user interface. Subtle changes can make all the difference. We didn't use any crazy filters or styles. We kept it simple and applied three core concepts - Spacing, Contrast, and Subtlety.

I'm on Twitter @eddieaich

The Pendulum Swing of Development and Technology Trends

Eddie — Wed, 06 Nov 2019 17:14:21 +0000

Pendulum swings happen all around us from time to time. It's when a response to one extreme is the opposite extreme. Examples of industries where pendulum swings are prevalent include:

Politics - left/right dichotomy
Fashion - jeans, hair
Design - open office vs. cubicles

Basically, any industry that is flush with trends and opinions is susceptible to extreme swings and it often feels like we are repeating history.

"…there is no single correct answer, just a lot of subjective decisions to make." — Kat Lynch, Why Software Developers Need Creativity

Software Development and Technology Trends

Our industry is no exception. It goes without saying that we are surrounded by opinions that we often adopt blindly, sometimes to the detriment of our own unique needs. Here is a list of some current trends and swings.

Monorepo

Theoretical Reasons for Trend

Multiple repositories are difficult to maintain.
Reduce dependency management.

Prior Trend

Multiple repositories - Separate our concerns. Teams can work independently. Easier to maintain.

Server-Side Rendering (SSR)

Theoretical Reasons for Trend

Client-side rendering is slow.
Poor to no SEO support.

Prior Trend

Client-side rendering - Browsers are fast now, server-side rendering is slow.

Prior PRIOR Trend

Render content from the Server-Side - PHP, Ruby, Java, Python, etc.

Functional Programming

Theoretical Reasons for Trend

Write less code.
Object-Oriented code is hard to read.
Inheritance and class extension is bad.

Prior Trend

Object-Oriented Programming - Separation of concerns. Everything is an object. Inheritance is good. Easier to read.

Web Components

Theoretical Reasons for Trend

(More) Reusable code.
Combine HTML, CSS, and JS. Everything is right in front of my face in one file.

Prior Trend

Separation of concerns - Separate HTML, CSS, JS from each other.

Desktop Apps

Theoretical Reasons for Trend

Users still like desktop apps for their convenience.
"Always on."

Prior Trend

Web apps - The future of apps will be purely web-based. No need for desktop apps anymore.

Prior PRIOR Trend

Desktop apps - Download and install everything on your computer.

j/k... Web(Assembly) Apps

Theoretical Reasons for Trend

Write using your favorite language - JavaScript, C#, Rust, etc.
The future of apps will be purely web-based.

Prior Trend

Web apps AND Desktop apps - Every useful web app has a companion Desktop app.

On-Premise

Theoretical Reasons for Trend

Any application that my company adopts must be installed internally in our private data centers for maximum security.
I don't care about added maintenance. Security is top priority.

Prior Trend

The Cloud - Less capital costs. Low maintenance of hardware and software upgrades and network management.

Microservices

Theoretical Reasons for Trend

Fix bugs and deploy features with minimal impact.
Tech stack flexibility and choice due to loose coupling.

Prior Trend

Monolith - Common language and tech stack that the entire team understands. Predictability.

GraphQL

Theoretical Reasons for Trend

Give me the data that I want and in the way that I want it.
Less noise and calls, more data.
Compatible with Microservices architecture.

Prior Trend

REST, RPC - Predictable endpoints. Great control and restriction.

...and last but not least, my favorite trend...

Virtual Reality (VR)

Prior Trend - VIRTUAL REALITY!

Prior PRIOR Trend - The real world.

Conclusion

Our industry changes fast and often. It's easy to fall into the shiny object trap. The purpose of this article is five-fold:

Make you aware of current trends
Explain why they exist
Understand the basic history that led up to the trends
Realize that there will be more pendulum swings in the future, and last but not least,
Help you outlast trends and to think for yourself.

Follow me on Twitter @eddieaich

What happens to our data when we die?

Eddie — Thu, 31 Oct 2019 17:57:35 +0000

Because it's Halloween, here's something to ponder...

How many online accounts do you have? Social media, banking, forums, apps, bills, blogs, code repositories, games. How much of your intellectual property, content, identity, and life in general live online?

What would happen if you were to die tomorrow?

Would anyone other than you be able to access all that you have online if you suddenly vanished? If you have friends solely on the Internet, how would they find out if you were no longer living?

Estate Planning

Your online presence and property are often overlooked during Estate Planning. We have common documents like Wills, Trusts, and Power of Attorney but no boilerplate to handle our online lives.

Why is this the case? In many ways, the Estate Planning industry is decades behind. With so much of people's lives now centered around the Internet, there is much room for improvement in this industry suffice to say.

What company policies exist to handle this?

There are a number of policies depending on the type of service you use. For social media, your loved ones' primary option is to memorialize your profile. Here are Facebook's guidelines tucked away in their Help documentation.

If, however, you use a service that may contain valuable information or intellectual property such as a note taking service or code repository, it gets a bit trickier Let's have a look at Evernote's Terms:

Basically, their policy is "store your credentials near your Will and give your account information to your friends." Ok, I guess that's fine.

What about our email accounts?

Google has a process to either close or obtain information from a deceased loved one's account outlined here. They recommend setting an Inactive Account Manager to let them know who can access your account when you have been inactive for a long time.

Steps you can take today

Each service has its own policy and process for handling deceased users. Unfortunately, this is not something we often think about. Setting an Inactive Account Manager is not something a user thinks to do immediately after creating an account.

If you have loved ones, children, or a business that depends on valuable intellectual property, you need to make sure that you have a means for your loved ones and/or business partners to gain access to your online content and properties.

So what can you do? Since every service is different, you can simply create a spreadsheet with all of your important accounts that describes use, purpose, and includes access credentials. If your account requires two-factor authentication, specify the method used (text, auth app, e-mail, phone). Print it out and keep it near your Will or Trust. Just make sure to safeguard your spreadsheet document! This is the easiest.

If you are concerned about storing credentials in a document, another method is to read the Terms of Service and deceased user policies of each service you use and create a document with references to each one. At least your loved ones will know the services and products that you currently use. They can then follow the service's procedures as outlined.

If you have a business/startup

Make sure you have at the very least a policy and process to handle deceased users, especially if you run a service that hosts their sensitive or valuable information.

Consult a qualified attorney to help you draft your process, which will then guide the design and workflow of any technologies you must create to fulfill your duties.

Conclusion

I hope that this gets you to start thinking about your life and content online. This topic is something we rarely think about, but as our lives continue to migrate more and more online and into the virtual world, it is absolutely crucial that you take some sort of action to protect yourself, your loved ones, and/or your business.

I wish you a Happy Halloween!

Follow me on Twitter @eddieaich

The one person/book that changed my life & made me a better developer

Eddie — Wed, 23 Oct 2019 18:41:09 +0000

TL;DR:
It's Addy Osmani. He wrote a book called Learning JavaScript Design Patterns. He made me infinitely better because I learned the underlying principles of programming. Frameworks, APIs, Languages come and go. Programming principles and design patterns are everlasting.

The Infinite Game

I recently saw Simon Sinek speak in NY to launch his new book called The Infinite Game. The core concept of an Infinite Game is to play for longevity - have a vision. Win the war, not the battle. A Finite Game has a predefined, fixed set of rules that all players must abide by. In an Infinite Game, the rules keep changing; the players come and go.

One of the five practices to successfully play in this Infinite Game is to have the capacity for existential flexibility. In other words, arm yourself with universal knowledge so that when the rules change, when the players come and go, you're still a viable player in the game. How does this concept apply to programming?

// Detect dark theme var iframe = document.getElementById('tweet-1186991102890565632-945'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1186991102890565632&theme=dark" }

The Game was Changing

It's 2011. I launched a streaming video startup. At the time, I was weighing which tech stack to use. Mind you, the next evolution of libraries and frameworks were brewing around this time. JS frameworks like Backbone, Ember, Angular were just coming on to the scene. jQuery was ubiquitous. ES6 did not exist. Internet Explorer was still a thing to work around. CORS rules were very loose. SASS was starting to be used more heavily. Node.js was starting to gain meaningful adoption.

The market was changing and changing quickly. It was clear that there was a huge appetite for speed - speed to market, development, production, deployment. Minimum Viable Product (MVP) became a religion.

As a startup founder, I also wanted in on the speed and I thought that with regards to technology, the aforementioned players were the way to go.

Permission to Launch

Suffice to say, I was overwhelmed and confused. The industry seemed to be diverging instead of converging. There were standards set forth by W3C and ECMA, yet these popular frameworks were doing things differently. New ideas were being introduced and pushing the limits - sometimes for the good, sometimes for the bad.

One day, I stumbled upon this unassuming, black and white website. It looked like this:

Screenshot from 2011.

One of the first sentences that I read:

"Another way of looking at patterns are as templates for how you solve problems - ones which can be used in quite a few different situations." - Addy Osmani

Sold.

Exactly what I was looking for. How do I build an application that is scalable enough so that pieces of my code could solve more than one problem across different situations? How do I get fast?

As I read further and learned about patterns, anti-patterns, structure, and specific and trusted patterns like Revealing Module, Decorator, Facade, Observer, I started to understand that there is no one gotcha technique, library, framework; there is more than one way to solve a problem.

"...it’s not the number of patterns you implement that’s important but how you choose to implement them. For example, don’t choose a pattern just for the sake of using ‘one’ but rather try understanding the pros and cons of what particular patterns have to offer and make a judgement based on it’s fitness for your application." - Addy Osmani

I can use more than one technique depending on the situation at hand. Wow - the world is my oyster. Now armed with universal knowledge, more confidence, and a greater understanding of techniques and when to use them, Addy Osmani gave me permission to launch my startup using --- JavaScript. I felt free and empowered.

"You might not think that programmers are artists, but programming is an extremely creative profession. It's logic-based creativity." - John Romero

Speed

I got what I wanted. Speed. Speed in development by being able to reuse code. Speed to market by being able to write with less duplication and looking to my previous solutions for answers. Speed in onboarding team members because now my code was easier to read and structured meaningfully. My 5,000 line file (!!) was broken up into bite-sized pieces.

Existential Flexibility and Longevity

Fast-forward a few years to 2014. Angular 2 was announced and caused an uproar. The JavaScript landscape was changing again. Some of the most used frameworks began to lose traction. Players were going. New players were arriving:

Source: The Brutal Lifecycle of JavaScript Frameworks

I started to question our code and architecture. Should we actively adopt these new frameworks? A bunch of large, successful companies were using them, does that mean we should too?

Changing Players

I came to the realization that what was happening now was deja vu. It happened to the generation of frameworks and libraries 3 years ago, and happened to the frameworks and libraries that came before them and so on. And with Addy Osmani in mind, I realized that developers had simply discovered patterns and recurring problems, sought ways to make better programming decisions and then released their findings in a thing called a framework. This time though, they were called React, Vue, etc. Soon to be followed by names like Next, Svelte, litHtml, and so on. SCSS, LESS. Django, Laravel. They were all just trying to help us because they had experienced their own pains at one point.

If you dig into the code and principles of these frameworks, you'll realize that they are all applying design patterns - some more prominently than others. Observer is a big one. You'll also realize that they are essentially someone's abstractions, opinions - written in a "pure" language like JavaScript, Python, etc. The "magic" was revealed and I realized, that the code that my team and I had written was aligned in principle to such frameworks.

Longevity

We continued to improve the application but because of a number of factors, we were unable to adopt new and emerging standards such as ES6 quickly. Our customers were mostly in the enterprise space which meant that they were using older browsers (IE) and were slow to adopt newer technologies and devices. Our code base stayed on ES5 until my departure in late 2018. Yet, our product was still working. Our customers were still happy. Our development was still fast and scalable. We were still building new features.

New Standards, ES6

The rules of the game had changed yet again. The new and better way of building things was now over there. So there is where people went. ES6 came along in 2015 and established new standards. Much of these new standards, it turns out, were inspired or derived from the frameworks and libraries that came before it!

Browsers changed. Mobile devices became faster. Support for modern language features arrived quickly. Yet, the underlying principles remained. Design patterns remained. ES6 introduced classes, which is just syntactic sugar for prototypical inheritance. Modules were introduced, which is simply extended support for the Module Pattern described by Addy Osmani in his book.

New Hotness and the Infinite Game

Now the hot new thing is Functional Programming and there are some proponents of this paradigm that view it as a religion. All of a sudden, nothing else matters and everything else is wrong. We saw this play out when React introduced Hooks. All of a sudden, if you were still using classes, you're now illegitimate. This is playing with a Finite Mindset inside an Infinite Game.

There will always be a new hotness. It's the nature of the Infinite Game of the software development industry. There is no winner or loser, only ahead and behind - Simon Sinek.

Addy Osmani, Mentor to Many

Addy Osmani equipped me with knowledge that rises above trends and stands the test of time. I can learn new languages and syntax quicker and more efficiently because of my understanding of principles and patterns used. He gave me the confidence to build applications without feeling constrained by certain rules and regulations (i.e. you must ALWAYS do it this way). He instilled in me an Infinite Mindset so that when players come and go, trends arrive and disappear, I am able to remain viable, ready to learn, able to refactor with minimal impact, and build applications that stand the test of time.

Final Thoughts on Mentorship and Thinking for Yourself

Addy Osmani was my mentor and he didn't even know it. He inspired me, gave me confidence and tools, but most importantly, he gave me the freedom to think for myself. The freedom to decide how best to solve my and my team's problems.

There is a big difference between thinking for yourself and reinventing the wheel. Sometimes, the wheels that are in the market just don't fit your requirements and you'll have to make a new one and that is absolutely OK.

Here is a link to Addy Osmani's book, Learning JavaScript Design Patterns - https://addyosmani.com/resources/essentialjsdesignpatterns/book/.