C++ Template Metaprogramming: A Comprehensive Analysis of Principles, Practices, Advantages, and Limitations Click the blue text to follow the author

1. Introduction

Templates are a powerful feature of modern C++, originally intended for generic programming. You can write code once and use it with different data types without having to write separate functions or classes for each type.

C++ templates are mainly divided into two types:

Function templates.
Class templates.

Both types of templates are easy to understand, and the runtime programming differences are not significant, with no particularly advanced techniques involved, so I won’t elaborate further here. However, there is something called “template specialization” in templates, which is very useful for optimizing code for specific types or handling special cases.

Thus, a notable figure (Erwin Unruh from Siemens) discovered that by combining template instantiation and specialization, the template system is actually Turing complete. This means that any computable problem can be computed at compile time using templates.

What is Template Metaprogramming (TMP)?

Definition: Using C++ templates to perform computations and generate code at compile time. In simple terms, template metaprogramming is a unique form of programming that is no longer just used to create generic functions or classes, but rather treats templates themselves as a Turing-complete “language” that utilizes the compiler’s behavior during template instantiation to execute complex algorithms and logic. The TMP code written does not directly generate runtime instructions but instructs the compiler to generate the final executable code during compilation.

C++ Template Metaprogramming: A Comprehensive Analysis of Principles, Practices, Advantages, and Limitations — Insert image description here

Differences from traditional runtime programming:

Traditional programming focuses on the behavior of the program at runtime (i.e., when the program is loaded into memory and executed). Template metaprogramming completely subverts this notion. It shifts the “battlefield” of computation from runtime to compile time. All logic implemented through TMP is determined and fixed during the process of the compiler converting source code into machine code. Once the program compilation is complete, the results of these metaprogramming calculations become part of the program structure, eliminating the need for any runtime recalculation.

Why is Template Metaprogramming needed?

Because all calculations are completed at compile time, the results of these calculations are “hard-coded” into the final executable file at runtime. The program no longer needs to allocate CPU time or memory resources for these logics, achieving true zero runtime overhead.
Bringing errors from runtime to compile time. Traditional runtime errors are only discovered when the program runs and triggers the corresponding code path. However, template metaprogramming can perform strict checks and operations on types at compile time, allowing many potential runtime errors to be “brought forward” to the compilation stage. If the types or logic do not meet expectations, the compiler will immediately report an error instead of waiting for the program to crash.
TMP can generate different code paths or data structures at compile time based on different type parameters or non-type parameters.

2. Core Principles and Mechanisms

Template metaprogramming is built on a solid foundation of C++ template mechanisms. Understanding its core principles, especially template instantiation, specialization, parameter types, and the SFINAE rule, is key to mastering TMP.

2.1. Template Instantiation and Specialization

The essence of template metaprogramming is to utilize the “computation” behavior executed by the compiler when processing templates. This computation process is mainly reflected in template instantiation and specialization.

When the compiler encounters a use of a template, it generates a specific class or function based on the passed template arguments. This process is called instantiation. TMP leverages this “on-demand generation” mechanism, allowing the compiler to execute preset compile-time logic while generating code.

Traditional programming loops (for, while) and conditional branches (if, else) cannot be directly used at compile time. However, TMP can simulate these control flow structures through recursive template instantiation and template specialization.

Recursive instantiation: A template definition calls itself, with each call handling a smaller part of the problem until reaching a base case.
Template specialization: Provides an independent definition for specific template parameters. It is used to define the termination condition of recursion (base case) or to provide different behaviors for certain special types, similar to the if-else branches in runtime programming.

For example: Compile-time factorial

// Recursive definition: Factorial<N> = N * Factorial<N-1>
template <int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

// Specialization (base case): Factorial<0> = 1
template <>
struct Factorial<0> {
    static const int value = 1;
};

// Usage:
int result_5 = Factorial<5>::value; // The compiler will compute 120
// The compiler will expand to:
Factorial<5>::value = 5 * Factorial<4>::value
Factorial<4>::value = 4 * Factorial<3>::value
// ...
Factorial<1>::value = 1 * Factorial<0>::value
Factorial<0>::value = 1 (specialization terminates recursion)

Now, let’s understand full specialization and partial specialization.

Full specialization: When all template parameters of a template are specified, it is called full specialization. It provides a completely independent implementation for a specific set of parameters. In TMP, full specialization is often used to define the base case of recursion or to handle specific types.
Partial specialization: When some template parameters of a class template (note: function templates do not have partial specialization, only overloading) are specified while others remain generic, it is called partial specialization. It allows for specialized implementations for a class of parameters (rather than a single specific parameter). Partial specialization is very useful in TMP, allowing for different compile-time logic to be selected based on relationships between types, achieving finer control.

2.2. The Clever Use of Template Parameters

Template parameters are the “variables” that TMP uses for compile-time calculations and type operations. They are mainly divided into three types:

Type parameters: Handling type information. This is the most common form of template parameter, defined as typename T or class T; templates accept any type as a parameter. In TMP, type parameters are not just placeholders; they are themselves “data” that can be manipulated. Through pattern matching, specialization, etc., the compile-time behavior can be determined based on the passed type parameters. For example, checking whether a type is const, whether it is a reference, etc.
Non-type parameters: Performing compile-time numerical calculations. Non-type parameters allow templates to accept compile-time constants as parameters, which are known at compile time and can directly participate in compile-time calculations. They are commonly used to define fixed-size arrays, bit masks, compile-time lookup tables, etc.
Template template parameters: Operating with templates as parameters. This type of parameter allows a template to accept another template as a parameter. This is very useful when needing to operate on or generate other templates, providing a higher level of abstraction and generalization capability.

2.3. The SFINAE Mechanism

SFINAE is a very important rule in the C++ template mechanism and is the basis for many advanced TMP techniques.

SFINAE stands for “Substitution Failure Is Not An Error”. The core idea is: when the compiler attempts to instantiate a function template (or a specialization of a class template), if a type or expression becomes invalid due to template parameter substitution, it does not immediately result in a compilation error. Instead, the compiler simply removes that specific template (or specialization) from the overload set and continues to look for other viable overloads or specializations. Only when all possible templates fail to substitute, or there are no other viable overloads, will a compilation error be reported.

The SFINAE mechanism can conditionally enable or disable specific function overloads or class template specializations based on certain characteristics of types or expressions.

Conditional enabling/disabling: By using expressions dependent on template parameters in the return type of function templates, parameter lists, or non-type parameters of class templates, SFINAE can be cleverly utilized. If the expression fails during substitution, that template will not be considered.

std::enable_if is a typical tool in the C++ standard library that utilizes SFINAE. Its definition is roughly as follows:

template <bool B, typename T = void>
struct enable_if {}; // Default template, no type member when B is false

template <typename T>
struct enable_if<true, T> { // Partial specialization, has type member when B is true
    using type = T;
};

When B is true, enable_if<true, T>::type will yield T; when B is false, enable_if<false, T>::type will lead to substitution failure because enable_if<false, T> does not have a type member. This substitution failure does not cause a compilation error but instead causes the function overload containing enable_if to be ignored.

Example: Using enable_if to restrict a function to accept only integral types.

#include <type_traits>

template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
print_integral_value(T value) {
   // This function will only be instantiated and called when T is an integral type
   std::cout << "Integral value: " << value << std::endl;
}

int main() 
{
    print_integral_value(10);     // OK, T is int, is_integral<int>::value is true
    // print_integral_value(3.14); // Compilation error, T is double, is_integral<double>::value is false, leading to substitution failure, function does not participate in overload resolution
    return 0;
}

Through SFINAE and std::enable_if, conditional compilation based on type characteristics can be achieved at compile time, which is crucial for writing highly generalized and type-safe library code.

2.4. Type Traits

Type traits are one of the most commonly used and powerful tools in template metaprogramming, providing a mechanism for querying and manipulating types at compile time.

Concept of type traits: Querying type properties (whether it is an integer, whether it is copyable, etc.) through template specialization.

Type traits are a set of class templates that provide information about specific types through specialization mechanisms. This information is provided in the form of static const bool value members or using type = ... members. The implementation principle is to define a general template and then provide specialized versions for specific types or type patterns, which set value to true or define the type member.

The C++ standard library provides many predefined type traits in the <type_traits> header file, aimed at simplifying TMP development. These traits cover various aspects such as type classification, type properties, type relationships, and type conversions.

Type classification:

std::is_void<T>: Is T a <code>void type?
std::is_integral<T>: Is T an integral type?
std::is_floating_point<T>: Is T a floating-point type?
std::is_array<T>: Is T an array type?
std::is_pointer<T>: Is T a pointer type?
std::is_class<T>: Is T a class type?
std::is_function<T>: Is T a function type?

Type properties:

std::is_const<T>: Is T <code>const qualified?
std::is_volatile<T>: Is T <code>volatile qualified?
std::is_lvalue_reference<T>: Is T an lvalue reference?
std::is_rvalue_reference<T>: Is T an rvalue reference?
std::is_default_constructible<T>: Can T be default constructed?
std::is_copy_constructible<T>: Can T be copy constructed?
std::is_move_constructible<T>: Can T be move constructed?

Type relationships:

std::is_same<T, U>: Are T and U the same type?
std::is_base_of<Base, Derived>: Is Base a base class of Derived?
std::is_convertible<From, To>: Can From be implicitly converted to To?

Type conversions/modifications:

std::remove_const<T>::type: Remove the <code>const qualifier from T.
std::remove_reference<T>::type: Remove the reference from T.
std::add_pointer<T>::type: Convert T to pointer type.
std::decay<T>::type: Convert T to its "decayed" type (e.g., arrays decay to pointers, functions decay to function pointers).

These type traits are the cornerstone for building complex TMP logic, allowing for detailed analysis and manipulation of types at compile time in a declarative manner, thus enabling powerful generic programming and compile-time checks.

3. Advantages of Template Metaprogramming

One of the most striking advantages of template metaprogramming is its ability to shift computational tasks from runtime to compile time, achieving true zero runtime overhead.

Traditional programs, whether performing simple arithmetic operations or complex algorithmic logic, consume CPU cycles and memory resources at runtime. However, computations achieved through template metaprogramming are completed before the program is compiled into an executable file. Therefore, when the program actually runs, the results of these computations are already fixed in the binary code, eliminating the need for recalculation. This “pre-computation” feature can significantly reduce the runtime burden of the program.
The compiler possesses precise information obtained through TMP at compile time, enabling more aggressive and effective optimizations.

Constant propagation: Compile-time computed constants are directly replaced in the code, eliminating the overhead of variable lookups and calculations.
Dead code elimination: If a certain code branch is determined to never execute at compile time based on TMP logic, the compiler can directly remove it, reducing the size of the final executable file and improving runtime efficiency.
Elimination of virtual function calls: In strategy-based template metaprogramming, by passing algorithm strategies as template parameters, the compiler can determine the specific function to call at compile time, avoiding the overhead of virtual function table lookups at runtime, achieving static polymorphism that outperforms dynamic polymorphism based on virtual functions.

In traditional programming, many issues such as type mismatches and unmet logical constraints are only exposed when the program runs and triggers the corresponding code path, leading to runtime crashes or difficult-to-trace bugs. Template metaprogramming, through its powerful compile-time type checking mechanism, can capture these issues during the program compilation phase.

TMP imposes strict constraints on template parameters at compile time.

Template metaprogramming transcends simple generics, allowing for highly customized code to be generated at compile time based on different input parameters (type or non-type).

TMP is a core tool for implementing many advanced generic programming paradigms, such as:

Strategy pattern: By passing different strategy classes as template parameters, components with different behaviors can be combined at compile time without using virtual functions or function pointers.
Singular recursive template pattern: The base class is a template, with derived classes as template parameters. This allows the base class to access the members of the derived class at compile time, achieving static polymorphism and some compile-time optimizations, avoiding runtime overhead.
Type lists and tuples: TMP can be used to create and manipulate compile-time collections of types. Through type lists, compile-time heterogeneous containers, type mappings, compile-time reflection, and other functionalities can be implemented.

TMP allows programs to “self-construct” and “self-customize” at compile time. Metafunctions can be written to generate new types, new functions, or new data structures based on input parameters during compilation, enabling C++ to implement “embedded” domain-specific languages (DSL).

In scientific computing libraries, expression templates can optimize and reorganize complex mathematical expressions at compile time, generating efficient loop code and avoiding the creation of numerous temporary objects.
Through TMP, a generic serialization framework can be written to automatically generate serialization and deserialization code based on the member types of classes.
Compile-time state machines: A state machine can be defined where the state transition logic is entirely determined at compile time, avoiding runtime state lookups and branching overhead.

4. Limitations of Template Metaprogramming

Despite the powerful compile-time capabilities and performance advantages offered by template metaprogramming (TMP), it is not without its drawbacks.

The thinking paradigm of template metaprogramming is vastly different from traditional runtime programming, making it relatively difficult to learn.

The essence of TMP is to view the compiler’s template instantiation process as a form of computation. Therefore, one must think about problems in a very unconventional way:

Recursion replaces loops: In TMP, there are no for or while loops; all repetitive logic must be implemented through recursive template instantiation.
Specialization replaces conditional branches: if-else statements are replaced by template specialization, selecting different implementation paths based on different template parameters.
Types as data: Types themselves become “data” that can be manipulated, while compile-time constants act as “variables”.

This paradigm shift requires a significant investment of time to adapt and understand for those accustomed to imperative programming.

TMP code is highly abstract, making extensive use of template parameters, specializations, type traits, and SFINAE, among other advanced C++ features. Therefore, the readability of TMP code is relatively poor, and understanding its intent and logic requires a deep knowledge of C++ templates. Even experienced C++ developers may find complex TMP code quite challenging.

Shifting computational tasks from runtime to compile time, while bringing performance advantages, also comes with increased compilation time and resource consumption.

The “computation” of template metaprogramming occurs during the compilation phase. Each template instantiation consumes CPU and memory resources of the compiler. When TMP logic is complex, recursion depth is large, or involves extensive type operations, the compiler needs to perform a significant amount of instantiation and type deduction work, which can lead to significantly increased compilation times. For large projects, even minor TMP changes can result in minutes or even hours of compilation wait, severely impacting development efficiency.
During the compilation process, the compiler needs to maintain a large amount of metadata and symbol table information for each template instantiation. Complex TMP code can lead to the compiler consuming vast amounts of memory, potentially exceeding the available system memory and causing compilation failures (“OOM” errors). This is particularly common when dealing with large template libraries or performing deep recursive metaprogramming.

Poor readability of error messages is one of the most criticized issues of TMP and a major reason many developers shy away from it.

When errors occur in TMP code, the error messages generated by the compiler can be catastrophic. Due to the nature of the SFINAE mechanism, a simple type mismatch or logical error can lead to a series of substitution failures, causing the compiler to print all failed instantiation paths, resulting in thousands or even tens of thousands of lines of error reports.
Due to the high complexity of error messages, it is challenging to quickly and accurately determine which line of code, which template specialization, or which type deduction caused the issue.

The computations of TMP occur at compile time, making it impossible to debug using runtime debugging tools.

Runtime debuggers like GDB and Visual Studio Debugger can only check variable states, set breakpoints, and step through execution when the program is running. However, the “execution” of TMP is completed during the compilation phase, making it impossible to set breakpoints, view intermediate variable values, or trace execution paths within TMP logic like one would with normal code.
To debug TMP, some workarounds exist (but these methods are far less intuitive and efficient than runtime debuggers):

Using static_assert to check conditions at compile time; if the condition is not met, it leads to a compilation error and outputs custom error messages.
Using some tricks to “print” compile-time type information.
Breaking complex TMP code into smaller parts and testing them one by one to locate issues.

Although modern IDEs have improved support for C++ templates, their smart sensing, code completion, and refactoring features still perform poorly with complex TMP structures. Static analysis tools also struggle to understand the complex logic of TMP, leading to false positives or negatives.

TMP is indeed powerful, and this cannot be denied, but not all problems are suitable for TMP solutions.

TMP can only handle information and logic that can be determined at compile time. It cannot perform any runtime behavior.
If the behavior of a program needs to change dynamically at runtime based on external inputs or unpredictable conditions, then TMP is not suitable. TMP is applicable to problems where its behavior and structure can be fully determined at compile time.
TMP is powerful, but it should not be abused. For some simple problems, forcing TMP solutions can lead to over-engineering, making the code unnecessarily complex and difficult to understand.

5. Typical Applications of Template Metaprogramming

TMP is the core of C++ generic programming and the foundation for many C++ standard libraries and well-known third-party libraries.

The C++ Standard Template Library (STL) is the most common application instance of TMP.std::vector, std::map, std::sort, and other containers and algorithms are implemented through templates, capable of operating on any type of data.

Type agnosticism, no need to write separate code for each type.
Algorithm generalization.
Type traits provide information about types at compile time, enabling STL to perform compile-time type checks and optimizations.

The well-known C++ third-party library Boost also extensively uses TMP to provide advanced generic programming capabilities:

Boost.MPL: Provides a set of tools for compile-time sequences, algorithms, and metafunctions, performing complex type operations and logical computations at compile time.
Boost.Fusion / Boost.Hana: These libraries utilize TMP to implement heterogeneous containers and limited compile-time reflection, making operations on different type collections more convenient and efficient.
Boost.Spirit: A library for parsers, its core is to construct parser syntax trees at compile time through TMP, achieving efficient text parsing.

In applications with extremely high performance requirements, TMP can shift computations from runtime to compile time, eliminating runtime overhead.

In scientific computing and linear algebra libraries, expression templates are key techniques for optimizing mathematical expressions. They can represent complex mathematical expressions as a data structure at compile time, allowing the compiler to analyze and generate highly optimized code, avoiding the creation of numerous temporary objects and performing loop fusion optimizations. Users can write in a natural syntax close to mathematical formulas while achieving performance close to handwritten assembly.
By passing the behavior strategy of algorithms or classes as template parameters, specific implementations can be selected at compile time, avoiding the runtime overhead of virtual functions, achieving static polymorphism.
Singular recursive template patterns access the members of derived classes at compile time, achieving:

Static polymorphism: A common interface is defined in the base class, and the specific implementation of the derived class is called through static_cast<Derived*>(this), avoiding virtual function table lookups.
Compile-time interface checks: Enforcing derived classes to implement certain methods in the base class.
Mixins: Injecting common functionality into multiple classes.

TMP enables C++ to perform compile-time code generation, even embedding domain-specific languages within C++.

Through TMP, a generic serialization framework can be written to analyze the member types and structures of classes at compile time, automatically generating code for serializing objects to files or networks and deserializing them back from files or networks.
For state machines where state transition logic is determined at compile time, TMP can be used to implement them. Each state and transition can be represented by types, and the behavior of the state machine is entirely determined at compile time, thus eliminating runtime state lookups and conditional judgment overhead, suitable for high-performance protocol parsing or control logic.
TMP can create an “embedded” domain-specific language in C++, allowing certain domain-specific problems to be described using C++ syntax that is more natural and closer to the expression of that domain, while the underlying complexity is resolved through TMP at compile time.

Bringing errors from runtime to compile time.

static_assert can check conditions at compile time. If the condition is not met, the compiler will report an error and display custom error messages. This is very useful for enforcing design constraints, validating the legality of template parameters, and discovering potential issues early.
Combining type traits and SFINAE can achieve very fine compile-time type checks and function overload selections.

6. Template Metaprogramming vs. Runtime Programming

Template metaprogramming (TMP) and traditional runtime programming represent two distinctly different programming paradigms.

Core differences:

Feature	Template Metaprogramming (TMP)	Runtime Programming
Execution phase	Compile time: All computations and code generation are completed during the compilation phase.	Runtime: After the program is compiled, computations and operations are performed during execution.
Computation model	Based on type operations, template instantiation, recursion, and specialization. Treating the compiler as a kind of “interpreter”.	Based on instruction sequences, variable operations, function calls, and control flow (loops, conditional branches).
Data representation	Types themselves, compile-time constants, type traits. Data is “static”.	Variables, objects, dynamic memory. Data is “dynamic”.
Error detection	Compile-time errors: If the metaprogram logic is incorrect, the compiler will report an error. Errors are verbose and difficult to understand.	Runtime errors: Logical errors, memory access errors, etc., only manifest when the program is executed, potentially leading to crashes.
Debugging	Extremely difficult, cannot use traditional debuggers. Relies on `<span>static_assert</span>` and type printing tricks.	Relatively easy, can use tools like GDB, Visual Studio Debugger for step debugging and variable inspection.
Performance	Zero runtime overhead: All computations are completed at compile time, with no additional calculations at runtime.	Runtime overhead exists: function calls, virtual function table lookups, conditional branches, loops, etc.
Flexibility	Can only handle logic determined at compile time, cannot respond to runtime dynamic changes.	Can flexibly handle dynamic inputs, I/O, network communication, dynamic memory allocation, etc.
Code readability	Generally poor, highly abstract, requires deep knowledge of C++ templates.	Relatively intuitive, aligns with human thought patterns, easy to understand and maintain.
Compilation time	Significantly increased, especially for complex metaprograms.	Relatively fast, unless the code volume is enormous.

Advantages of Template Metaprogramming:

Extreme performance optimization: Shifting computations from runtime to compile time eliminates runtime overhead and generates highly optimized code.
Compile-time code generation: Reduces the workload of manually writing repetitive code, improving development efficiency and code consistency.
Strong type safety and compile-time error detection: Captures more errors during the compilation phase.
Powerful generic programming capabilities: Achieves highly generic and reusable components.

Disadvantages of Template Metaprogramming:

Non-intuitive programming paradigm, making code difficult to understand and maintain.
Complex metaprograms lead to significantly increased compilation times, even causing memory overflow.
Compiler error reports are verbose and difficult to pinpoint the root cause of issues.
Cannot use traditional debuggers, relying on indirect compile-time assertions and type printing tricks.
Cannot perform I/O, dynamic memory allocation, or other runtime operations.

Advantages of Runtime Programming:

More aligned with traditional imperative programming thinking, easier to get started.
Fast compilation speed, with mature debugging tool support.
Can easily handle runtime changes.
Code structure is clear, suitable for team collaboration and long-term maintenance.
Most C++ libraries and frameworks are based on runtime programming.

Disadvantages of Runtime Programming:

Function calls, virtual functions, conditional branches, loops, etc., all incur some performance loss.
Errors are usually discovered at runtime.
Although templates exist, they are not as powerful as TMP for complex operations on types, sometimes requiring runtime polymorphism or type erasure.

Choosing TMP should be based on clear needs and trade-offs, rather than blindly chasing technological trends. Ideal application scenarios for TMP include:

Extreme performance requirements: When the performance bottleneck of an application lies in runtime computations that can be determined at compile time, TMP is an effective means to eliminate overhead.
When you want to capture as many errors as possible before the program runs.
Compile-time code generation.
Implementing highly generalized libraries or components.
When the behavior and structure of the program are fixed at compile time, without needing to adjust dynamically at runtime.

For most everyday software development tasks, runtime programming remains the preferred choice, as it offers better development efficiency, readability, and maintainability.

Most general application development: Including business logic, user interfaces, server-side applications, etc., which do not pursue extreme performance but focus more on development speed and maintainability.
Handling dynamic data and runtime behavior: Involving user input, file I/O, network communication, dynamic memory allocation, random number generation, etc.
When program behavior needs to change flexibly at runtime based on external conditions.
If runtime overhead does not significantly impact overall performance, or can be optimized through other means, then the complexity of introducing TMP is unnecessary.

TMP and runtime programming can complement each other, leveraging their respective advantages.

Using TMP to define compile-time strategies, and then performing specific operations in runtime code based on those strategies.
Although C++ currently lacks native runtime reflection, TMP can be used to generate metadata about type structures, member information, etc., at compile time, which can then be used at runtime to achieve reflection-like functionality.
Using TMP to automatically generate framework code, data structures, or protocol parsers, and then filling in specific business logic and dynamic behavior with runtime code.

7. Conclusion

Template metaprogramming has pushed the boundaries of generic programming and provided unique solutions for performance optimization and code generation. With the development of the C++ language itself, especially the standardization of Concepts and the emergence of features like compile-time reflection in future C++26, the usage and complexity of TMP will improve. Some complex TMP techniques will be replaced by higher-level, more user-friendly language features, but the core idea—performing computations and code generation at compile time—remains very important, driving the C++ language towards higher performance, stronger type safety, and higher levels of abstraction.

PreviousReviewTutorials

Why does C++11 thread parameter passing require std::ref instead of direct references?

C++

STL Algorithms: Master these, and your code efficiency will increase tenfold!

Build

C++ Training Camp: Rapid Advancement and Project Practice

Thoroughly understand asynchronous and multithreading: Concepts, Principles, and Application Scenario Comparisons C++ Template Metaprogramming: A Comprehensive Analysis of Principles, Practices, Advantages, and Limitations Lion RyanWelcome to follow my public account for learning technology or submissions