From Hello, World
to systems that move real money.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

public class Student
{
    public int Id { get; init; }
    public string Name { get; init; } = "";
    public List<Module> Modules { get; } = new();

    public decimal Average() =>
        Modules.Count == 0 ? 0 : Modules.Average(m => m.Mark);
}

CREATE PROCEDURE dbo.usp_GetOpenOrders
    @CustomerId INT,
    @Since      DATETIME2
AS
BEGIN
    SET NOCOUNT ON;

    SELECT o.OrderId, o.Total, o.CreatedAt
    FROM dbo.Orders AS o
    WHERE o.CustomerId = @CustomerId
      AND o.Status = 'Open'
      AND o.CreatedAt >= @Since
    ORDER BY o.CreatedAt DESC;
END

export function LiveScore({ feed }: { feed: Match[] }) {
  const [live, setLive] = useState(feed);

  useEffect(() => {
    const unsub = subscribe((m) =>
      setLive((prev) => prev.map((x) => (x.id === m.id ? m : x))));
    return unsub;
  }, []);

  return <ScoreList matches={live} />;
}

trigger:
  branches:
    include: [ main ]

stages:
  - stage: Build
    jobs:
      - job: build_and_test
        steps:
          - task: DotNetCoreCLI@2
            inputs: { command: build }
          - task: DotNetCoreCLI@2
            inputs: { command: test }

public interface ITenantContext
{
    Guid TenantId { get; }
    string ConnectionString { get; }
}

app.Use(async (ctx, next) =>
{
    var tenant = await resolver.ResolveAsync(ctx.Request.Host);
    ctx.Items["tenant"] = tenant;
    await next();
});

public async Task<ReadResult> ReadAsync(Stream pdf, DocType type)
{
    // cheap path first: text that is already in the PDF
    var text = await _pdfText.ExtractAsync(pdf);
    if (string.IsNullOrWhiteSpace(text))
        text = await _ocr.RecogniseAsync(await _raster.ToImagesAsync(pdf));

    var match = _patterns[type].Match(text);
    return match.Success ? ReadResult.Found(match) : ReadResult.NeedsReview(text);
}

export function useTickets(filters: Ref<TicketFilters>) {
  const tickets = ref<Ticket[]>([]);
  const loading = ref(false);

  watch(filters, async (f) => {
    loading.value = true;
    tickets.value = await api.tickets.list(f);
    router.replace({ query: toQuery(f) }); // filters survive a refresh
    loading.value = false;
  }, { deep: true, immediate: true });

  return { tickets, loading };
}

public string CreateLink(string accountRef, TimeSpan ttl)
{
    var payload = new LinkPayload(accountRef, DateTimeOffset.UtcNow.Add(ttl));
    var token = _protector.Protect(JsonSerializer.Serialize(payload));
    return $"{_options.PortalUrl}/auto-login?t={Uri.EscapeDataString(token)}";
}

var dense  = await _vectors.SearchAsync(await _embed.EmbedAsync(question), top: 40);
var sparse = await _lexical.SearchAsync(question, top: 40);

// fuse both result lists, then keep only chunks we can cite
var ranked = ReciprocalRankFusion.Merge(dense, sparse)
    .Where(c => c.Source is not null)
    .Take(8)
    .ToList();

## Microsoft Certified: AI Transformation Leader

- Earned: 11 September 2026
- Score: 90%
- Verify: learn.microsoft.com/users/preshennaidoo-0314

> Next up: hands-on Azure AI certifications

export const next = {
  role: "Intermediate Software Developer",
  focus: ["AI integration", ".NET", "distributed systems"],
  certifications: ["Azure AI Engineer"],
  location: "remote | hybrid",
} as const;