Evan Martin

I did some exploration of this idea in a followup build system! See https://neugierig.org/software/blog/2022/03/n2.html . (It's not really production-ready.)

Ninja is one of the best tools I have used. It is extremely simple and always works flawlessly. Some blog posts from the creator of ninja: https://neugierig.org/software/blog/2018/07/options.html https://neugierig.org/software/blog/2011/04/complexity.html

There was an entry from one of the Chrome early developers on NH recently: https://neugierig.org/software/blog/2022/12/chrome.html > “Chrome 12 [an old version] was the best Chrome", but since I’ve come to see underneath that for me what I wanted was a fast tight browser, and once I had that, pretty much by definition most subsequent work was just gonna make it worse. Safari is today’s fast tight browser I dare say.

Great post. A point that neither this article nor the recent ninja retrospective (http://neugierig.org/software/blog/2020/05/ninja.html) touch on though is that hashing of files is an important step if you'd like to keep caches locally, but especially if you'd like to keep caches remotely. A key reason that Bazel-alikes (including http://www.pantsbuild.org, which I work on) hash things is for use in cache keys. And many of those systems use file watching facilities (notify, fsevents) to determine whether files need to be rehashed. If done properly (i.e.: no false negatives), this is significantly faster than checking file mtimes, and it allows for "early cutoff", where if after hashing the digest of a file has not actually changed, you can skip rebuilding its dependents.

I wouldn't recommend Iron. http://neugierig.org/software/chromium/notes/2009/12/iron.html

If you measure by number of commits (whatever that's worth), data is at http://neugierig.org/software/chromium/notes/2010/02/webkit-commits.ht… So the answers for "currently" and "cumulatively" differ at least by this metric. And the metric itself is questionable, as the blog post says.

> Also, I see you amended your original comment with a jab against me for the type keys post. I didn't realize you were the same person who wrote that blog post, and I edited it to include it when I realized. I linked your amended version, not your initial version if that's of any worth. And you're correct it's not closed. I still stand by that particular proposal is going nowhere. You can make any proposal you want. It hasn't even moved to the design stage yet in 3 years, so I'm not sure why it's something you hang on to as a signal error handling is changing. Take generics for example, and the years (decade) of work that it took. This is unsolicited blog feedback: Your blog and writing style doesn't read like it comes from a place of humility and learning, but from a place of authority. Sometimes that's OK, but in your case, feels unwarranted. And the constant push to get it on to HN or Reddit or N other platforms so it can spread... Thought leadership as an aspirational goal has never been something I look for in blogs I read (I recoil and go elsewhere when I sense this is the goal). I understand it's hard work, and you want others to see it, but just someone else's perspective. Some blogs that I really enjoy (and I hope others emulate so I'm sharing): - http://neugierig.org/software/blog/ - https://brooker.co.za/blog/

The author actually talks about this in an earlier post[0] [0]: https://neugierig.org/software/blog/2026/04/theseus.html

Here are some notes on Jujutsu from Evan Martin that I found interesting/useful: https://neugierig.org/software/blog/2025/08/jj-bookmarks.html

Evan Martin started Ninja when he was working on Chrome at Google: https://neugierig.org/software/chromium/notes/2011/02/ninja.html Hence, it's used in a lot of Google projects.

OMG, so many open source projects need to read this: https://neugierig.org/software/blog/2018/07/options.html (hello FreeCAD ;)

Direct link: https://neugierig.org/software/blog/2023/08/x86-x64-aarch64.html

A lot of personal sites such as this one are built on a public repo someplace, and one is often invited to submit typo corrections etc. upon finding the source. In this case, though, my search dead-ended at code for your custom, minimalist static site generator. https://github.com/evmar/cms Date stamp is part of the metadata passed into the generator, according to https://neugierig.org/software/blog/2022/10/blog-software.html, but I don't see anywhere that the Go code checks whether a post's date is in the future. Did you intend to add a post-scheduling feature but haven't gotten to it?

Having been moderately involved in it, that isn't my impression. They were a helpful and informative bunch, and I learned a lot from them. That said, being an outsider, I'm reminded of this quote from a recent article: > "What was the deal with [person X] on your team, why are they such a jerk?" (Sadly, if you worked on Chrome you probably know exactly who I'm talking about.) The experience gave me an appreciation for how a group, especially a faceless internet group, can be perceived by its worst behavior. Source: https://neugierig.org/software/blog/2022/12/chrome.html

Very cool! The two demos seem to be broken right now, but I guess this is nowhere near being released and/or intended for public consumption yet. Also (from "Taking a break" linked [1] in the post): does Figma not use email? Wut? [1]: https://neugierig.org/software/blog/2022/09/break.html

This comment (https://news.ycombinator.com/item?id=32702062#32703005) from this thread links to this post: https://neugierig.org/software/chromium/notes/2011/08/zygote.html TL;DR: right after launch, Chrome forks off a helper process which is then responsible for forking off child processes, so that all child processes use the same process image as the main Chrome process. It also opens all files it will need right after launch and just re-uses the same file descriptors, so it always keeps references to the old files. This is complicated and brittle and a source of bugs, but when everything works and nobody makes a mistake, it means the old Chrome can keep running without problems even after all its files have been replaced with those from a new Chrome. At least that's how it worked in 2011 according to Evan Martin.

Corresponding blog post: http://neugierig.org/software/blog/2022/03/n2.html

Be sure to also read this link he mentions: http://neugierig.org/software/blog/2018/09/typescript-at-google.html There you will get a clear view of why you DO NOT want to become a frontend developper at Google. (plus the dilemna of maintaining internal tools).

There's no secret sauce. The typical aphorisms of software development are generally correct and apply here: * internalize the cost of core changes and don't push them downstream unless you have a really good reason * staff a core team to take care of high ROI horizontal efforts that have high fixed cost to do efficiently, e.g. TypeScript migration of a massive codebase * be careful of what you take on * complexity and code are costs and not end goals Reading them is one thing but seeing the principles play out in detail amidst the mess of reality was illuminating for me. The author's blog[1] touches on these themes a bit more and I think are a good glimpse into their stewardship of the TS/JS codebase. [1] - http://neugierig.org/software/blog/

There is at least one more Evan working in this space who should be on that list. Evan Martin created the Ninja build system and works on making JavaScript builds fast at Google. He has blogged about it here: http://neugierig.org/software/blog/2020/10/scaling-typescript.html

The ninja author has a (relatively) recent blog post about design decisions and lessons learned: * The success and failure of ninja http://neugierig.org/software/blog/2020/05/ninja.html

This write-up led me to Evan Martins blog. What a gold mine. Digestible writing with a peek inside of Google's internals. http://neugierig.org/software/blog/

Chrome and Android have both forked() warmed-up processes to speed application startup. Although looking at this 2011 post it's more complicated than I thought in Chrome: http://neugierig.org/software/chromium/notes/2011/08/zygote.html This one is also kind of old: http://coltf.blogspot.com/p/android-os-processes-and-zygote.html If anyone has any updates on these I'd be interested. As far as I remember App Engine also did a similar thing to avoid reinitializing a Python VM for every request.

In general I agree. My only current exception is that I use Brave[1] instead of Chrome on Android, because Chrome is missing adblocking. It appears that the company behind Brave is large enough to keep the fork somewhat up to date (compared with several other forks that are only updated very infrequently). Also not only security updates are an issue. Some of the previous forks have been maintained by people who hardly had any idea of what they were doing. Interesting blog post about the Iron fork: http://neugierig.org/software/chromium/notes/2009/12/iron.html [1] https://en.wikipedia.org/wiki/Brave_(web_browser)

don't use Iron http://neugierig.org/software/chromium/notes/2009/12/iron.html

Good idea. Give them these: http://neugierig.org/software/c-repl/ https://root.cern.ch/cint

Every time I read a story like this, I'm reminded of Iron: http://neugierig.org/software/chromium/notes/2009/12/iron.html

Here is the blog post about it from the author. It goes into the motivations behind building it and the fact that it was fun project over the weekend http://neugierig.org/software/chromium/notes/2011/02/ninja.html I've used ninja only during my experiments with chromium and I found it blazing fast.

You'll uninstall Iron after you've read this: http://en.wikipedia.org/wiki/SRWare_Iron "Although SRWare claims 'Iron is free and OpenSource' ... Iron 'is entirely closed source and has been since at least version 6'." Or this: http://neugierig.org/software/chromium/notes/2009/12/iron.html

That assumption relies on two uncertainties: 1. The probability of discovering something in all that binary code, especially with the intricate and non-orthogonal nature of x86/x64 assembly and odd compiler optimisations. This isn't some 80's game. A comparison: 28500000 = Chrome binary size [1] 750000000 = Human Genome size (converted to bytes - 1BP = 2bits so 4BP per byte) [2] So we're only 26x more complicated than Chrome and we have absolutely no fucking idea what is going on with us most of the time. 2. The probability of a vulnerability being published to Google versus selling it on the private market. [1] http://neugierig.org/software/chromium/bloat/ [2] http://www.biostars.org/p/5514/