build - tecnologia - tipos de programacion
Definiciones de programación: ¿Qué es exactamente ''Building''. (4)
Construir significa muchas cosas para muchas personas, pero en general significa comenzar con archivos de origen producidos por desarrolladores y terminar con cosas como paquetes de instalación que están listos para su implementación .
"La construcción" puede contener muchas cosas:
- Compilación de archivos de origen (para idiomas / entornos que admiten un paso de compilación separado / explícito)
- Enlace de código de objeto (para idiomas / entornos que admiten un paso de enlace separado / explícito)
- Producción de paquetes de distribución, también llamados "instaladores".
- Generación de documentación incrustada en los archivos de código fuente, por ejemplo, Doxygen, Javadoc
- Ejecución de pruebas automatizadas como pruebas unitarias, pruebas de análisis estático y pruebas de rendimiento
- Generación de informes que indican al equipo de desarrollo cuántas advertencias y errores se produjeron durante la compilación
- Despliegue de paquetes de distribución. Por ejemplo, la compilación podría implementar / publicar automáticamente una nueva versión de una aplicación web (suponiendo que la compilación sea exitosa).
"La construcción" se puede hacer "a mano" o se puede automatizar, o algún híbrido de los dos. Una compilación manual es una compilación que requiere que los comandos de compilación, como los compiladores, se ejecuten uno por uno. Una compilación automatizada reúne todas las herramientas de compilación individuales en un programa de compilación grande que puede ejecutarse (idealmente) en un solo paso.
¿Qué significa construir una solución / proyecto / programa? Quiero asegurarme de que tengo mis definiciones correctas (para no sonar como un idiota cuando converso). En IDE''s, puedes (corregirme si estoy equivocado) compilar el código fuente / código de programación en un código de máquina legible por computadora. Puede depurar un programa, que básicamente es pasar por el programa y buscar errores.
Pero, ¿qué hace exactamente construir un programa? En VS soy consciente de que cuando construyes un programa produce un archivo ejecutable en una carpeta de depuración.
¿Alguna definición tecnológica de lo que significa construir un programa?
Esto no necesariamente tiene que ver con lo que los humanos quieren decir con ''compilación'', pero en lo que respecta a MSBuild 2.0, el código en Microsoft.Common.targets lo describe así:
...
<!--
============================================================
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>
...
lo que sugiere que ''compilar'' significa aproximadamente "compilar más todos los eventos auxiliares asociados que lo llevan de artefactos de código a un resultado desplegable".
Muchos proyectos involucran muchos archivos fuente. En principio, puede compilar manualmente cualquiera de esos archivos por sí mismo: utiliza un compilador para compilar ese archivo fuente en un archivo objeto (temporal) que contiene código de máquina.
En la práctica, es demasiado tedioso compilar manualmente cada archivo de origen de uno en uno, e incluso más tedioso para realizar un seguimiento manual de los archivos de origen que deben recompilarse. Así que construimos todo el proyecto de una vez ejecutando un programa de compilación automatizado, generalmente llamado "make". Ese programa recorre una lista de archivos de origen, a menudo almacenados en otro archivo "de origen" llamado "makefile", y llama al compilador en cada uno de ellos: muchas versiones de "make" son lo suficientemente inteligentes como para recompilar solo los archivos que han cambiado Y así hay que volver a compilar.
Aunque la compilación es posiblemente la parte más importante del proceso de compilación, a menudo una "compilación" ejecuta muchos otros programas después del compilador. Ocasionalmente, una compilación completa pasará más tiempo ejecutando estos otros programas que ejecutando el compilador.
Por ejemplo, muchas personas consideran conveniente tener un solo botón no solo para compilar todo el código fuente a la última versión, sino también para ejecutar una serie estándar de pruebas ( C2: One Button Testing ). Por lo tanto, el makefile también enumera los comandos necesarios para ejecutar esas pruebas, que se convierten en parte del proceso de compilación.
Significa el proceso de convertir los artefactos de origen legibles por humanos en artefactos legibles por máquina.