conditional assignment terraform

Terraform by Example

Conditionals

Infrastructure is often deployed using certain conditions, you might want to deploy a less nodes to development than to production or not deploy a certain resource at all.

Terraform provides a way to conditionally write resources using a ternary operator, the conditional expression is as following:

Using a ternary operator to assign a value to a variable #

Assign a value to a variable if a condition is true, otherwise assign a different value.

Using a ternary operator to optionally create resources #

Conditionally deploy a Redis ElastiCache cluster to only the dev environment.

Here we are using the count argument to determine the number of times we should create this resource, if it’s not a dev environment, we’ll set the count to 0 and therefore not create the resource at all.

Want to learn more about Conditionals? Check out the docs .

Continue to For

Understand Conditional Statements in Terraform in 5 minutes

Whilst the Terraform documentation states that there is only a single type of conditional expression -the ternary operator- there is technically an if expression available to us within the for_each meta-argument. Today we are going to dive into both of those scenarios and see how we can conditionally do things within Terraform.

• The test expression — the conditions we are using to test truthfulness
• The truthful expression — what is returned if the condition is true
• The false expression — what is returned if the condition is false

This allows us to do a range of things as engineers from simply checking if something has a value to more complex logic such as if multiple things exist within a network or have permissions to another thing.

NOTE — Return TypesIt is very important to note that both sides of the ternary expression itself MUST be the same type.

We are now going to dive into an example where we will be using the conditional as a way to feature flag some Terraform resource.

These can be used absolutely anywhere within Terraform, another example might be as follows:

In this example we are going to create a virtual machine that is significantly more powerful for our production environment than any other. It is also possible to nest these expressions to allow for checking more and more conditions, ideally you wouldn't do this unless you had no other choice however.

It is obvious to see here that the more conditions we add the harder the code becomes to read and the more brittle it becomes too. But it certainly is possible.

The second conditional type to touch on is the if within the for expression, which we are going to look at now.

In this article we looked at the ternary operator which allows us to return a true value or a false value based on the result of a condition. These are exceptionally powerful and allow us to create logic such as what size of a resource to provision in different environments, or if a resource should even be provisioned at all. We then took a dive into the if expression on the for expression which allows us to filter out data before returning it to the consumer. These are some fantastic concepts that you can apply to your Terraform code today!

Sign Up and get started by using Scalr today.

Related posts

OpenTofu Language Guide

API Driven Workflows for Terraform and OpenTofu

Understanding OpenTofu Remote Backends

Start using the terraform platform of the future..

Terraform Conditionals

What is a conditional .css-1a60e3e{transition-property:var(--chakra-transition-property-common);transition-duration:var(--chakra-transition-duration-fast);transition-timing-function:var(--chakra-transition-easing-ease-out);cursor:pointer;-webkit-text-decoration:none;text-decoration:none;outline:2px solid transparent;outline-offset:2px;color:inherit;font-weight:var(--chakra-fontweights-normal);opacity:0;margin-left:var(--chakra-space-2);}.css-1a60e3e:hover,.css-1a60e3e[data-hover]{opacity:1;color:var(--chakra-colors-accent-500);-webkit-text-decoration:underline;text-decoration:underline;}.css-1a60e3e:focus,.css-1a60e3e[data-focus]{opacity:1;color:var(--chakra-colors-accent-500);-webkit-text-decoration:underline;text-decoration:underline;} #.

The syntax for a conditional is:

When to use a conditional? #

Conditionals are a pretty valuable part of the Terraform DSL. It allows our code to be selective when it runs. Here are some common scenarios when conditionals should be used:

• As a feature flag to turn on or off a Resource or Data Source
• Enable/Disable a feature inside of a Resource with a Dynamic Block
• Enable/Disable a field or property on a Resource or Data Source

How to use a conditional? #

As a feature flag #.

In this section, we will go through a few ways that conditionals can be used as feature flags, there are two ways to achieve this; count and for_each .

In the below count example, we will set the instance count of the resource to be 1 if our variable enabled is true and set it to 0 if it is false . This gives you a straightforward way to create one or more resource instances if your condition is true . The thing to remember here is that you will have to deal with your resource as an array from here on out.

We will use the same variable as above ( enabled ) for our following scenario. We are going to create one or more instances of an object where we will be setting some properties, we will use a locals block.

When the condition is true , our code will iterate over a map defined in our locals , although this could be defined anywhere, including the output of another resource or data source. This option allows us a lot more flexibility as we can change properties on each instance of our resource and we could even include conditionals inside the resource to further let us define if a property is required or not!

Dynamic Blocks #

In this instance, we will be dynamically set the properties for the SSH Key on an Azure Virtual Machine instance. We will use some of the above for conditionally enabling or disabling properties on the resources as well!

The following excerpt demonstrates how we use dynamic blocks:

If the variable ssh_enabled is set to true , we are going to create an instance of the admin_ssh_key block and consume some properties from the locals block we have defined. If the condition is false then we will pass in an empty map; this will mean that the entire block will not get set! Doing this is even more helpful when creating multiple instances of a block. You want to pass in the parameters via a Terraform variable or ingest out of config.

Resource Fields #

The last scenario I would like to go through in this post is how to enable or disable fields on a resource using conditionals. There are situations where you might do this either on its own or in conjunction with one of the other conditional scenarios described above. I will use the above Virtual Machine example to talk through this; however, I will pull out the relevant pieces for the sake of clarity.

In the below excerpt, it can be seen that we are applying some conditional logic on the admin_password and disable_password_authentication properties. When var.ssh_enabled is false , we still need to authenticate to our instance; the only other way Azure allows you to do this is via password authentication. Thus, when it is disabled, we are enabling the creation of the random_password resource (see the above), and setting its result to the admin_password property, we must ensure that disable_password_authentication is set to true .

Closing Out #

Hopefully, this post has given you some insight into how to use conditionals in Terraform and some typical scenarios where they could be used.

Terraform Conditional: Essentials And Applications

Explore the essentials of Terraform conditionals, a key tool for dynamic infrastructure management. This article delves into their syntax, use cases, best practices, and troubleshooting, equipping you with the knowledge to efficiently handle conditional logic in Terraform.

💡 KEY INSIGHTS

• In Terraform, conditional expressions are essential for making decisions within your infrastructure code based on certain criteria.
• Using conditionals, you can control resource creation, variable values , and other aspects of your configuration based on dynamic conditions.
• Terraform's built-in functions like **if**, **else**, and **coalesce** allow you to create flexible configurations that adapt to different scenarios.
• Leveraging conditionals appropriately helps you build responsive infrastructure that can handle various deployment scenarios.

Terraform conditionals are a crucial tool in your infrastructure as code toolkit, allowing for flexible and adaptive configurations. Understanding how to effectively use these conditionals can streamline your deployment processes and tailor your infrastructure to various environments. This article aims to enhance your skills in leveraging Terraform conditionals for more efficient and responsive infrastructure management.

Terraform Conditionals

Basic syntax of terraform conditionals, common use cases for terraform conditionals, best practices for using terraform conditionals, troubleshooting common issues with terraform conditionals, frequently asked questions, terraform conditional basics, conditional expressions in terraform, practical examples of terraform conditionals.

Terraform conditionals are a fundamental aspect of Terraform's configuration language . They allow you to specify conditions under which certain actions are taken. This flexibility is key in creating dynamic and adaptable infrastructure as code.

A conditional expression in Terraform uses a simple syntax: condition ? true_val : false_val . Here, condition is an expression that Terraform evaluates. If the condition is true, Terraform returns true_val ; if false, false_val is returned. This ternary operation is crucial for decision-making in your configurations.

For example:

In this snippet, Terraform creates instances based on the instance_count variable. If instance_count is greater than 0, that number of instances is created. Otherwise, no instances are created.

Terraform conditionals shine in scenarios where infrastructure needs vary. For instance, you might want a larger instance size in production than in development. Using a conditional, you can adjust this setting based on an environment variable. Example:

In this example, instance_type is determined by the environment variable. For production, a t3.large instance is used, while for other environments, t3.micro is chosen.

Terraform conditionals are not just limited to resource attributes. They can also control whether entire resources or modules are included in your plan. This level of control is essential for tailoring infrastructure to specific needs without duplicating code.

The Ternary Operator

Writing conditional expressions, examples of conditional syntax.

The ternary operator in Terraform is a concise way to express conditional logic. It follows the format: condition ? true_value : false_value . This operator evaluates the condition and selects one of the two values based on the result.

To write an effective conditional expression, start with a Boolean condition . This condition can be a comparison, like var.a > var.b , or a more complex expression. The key is that it must resolve to either true or false.

Writing conditional expressions in Terraform is like crafting a roadmap, where each decision point smartly guides the journey of your infrastructure's configuration.

Here, the output instance_size depends on whether the environment variable equals "production".

Conditional expressions can be used in various parts of your Terraform configuration. They're particularly useful in resource attributes , count parameters, and module arguments. Consider this example:

In this case, an AWS instance is created only if var.create_instance is true. This approach is handy for creating optional resources in your infrastructure.

Environment-Specific Configurations

Conditional resource creation, dynamic outputs and variables.

Terraform conditionals are ideal for managing different environments such as development, staging, and production. They allow you to alter configurations based on the environment, ensuring that each setup is tailored appropriately.

In this example, the instance type changes based on the environment variable, allowing for different setups in production and non-production environments.

Another common use case is conditional resource creation . This technique is useful when you need to create resources only under certain conditions, such as in specific environments or based on user input. For instance:

Here, a database instance is created only if var.create_db is set to true.

Terraform conditionals also enhance the dynamism of outputs and variables. You can use them to provide different outputs based on the state of your infrastructure or input variables. Example:

This output returns the database address if it exists, otherwise, it outputs "N/A".

These examples illustrate how Terraform conditionals can be applied in practical scenarios, enhancing the flexibility and adaptability of your infrastructure configurations.

Keep Conditionals Simple

Use descriptive variable names, avoid overusing conditionals.

When using Terraform conditionals , it's best to keep them as simple and readable as possible. Complex conditional logic can make your code hard to understand and maintain. Stick to straightforward comparisons and avoid nested conditionals when possible.

This example demonstrates a simple conditional for creating a resource only in a production environment.

Descriptive variable names make your Terraform code more understandable. When using conditionals, ensure your variable names clearly indicate their purpose and the conditions they represent. For example:

Here, enable_logging clearly indicates its role in the conditional logic.

While conditionals are powerful, overusing them can lead to complex and brittle configurations . Use them judiciously, focusing on scenarios where they add clear value. Remember, the goal is to make your infrastructure code more manageable, not more complicated. These best practices for using Terraform conditionals will help you write more efficient, readable, and maintainable infrastructure code. By keeping conditionals simple, using descriptive variable names, and avoiding their overuse, you can leverage the full power of Terraform's flexibility while maintaining code quality.

Syntax Errors In Conditionals

Handling undefined variables, debugging conditional logic.

One common issue with Terraform conditionals is syntax errors. These often occur when the ternary operator is not used correctly. Ensure that your conditionals follow the condition ? true_value : false_value format and that each part of the expression is valid Terraform code.

Example of a syntax error:

In this example, the comma after the conditional expression is a syntax error.

Another issue arises when variables used in conditionals are undefined . This can lead to unexpected behavior or errors. Always ensure that your variables are properly defined and initialized before they are used in conditionals. Example of handling undefined variables:

Defining a default value for is_prod ensures it always has a valid value.

Debugging conditional logic can be challenging. If you're encountering issues, break down your conditionals into smaller parts and test each part individually. Use terraform console to experiment with and evaluate expressions. For example:

Using the Terraform console, you can test what value this expression will return based on different values of var.is_prod .

Troubleshooting common issues with Terraform conditionals involves checking for syntax errors, ensuring variables are defined, and methodically debugging conditional logic. By addressing these areas, you can resolve most problems encountered when working with Terraform conditionals.

What are Terraform conditionals?

Terraform conditionals are expressions that evaluate to either true or false, used to dynamically configure infrastructure based on certain conditions.

How do you write a basic conditional expression in Terraform?

A basic conditional in Terraform uses the syntax condition ? true_val : false_val , where condition is the expression to evaluate, and true_val and false_val are the values returned based on the condition's truth.

Can Terraform conditionals be used with any type of resource?

Yes, Terraform conditionals can be applied to virtually any resource or module, allowing for dynamic and flexible infrastructure configurations.

What is the difference between count and for_each in Terraform, in the context of conditionals?

count is used to create multiple instances of a resource based on a count, while for_each iterates over a map or set of strings to create an instance for each item. Both can be used with conditionals to control resource creation.

How can I use Terraform conditionals to manage different environments?

You can use Terraform conditionals to specify different resource configurations or parameters for different environments (like staging vs. production) by setting environment-based conditions.

Are there any limitations to using Terraform conditionals?

While powerful, Terraform conditionals have limitations, such as not being able to dynamically create resource types. They are best used for changing resource properties or toggling resources on and off.

How can I debug issues with Terraform conditionals?

Debugging Terraform conditionals often involves ensuring your expressions are correctly structured and evaluating as expected. Using terraform console can help test and troubleshoot expressions.

What Is The Basic Syntax Of A Terraform Conditional?

Continue learning with these terraform guides.

• Terraform Vs Pulumi: The Differences And Applications
• Essentials And Usage For Terraform Map
• Terraform Taint And Its Usage
• Terraform Merge: Key Concepts And Usage
• Terraform GCP: Essentials And Usage Strategies

Subscribe to our newsletter

Subscribe to be notified of new content on marketsplash..

Living Devops

Complete guide to conditional If/Else statement in Terraform

If/Else statement in Terraform is much more powerful than you think. In this blog, I will explain how to use the If/Else conditional statement in Terraform effectively.

There are two opinions when it comes to the If/Else statement in Terraform

• First one — Terraform doesn’t have an If/Else conditional statement
• And the second one — Terraform provides If/Else conditional logic but you can’t do much with 

I kinda agree and at the same time, disagree with the second opinion.

Terraform provides conditional statement-type logic using Ternary Operators and there is so much you can do with it.

If/Else statement syntax in Terraform

The above statement means if the given condition is true, use true_val else use false_val

Let’s take the below example of creating vpc network in google cloud

In the above example, i am using checking if the local variable use_local_name is true, if the condition is met then use the local.name as the name of the VPC, else use the name ‘base-vpc’

Let me show where we can use this If/Else conditional logic to make our terraform code more flexible.

Conditional Attribute Assignment

In the above example, we can define the instance type to use as per the environment type while creating an aws instance. If it’s production, use ‘t2.large’ else use “t2.micro”.

To replace invalid values

In the above example, we check if the value provided for the variable namespace is an empty string, if it is, then it will assume the value “my-namespace”

Dynamic resource creation

Suppose you want to create an AWS instance only when it is explicitly told to do so. We can use the meta argument Count with conditional logic as below

You can think about it this way: you can set count to 1 on a specific resource and get one copy of that resource. if its set to 0 then no resource will be created

If you set the value for variable create_instances to true the count value will be set to 1 and one copy of the AWS instance will be created.

If you will not set any value, or set the value as false , then the value for variable create_instances will be false and no aws instance will be created.

With Dynamic Block

The dynamic block allows you to generate multiple blocks of configuration dynamically based on a list or map variable.

We can combine Terraform’s dynamic blocks with if/else conditions to create more complex configurations.

Let’s take an example where we want to configure firewall logging when it is explicitly asked for using variable ingress_tcp_log_enabled

Or we can use it to dynamically create tags

Note: In conditional expression, the two result types can be of any type, lets say one is number and other is string  var.network_name ? 1000 : “base-vpc” Terraform will attempt find a type in which it can convert both results, in this case it will convert both to string.  var.network_name ? “1000” : “base-vpc” It can often cause confusion, to avoid this, it is recommended to write specific conversion function as below var.network_name ? tostring(1000) : “base-vpc”

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

How to write conditional logic in Terraform

Introduction.

Terraform, by HashiCorp, is a tool that allows for the definition, preview, and deployment of infrastructure as code. The tool utilizes a declarative configuration language known as HCL (HashiCorp Configuration Language) to describe the desired state of your infrastructure. This enables version control of your infrastructure in the same way as you might with application code. An essential aspect of writing Terraform configurations is implementing conditional logic. Conditional logic allows for dynamic configurations that can adapt based on variables or the current state of the provisioned infrastructure.

Understanding the Basics

Before diving into conditional logic, it’s important to grasp a few fundamentals of Terraform syntax, particularly regarding variables and the count parameter, which will play a significant role in our conditional structures.

In this basic example, we create a variable, deploy_instance , that controls whether an AWS EC2 instance is deployed. The count argument is used to conditionally create the instance based on the variable’s boolean value.

Implementing Conditional Expressions

Conditional expressions in Terraform use a simple condition ? true_val : false_val syntax, which mirrors many programming languages. These expressions can dynamically set the values for arguments within your Terraform configuration based on any logic you define.

This example demonstrates how to use conditional expressions to manage the creation of a security group’s ingress rules based on a boolean variable.

Using Conditional Logic with Collections

Terraform’s advanced features include the ability to work with complex data types such as lists and maps. Conditional logic can extend to these types, enabling more nuanced configurations.

In this more complex scenario, we use a map of maps stored in local to define settings for different environments. The look-up function determines the minimum instance size based on the deployed environment.

Advanced Conditional Logic

More complex conditional logic might involve using expressions within expressions or applying conditions based on the output of other resources. Creating modular and dynamic configurations greatly increases the power and flexibility of your Terraform code.

This example illustrates how to use the terraform.workspace as a condition to dynamically configure a module, including the number of instances to deploy based on the current workspace.

Error Handling and Conditional Logic

It’s important to remember that while conditional logic can greatly enhance the flexibility of your Terraform configurations, it can also introduce complexity that could lead to errors. Clear documentation, thorough testing, and understanding the limitations of HCL’s conditional logic are paramount.

Conditional logic in Terraform allows for dynamic and flexible infrastructure configurations. By understanding and implementing basic to advanced conditional expressions, Terraform configurations can adapt to various scenarios, providing a robust infrastructure as code solution. Always test and document your configurations to ensure their reliability and maintainability.

Next Article: When NOT to use Terraform (and what to use instead)

Previous Article: Terraform: How to concatenate lists

Series: Terraform Tutorials

Related Articles

• Git: What is .DS_Store and should you ignore it?
• NGINX underscores_in_headers: Explained with examples
• How to use Jenkins CI with private GitHub repositories
• Terraform: Understanding State and State Files (with Examples)
• SHA1, SHA256, and SHA512 in Terraform: A Practical Guide
• CSRF Protection in Jenkins: An In-depth Guide (with examples)
• Terraform: How to Merge 2 Maps
• Terraform: How to extract filename/extension from a path
• JSON encoding/decoding in Terraform: Explained with examples
• Sorting Lists in Terraform: A Practical Guide
• Terraform: How to trigger a Lambda function on resource creation
• How to use Terraform templates

Search tutorials, examples, and resources

• PHP programming
• Symfony & Doctrine
• Laravel & Eloquent
• Tailwind CSS
• Sequelize.js
• Mongoose.js

Terraform: If/Else Conditional Resource and Module Deployment

Terraform has an inline If/Else conditional expression that enables you to set parameters and variables programmatically based on the condition being evaluated. The syntax of this “If/Then” or “If/Else” expression is similar to other programming languages where you have a condition to evaluate, then the result to return if either True or False are the evaluated conditions. It follows the below format in HCL:

This conditional expression can be used to programmatically assign resource parameters and variables based on an expression being evaluated. However, this feature is also very useful for other scenarios as well.

When setting up a block of HCL code to deploy / manage a resource, you can combine the inline If/Else conditional expression with the Resource count feature to easily be able to check a condition, then decide programmatically whether to deploy / manage the resource or not in your deployment. This can be useful with implementing Feature Flags in your Terraform code , as well as other scenarios where you may need to conditionally deploy resources.

You simply set the value of the count property of the resource using the If/Else conditional expression to assign the values of either 1 (to deploy the resource) or 0 (to not deploy the resource). This is a useful features that helps when developing custom Terraform Modules or other blocks of HCL that are reusable across may different Terraform projects.

The following is an example of using this technique to implement the conditional deployment of a resource based on a feature flag variable:

The count property on the resource block in Terraform used in conjunction with a conditional expression is the closest to supporting an “if” property to determine conditional resources. The conditional expression above essentially set the count to 1 to provision a single instance of the resource . When set to 0 then it will not provision the resource at all.

The count property is also supported on Terraform module blocks as well; as of Terraform 0.13 or later. So, this conditional deployment technique is not just available for resource blocks, but also Terraform Modules with the module block too!

The following is an example of using this technique to implement the conditional deployment of a module based on a feature flag variable:

Using these conditional expressions to conditionally deploy / manage resources in Terraform does not throw any exceptions or raise any errors based on the conditional expression. This is just an easy way to programmatically determine whether to deploy / manage the resource. If you need to raise an error if a certain condition is met within your Terraform code, then you’ll want to look into the Preconditions and Postconditions features.

Share this:

• Click to share on Twitter (Opens in new window)
• Click to share on Facebook (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to email a link to a friend (Opens in new window)
• Click to share on Reddit (Opens in new window)

About the Author

Chris Pietschmann

Popular Articles

Related Articles

• Workshop: Migrate RHEL Linux and MySQL Database to Azure
• Workshop: Migrate Windows Server and SQL Server to Azure
• Terraform with Azure Key Vault to get secret value
• Terraform resource with the ID already exists
• Having the Terraform azure state file under different subscription
• Azure Terraform with depends_on with modules
• How to Use for_each with a List of Objects in Terraform

Discover more from Build5Nines

Subscribe now to keep reading and get access to the full archive.

Type your email…

Continue reading

• HashiCorp Developer
• HashiCorp Cloud Platform

dynamic Blocks

Within top-level block constructs like resources, expressions can usually be used only when assigning a value to an argument using the name = expression form. This covers many uses, but some resource types include repeatable nested blocks in their arguments, which typically represent separate objects that are related to (or embedded within) the containing object:

You can dynamically construct repeatable nested blocks like setting using a special dynamic block type, which is supported inside resource , data , provider , and provisioner blocks:

A dynamic block acts much like a for expression , but produces nested blocks instead of a complex typed value. It iterates over a given complex value, and generates a nested block for each element of that complex value.

• The label of the dynamic block ( "setting" in the example above) specifies what kind of nested block to generate.
• The for_each argument provides the complex value to iterate over.
• The iterator argument (optional) sets the name of a temporary variable that represents the current element of the complex value. If omitted, the name of the variable defaults to the label of the dynamic block ( "setting" in the example above).
• The labels argument (optional) is a list of strings that specifies the block labels, in order, to use for each generated block. You can use the temporary iterator variable in this value.
• The nested content block defines the body of each generated block. You can use the temporary iterator variable inside this block.

Since the for_each argument accepts any collection or structural value, you can use a for expression or splat expression to transform an existing collection.

The iterator object ( setting in the example above) has two attributes:

• key is the map key or list element index for the current element. If the for_each expression produces a set value then key is identical to value and should not be used.
• value is the value of the current element.

A dynamic block can only generate arguments that belong to the resource type, data source, provider or provisioner being configured. It is not possible to generate meta-argument blocks such as lifecycle and provisioner blocks, since Terraform must process these before it is safe to evaluate expressions.

The for_each value must be a collection with one element per desired nested block. If you need to declare resource instances based on a nested data structure or combinations of elements from multiple data structures you can use Terraform expressions and functions to derive a suitable value. For some common examples of such situations, see the flatten and setproduct functions.

Multi-level Nested Block Structures

Some providers define resource types that include multiple levels of blocks nested inside one another. You can generate these nested structures dynamically when necessary by nesting dynamic blocks in the content portion of other dynamic blocks.

For example, a module might accept a complex data structure like the following:

If you were defining a resource whose type expects a block for each origin group and then nested blocks for each origin within a group, you could ask Terraform to generate that dynamically using the following nested dynamic blocks:

When using nested dynamic blocks it's particularly important to pay attention to the iterator symbol for each block. In the above example, origin_group.value refers to the current element of the outer block, while origin.value refers to the current element of the inner block.

If a particular resource type defines nested blocks that have the same type name as one of their parents, you can use the iterator argument in each of dynamic blocks to choose a different iterator symbol that makes the two easier to distinguish.

Best Practices for dynamic Blocks

Overuse of dynamic blocks can make configuration hard to read and maintain, so we recommend using them only when you need to hide details in order to build a clean user interface for a re-usable module. Always write nested blocks out literally where possible.

If you find yourself defining most or all of a resource block's arguments and nested blocks using directly-corresponding attributes from an input variable then that might suggest that your module is not creating a useful abstraction. It may be better for the calling module to define the resource itself then pass information about it into your module. For more information on this design tradeoff, see When to Write a Module and Module Composition .