Programmierung Definitionen: Was genau ist "Bauen"?

Question

Was bedeutet es, dass bauen eine Lösung/Projekt/Programm? Ich möchte sichergehen, dass ich meine Definitionen richtig verstehe (damit ich mich nicht wie ein Idiot anhöre, wenn ich mich unterhalte). In IDEs können Sie (korrigieren Sie mich, wenn ich falsch liege) kompilieren Quellcode/Programmiercode in computerlesbaren Maschinencode. Sie können Fehlersuche ein Programm, das im Grunde genommen das Programm durchläuft und nach Fehlern sucht.

Aber was genau bedeutet Gebäude ein Programm tun? In VS weiß ich, dass beim Erstellen eines Programms eine ausführbare Datei in einem Debug-Ordner erzeugt wird.

Irgendwelche knallharten technischen Definitionen dessen, was es bedeutet bauen ein Programm?

Answer 1

Bauen bedeutet viele Dinge für viele Menschen, aber im Allgemeinen bedeutet dies, dass man mit den von den Entwicklern erstellten Quelldateien beginnt und mit Dingen wie Installationspaketen endet, die für die Bereitstellung bereit sind .

"Das Gebäude" kann viele Dinge enthalten:

• Kompilierung von Quelldateien (für Sprachen/Umgebungen, die einen separaten/expliziten Kompilierungsschritt unterstützen)
• Linken von Objektcode (für Sprachen/Umgebungen, die einen separaten/expliziten Linking-Schritt unterstützen)
• Herstellung von Verteilungspaketen, auch "Installer" genannt
• Erstellung von Dokumentation, die in die Quellcode-Dateien eingebettet ist, z. B. Doxygen, Javadoc
• Durchführung von automatisierten Tests wie Unit-Tests, statische Analyse-Tests und Leistungstests
• Erstellung von Berichten, die dem Entwicklungsteam mitteilen, wie viele Warnungen und Fehler während des Builds aufgetreten sind
• Bereitstellung von Verteilungspaketen. Zum Beispiel könnte der Build automatisch eine neue Version einer Webanwendung bereitstellen/veröffentlichen (vorausgesetzt, der Build ist erfolgreich).

Der "Build" kann "von Hand" erfolgen oder automatisiert werden, oder eine Mischung aus beidem. Ein manueller Build ist ein Build, bei dem Build-Befehle wie Compiler einzeln ausgeführt werden müssen. Bei einem automatisierten Build werden alle einzelnen Build-Tools zu einem großen Build-Programm zusammengefasst, das (idealerweise) in einem einzigen Schritt ausgeführt werden kann.

Answer 2

Viele Projekte umfassen eine Vielzahl von Quelldateien. Im Prinzip können Sie jede dieser Dateien manuell kompilieren - Sie verwenden einen Compiler, um diese Quelldatei in eine (temporäre) Objektdatei mit Maschinencode zu kompilieren.

In der Praxis ist es viel zu mühsam, jede Quelldatei einzeln manuell zu kompilieren, und noch mühsamer ist es, sich manuell zu merken, welche Quelldateien neu kompiliert werden müssen. Daher erstellen wir das gesamte Projekt auf einmal, indem wir ein automatisiertes Build-Programm - normalerweise "make" genannt - ausführen. Dieses Programm geht eine Liste von Quelldateien durch, die oft in einer weiteren "Quell"-Datei namens "makefile" gespeichert ist, und ruft den Compiler für jede einzelne Datei auf - viele Versionen von "make" sind intelligent genug, um nur die Dateien neu zu kompilieren, die sich geändert haben und daher neu kompiliert werden müssen.

Während das Kompilieren wohl der wichtigste Teil des Build-Prozesses ist, werden bei einem "Build" oft viele andere Programme nach dem Compiler ausgeführt. Gelegentlich verbringt ein vollständiger Build mehr Zeit mit der Ausführung dieser anderen Programme als mit der Ausführung des Compilers.

Viele Leute finden es zum Beispiel praktisch, wenn eine einzige Schaltfläche nicht nur den gesamten Quellcode in die neueste Version kompiliert, sondern auch eine Reihe von Standardtests ausführt ( C2: Testen mit einer Taste ). Daher listet das Makefile auch alle Befehle auf, die für die Ausführung dieser Tests benötigt werden und die Teil des Build-Prozesses werden.

Answer 3

Darunter versteht man den Prozess der Umwandlung von menschenlesbaren Quellartefakten in maschinenlesbare Artefakte.

Answer 4

Dies hat nicht unbedingt etwas mit dem zu tun, was Menschen mit "Build" meinen, aber was MSBuild 2.0 betrifft, beschreibt der Code in Microsoft.Common.targets es so:

...
<!--
============================================================
                                    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>
...

was darauf hindeutet, dass "Build" in etwa "Kompilieren plus alle damit verbundenen Hilfsereignisse, die Sie von Code-Artefakten zu einem einsatzfähigen Ergebnis bringen" bedeutet.