Addy Osmani

Why?

I feel like the person who proposed this is relatively young and newer to coding. The reason why i say this is the functionality he is proposing can already be done using one of the myriad of JavaScript design patterns - https://addyosmani.com/resources/essentialjsdesignpatterns/book/

It can already be done in a clean and easy way with a an anonymous self executing function - (function(){//EVERYTHING HERE IS PRIVATE SCOPE})();

this also has massive added benefits to execution time and variable name resolutions.

Learn more about variable scopes and how powerful JavaScript is.

Also recognize that JavaScript is much closer to a functional programming language than a typical Object oriented language. If u are going to try and make JavaScript objects try and behave like classes that you know and love from java, you are gonna have a BAD time. its going to take way longer to code, gonna be hard to maintain and reason about it. Try instead to write asynchronous event driven code where functions pass data around rather then data passing functions around.

Also it is really dumb trying to set private/public fields in JavaScript code that runs in the browser, i can still easily access all the variables through a debugger or running in a custom environment( like Selenium).

and if your concern is about keeping that data safe in a server environment.. well then your really shouldn't rely on private/public to keep you safe and put in actual user role management and access at the…

There was not such thing like ES3 module syntax. This is just programming pattern many people used: https://addyosmani.com/resources/essentialjsdesignpatterns/book/#modulepatternjavascript

It was a great idea back then, but that was never syntax. This and similar patterns rely on the fact JavaScript is very dynamic and flexible language and enables creating closures and creating objects dynamically.

These are very powerful features of language, but they're dynamic, which is unfortunate because to know what exactly is happening in this code you have to run it. for IDEs/editors it's hard to look at your code and guess "well, it's module pattern, I see! You mean this and that". Tooling operates usually on static analysis of syntax. They use JS parsers to parse code to AST(Abstract Syntax Tree).

And here's the thing: ES6 classes are visible in AST, there is something called ClassDeclaration. This means that every programmer can install some ES6 parser from NPM and analyse ES6 classes. This means that there will be better linting, better autocompletion etc.

On the other hand - JavaScript parsers don't understand module pattern or other homegrown idioms. It's harder to analyse them statically. Especially if they rely on dynamic aspects on language. ES6 parser doesn't run your code. That's why ES6 classes, because they're static, are better for parsers, and consequently, enable better tooling, IDE support, autocomplete etc.

Situation maybe were a little bit different if we had…

I agree with the premise but disagree with the argument.

> Which brings me to the pattern of ever failing technologies. Remember Moo Tools? Prototype? ... Prototype and moo tools tried to be innovative, but they just made things harder. Not only were they not intuitive to use, but referring to the documentation was even worse. Would take hours what jQuery could accomplish in mere minutes.

That's just not true. I can't speak to MooTools, but I used Prototype back in the early Rails days, and it was a pleasure. Great documentation and it jived with the Rails automagical convention-over-configuration approach. Prototype failed because a) it stopped being actively developed, and b) it overrode native object prototypes in a way that could cause other libraries to catastrophically fail. But Prototype didn't fail because it wasn't intuitive, and it didn't fail because it wasn't documented. IIRC, Prototype documentation was actually better than jQuery documentation.

> The main reason Angular JS will fail is because it’s difficult.

This is fair criticism, but there's no supporting evidence provided—only that Angular JS didn't "feel" right and that more people search for "Angular sucks" than "jQuery sucks" on Google.

I think Angular got a lot of core ideas right: two-way binding and extending HTML. But it also comes with an extremely steep learning curve. The directive definition object, with its pre-compile, post-compile, pre-link, and post-link phases is too complex and exposes…

Remote: Yes

Technologies: TypeScript, JavaScript, Next, React, Node.js, Express.js, AWS, Docker, Github Actions, Bash, XState, Redux, React Query, Pixi.js, Playwright, React Native, PostgreSQL, k6

Résumé/CV:https://drive.google.com/file/d/1wqOxf0dmood6Gp5QiRCIP5ZFT4R26L1n/view?usp=sharing

Email: danishali0051 @ gmail . com

My work flow these days looks like this - 50% of time planning and finalising exactly what the requirements are, generating a requirement doc which includes user requirements, our performance budget (https://addyosmani.com/blog/performance-budgets/), how to test it (locally husky or on ci/cd or both) e.t.c performance test and non functional requirements - then 10-15% of the time is spent on Implementation planning and communication with team - The main code implementation , I just tell my friend claude to do it :) - Then my work starts reviewing the the code written by my friend. then comes deploying and monitoring work the Final Boss AWS :P.

dont worry most of these works are done by my besties CKCC Chat GPT, Kiro, Cursor and Claude Code

My formal introduction:

Full Stack Engineer with 5+ years of experience building fast, scalable apps using React, Next.js, and Node.js. I emphasize production readiness with functional testing (Supertest/Jest/Playwright), performance testing (k6/Lighthouse/Networks), and database optimizations (Postgres indexing & queries). Experienced in Docker deployments and AWS (EC2, S3, RDS, Fargate, CodePipeline), I design…

I honestly don't feel like any of the "large scale (JS|Backbone) applications" posts really addresses the difficulties you run into when scaling JS applications.
Most of these things are common sense (eg. "use namespaces", "make use of consistent naming conventions" etc.) and should hold for any kind of application development.

For me, one of the main problems when scaling the Backbone app I work with is decoupling View interactions. Now the usual recommendation you receive is using an event bus. In the link @analog just posted [1], Addy Osmani talks about using the Mediator pattern to achieve the decoupling, which certainly does help, but imho his example does not fully reflect the purpose of the Mediator pattern. His Mediator is barely more than just an event bus.

A Mediator can make use of an event bus, but an event bus is not automatically a mediator.
It still forces the views to know about events triggered from other views and react to them. This still causes coupling, and even worse, it keeps the coupling in the views. The mediator should exist to take care of that coupling and pull it out of the views.

Let's take for example a checkout page. The checkout page has a view containing a form for address data. It also has a view that lets you pick the payment provider, a view that allows you to enter a coupon and a view that shows the order total.

Here are some of the required view-to-view interactions:

* If the user email changed, revalidate the coupon to make…

The industry needs more people like you, passionate and eager to learn.

Start networking. You never know who you might meet. You have a better chance at landing your first job through an acquaintance as opposed to answering a help wanted ad.

Start attending meetups, now. My top recommendation would be OpenHack http://openhack.github.io/new_york/ While you don't have a portfolio of projects on a website, you most likely still have them on your computer. OpenHack may be good place to showcase what you're working on if someone shows interest. Those projects also come in handy for when you start landing interviews. I always took a computer to job interviews to showcase what I was working on and even did some live coding. There's also another advantage to doing it this way: You are in control of the interview and I feel it's a much better approach than sitting through a Q & A with a hiring team. It says, "I came prepared."

For your first job, don't undercut yourself on salary. At least make enough to live. Even if you find a company is horrible, you can still leave yourself open to other options. You might even land your next job, doubling your salary, through someone you worked with and recently left said horrible company. It may take your 2-3 employers to get to your desired salary.

I landed my first job through a random conversation with a neighbor (before that I was college dropout and an office temp for two months trying to land said job). It paid $28k and half of my…