Engineering Tools Ecosystem

# C++ Modern Toolchain (2024+)

# Build system
# cmake -B build -DCMAKE_BUILD_TYPE=Release
# cmake --build build

# clang-format (formatting)
# clang-tidy (static analysis)
# clangd (LSP)

# .clang-format
# BasedOnStyle: LLVM
# IndentWidth: 4
# ColumnLimit: 100

# clang-tidy config
# Checks: "**"
# WarningsAsErrors: ""

# vcpkg for package management
# vcpkg install fmt spdlog boost-asio

# Testing: Catch2, GoogleTest
# Mutation: Mull
# Coverage: gcov/lcov/gcovr

// Java Modern Toolchain (2024+)

// Build: Maven or Gradle (Kotlin DSL preferred)
// build.gradle.kts
plugins {
    id("java")
    id("application")
    id("org.springframework.boot") version "3.2.0"
}

java {
    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.0")
    testImplementation("org.mockito:mockito-core:5.8.0")
}

// Linting: SpotBugs, Checkstyle, Error Prone (via Gradle plugins)
// Testing: JUnit 5 + AssertJ + Mockito
// Mutation: PITest

// C# Modern Toolchain (2024+)

// .csproj (modern SDK-style)
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.*" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.*" />
    <PackageReference Include="FluentValidation.AspNetCore" Version="11.*" />
  </ItemGroup>
</Project>

// Linting: dotnet format --verify-no-changes
// Testing: xUnit + xUnit.extensibility + FluentAssertions + AutoFixture
// Mutation: Stryker.NET

# Gemfile — modern Ruby toolchain
# gem "rubocop", require: false        # lint + style
# gem "rspec"                          # tests
# gem "simplecov", require: false      # coverage
# gem "mutant-rspec", require: false   # mutation testing

# .rubocop.yml
# AllCops:
#   TargetRubyVersion: 3.3
#   NewCops: enable
# Layout/LineLength:
#   Max: 100

# .rspec
# --require spec_helper --format documentation

# spec/spec_helper.rb — coverage gate
require "simplecov"
SimpleCov.start do
  minimum_coverage 85
  add_filter "/spec/"
end

// Pulumi C++ infrastructure as code
#include <pulumi/pulumi.hpp>
#include <pulumi/aws/s3/bucket.hpp>

int main() {
    pulumi::Run([]() {
        auto bucket = std::make_shared<aws::s3::Bucket>("my-bucket", 
            pulumi::Args{
                {"versioning", pulumi::Object{
                    {"enabled", true}
                }},
                {"serverSideEncryptionConfiguration", pulumi::Object{
                    {"rule", pulumi::Object{
                        {"applyServerSideEncryptionByDefault", pulumi::Object{
                            {"sseAlgorithm", "AES256"}
                        }}
                    }}
                }}
            )
        });
    });
    return 0;
}

// Pulumi Java example
import com.pulumi.Pulumi;
import com.pulumi.aws.s3.Bucket;
import com.pulumi.aws.s3.BucketArgs;
import com.pulumi.aws.s3.inputs.BucketVersioningArgs;

public class MyStack {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var bucket = new Bucket("my-bucket", BucketArgs.builder()
                .versioning(BucketVersioningArgs.builder().enabled(true).build())
                .serverSideEncryptionConfiguration(List.of(
                    BucketServerSideEncryptionConfigurationArgs.builder()
                        .rule(BucketServerSideEncryptionRuleArgs.builder()
                            .applyServerSideEncryptionByDefault(
                                ServerSideEncryptionByDefaultArgs.builder()
                                    .sseAlgorithm("AES256")
                                    .build())
                            .build())
                ))
                .build());
        });
    }
}

// Pulumi C# Example
using Pulumi;
using Pulumi.Aws.S3;

class MyStack : Stack
{
    public MyStack()
    {
        var bucket = new Bucket("my-bucket", new BucketArgs
        {
            Versioning = new BucketVersioningArgs { Enabled = true },
            ServerSideEncryptionConfiguration = new[]
            {
                new BucketServerSideEncryptionConfigurationArgs
                {
                    Rule = new BucketServerSideEncryptionRuleArgs
                    {
                        ApplyServerSideEncryptionByDefault = 
                            new ServerSideEncryptionByDefaultArgs
                            {
                                SseAlgorithm = "AES256"
                            }
                        }
                    }
                }
        });
    }
}

// OpenTelemetry C++
#include <opentelemetry/trace/provider.h>
#include <opentelemetry/exporters/otlp/otlp_http_exporter_factory.h>
#include <opentelemetry/sdk/trace/simple_processor_factory.h>
#include <opentelemetry/sdk/trace/tracer_provider_factory.h>

using namespace opentelemetry::trace;
using namespace opentelemetry::sdk::trace;
using namespace opentelemetry::exporter::otlp;

void InitTracer() {
    auto exporter = OtlpHttpExporterFactory::Create(OtlpHttpExporterOptions{
        .endpoint = "http://localhost:4317/v1/traces"
    });
    auto processor = SimpleSpanProcessorFactory::Create(std::move(exporter));
    auto provider = TracerProviderFactory::Create(std::move(processor));
    Provider::SetTracerProvider(provider);
}

auto tracer = trace::Provider::GetTracerProvider()->GetTracer("my-service");

Money calculate_discount(Customer customer, Cart cart) {
    auto span = tracer->StartSpan("calculate_discount");
    auto scope = opentelemetry::trace::Scope(span);
    span->SetAttribute("customer.tier", customer.tier);
    span->SetAttribute("cart.total", cart.total());
    // ... logic
}

// OpenTelemetry Java
import io.opentelemetry.api.trace.*;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.sdk.trace.*;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;

public class TracingConfig {
    public static void init() {
        var exporter = OtlpGrpcSpanExporter.builder()
            .setEndpoint("http://localhost:4317")
            .build();

        var processor = BatchSpanProcessor.builder(exporter).build();
        var provider = SdkTracerProvider.builder()
            .addSpanProcessor(processor)
            .build();

        GlobalOpenTelemetry.resetFor(
            OpenTelemetrySdk.builder()
                .setTracerProvider(provider)
                .buildAndRegisterGlobal()
        );
    }
}

// Usage
Tracer tracer = GlobalOpenTelemetry.getTracer("my-service");

@WithSpan("calculate_discount")
public Money calculateDiscount(Customer customer, Cart cart) {
    Span span = Span.current();
    span.setAttribute("customer.tier", customer.getTier());
    span.setAttribute("cart.total", cart.getTotal());
    // ... logic
}

// OpenTelemetry .NET
using OpenTelemetry;
using OpenTelemetry.Trace;
using OpenTelemetry.Exporter.OpenTelemetryProtocol;
using OpenTelemetry.Resources;
using OpenTelemetry.Instrumentation.AspNetCore;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddOpenTelemetry()
    .WithTracing(builder => builder
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddSource("MyApp")
        .SetResourceBuilder(ResourceBuilder.CreateDefault()
            .AddService("MyApp"))
        .AddOtlpExporter(options => {
            options.Endpoint = new Uri("http://localhost:4317");
        })
    );

// Usage
var tracer = TracerProvider.Default.GetTracer("MyApp");

using var span = tracer.StartActiveSpan("calculate_discount");
span.SetAttribute("customer.tier", customer.Tier);
span.SetAttribute("cart.total", cart.Total);
// ... logic

# Ruby instrumentation
# gem install opentelemetry-sdk opentelemetry-exporter-otlp \
#             opentelemetry-instrumentation-all

require "opentelemetry/sdk"
require "opentelemetry/instrumentation/all"

OpenTelemetry::SDK.configure do |c|
  c.service_name = "pricing-service"
  c.use_all # auto-instrument every supported library
end

# Manual instrumentation for business logic
TRACER = OpenTelemetry.tracer_provider.tracer("pricing")

def calculate_discount(customer, cart)
  TRACER.in_span("calculate_discount") do |span|
    span.set_attribute("customer.tier", customer.tier)
    span.set_attribute("cart.total", cart.total.to_f)
    # ... logic
  end
end