C Is Not A Language Anymore

ThePrimeTime34 minutes read

The text discusses the challenges with C as a programming language, emphasizing ABI problems and the need for a Foreign Function Interface. It highlights the complexities of integer types, ABI compatibility, and changing data type assumptions, proposing Zig as a solution for handling C and ABI issues.

Insights

  • The text emphasizes the critical role of C as a universal protocol for programming languages, highlighting the challenges in maintaining ABI compatibility across different languages and platforms.
  • The discussion underscores the intricate complexities of ABI issues, ranging from handling integer types and calling conventions to the necessity of Foreign Function Interfaces (FFIs) for seamless interaction between languages, ultimately pointing towards Zig as a potential solution for navigating these intricate C and ABI-related challenges.

Get key ideas from YouTube videos. It’s free

Recent questions

  • What are the challenges of interacting with major operating systems using a new language?

    ABI problems and instability hinder compatibility.

  • How does Zig address the complexities of C and ABI issues?

    Zig is presented as a solution for handling C and ABI complexities.

  • What impact do ABI changes have on software development in Debian?

    ABI changes in Glibc lead to recompilation in Debian.

  • Why is handling changes in type layouts crucial for forward compatibility?

    Ensuring type layout consistency prevents ABI compatibility issues.

  • What are the challenges associated with specific data types like Size T in C programming?

    Size T poses complexity and consistency challenges in data type usage.

Related videos

Summary

00:00

Navigating ABI Challenges in Programming Languages

  • The text discusses the frustration with C as a programming language and the desire to improve conditions for using other languages.
  • There is a focus on ABI problems and the instability of ABI compatibility across different languages.
  • C is described as a protocol that every general-purpose programming language needs to speak, making it more than just a programming language.
  • The challenges of interacting with major operating systems using a new language, Babby Script, are highlighted.
  • The need for a Foreign Function Interface (FFI) to allow languages to call functions foreign to them is explained.
  • The difficulties in parsing C headers and resolving include type definitions and macros are discussed.
  • The text delves into the issues with integer types in C and the lack of standardized calling conventions and ABIs.
  • The complexity of different calling conventions and ABIs for various platforms is explored.
  • The disagreement between major C compilers on ABIs for a particular platform is mentioned, causing inconsistencies.
  • The text concludes with a mention of Zig as a solution for dealing with the complexities of C and ABI issues.

13:36

Addressing Portability Challenges in Type Definitions

  • Unsigned long long poses portability challenges
  • Option to handle challenges: lie, cheat, steal
  • Rust uses manual translation of type definitions
  • Challenges with INT Max and long long N64 definitions
  • Hardcoding core type definitions in code
  • Difficulty in changing INT Max due to ABI constraints
  • Transparent aliases for ABI compatibility
  • Target triples for platform compatibility
  • Forward compatibility in changing signatures without breaking ABI
  • Techniques like symbol versioning for ABI-compatible changes
  • Microsoft's meticulous approach to forward compatibility
  • Handling changes in type layouts between versions
  • Strategies for forward compatibility in type layouts
  • Microsoft's versioning schema for array elements
  • Glibc's ABI break on s390 leading to chaos
  • Symbol versioning for ABI changes in Glibc
  • Impact of ABI changes on Debian, requiring recompilation
  • Possibility of version bumping libc for mixed ABI environments

27:55

Challenges of Int Max T in Software

  • Int Max T is a 64-bit fundamental data type, crucial for various languages and compilers, impacting public interfaces and ABI compatibility.
  • Changing the size of Int Max T could lead to chaos in the ecosystem, requiring a new triple target and preventing old ABI binary libraries from running on the new triple.
  • The article highlights the challenges of updating software assumptions about data types, like Int, which has been 32-bit on x64 despite being intended as 64-bit.
  • The use of specific data types like Uint 64t is preferred over long int due to reliability concerns and platform-specific variations in data type sizes.
  • Size T, essential for operations like indexing vectors, poses challenges due to its complexity and the need for consistency in data type usage, especially in C programming.
Channel avatarChannel avatarChannel avatarChannel avatarChannel avatar

Try it yourself — It’s free.