1. Google builds a new process architecture into Chrome as a product differentiator. (It was a major part of Chrome's initial marketing)
2. WebKit 2 is built (mostly by Apple?) to bake the same type of architecture straight into the core framework -- anyone using WebKit can use it and get the same security/stability benefits.
3. Google says that the pain in maintaining their separate, non standard, process architecture is too much of a burden to continue to contribute into WebKit proper, so they must fork.
Why can't Chrome implement WebKit 2? Are there major advantages to Chrome's process model that are not present in WebKit 2? Is there a reason why WebKit 2 cannot be patched to provide those advantages?
This seems like a failure of open source.
: see the first paragraph on http://trac.webkit.org/wiki/WebKit2
Just out of curiosity, why do you think WebKit2 is the "standard"? Just because they named it "WebKit2"? Had Google named their multi-process version "WebKitB" would it be equally standard? It certainly came FIRST (I think it took WebKit2 years before it had an answer).
I think this is a success of open source. Was the creation of WebKit a failure of Mozilla open source? Of course not. Sometimes you need to just actually test two ideas instead of discussing them.
EDIT: Upon further inspection, I think current Safari isn't even using WebKit2. The wiki still says it should be considered a "technology demo", and exists largely in parallel to WebKit. So whatever multi-process thing its doing now I guess is separate? It's not clear to me.
EDIT 2: I guess it is using WebKit2, so my criticisms stand.
I don't know all the history here, but my understanding is that Chrome's engine was never offered in that same sort of way. It was just part of the chromium project, apparently a part that increased the difficulty of integrating with WebKit, not an api intended to be taken by others and integrated into their browser.
It also means that the work they do on the rendering engine for Blink won't be constrained by the constraints imposed by support the various WebKit implementations.
Why is it sad for Chrome development not to be held back by WebKit when each project prefers a different approach?
Personally, I think its win-win: Chrome and WebKit, which have conflicting approaches to a variety of different issues, are free to take their own approaches and prove them. This is a good thing for progress.
> It's certainly not the argument that was made in this blog post, but it certainly is a believable one.
Its actually exactly what the post says when it says "However, Chromium uses a different multi-process architecture than other WebKit-based browsers, and supporting multiple architectures over the years has led to increasing complexity for both the WebKit and Chromium projects. This has slowed down the collective pace of innovation - so today, we are introducing Blink, a new open source rendering engine based on WebKit."
Forking happens all the time and is natural: good since you can go your own way, bad since you no longer contribute to the mainline. Its like speciation in that way, where some group of animals splits off and stops mating with (and hence evolving with) another group of animals.
Blink is open source, it's simply a fork of WebKit. That's why Opera is intending to use it instead of WebKit2. It's like Google wanted to take their ball to another court and still let everyone play.
That's in theory. In practice nobody bothered besides Apple.
That being said, I do like the way Safari "feels" a lot more than Chrome. I think Chrome is actually quite ugly, and bad from a UI perspective. For example, Safari's overflow tab menu is a much nicer solution than Chrome's insistence on shrinking tabs ever smaller until you can't tell them apart at all.
Additionally Chrome is missing a killer feature I use all the time: zoom, and more specifically, double tap to zoom. I find it hard to read a lot of text on websites, and double tap, centered, zoom, is amazing. Its too bad everything else feels like its gotten way worse in the last 5 or so years.
I also think Safari has a much better solution for handling bookmarking when you have multiple tabs. Solve these two issues and I'd switch to Chrome in a second.
I digress… :)
Stacked Tabs Windows
Tabs never shrink, instead they stack on top of each other when there is not enough space.
Sorry, this experiment is not available on your platform.
Double click to zoom seems like something that shouldn't be too hard to do in an extension.
Another example, I'm watching an embedded YouTube video which thus annoyingly doesn't allow fullscreen, so I double tap it, and it fills the browser window, and it seems to be smart enough to render at correct resolution at that scale (since it still allows you to choose a higher resolution even though it won't full screen).
To do similar feats with Chrome I have to manually jigger things around.
Chrome doesn't have the same incentives to get that particular machine working well, especially since the next revision of the Retina Macbook probably won't even need special handling since it will surely have a more powerful GPU. They can just wait it out, similar to what happened with the iPad 3 vs iPad 4, where people had to optimize for the iPad 3 and then those optimizations were unneeded on the iPad 4.
Actually, they "merely" leverage their platform by using CoreAnimation, making it GPU accelerated (and enabling pinch-to-zoom), while Chrome scrolling hits the CPU really hard.
Chrome is even starting to drop native dialog boxes
Also note that the timing is fairly important: Chromium was quite far along with our implementation when WebKit2 was announced, and rather than iterating on the solution we'd proposed and run with, Apple created its own framework. That had advantages and disadvantages.
More generally, I'd point to the Content layer as a better integration point: Opera, for instance, is building on top of our multi-process architecture successfully. Chromium Embedded Framework (https://code.google.com/p/chromiumembedded/) is another example of how other projects can leverage the work we've done.
Before we wrote a single line of what would become WebKit2 we directly asked Google folks if they would be willing to contribute their multiprocess support back to WebKit, so that we could build on it. They said no.
At that point, our choices were to do a hostile fork of Chromium into the WebKit tree, write our own process model, or live with being single-process forever. (At the time, there wasn't really an API-stable layer of the Chromium stack that packaged the process support.)
Writing our own seemed like the least bad approach.
If Google had upstreamed their multiprocess support, we almost surely would have built on it. And history might have turned out differently.
I'd also add that I disagree with Mike about the architectures being really different. In fact, they are quite similar in broad strokes, but with many differences in details (and with the significant difference that the Chromium model isn't in WebKit per se).
I don't know if the contents of these conversations were ever shared with the whole Chrome team as som Chrome people seemed super surprised at our announcement.
It is true that when we announced our effort, it came with a rough working prototype and not just an empty directory. Basically because we did not know if we could do it until we tried.
BTW I am not trying to pick a fight here. I think mikewest's comment gave the impression that Apple built a multiprocess architecture out of cussedness or NIH. But that's not how it was.
Google had the right to make their choices and we had the right to make ours.
Yes, I'm aware of that, but the work had been underway for a long time and was about to be dropped by the time there was a real heads up. So the core of the architecture was already being frozen from a larger perspective.
>BTW I am not trying to pick a fight here. I think mikewest's comment gave the impression that Apple built a multiprocess architecture out of cussedness or NIH. But that's not how it was.
I don't interpret Mike's comments that way. Chromium's architecture was public and available, but we assumed it wasn't used because it didn't fit the needs of WebKit2. There's no malice in that. We designed Chromium from the beginning for SFI (as Adam tried to convey), and that incurs quite a bit of complexity. I'm comfortable that the divergence was simply a result of different needs. I just don't see how it could be presented as something malicious or anti-collaborative.
Are you aware of the earlier conversation that occurred before we wrote any lines of code or even had a name? Where we talked about the possibility of just using Chromium's model if Google was willing to contribute it back? I have mentioned it twice - maybe you overlooked those parts of my remarks.
> Chromium's architecture was public and available, but we assumed it wasn't used because it didn't fit the needs of WebKit2. There's no malice in that. We designed Chromium from the beginning for SFI (as Adam tried to convey), and that incurs quite a bit of complexity.
It had nothing to do with SFI (which wasn't brought up at the time) or complexity. It was for the reasons I stated upthread.
The Chromium code is all in a public repository and was already integrated into WebKit via Chrome's platform layer. Members of the Chrome team were also interested in helping better incorporate Chrome's model into WebKit. So, I must be misunderstanding you, because it seems like you're suggesting that you expected Chrome engineers to simply do all the work.
>It had nothing to do with SFI (which wasn't brought up at the time) or complexity. It was for the reasons I stated upthread.
I still don't get what that reason is supposed to be. Regardless, the resulting WebKit2 design was clearly incompatible with the existing Chrome architecture. And the fact that they were continuing to diverge and place a burden on both projects was a clear problem. This was raised repeatedly, but never seemed to receive any serious consideration.
I regret that this thread has turned into such a back-and-forth. It's not my goal to detract from the Blink announcement. I feel like it would be rude to leave you hanging on mid-thread. However, I feel like:
(a) You are trying to argue with my version of specific events where I was present in person and you (as far as I recall) were not.
(b) You are trying to argue with my stated motivations for decisions that I was part of and you were not.
(c) You seem to want to assign blame.
Maybe my impressions are wrong. But given this, I find it hard to reply in a way that would be constructive and would not further escalate. I hope you will forgive me for not debating about it further.
In light of this, your initial "if Google had only upstreamed their multiprocess support...we almost surely" and reiterations on this point within the thread do seem a bit like PR sleight of hand, since out of context it implies willingness to do so was the only issue on their part.
2) My recollection is that we talked about it around a year after Chrome was released.
Chrome Beta release date: September 2, 2008
Date of WebKit2 announcement: Thu Apr 8, 2010 (after <1 year of development)
I don't have records of the meetings where we walked though.
3) Does the reason for saying no affect whether our choice to make our own thing was reasonable?
This is somewhat moot with 1) and 2) being the case (or at the very least strongly perceived to be the case on your side). At any rate neither side being able to settle on a single version of events signals a communication problem, which makes the whole value of this hypothetical joint undertaking fuzzy anyway.
Nah, you're not misunderstanding, Apple/WebKit has a track record of doing this.
To be clear, I do not consider Blink to be a hostile fork. I wish the Blink developers good luck & godspeed.
As long as the license allows it and the maintainer is not burdened in any way, no?
Compare to forking to solve a very specific or specialized problem that doesn't make sense to merge upstream, like a set of changes that only apply to a very narrow audience or esoteric use-case. In such a case, it's common that changes that do affect the main project are still merged upstream and special care is done to make sure the forks don't diverge too much.
I always believed (hoped) you guys would never be corrupted and do the right thing for the world and not be swayed by organizational affinities / commercial gains.
You have a greater responsibility than to your company or country to keep the web open.
Think on that before you have a further public 'kiddy debate' on she said / he said and throwing the rattle out of the pram.
I don't know much of this history, but was integrating Chrome's processor model into WebKit feasible at the time that WebKit2 was built? What were the reasons for not doing so?
The position we're taking is that the Content layer (in Chromium) is the right place to hook into the system: http://www.chromium.org/developers/content-module That's where we've drawn the boundary between the embeddable bits and the Chrome and browser-specific bits.
Regarding the history, I'd suggest adding some questions to the Moderator for tomorrow's video Q/A: http://google.com/moderator/#15/e=20ac1d&t=20ac1d.40&... The folks answering questions there were around right at the beginning... I only hopped on board ~2.5 years ago. :)
Actually, they didn't say that the pain of maintaining their own work was too much of a burden, they said the pain of maintaining their model within the constraints and obligations WebKit had was too much of a burden (and, imposed too much of a burden on WebKit with regard to what WebKit wanted to do), so they decided fork so that WebKit can do what it wants to do without worrying about Chrome while Blink does what is needed for Chrome without worrying about WebKit.
> Why can't Chrome implement WebKit 2?
Implementing WebKit 2 wouldn't solve the problem going forward. Changes to WebKit to serve Chrome's needs would still have to meet all of the commitments WebKit has, and Chrome would still be placing demands on WebKit.
> This seems like a failure of open source.
Forking isn't failure. The purpose of open source isn't to create a monoculture, it is to enable groups to share effort when they have common goals, and to allow groups with divergent goals (including where those goals diverged after a period of shared work) to continue to benefit from the shared work without having to start back at square one. This is a success of open source.
For a cross-platform project, this is a stunning policy change. I don't know what was the chicken and what was the egg, but it looks like this split was inevitable.
I've always found it curious that open-source advocates rail on people that fork or split from projects instead of maintaining code that they believe isn't worth maintaining.
1. Google builds new process architecture into Chromium.
1a. Apple asks for it to be contributed back to Webkit.
1b. Google either says "no" or doesn't care but expects Apple to do all the work (note that if Google doesn't do it then this would mean the same functionality being implemented at two different points in the code tree -- webkit and chromium)
2. Apple decides to build its own multiprocess support into Webkit2.
Seems to me that the forking is probably overall a Good Thing, no-one is angry at anybody else, it's just a very important codebase which now has way too many stakeholders.
Historically, browsers have relied on vendor prefixes (e.g., -webkit-feature) to
ship experimental features to web developers. This approach can be harmful to
compatibility because web content comes to rely upon these vendor-prefixed
names. Going forward ... we will instead keep the (unprefixed) feature behind
the “enable experimental web platform features” flag in about:flags until the
feature is ready to be enabled by default.
Before anyone starts moaning about incompatibility, let's face it: developers start to rely on new features the moment they're added. Differentiating between different implementations is pointless, since CSS's design means you can specify a property multiple times and your browser will only use the one it understands. The current system also excluded other rendering engines who web developers didn't consider.
So this is a huge win for us, the developers.
All this means is we'll have to go back to the old ways of sniffing out browsers, and I fail to see how that's better.
Nor do I look forward to a deluge of websites prompting me to fiddle with a config to "get the full experience".
Most web developers have very little sway when marketing or clients demand certain things, and this is likely to be something they demand.
>All this means is we'll have to go back to the old ways of sniffing out browsers, and I fail to see how that's better.
The situation is no different just now, because -webkit- applies to Safari, Opera and many mobile browsers, not just Chrome. :/
>Nor do I look forward to a deluge of websites prompting me to fiddle with a config to "get the full experience".
Most web developers have very little sway when marketing or clients demand certain things, and this is likely to be something they demand.
"Use a modern browser [actually, Chrome] to get the full experience" is not an uncommon sight these days.
>"Use a modern browser [actually, Chrome] to get the full experience" is not an uncommon sight these days.
Yup, and it's sucky. It's no different to "this site is optimised for Internet Explorer".
Well, this won't help you here anyway. By the sounds of things, features won't be enabled by default until they're ready. Things currently aren't unprefixed until they're ready. The only way to avoid IE if the feature is unprefixed is UA sniffing.
>Yup, and it's sucky. It's no different to "this site is optimised for Internet Explorer".
It's quite different, actually. Chrome is just quick at implementing web standards, they aren't dictating things and people aren't relying on proprietary APIs.
More so, as I said that particular problem was not nearly as bad as people targeting the rendering of their site to the particular quirks of one particular browser. That was horrible, but it's not even remotely the same problem we face today.
To answer your sort-of question, that time was overshadowed when it became obvious that IE6 (and later IE7) was the absolute worst choice. And that's a reputation Microsoft is still trying to clean, years later.
You file a bug report on the Chrome (and/or Blink) issue tracker, and it gets fixed.
> Something you might, as a developer, want to disable in Chrome, but leave in for everything else?
Then you use user-agent sniffing to disable it, if you must. The same as you'd do for any flaky implementation of a generally-used feature in a browser. That's not really the notional purpose of vendor-prefixing, anyway (which is about not using the unprefixed name space for things which might later end up with a different standard semantics, not about making it easier for developers to avoid buggy implementation of cross-browser common features).
> All this means is we'll have to go back to the old ways of sniffing out browsers
Or only use features that are well supported across common browsers if you want to avoid browser sniffing.
You had me until that. I've had legit, simple, reproducible bugs sit in browsers for years when they're on "new" features that aren't standardized, yet somehow, every other browser that implements the same feature doesn't have the bug.
Browser vendors use the "not-standardized yet" claim to avoid fixing bugs, while still shipping those features, in my experience.
Another issue with Chrome is that percentage widths are rounded or truncated to the nearest pixel, so creating three 33.3% divs won't fill 100% of the space. It makes a fluid grid difficult to create. I reported this one with the built-in bug reporter, so I don't have an issue link.
I'm not sure that pointing out a "known WebKit bug" (as stated in the linked issue) affecting Chrome for which the Chromium team has a patch that apparently hasn't been implemented upstream is the best example of a problem with the "post on the Chrome/Blink tracker and get the issue fixed" approach, given that that approach was offered as an approach to take to deal with issues arising after Chrome splits from WebKit specifically to stop being constrained by WebKit from making changes.
"So this is a huge win for us, the developers."
There's a contradiction here, and I'm not being cute. Your argument is not the only argument to be made, and personally, as a developer, I preferred the old way.
Yep, there are negative externalities, and that always has to be weighed, but I think it was a reasonable approach to allow developers to weigh the use of cutting edge features against their own communities, needs, and goals. That calculation would change depending on how many browsers were offering a proposed recommendation and the browser proportions of your viewers. Lots of interesting stuff was posted around the web, including here, taking advantage of these things. On the other hand, there's virtually no community for whom it would be reasonable to ask to make config changes to view a site, so you you simply can't use cutting edge features. Experimental site designs will be harder to show off and we'll have less public consideration of the implications of new recommendations since there's much less joy in putting together projects that few people will see.
Showing off demos leveraging experimental browser features that don't happen to be CSS features has often been done with requests to make config changes, because the "put it behind a config flag until it is ready" is pretty standard for everything other than CSS (and, actually, browser vendors have also done it for plenty of experimental implementations of CSS, whether or not the features themselves are standard or vendor-prefixed experimental extensions.)
Actually, HN is exactly the sort of place where people might be willing to do so. Things are posted here which require specific browsers or about:flags changes in Chrome, what would change?
Having experimental features available to developers creates pressure for all browsers to move forward. Without that we won't know what is important to developers because they'll be stuck using what the browser maker's deign to make "official".
Just playing devil's advocate here ...
The 'yay no vendor prefixes!' crew seem to have very short memories on what it was like before vendor prefixes..IE Waiting a LONG time (years) for a CSS feature to be 'recommended' by the w3c.
Vendor Prefixes were the best of a bad situation, I think they will be missed quite quickly.
I'm all up for this movement, but the W3C will need to move a lot quicker if this is to happen. Otherwise innovation will just grind to a halt again like it did before.
or can someone explain to me the difference?
I couldn't care less if they add -blink, it takes minutes to push that through a modern CSS codebase. At least I can use the features where they exist.
Coupled with Mozilla's announcement of its partnership with Samsung to move Servo forward this is great news for the future of the web. Hopefully multi-process/multi-threaded rendering engines will address some of our current performance gripes with the DOM and open the gate for even more complex UIs and interactions.
"Our shitty slow and poorly architected mess of document and script languages is too slow for good application performance, everyone, start floundering around looking for some technology to squeeze another inch of performance out of everything so we can maybe hopefully make our awful mess work finally"
It is probably my bitterness towards XML, but I feel like the whole "use-a-document-markup-language-as-an-application-builder" is making people do crazy things, and not in a good way - it is happening because html is entrenched, and it is the only truly device-agnostic framework right now. So everyone tries to make it work for everything.
I just see it as a sad circumstance is all.
Hopefully this is easier for everyone. If the chrome multithreading architecture really was the pain point then does that mean that webkit will also be deleting thousands of files and become easier to build, just as the chrome team is removing compatibility for other webkit targets? Or will WebKit remain the mess it is now because it strives to work on all the other platforms?
What if Apple decided to do the same thing? WebKit is this wonderful open source success story in part because it runs in so many places on so many things, but isn't a large part of that only enabled because the main contributors took the time to make sure that their work continued to run on the various different architectures? Will Google turn away patches that enable Blink to be compatible with platforms not their own?
This is an interesting move.
From a short-term perspective, monocultures seem good for developer
productivity. From the long term perspective, however, monocultures
inevitably lead to stagnation. It is our firm belief that more options in
rendering engines will lead to more innovation and a healthier web ecosystem.
I've lost track of the number of times I've had to pretend to be something different (desktop Firefox, default Android, Mobile Safari ...) to make a website usable. Every time I have a fresh Firefox install on Android, the first extension I install is Phony.
They were probably carrying webkit in their own shoulders anyway, cause nobody does so much experiments as chromium team does..
If they have the energy to do it.. thats good news for us :)
Do you have a source for this?
If I remember correctly, the patch was not merged in. I guess now google can do whatever it wants!
Additionally: we have had experimental Dart+Chromium builds for a long time, they use a different approach (V8 bindings layer) that doesn't require WebKit changes. However we only use these builds for fast development edit+refresh, for deploying Dart code you should use dart2js (it's just like deploying CoffeeScript, C code via emscripten, etc).
disclaimer: I'm on the Dart team (libraries, not core language/VM/dart2js). As exciting as it would be to have Dart VM in Chrome, personally I hope the order is more like:
* dart2js and VM work the same way (basically true already, modulo a few quirks unlikely to affect program behavior. It's not any worse than your typical web standard polyfill, probably a lot better.)
* The language spec is standardized.
* People like Dart, and it becomes really popular for building web apps.
* We have great Dart<->JS interop and it's possible to make the two native VMs work nicely together in the same browser.
* The toolchain makes it practically impossible for a web developer to publish an app that only has .dart files, without the .js version that works on all browsers.
* At that point, it might make sense to add the Dart VM to a browser purely a performance optimization.
Of course a lot could change between now and then. For example, if JS engines keep getting faster and introduce enough fast stuff (like typed arrays, asm.js, etc), maybe we can achieve the speed we need with dart2js.
Fortunately, there are plenty of folks that work on Blink/Chromium that share both the enthusiasm and skepticism that the web community has about Dart. As someone that works on it, I deeply want our team to succeed, but I would like to see it happen in the right way--open web and open source friendly.
Sorry if this is a naive question!
Edit: just found the answer here, if anyone is interested :
We've been waiting for Apple to include support for the W3C Navigation Timing for a long time so their pissing match over multi-VM support in WebKit because it doesn't conform to standards rings hollow.
The multi vm discussion was in 2011. If you think supporting dart natively in a browser is a good thing you're either a google employee or have your head too far up googles ass to see they are the new Microsoft and this is/was an attempt no different than vbscript in ie
This blog post doesn't make an engineering based argument* so I'm left with the business ones. Which sucks.
* - Just vague "we need to innovate faster" boilerplate. Which is what business people say when there's not a solid engineering based reason.
At the bottom of the project page are some engineering reasons:
Each person can judge whether it's worth forking or not.
I believe this is an honest move. This is what happens with software. Goals change, old code and design no longer makes sense, you refactor or rewrite. The architecture of WebKit was created to address goals that are a decade old now. The multi-process nature of Chrome alone, an amazing achievement and really quite elegant if you've looked at the way they bolted it on, was bolted on all the same.
One has to wonder if Google will be recruiting other WebKit contributors (RIM, Intel, Nokia, etc) to move over to Blink. This would put Apple in a tough spot.
We're going to be even more transparent than we currently are, actually, about how things get added to the platform http://www.chromium.org/blink#new-features. I'm pretty excited about how that's going to play out with regard to sharing ideas and implementations.
I'm honestly quite hopeful, both about Blink, and about WebKit.
The engineering argument is that the differences between Chromium's multi-process model and WebKit2 are big enough that, in order for both projects to move forward, Google needs to fork WebKit. I'm not competent to judge whether this is actually true.
1. Not affiliated with Apple or Google.
2. Not specifically associated with a port in terms of their review areas.
To me, that says a lot about how WebKit governance works in practice.
>Longer term, we can expect to see Blink evolve in a different direction from WebKit. Upson and Komoroske told us that there were all manner of ideas that may or may not pan out that Google would like to try. The company says that forking WebKit will give it the flexibility to do so.
Also, how much does Apple really control WebKit? At a glance, it looks to me like FOSS. (Apple might be the maintainer, but it seems trivial to fork it in a different direction.) Perhaps this is a more nebulous "thought leadership" kind of thing?
b) Although it is a little hand wavey, they do make an engineering argument: "However, Chromium uses a different multi-process architecture than other WebKit-based browsers, and supporting multiple architectures over the years has led to increasing complexity for both the WebKit and Chromium projects."
Immediately being able to eliminate and not worry about maintaining 7,000 files comprising 4.5 million LOC seems to be a pretty concrete benefit, rather than a hand-wavey one.
How is that not engineering based?
Mozilla isn't WebKit.
> I don't believe that by simply streamlining things they'll be able to remove anything like 4.5 million lines.
I suppose you could compare WebKit repos against Blink repos once the latter is live to see exactly what is cut, but I'm going to say the people working on the code that are the source of the count know how many LOC are involved, and that there direct count is more reliable than a third-party estimate based on a different browser's repo.
http://www.ohloh.net/p/mozilla claims that Mozilla is 11,614,049 lines of code.
Hmm. Not sure what to make of that, but the "we're removing 4.5 MLOC" claim still sounds ridiculous.
> Establish a simpler, stricter tree-gardening system that does not require 2 full time engineers per day
Almost any project worth its salt has someone doing testing. But it is really time consuming.
Two of the biggest players (and now arch rivals) sharing what's arguably the most strategic piece of code there is, couldn't last very long.
It's a shame though. It was probably the biggest open source success story.
An open source monoculture is not the same as a proprietary monopoly.
Likewise, look at how GCC is now dramatically improving since Clang became competitive.
Or look at how Firefox back in the good old days picked up the pace after Chrome(ium) happened.
We already have 3 major engines. Do we need a fourth? The Linux Kernel combines all efforts in a single thriving project, while we have multiple desktop distributions struggling to get a single digit percentage of the market.
Though considering how they fund Mozilla in the first place, if they wanted Gecko, they would just buy Mozilla. They keep the lights on anyway.
Firefox is still using Gecko, and is working with Samsung on a long term effort to develop a new engine (Servo) in Rust.
You may be thinking of the recent news that Opera is using WebKit, but even when that was first report it was identified that they were really basing on Chromium rather than WebKit proper, and they've announced (in this thread, even) that with Chromium moving to Blink, Opera is following.
1. How does this affect the build system?
2. Will Blink always remain a fork of Webcore, or do you plan on replacing all the bits and pieces from Webcore with your own code?
3. Are we still stuck with the LGPL license?
4. Does this change anything in the spectacularly lacking source documentation / porting guidelines front.
5. You mentioned stripping out a lot. Will this have a significant impact on the size of the codebase?
6. Will the rendering architecture be changed completely? Or, is the render layer hierarchy still intact in blink?
2. I'm not sure what you mean.
3. We can't, and don't want to, change the license of code that's already been released. That said, most (all?) of WebCore isn't LGPL. See my favourite file, http://trac.webkit.org/browser/trunk/Source/WebCore/page/Con... for example.
4. WebKit and Chromium have historically had differing opinions regarding what makes a "good" comment. I think you can expect Blink's code to tend more and more towards Chromium-style as time goes on, but it's not going to happen overnight.
5. ~5 million lines of code that we don't currently compile or run in Chromium. That's a bit, but it won't have much effect on the binary size.
6. Short term, not much will change. Longer term, a few things will probably happen: for instance, the widget tree will likely be removed, and we'll likely be able to step back and reevaluate some changes in light of that.
I love seeing what creative devs are doing out on the fringes, and having to dig around in flags every time something new gets added could potentially get pretty annoying. The benefit of vendor prefixes was this - if you were on a latest version, not just dev/canary channel, there was a lot which was turned on by default, even if theoretically it wasn't stable. That was actually quite a good driver of fresh technique and innovation, seeing this straight away, despite the major hassle of bloated CSS.
It's inspirational seeing people who maybe aren't totally technical being able to get their hands on very fresh stuff without having to completely hand hold them on every step required to get it going.
Really, a lot to be said on this topic, but just wanted to mention this as didn't see it discussed yet.
On my 2GB netbook, chrome has gone from my preferred browser to unusable due to the high memory footprint of recent builds. I wonder if this cleanup will help get the memory down to something reasonable like where it was up until Chrome 10 or so.
"Removing obscure parts of the DOM and make backwards incompatible changes to obscure parts of the DOM that benefit performance or remove complexity."
Not saying EEE is the strategy Google is trying to do here. But it's certainly a possibility and we should pay close attention IMO.
For example, he claims it's a political move, yet the official FAQ lists many practical reasons for the move. Also, he says it will fragment the web: half the comments in this very thread explains why it won't. Then he says it's not open source because it's hard to understand how an HTML parser works? wtf?
So what? They couldn't make up excuses?
>Also, he says it will fragment the web: half the comments in this very thread explains why it won't.
And others argue why it will.
>Then he says it's not open source because it's hard to understand how an HTML parser works? wtf?
A complex multi-million line project representing 1000s of manyears of work, essentially needs dedicated full-time highly skilled engineers to be forked. It might be technically "open source", but it's not bazaar-style open source, the way something like a simpler program or web framework is.
Even a highly skilled C++ programmer has to spend months to understand the WebKit codebase, much less do any pervasive changes or take over the code. This kind of devotion cannot be sustained by unpaid volunteers. That makes it essentially un-forkable unless some other company can devote resources to it.
Highly complex codebases seldom progress much as community projects after the original company has abandoned the paid contributors (see the lackluster Gnome development the last 10 years, after all the late 199x early 200x backers backed down, Open/Libre Offices --haven't progressed much from 2000's SUN's offering--, etc). And those are the cool cases, others die completely or languish (e.g Hazel's Nautilus, or Evolution).
WebKit, from which Google Blink was forked includes dedicated, full-time, highly-skilled engineers from Apple and elsewhere that could incorporate material from Blink -- as well as all the other browser projects which might want to use material from WebKit (pre- or post-fork) or Blink; so the situation with regard to "open source"-ness is the same as it was before the fork, even with this "it needs full-time highly-skilled engineers" to use it proviso.
> Highly complex codebases seldom progress much as community projects after the original company has abandoned the paid contributors
Which is one of the reasons that forks between projects where both sides of the fork are paying contributors and the fork results in both sides being able to streamline and more efficiently return value to their sponsors (thus, making the sponsorship from both the prime sponsor of the original project and the sponsor that used to pay people to work on that project but which is now sponsoring their own fork more likely to continue) is good, as it puts each post-fork project on a more secure footing than the pre-fork project was.
?? If there's practical reasons, then you need to explain why the practical reasons are not strong enough to warrant this? Just look at what was accomplished by this, they were able to delete over 8 million lines of code that was boilerplate.
> And others argue why it will.
Then, it's still not a strong argument against this.
What exactly are you advocating? Look at all the chromium design docs they wrote, and all the code reviews are in the open. If anything, the WebKit reviews are much harder to look through. The rest of your rant is irrelevant. Do you want them to spoon-feed you everything Chromium/Blink engineers do?
You can argue all day if you want, but what exactly are you proposing the alternative is? How does not forking help in any of those?
We'll be coming at the same problems from different angles, find and fix different bugs, and have the opportunity to peek at how other browsers have done things. I'm quite hopeful that will mean that we'll all end up with better implementations.
Or something like that. Something about security concerns.
It was this reason that Adobe could never launch a flash enabled browser on iOS.
And no, Apple does not allow other rendering engines so much. Specifically, they do not allow anything that can execute code that is not distributed with the app. So for example, no JS engine that's allowed to run scripts that don't ship with the app, period (even without a JIT).