Addy Osmani

https://addyosmani.com I'm not a great designer, but I've tried to capture the who, what and jump off points for reading my writing as well as I could. Always impressed by the creativity and soul many other folks seem able to put into their personal homepages!

This feels somewhat hypocritical coming from Addy. Addy Osmani plagiarized my code and 'apologized' years later by publishing an article on his website[1] that he has never linked to from his social media accounts. I cannot accept his apology until he actually syndicates it with his followers. Seems relevant to note this behavior in light of points "6. Your code doesn’t advocate for you. People do.", "7. The best code is the code you never had to write.", and "14. If you win every debate, you’re probably accumulating silent resistance." 1. https://addyosmani.com/an-apology-to-eli/

Forget about Bootstrap and jQuery, learn vanilla js. Reading Eloquent JavaScript is a good starting point. Once you are done with that, build something and join #javascript @ FreenodeIRC and ask for help when you get stuck on something. The good parts is nice but keep in mind that it is very opinionated, still it is worth reading. There are some lectures by Crockford on youtube too (tl;dr) https://www.youtube.com/watch?v=JxAXlJEmNMg&list=PL7664379246A246C… Also this on OOP https://www.youtube.com/watch?v=DwYPG6vreJg Finally you may want to familiarize with the most common JavaScript design patterns (some are not unique to js) http://addyosmani.com/resources/essentialjsdesignpatterns/book/

My favorite JS resource at the moment: http://addyosmani.com/resources/essentialjsdesignpatterns/book/

There is similar content in http://addyosmani.com/resources/essentialjsdesignpatterns/book/ It would be great if you mentioned what works with browserify, webpack, gulp etc.. I'm not sure what percentage of front-end developers still just link a bunch on JS files in the HTML.

'Eloquent Javascript' (http://eloquentjavascript.net/) and 'Learning JavaScript Design Patterns' (http://addyosmani.com/resources/essentialjsdesignpatterns/book/) are the best resources so far.

http://addyosmani.com/blog/ has a lot of good info on working with javascript. The recommended reading in the side bar, particularly javascript garden and principals of idiomatic javascirpt have useful notes about the language and testing suites. I really like Sublime Text 2, there are some great packages for web development and javascript specifically available for it. Plus SFTP and GIT plugins. The Yahoo theater stuff, and crockford's lectures are good. But I would start with Addy Osmani's site and the stuff he recommends.

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… 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…

> You don't have to get 100 score, but passing the core web vitals score and having higher score on mobile is recommended Note that they don't have a CWV score yet due to low traffic. But a 39 performance score from the simulated Lighthouse is often more than enough for a passing grade. That is: if a Moto G4 can do OK, your normal users will likely do great. For instance, a site I made[0] has a 22 from Lighthouse, but a passing CWV grade, so further improvement to the LCP, FID, and CLS would confer no direct Google SEO benefit.[1] (But it may help things like bounce rate, which may confer second-order benefits) > by removing the lazy load effect from the LCP Indeed. Even better, making it high priority instead of normal: https://addyosmani.com/blog/fetch-priority/ [0] https://i.imgur.com/TGD1sj2.png [1] "For example, a page with an LCP of 1750 ms (better than the “good” LCP guidance) and another one with 2500 ms (at the “good” guidance) would not be distinguished on the basis of the LCP signal" – https://support.google.com/webmasters/thread/104436075/core-web-vitals…

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/#modul… 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…

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…

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…

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…

Been exploring loop engineering. Addy Osmani has a good post on it: https://addyosmani.com/blog/loop-engineering/ The hard part of loop engineering IMO is the machinery around it, and omnigent sits above pi, claude, codex, etc. and wraps each in a uniform api. The things it adds are exactly that machinery. - Parallel git worktrees so concurrent agents don't step on each other. - Approval and cost policies enforced at the harness layer rather than living in a prompt the agent can talk its way around. - A maker/checker split where the reviewer can run on a different vendor than the writer, which is a more honest check than a second pass from the same model with the same blind spots.

I'm amazed at how steep the AI learning curve continues to be and how people are spread so far apart on it. I think supercharged learning with AI and agents is undervalued at this point but that more people will realize its utility over time, especially as a complement to delegating work. It also makes me think about the temptation to stop thinking with these tools, i.e. "cognitive surrender". Addy Osmani wrote a nice blog post about this: https://addyosmani.com/blog/cognitive-surrender

Same vibe, different angle: > 11. Abstractions don’t remove complexity. They move it to the day you’re on call. Source: https://addyosmani.com/blog/21-lessons/

Comprehension Debt https://addyosmani.com/blog/comprehension-debt/

Seeing a lot of bullish AI posts today, it makes you wonder if its all a coincidence, or there is a coordinated hype campaign? Antirez - https://antirez.com/news/158 Addy Osmani - https://addyosmani.com/blog/next-two-years/

Or to say it in his own words: "Few individuals have done as much to push the web forward while uplifting its developers, and that legacy will be felt for a long time to come." source: https://addyosmani.com/bio/

I do sort of miss bower [0] for this reason. It was really just a way to download javascript and plunk it into your application. It was standard practice to check all of your vendor dependencies into SCM. [1] Of course a good chunk of it was transformed through something like Gulp or Grunt before being added to the bower repository so you were unlikely to maintain those once checked in, but there was still quite a few packages (small jquery image gallery plugins and the like) that were just some un-transformed javascript someone typed up and threw at bower verbatim. [0] https://bower.io [1] https://addyosmani.com/blog/checking-in-front-end-dependencies/

What about him? It's that he's a model tech evangelist. Who else? When I was paying attention, I thought Addy Osmani was good, https://addyosmani.com/blog/. Eric J. Ma, https://ericmjl.github.io/, is terrific, though I don't know that he would describe him self that way. Hadley Wickham, https://hadley.nz/, for me would be the gold standard.

This seems pretty useful. Addy's Javascript patterns is also a useful side read: https://addyosmani.com/resources/essentialjsdesignpatterns/book/

It doesn't have to be wild west but I don't disagree it usually turns into that. Before frameworks I spent a lot of cycles learning (usually the hard way) how to organize jQuery/JS code so it wasn't a total mess. I like to think I finally got it fairly maintainable for reasonable sized code bases. But by that time existing frameworks made a lot more sense so that's a bunch of thinking I'll never get back. I would guess I'm not the only one in this situation either. Here's a really good book BTW if someone isn't aware of it. https://addyosmani.com/resources/essentialjsdesignpatterns/book/

The term isn't very ubiquitous, but the problem it describes is. Some references — https://addyosmani.com/blog/rehydration/ https://developers.google.com/web/updates/2019/02/rendering-on-the-web

Native lazy-loading[0] is coming in Chrome 75. <img src="celebration.jpg" loading="lazy" alt="..." /> [0] https://addyosmani.com/blog/lazy-loading/

All of Addy Osmani's stuff is well-coded and/or well-written, I've been reading his front-end stuff for almost a decade now: https://addyosmani.com/blog/large-scale-jquery/

This is similar to the Revealing Module Pattern in Learning JavaScript Design Patterns: https://addyosmani.com/resources/essentialjsdesignpatterns/book/#revea… I think it's perfectly readable, and it requires no more language hacks that obfuscate the JavaScript underlying `class` syntax sugar.

Perhaps it's just their preferred platform. If it weren't for the expense I'd probably prefer it over Windows at least. At any rate, the readme does link to this article[1] if macOS isn't your thang. [1] https://addyosmani.com/blog/image-optimization-tools/

I haven't actually used an NPM caching proxy myself. It looks like Artifactory does support acting as an NPM proxy. The other tools I've heard of are Sinopia, Verdaccio, and local-npm. Addy Osmani has a related article at https://addyosmani.com/blog/using-npm-offline/ .