Introduction

When developing software applications, you often need to organize and manage your code in a structured manner. This is where the concepts of libraries, static linking, dynamic linking, and frameworks come into play. Furthermore, the notion of embedding a project inside another project can complicate these concepts. Let's delve deeper into these aspects and understand their roles in project management and software development.

Libraries

A library is a collection of subroutines, classes, functions, or types packaged together. It provides reusable code so developers don’t have to write code from scratch.

Types of Libraries

1. Static Libraries:
   • Explanation: Static libraries are collections of object files that are linked into a program during the compile time. They become part of the final executable.
   • Advantages:
     • Improved execution speed since all code is in a single executable.
     • No dependency management required for end-users.
   • Disadvantages:
     • Larger executable file size.
     • Updating the library requires recompiling all dependent programs.
   • File Extensions: `.lib` (Windows), `.a` (Unix/Linux).
2. Dynamic Libraries:
   • Explanation: Dynamic libraries are linked at runtime rather than compile time. The code is loaded into memory when executed.
   • Advantages:
     • Smaller executable size.
     • Libraries can be updated without recompiling dependent executables.
   • Disadvantages:
     • Additional complexity in handling runtime dependencies.
   • File Extensions: `.dll` (Windows), `.so` (Unix/Linux), `.dylib` (macOS).

Example of Library Usage

• Inversion of Control (IoC): Unlike libraries, frameworks call your code, not vice versa, using a concept known as Inversion of Control.
• Examples: ASP.NET, Angular, React, Django.
• Standardization: Enforces coding standards across the application.
• Productivity: Offers pre-written code templates and modules to speed up development.
• Limitations: Can limit flexibility due to predefined standards.
• Steep Learning Curve: Can be difficult to learn and requires familiarity with its workings.
  • Tools like Git support submodules, allowing you to include repositories inside other repositories.
• Build Configuration: Projects should have clear build processes. Configure build scripts (like `Makefile`, `CMake`, or `Gradle`) to handle multiple modules.
• Dependency Management: Ensure version consistency and dependency resolution across projects.
• Main Application
  • Core Library (Static)
  • UI Framework
  • Utility Tools (Dynamic)