That said, what you describe isn't really an issue with Firefox. Unless you're running a very odd distro, apt-get build-dep or mach bootstrap will set you up automatically, and on Windows there's an installer with the dependencies (outside MSVC). Of coure, the people who like to customize to no end might be those running an odd distro, but something something digging yourself out of your own hole.
You could write your comment without accusing tweakers of digging themselves out of their own hole and all that unnecessary tone. In that case it would have more power to teach people something new.
In fact I'm more scared by people trying to silence him/her.
I certainly didn't want to silence the parent, but tried to point out that having a much more helpful tone will reach his message much farther.
Maybe reread this comment thread later, and compare the tone of the comments.
But that's the problem with context and text. Emoji FTW.
It's basically one line to add to a config file to enable it.
I actually had a proposal for a tool that would let you hack directly on your Firefox install without needing to download the full source (which is hard to do on flaky connections and annoying on slow ones). This is already possible, Firefox ships with a zip file (omni.ja) containing its UI code. The UI code is precompiled and cached, however you can edit the code and delete its cached form and stuff just works.
It's a hack, but it makes it incredibly easy to just get started hacking on Firefox code. I could imagine there being an addon that helped smooth this process.
For more info about contributing to Firefox, see https://developer.mozilla.org/en-US/docs/Mozilla/Developer_g...
Have people traditionally been running their own modified browsers? Seems a bit scary given how you'd have to be on the ball to merge security fixes into your branch regularly.
Of course, that feed of patches will stop at some point. Don't ask me what the contingency plan for those forks is...
I imagine an image with the full toolchain installed, geared towards using it as a kind of "firefox-compiler" CLI (so coupled with a few shell scripts), that only requires you to know how to install Docker|Vagrant. This could easily be bundled with the source code.
FROM suitable-base-image
ADD ./install.sh /tmp
RUN chmod a+rx /tmp/install.sh && /tmp/install.sh
and write a script to install the dependencies that people can opt to run outside of Docker if they prefer.The point is not to take away peoples ability to pull together all of the dependencies on their own, but to make replicating the build environment trivial.
Personally I don't want install scripts etc. polluting my server or laptop setups - I always spin up containers to run builds in these days, because it means I at the end have a repeatable description of how to set it up. But once someone has done that job once, it's silly for everyone else to have to repeat it.
Docker maybe makes sense as a "compilation target" - generating a dockerfile of your dependencies to make it easy for people to use makes sense. But it's not rich or structured enough to be the canonical record of what dependencies your project needs.
I'm not arguing for it to be that, and I largly agree with you.
As my example shows, the Dockerfile doesn't need to contain any detail of the dependencies - you can "outsource" that entirely to whatever mechanism you wish, as long as you can easily add whatever you need to apply those dependencies to a suitable base image to the Dockerfile.
But most of the time I don't care about precision - I just want a means of getting a working build environment quickly. If it pulls in 100MB of unnecessary libraries, I don't care, if it gets me an uncomplicated way of building the project without having to assemble the dependencies myself.
For a lot of projects I come across, my experience is that because the list of build dependencies are often never automatically tested, it's a crapshoot whether or not their build instructions and dependency list will yield a working build environment on any given system.
"Even" a plain Dockerfile that is regularly used to rebuild the build environment is far superior to a text file of dependencies that is rarely to never verified.
If you want to go one better and storing more precise instructions and then use them to generate a build script or Dockerfile, then awesome.
The main thing is that absent automated testing of the build environment too, the list of dependencies isn't worth the bytes they're stored in. And a simple way of regularly testing the build environment is to rebuild it automatically.
My experience is that the dependency lists for projects that automatically rebuild the build environment - whether as Docker containers or in a chroot or any number of other ways - tends to be far more reliable.
And if you first can automatically build the build environment, it makes sense to make it easy for everyone to use that automatically built build environment.
If people want to install all the build dependencies themselves, that's fine, but there's really no reason to make people go through that hassle. Automating and isolating it also makes it far more liely that the dependency list remains accurate.
It only includes the build tools though. You need the source code separately. I think I have provided enough info in the README to get you going.
The release engineering team has started using Nix in their build process. Once all dependencies are mapped in Nix it means you just need to install the tool itself and all the dependencies will get pulled automatically.
It doesn't solve porting to new arch and platforms (especially Windows) so it's still a good idea to keep the number of dependencies down. But on any amd64 Linux it should be fine.
In this case it looks like you can contribute to one of the servo project packages and those changes will make it downstream into Firefox, that's great as Servo has a (relatively) small and easily understood code base!
Use open source projects' CI file to find which dependencies / commands are needed to compile / run the project. Run all this inside whichever container the CI system uses (circle & travis use only a few).
The issue described will never be an issue again!
$ git clone git://anongit.freedesktop.org/libreoffice/core
$ apt-get build-dep libreoffice
$ ./autogen.sh && make
With any relatively standard Debian/Ubuntu distro, you can have your own custom build in about an hour or so. Progressive builds just a few min if you have ccache setup.
edit: I noticed you typed make. Do you perhaps mean make -j 8 or something (depending on core count)
Here's what I can think of off the bat:
- Handling fonts. A whole world of hurt. Not all of this can be offloaded to OS libraries.
- Handling layout. Another world of hurt. Especially given that many formats have their own quirks.
- Handling complicated things like math and svg.
- Understanding HTML (for formatted paste and save-as-html to work)
- Understanding PDF
- Canvas for the shapes and stuff
- Codecs and stuff for images and video
- General rendering/compositing code
- Accessibility code
There's a LOT that goes into building software like this.
I worked on Microsoft Office as an intern once. The codebase is huge. Build times would be forever without artifact builds. I currently work on browsers, which are in the same situation with a lot of not-immediately-obvious costs.
Layout is in every modern game engine as UI and is even more powerful. See scaleform for example.
Math... isn't in a game engine?
HTML/PDF and other formats? Please how about DXT1-N texture formats, crunched textures, scene descriptions, meshes, animation rigging, etc. HTML and PDF are small in comparison.
Yea I'm not going to continue. What you may not have realized as a MSFT Office intern is that just because it was slow and awful, it might not have necessarily needed to be.
It's not just Office. It's also the two browsers I have worked on (a word processor in particular has a lot in common with a web browser, but it also needs to deal with authoring). There are many things that need to be done that aren't immediately obvious. Sure, a graphics engine has such costs too but it's hard to compare unless you're well acquainted with both sides.
That being said complicatedness has little to do with compile time now, has it? :)
There are some articles of Joel Spolsky explaning why office document formats are so complicated (not my word) [1]. The spec for MS doc is like 500 or so pages. The spec is longer than my video game graphics book I had in college. I recommend some research before assuming.
> That being said complicatedness has little to do with compile time now, has it? :)
Actually there is a correlation [2]. Of course it depends on what you call or think complexity is.
Believe it or not engines may not actually be as complex because they typically are based on math formulas or combinations of simple algorithms. Math is often simple and doesn't require lots of branching (if conditions). The algorithms have to be fairly simple anyway otherwise performance would be bad.
Buisiness software or actual video games on the other hand are full of branching. NetHack may not have 3D graphics or any graphics but it is an extremely complicated game.
[1]: https://www.joelonsoftware.com/2008/02/19/why-are-the-micros...
But they may have meant Midori or similar which actually uses WebKit, through WebKitGTK+... Which means linking against GTK+, probably GTK+3 to get the main benefits like single-page not whole application crashing.
Which depending on your custom build, may or may not be an absolutely huge overhead.
It could be a tiny change to add to an OS. Or huge.
Especially with browsers, which not everyone agrees on how they should be and desires to customise, only to find that the option to do so has been removed or a source change must be performed, is subsequently delighted to know that it's open-source so they should be able to do it easily, but then get overwhelmed and give up after they realise the effort needed just to build an unmodified version of the software themselves. They then fall back to merely complaining on the Internet, and reluctantly accepting their "fate"... somehow, I feel like some of the visions of open-source didn't quite turn out as well as hoped.