Real-world code modernization use cases

/* Original C Claims Processing */
#include <stdio.h>
#include <string.h>

#define APPROVED 'A'
#define DENIED 'D'
#define PENDING 'P'

typedef struct {
    int         claim_id;
    char        policy_number[11];
    double      claim_amount;
    double      deductible;
    double      coverage_limit;
    char
} ClaimRecord;

int main() {
    ClaimRecord claim;

    read_claim (&claim);
    validate_claim (&claim);
    calculate_payout (&claim);
    update_status (&claim);

    return 0;
}

// Migrated Java implementation with modern patterns
@Service
@Transactional
public class ClaimProcessingService {

  @Data
  @Builder
  public static class ClaimRecord {
    private Long claimId;
    private String policyNumber;
    private BigDecimal claimAmount;
    private BigDecimal deductible;
    private BigDecimal coverageLimit;
    private ClaimStatus approvalStatus;
  }

    public ClaimRecord processClaim(ClaimRecord claim) {
// Preserved business logic with enhanced error handling

    validateClaim(claim);
    calculatePayout(claim);
    updateClaimStatus(claim);

// Modern additions: async processing, event publishing
    publishClaimEvent(claim);
    return claimRepository.save(claim);
  }
}

#1/bin/bash
# Cron: 02**/scripts/process_shipments.sh
# Partners upload CSV files via SFTP every 4 hours
sftp -b - $SFTP_USER@SSFTP_SERVER << EOF
cd /inbound
mget PARTNER_SHIPMENT_*. csv bye
EOF

# Process each file sequentially
for file in PARTNER_SHIPMENT_*. csv; do
•/process_shipment.pl §file
mv §file ./processed/
Done

# Converted AWS Lambda Function - Real-time inventory processing
import json
import boto3
from decimal import Decimal

def lambda_handler(event, context):
  """Process inventory changes in real-time as they occur"""
try:
for record in event['Records']:
      transaction = json.loads(record['body'])
      # Real-time inventory update with DynamoDB
      response = inventory_table.update_item(
        Key={
          'store_id': transaction['store_id'],
          'product_id': transaction['product_id']
        },
        UpdateExpression="SET qty_on_hand = qty_on_hand + :qty_change",
        ExpressionAttributeValues={
          ':qty_change': Decimal(str(transaction['quantity_change']))
        }
      )

# Real-time reorder alerts (no more waiting for nightly batch)
      if response['Attributes']['qty_on_hand'] <= response['Attributes']['reorder_point']:
          send_reorder_alert(response['Attributes'])

  except Exception as e:
    logger.error(f"Error processing inventory: {str(e)}")
    raise

// Original Monolithic Trading System
@Component
public class TradingSystemMonolith {
  @Transactional
  public TradeResult executeTrade(TradeRequest request) {
    // Order validation mixed with risk checks
    if (!validateOrder(request)) {
      return TradeResult.rejected("Invalid order");
    }

    // Risk calculation embedded in order flow
    RiskMetrics risk = calculateRisk(request, currentPosition);
    if (risk.getVaR() > getAccountLimit(request.getAccountId())) {
      return TradeResult.rejected("Risk limit exceeded");
    }

    // Settlement logic intertwined with order execution
    Order order = new Order(request);
    db.insert("INSERT INTO orders VALUES (?)", order);

    // Synchronous settlement causing bottlenecks
    Settlement settlement = settlementProcessor.process(order);

    return TradeResult.success(order.getId());
  }
}

// Decomposed Order Management Microservice
@RestController
@RequestMapping("/api/v1/orders")
public class OrderService {

  @PostMapping
  @CircuitBreaker(name = "order-creation")
  public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
    // Focused solely on order management
    Order order = Order.builder()
      .accountId(request.getAccountId())
      .symbol(request.getSymbol())
      .quantity(request.getQuantity())
      .status(OrderStatus.PENDING_RISK_CHECK)
      .build();

    order = orderRepository.save(order);

    // Asynchronous event-driven communication
    eventPublisher.publish(new OrderCreatedEvent(order));

    return ResponseEntity.accepted().body(OrderResponse.from(order));
  }
}

// Risk Calculation Microservice
@Service
public class RiskService {
  @EventListener
  @Async
  public void handleOrderCreated(OrderCreatedEvent event) {
    // Independent risk calculation with its own data store
    RiskAssessment assessment = performRiskAssessment(event.getOrder());

    if (assessment.isApproved()) {
      publishEvent(new RiskApprovedEvent(event.getOrderId(), assessment));
    } else {
      publishEvent(new RiskRejectedEvent(event.getOrderId(), assessment));
    }
  }
}

# Original FTP-based Integration
#!/bin/bash
# Partners upload CSV files to FTP every 4 hours
ftp -inv $FTP_SERVER << EOF
user $FTP_USER $FTP_PASS
cd /inbound
mget PARTNER_SHIPMENT_*.csv
bye
EOF

# Process each file sequentially
for file in PARTNER_SHIPMENT_*.csv; do
  ./process_shipment.pl $file  # No error handling
  mv $file ./processed/
done

// Modern REST API Implementation
export class ShipmentAPIRouter {
  private setupRoutes() {
    // Real-time shipment creation with validation
    this.router.post('/api/v2/shipments',
      this.authenticate,
      this.validateRequest(ShipmentSchema),
      this.rateLimit,
      async (req: Request, res: Response) => {
        try {
          const shipment = await this.createShipment(req.body, req.partner);

          res.status(201).json({
            id: shipment.id,
            status: 'CREATED',
            trackingUrl: `https://track.logistics.com/${shipment.id}`,
            _links: {
              self: `/api/v2/shipments/${shipment.id}`,
              events: `/api/v2/shipments/${shipment.id}/events`
            }
          });

          // Real-time notifications
          this.eventBus.broadcast(shipment.id, {
            type: 'SHIPMENT_CREATED',
            timestamp: new Date().toISOString(),
            data: shipment
          });
        } catch (error) {
          this.handleError(error, res);
        }
      }
    );

    // Backward compatibility endpoint
    this.router.post('/api/v2/shipments/batch',
      this.authenticate,
      upload.single('file'),
      async (req: Request, res: Response) => {
        // Support legacy CSV format while providing modern API benefits
        const shipments = req.body.format === 'csv'
          ? await this.parseCSVFile(req.file)
          : JSON.parse(req.file.buffer.toString());

        const results = await Promise.allSettled(
          shipments.map(s => this.createShipment(s, req.partner))
        );

        res.status(207).json({
          total: results.length,
          successful: results.filter(r => r.status === 'fulfilled').length,
          failed: results.filter(r => r.status === 'rejected').length
        });
      }
    );
  }
}