Definizioni di programmazione: cos'è esattamente "Building".

Question

Che cosa significa build una soluzione / progetto / programma? Voglio assicurarmi di avere le mie definizioni corrette (quindi non sembro un idiota durante la conversazione). In IDE, puoi (correggimi se sbaglio) compila codice sorgente / codice di programmazione in codice macchina leggibile dal computer. Puoi eseguire il debug di un programma, che in sostanza esegue il programma e cerca errori.

Ma cosa fa esattamente building un programma? In VS sono consapevole che quando si crea un programma produce un file eseguibile in una cartella di debug.

Qualche definizione tecnica hard-core di cosa significhi build un programma?

Answer 1

Questo non riguarda necessariamente ciò che gli umani intendono per "costruire", ma per quanto riguarda MSBuild 2.0, il codice in Microsoft.Common.targets lo descrive così:

...
<!--
============================================================
                                    Build

The main build entry point.
============================================================
-->
<PropertyGroup>
    <BuildDependsOn>
        BeforeBuild;
        CoreBuild;
        AfterBuild
    </BuildDependsOn>
</PropertyGroup>
<Target
    Name="Build"
    Condition=" '$(_InvalidConfigurationWarning)' != 'true' "
    DependsOnTargets="$(BuildDependsOn)"
    Outputs="$(TargetPath)"/>

<!--
============================================================
                                    BeforeBuild

Redefine this target in your project in order to run tasks just before Build
============================================================
-->
<Target Name="BeforeBuild"/>

<!--
============================================================
                                    AfterBuild

Redefine this target in your project in order to run tasks just after Build 
============================================================
-->
<Target Name="AfterBuild"/>

<!--
============================================================
                                    CoreBuild

The core build step calls each of the build targets.
============================================================
-->
<PropertyGroup>
    <CoreBuildDependsOn>
          BuildOnlySettings;
          PrepareForBuild;
          PreBuildEvent;
          UnmanagedUnregistration;
          ResolveReferences;
          PrepareResources;
          ResolveKeySource;
          Compile;
          GenerateSerializationAssemblies;
          CreateSatelliteAssemblies;
          GenerateManifests;
          GetTargetPath;
          PrepareForRun;
          UnmanagedRegistration;
          IncrementalClean;
          PostBuildEvent
    </CoreBuildDependsOn>
</PropertyGroup>
<Target
    Name="CoreBuild"
    DependsOnTargets="$(CoreBuildDependsOn)">

    <OnError ExecuteTargets="_TimeStampAfterCompile;PostBuildEvent" Condition="'$(RunPostBuildEvent)'=='Always' or '$(RunPostBuildEvent)'=='OnOutputUpdated'"/>
    <OnError ExecuteTargets="_CleanRecordFileWrites"/>

</Target>
...

che suggerisce che "build" significa approssimativamente "compilare più tutti gli eventi ausiliari associati che ti portano da artefatti di codice a un risultato distribuibile".

Answer 2

Costruire significa molte cose per molte persone, ma in generale significa iniziare con i file sorgente prodotti dagli sviluppatori e terminare con cose come i pacchetti di installazione che sono pronti per la distribuzione .

" La build " può contenere molte cose:

• Compilazione di file di origine (per lingue / ambienti che supportano una fase di compilazione separata / esplicita)
• Collegamento del codice oggetto (per lingue / ambienti che supportano una fase di collegamento separata / esplicita)
• Produzione di pacchetti di distribuzione, chiamati anche " installer "
• Generazione di documentazione incorporata nei file del codice sorgente, ad es. Doxygen, Javadoc
• Esecuzione di test automatizzati come unit test, test di analisi statica e test delle prestazioni
• Generazione di report che indicano al team di sviluppo quanti avvisi ed errori si sono verificati durante la compilazione
• Distribuzione di pacchetti di distribuzione. Ad esempio, la build potrebbe distribuire / pubblicare automaticamente una nuova versione di un'applicazione Web (presupponendo che la build abbia esito positivo).

" La build " può essere fatto " a mano " o può essere automatizzato, o qualche ibrido dei due. Una build manuale è una build che richiede l'esecuzione di comandi di compilazione come i compilatori uno per uno. Un pacchetto di build automatizzato riunisce tutti i singoli strumenti di build in un grande programma di build che può essere (idealmente) eseguito in un unico passaggio.

Answer 3

Significa il processo di conversione degli artefatti di origine leggibili dall'uomo in artefatti leggibili automaticamente.

Answer 4

Molti progetti coinvolgono molti file di origine. In linea di principio, è possibile compilare manualmente uno di quei file da solo: si utilizza un compilatore per compilare quel file sorgente in un file oggetto (temporaneo) contenente il codice macchina.

In pratica, è troppo noioso compilare manualmente ogni file sorgente uno alla volta, e ancora più noioso tenere traccia manualmente di quali file sorgente devono essere ricompilati. Quindi costruiamo l'intero progetto in una sola volta eseguendo un programma di compilazione automatizzato, generalmente chiamato "quot". Quel programma passa attraverso un elenco di file sorgente, spesso memorizzati in ancora un altro "sorgente". file chiamato " makefile " ;, e chiama il compilatore su ognuna - molte versioni di " make " sono abbastanza intelligenti da ricompilare solo i file che sono stati modificati e quindi devono essere ricompilati.

Mentre la compilazione è probabilmente la parte più importante del processo di compilazione, spesso una "compilazione" esegue molti altri programmi dopo il compilatore. A volte una build completa impiegherà più tempo a eseguire questi altri programmi che a eseguire il compilatore.

Ad esempio, molte persone trovano conveniente avere un solo pulsante non solo per compilare tutto il codice sorgente all'ultima versione, ma anche per eseguire una serie standard di test ( C2: Test di un pulsante ). Quindi il makefile elenca anche tutti i comandi necessari per eseguire quei test, che diventano parte del processo di compilazione.