# NASA-style Programming for C#

I asked the AI to write their [NASA-style](https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code) [coding instructions](Powerof10PPrompt.txt) in the form of guidelines. I figured I'd use C# since it's both my preferred language and the syntax should be fairly easy to grasp once you understand the basics.

Why NASA? Their coding standards have loads of redundancies, and if AI is going to behave like advanced code generation tools, they need to be as fault-tolerant as possible. While my instructions were modified to account for modern languages, the principles are still the same.

My only request was to apply .NET 6's [top-level statements](https://learn.microsoft.com/en-us/dotnet/csharp/tutorials/top-level-statements) for brevity. Aside from a few organizational tweaks with the guidelines and fixing the scope example to be wrapped in a class, it all works flawlessly.

## 1. Write Clear, Well-Structured, and Maintainable Code

- Keep the code simple and coherent. Use meaningful identifiers and limit the complexity of expressions.
- Keep functions or methods short, with a single responsibility.

### Example:

```csharp
// Good example of a short, focused method
int Sum(int a, int b)
{
    return a + b;
}

// Good example of clear, well-structured code
var result = Sum(5, 3);
Console.WriteLine($"The sum is {result}");
```

## 2. Follow Best Practices for Security, Performance, and Reliability

- Validate and sanitize inputs to prevent security vulnerabilities like injection attacks.
- Use try-catch blocks to handle exceptions gracefully.

### Example:

```csharp
using System.Globalization;

string userInput = "2023-10-30";
if (DateTime.TryParseExact(userInput, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
{
    Console.WriteLine($"Parsed date: {date}");
}
else
{
    throw new FormatException("Invalid date format.");
}
```

## 3. Ensure Portability and Adaptability Across Different Environments

- Use environment variables or configuration files for environment-specific settings.
- Rely on cross-platform libraries within .NET.

### Example:

```csharp
// Reading configuration using environment variables
var configValue = Environment.GetEnvironmentVariable("CONFIG_KEY");
if (configValue != null)
{
    Console.WriteLine($"Configuration value: {configValue}");
}
else
{
    throw new InvalidOperationException("Configuration key not found.");
}
```

## 4. Manage Resources Efficiently and Safely

- Prefer `using` statements to safely manage resource cleanup.
- Avoid excessive memory allocation and prefer stack-allocated variables.

### Example:

```csharp
// Using statement to ensure safe disposal
using (var reader = new StreamReader("example.txt"))
{
    string line;
    while ((line = reader.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}
```

## 5. Use Minimal Scope for Variables and Functions

- Limit the visibility of variables and functions to the smallest scope necessary.

### Example:

```csharp
namespace Application;

class Program
{
	static void Main()
	{
        // 'a' and 'b' are limited to Main method scope
		int a = 5, b = 3;
		Console.WriteLine($"Sum: {Add(a, b)}");
	}

	static int Add(int a, int b)
	{
		// 'a' and 'b' are limited to Add method scope
		return a + b;
	}
}
```

## 6. Always Validate and Sanitize Input

- Sanitize and validate all external inputs to secure your application.

### Example:

```csharp
using System.Web;

string input = Console.ReadLine();
if (string.IsNullOrWhiteSpace(input))
{
    throw new ArgumentException("Input cannot be null or whitespace.");
}
else
{
    string sanitizedInput = HttpUtility.HtmlEncode(input);
    Console.WriteLine($"Processed input: {sanitizedInput}");
}
```

## 7. Documentation Comments

- Use XML documentation comments for functions or methods to improve maintainability and provide documentation.

### Example:

```csharp
/// <summary>
/// Sums two integers.
/// </summary>
/// <param name="a">The first integer.</param>
/// <param name="b">The second integer.</param>
/// <returns>The sum of the two integers.</returns>
int Sum(int a, int b)
{
    return a + b;
}
```

### 8. Use Preprocessors, Macros, or Metaprogramming Techniques Sparingly to Maintain Code Clarity

- Preprocessor directives can be useful for conditional compilation but should be used judiciously to avoid obscuring the code.

### Example:

```csharp
#if DEBUG
Console.WriteLine("Running in Debug mode.");
#else
Console.WriteLine("Running in Release mode.");
#endif

int result = Sum(5, 3);
Console.WriteLine($"The sum is {result}");

int Sum(int a, int b) => a + b;
```

## Example Using Top-Level Statements in .NET 6

Combining several of the above principles:

```csharp
using System;
using System.Globalization;

string userInput = "45";
if (!int.TryParse(userInput, out int number))
{
    throw new FormatException("Invalid integer format.");
}

Console.WriteLine($"Parsed number: {number}");

void ProcessDate(string dateString)
{
    if (DateTime.TryParseExact(dateString, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
    {
        Console.WriteLine($"Parsed date: {date}");
    }
    else
    {
        throw new FormatException("Invalid date format.");
    }
}

ProcessDate("2023-10-31");
```