Hello! I have such a question. There are various projects in which there is a huge amount of code. Well, let's say some Google Chrome. How can such projects be developed using IDE? Surely any environment will simply stall from such a huge number of files with code and such a volume of code. Moreover, such projects are probably compiled for a very long time. How do these problems solve adult and clever uncles?

  • one
    Adult and clever uncles break such projects into separate modules and use incremental compilation. - falstaf
  • 2
    and for full build use make, cmake and even self-written utilities. But there is one ide (and even two) that are not stalled by this amount of code. This is vim and emacs. But in any case, the principle of "divide and conquer" always works. - KoVadim
  • one
    @KoVadim vim what side got into IDE? linux with vim - agree, naked vim is an editor. - alexlz
  • one
    Do you know a lot of IDEs that can work without an OS? I know only one such editor - a typewriter. And about the emax no questions? - KoVadim
  • @KoVadim: I guess some embedded linux is running in modern typewriters :) And about Emacs :> It is a great operating system - VladD

1 answer 1

IDE, in principle, take out is normal.

For example, you can work with LLVM / Clang on my machine (MacBook Pro, Late 2011), Xcode / AppCode copes with them perfectly, indexing lasts quite a long time, but then you can work normally.

Regarding the compilation - it all depends on the organization of the code, there are at least two solutions to this problem, which are perfectly combined:

  1. Splitting the entire program into modules. This will allow you to assemble each module once (or get this module already assembled) and then reassemble only the module you are working with. In fact, all systems work this way: you do not have to rebuild the kernel every time to compile "Hello world", you just connect ( compile ) third-party libraries (static libs, dynamic libs).
  2. Incremental build. You have all the source code with you and collect them all only once, then only the code you corrected (and its dependencies) is rebuilt. To reduce the number of dependencies it is worth remembering the preliminary declaration ( Forward Declaration ). Here you can read about how to use it in Objective-C, I understand that this is not exactly your profile, but the article has a clear (IMHO) example that will help you understand why this is really important.

PS I am not a sufficiently experienced expert in this field, so be vigilant and take my answer rather as "reflections on the subject."

  • one
    @AlexDenisov agree. I in IDE (namely, the corresponding version of MSVC) opened quite large projects - like the graphics engines of Q3, HL2 and Nitsche games - nobody died :-) However, it slowed down at the beginning and at certain moments of work, but, in general, normal. - gecube