bengoodger

Documentation lists integrations with "select partners" -- and that's why this isn't a serious play for the home. You need to work with everything, like HomeAssistant, Control4, etc. to be a serious contender. They have had years to do this, could have got it all lined up with HomeKit + existing iOS devices. People aren't going to rip out their security system just to integrate with your device. But that would require having a non-adversarial relationship with your developer ecosystem. It's frustrating because home integration software is a wasteland. Those that have succeeded in it have understood it's an ecosystem game.

Seeing the comments here talking about ancient codebases got me wistful for when Chromium was new and everything seemed possible.

That triggered a flash of feeling extremely old realizing we broke ground on this codebase 20 years ago this year!

United seems to like to hang onto extremely old airplanes even as the number of these disruptions mount. We can argue how statistically they're safer etc but these events are extremely unsettling and disruptive for passengers and frankly it's lucky no one's been killed yet. One of these planes dropped a wheel on a parked car at SFO last year.

It's not hard to notice there are other major airlines that generally maintain newer widebody fleets.

I too have nostalgia for a time when prices were reasonable, politicians didn't philander and children respected their elders.

And yet here we are :-)

For what it's worth, despite it being /en vogue/ to rag on Google, the Chrome team has some of the most talented and dedicated folks focused on building a vibrant and interesting web for most people in the world.

Genuinely curious - what do people want to see from a new/different rendering engine?

The web is crazy complex these days because it is an entire app platform.

The incentive for anyone building a browser is to use the platform that gives you the best web compat especially at the outset when you don’t have enough users of your app to be able to make big changes to the platform. Even Chrome didn’t start from scratch - it used WebKit!

The Chromium community has built an excellent open platform that everyone can use. We are fortunate to be able to use it.

Incognito clearly states how it works every time you start it, including what it doesn't protect against.

If we're saying that developers can't clearly and obviously state how things work, and are instead bound by however people think they work based on not reading anything at all, we're in a lot of trouble.

Though... can we at least then get rid of every intrusive TOS screen and cookie banner in existence? Because people click past all of those too without reading them.

netscape.public.mozilla.*

The hierarchy there was basically a reflection of the company's browser team org chart. You could find a group for every team working on the browser where many of them were having their regular technical conversations.

I'm about a half hour into this, and listening to Marc talk about newsgroups brings strong pangs of nostalgia. These days I'm a bit of a greybeard (salt-n-pepper beard?) of web browsing, but I remember getting started in the late days of Netscape, as a teenage open source hacker discovering all the Netscape engineers sitting on the npm.* newsgroups.. how wild it was to be able to turn up there with a question about the browser you used every day and have someone working on it answer! Netscape didn't survive, but what a legacy.

Have a BMW X5 with this auto-steer nonsense and have had several incidents where it's abruptly turned the wheel, where if I weren't grabbing it it would have caused an accident. Ended up disabling the assistant system.

Most Americans don't travel abroad. Those that are accustomed to frequent travel for business or leisure are acutely aware of the current situation because it's already blown up their year.

Quality can be worse in a long-time cycle project: - Engineers are motivated to slam their feature in, because if they miss the train the next one's not for 12 months. - You get one moment per year to connect with your customers & understand how well/not well your changes worked. This means either riskier things happen or that innovation slows to a crawl.

My 2 cents, speaking from some experience working on long time cycle projects and shorter cycle projects.

Is anyone concerned that even in the face of re-training, that two aircraft could find themselves in this position within the first year of operations?

Let's say you were on one of these aircraft and the pilots were able to recover. How terrifying would that be? This is the designed behavior?

It takes special effort to configure a variable width font in a code editor. I have to wonder if they do this to troll observant people like you :p

One maybe interesting anecdote.

May 2015, a few Chrome old timers reacting to the complexity of the code, decided we should try and build something new. This is nothing new for me personally (having worked on Netscape, Firefox and Chrome, and various false-starts along the way). We decided to design a browser based on a service-oriented architecture, using our new IPC and bindings tool (Mojo). This project was called Mandoline. We got a shell up and running that could complete some of Chrome's telemetry test suite. Performance was good. The architecture was clean. Problem was, the browser didn't do all that much. While a team of 6-7 people might have been able to build a browser 10-15 years ago, today browsers are just too complex (in feature requirements).

So our options were to try and convince the Chrome team (huge org) that they should drop everything and help us build this prototype into something real (unlikely, many past examples of failure of this kind of thing - see: Gecko transition/Netscape 6), or to find a way to bring this architecture into Chrome. The first not being a real option, we settled on the latter.

OK so you might ask - why labor under this delusion of building a new browser from scratch at all? Why not just stay within the confines of Chrome from the start, and look at the incremental projects that can be done to pragmatically improve things? My answer is that incrementalism should not be a destination or a goal. It's a tool that helps you get somewhere interesting. If you don't know where you're going, you're lost and incrementalism is just a delusion to trick you into thinking you're making meaningful progress. In the suffocating confines of a massive codebase, it can sometimes be hard to see the forest for the trees. It can be very valuable to step aside and try something else. Stepping aside can be creating a branch and hacking away liberally, or creating something entirely new. The other benefit of doing this is that it doesn't distract or further complicate the shipping product. But then bring the learnings back into the main line. And hopefully in your project you have leads on the main line willing to learn from such discoveries. On the Chrome team we're fortunate that we do.

So this is what we're doing now. We're bringing a service-oriented architecture to Chrome. A few of us have a pretty good mental picture in our heads of what the end state looks like (roughly) and we're using incrementalism to nudge the Chromium codebase there over a few years. The value in this approach is we get to validate our ideas against all the different platforms & features Chrome supports and test it on all of Chrome's users. It means if our changes land & stick that they really are by definition "good". By the end (if there ever really is one) we will have rebuilt much of the system architecture, while shipping every 6 weeks.

I was interested recently to read a similar story here about the plans in Firefox to integrate some of Servo into Gecko. The rationale was very similar. The reality is that you can't burn your user base by neglecting them while you build the massive new thing, or by expecting them to switch to something else. Instead you have to embrace the complexity & figure out how to work within it, while not giving up your dreams.

Chrome team co-founder/engineer/etc. here. Glad you found it useful! Some components like our net stack are particularly cleanly factored. Others have more room for improvement.

I would say that at the beginning of the project (2006-2008) we didn't have so much of a focus on platform design, just on shipping a browser as quickly as possible. Some of the abstractions from that era haven't stood the test of time as the project has scaled to many platforms, features etc.

Over the course of time we've had various refactoring projects to try and pay down some of the technical debt. The first major one was the "content refactor" from 2011. This led to the separation of the multi-process browser shell from the UI layer, which has allowed for other chromium-derived browser apps to emerge.

Today, we've observed that even this layer is a bit too complicated, so we're running more projects to try and modularize it a bit more. My mental model is that the browser is kind of like a set of system services for an ephemeral app runtime, and it's good to imagine what the APIs & separation between those things should be. To aid this we've developed a new suite of IPC tools which are way more useful than the original stuff we have used for much of the lifetime of Chrome.

Anyway this kind of thing requires an ongoing investment and a set of people who thrive on the art of API design and in grungy, challenging refactoring work. I probably have many more thoughts on this topic but this'll do for right now :-)