Every time you write to or modify a variable in the blockchain's state (e.g., SSTORE opcode), it incurs a significant gas cost. This cost is even higher for initial storage (0x6000 gas) compared to updating existing storage (5000 gas). Therefore, minimizing state writes is paramount. Consider using delete for variables that will no longer be used, as it refunds some gas. Also, avoid storing the same piece of data in multiple places if it can be derived or accessed efficiently.

Loops are a common source of high gas consumption, especially if they iterate over a large number of elements. Each iteration typically involves gas costs for reading, processing, and potentially writing. Techniques include:

1. Batching operations: Instead of processing items one by one, group them into batches.
2. Using efficient data structures: Arrays can be costly to iterate over. Consider using mappings for direct lookups if the order doesn't matter.
3. Limiting loop size: If possible, cap the number of iterations or use pagination.
4. Off-chain computation: For very large datasets or complex calculations, perform the computation off-chain and only store the final result on-chain.

Solidity provides immutable and constant keywords for variables. immutable variables can be set once in the constructor and cannot be changed thereafter. constant variables are compile-time constants. Using these keywords allows the compiler to optimize gas costs because the values don't need to be stored in the contract's state and read from it repeatedly. They are often embedded directly into the bytecode.

Every time your contract calls another contract, it consumes gas for the message call. This gas is used for context switching, data encoding, and execution. To optimize:

1. Batch external calls: If you need to call the same function on multiple contracts, consider a single function that accepts an array of addresses or parameters.
2. Use libraries: If you have reusable logic, consider deploying it as a library. Libraries can be called more efficiently than regular contract calls, especially when using delegatecall for state-modifying operations.
3. Avoid unnecessary calls: Ensure that external calls are only made when absolutely necessary.

Function arguments are passed via calldata, which is a read-only, non-persistent data area. For temporary variables within a function, memory is used. calldata is generally cheaper than memory for function arguments. When passing large data structures or arrays, consider if they can be passed as calldata if they are only read. memory is more flexible but incurs higher gas costs for its management.

When interacting with contracts or sending data, the encoding of parameters matters. For example, using uint256 for a boolean value is inefficient. Pack smaller data types together where possible. Libraries like Solidity-Bytes can help with efficient byte manipulation. Be mindful of how ABI encoding works, as it has specific rules that can impact gas.