Algorithms & Data Structures 2
▼
Understands Big-O notation and basic algorithms. Uses LINQ (OrderBy, Where, GroupBy) with complexity understanding. Chooses between List<T>, Dictionary<TK,TV>, HashSet<T> for tasks.
Optimizes LINQ chains for large collections through Span<T> and ArrayPool. Implements traversal algorithms for TreeView models. Profiles bottlenecks through BenchmarkDotNet.
Conducts algorithmic reviews for .NET desktop projects. Defines performance standards. Mentors on algorithm optimization in C#.
Shapes algorithmic standards for .NET desktop organization. Evaluates .NET runtime optimizations (JIT, PGO). Defines performance architecture.
Uses .NET collections: List<T>, Dictionary<TK,TV>, Queue<T>, Stack<T>. Works with ObservableCollection<T> for WPF DataBinding. Understands IEnumerable<T> and deferred execution.
Creates custom ObservableCollection with filtering/sorting through CollectionViewSource. Uses ImmutableList<T>/ImmutableDictionary for thread-safe data. Applies ReadOnlyObservableCollection for encapsulation.
Defines data layer standards for .NET desktop. Coordinates collection selection for performance-critical code. Mentors on data structures in .NET.
Shapes enterprise data handling standards for .NET desktop. Evaluates new collection types (.NET 9+). Defines data architecture for the organization.
Application Security 1
▼
Knows OWASP Desktop Application Security. Understands secure storage through Windows DPAPI (ProtectedData). Avoids hardcoded secrets. Validates user input in WPF/WinUI.
Applies OWASP for .NET desktop: secure communication (HttpClient + TLS), input validation through DataAnnotations, secure logging. Configures code signing through Authenticode. Conducts security self-review.
Defines security strategy for .NET desktop team. Establishes security guidelines. Coordinates security audit and penetration testing.
Shapes enterprise security standards for .NET desktop. Evaluates compliance (SOC2, HIPAA). Defines secure SDLC for the organization.
CI/CD 1
▼
Understands CI/CD for .NET desktop. Configures GitHub Actions with dotnet build/test/publish. Runs basic workflow for a single platform.
Configures matrix build for .NET on Windows/Linux/macOS. Caches NuGet packages. Automates MSIX/WiX packaging and artifact upload. Integrates code analysis.
Defines CI/CD strategy for .NET desktop team. Coordinates release automation. Introduces quality gates.
Shapes enterprise CI/CD standards for .NET desktop. Evaluates CI platforms. Defines build infrastructure.
Clean Code & Refactoring 1
▼
Follows team coding standards for C#. Uses EditorConfig and .NET analyzers. Applies nullable reference types. Passes code review without critical comments.
Configures StyleCop, SonarAnalyzer for static analysis. Uses Roslyn analyzers and code fixes. Applies code metrics (cyclomatic complexity, coupling). Writes self-documenting code with XML comments.
Establishes code quality standards for .NET desktop team. Defines metrics, coordinates technical debt. Introduces automated quality gates.
Shapes enterprise code quality standards for .NET desktop. Defines best practices at organizational level. Coordinates quality across teams.
Code Review 1
▼
Participates in code review as a reviewee for C#/.NET code. Applies reviewer feedback. Leaves comments on readability and naming conventions.
Conducts code review for C#/.NET desktop code. Checks async/await correctness, MVVM adherence, memory management. Provides constructive feedback. Reviews XAML.
Defines code review process for .NET desktop team. Establishes review checklist. Coordinates review workflow.
Shapes enterprise code review standards for .NET desktop. Defines review culture. Coordinates cross-team reviews.
Concurrency & Parallelism 2
▼
Understands async/await in C#. Uses Task.Run to offload work from UI thread. Handles async events in WPF/WinUI. Knows ConfigureAwait(false) for library code.
Applies IAsyncEnumerable for streaming data. Implements async initialization through AsyncLazy. Uses Polly for retry/circuit-breaker in async operations. Handles async exceptions through ExceptionDispatchInfo.
Defines async strategy for .NET desktop platform. Establishes async coding standards. Coordinates transition to new async patterns in .NET.
Shapes enterprise async standards for .NET desktop. Evaluates async evolution in .NET (task groups, structured concurrency). Defines async architecture for the organization.
Understands multithreading in .NET: Task, Thread, ThreadPool. Uses Dispatcher.Invoke for UI thread access in WPF. Knows async/await at basic level. Avoids deadlocks when accessing UI.
Implements concurrent operations through Task Parallel Library (TPL). Uses CancellationToken for operation cancellation. Applies SemaphoreSlim, lock, ReaderWriterLockSlim for synchronization. Works with Channels.
Defines concurrency model for .NET desktop platform. Establishes async/await standards, coordinates thread safety. Conducts concurrent code reviews.
Shapes enterprise concurrency standards for .NET desktop. Evaluates .NET threading model evolution (green threads). Defines parallelism strategy for the organization.
Cross-Platform Desktop 2
▼
Understands auto-update principles for .NET desktop. Familiar with ClickOnce deployment and Squirrel.Windows. Tests updates on local builds through Visual Studio publish.
Implements auto-update through Velopack or AutoUpdater.NET. Configures delta updates, signature verification through Authenticode. Works with update channels (stable/beta). Integrates update UI into application.
Defines update strategy for .NET desktop. Coordinates update pipeline with CI/CD (GitHub Actions/Azure DevOps). Establishes SLA for update delivery.
Shapes enterprise update strategy for .NET desktop. Designs centralized update infrastructure with SCCM/Intune integration. Evaluates Windows App SDK update capabilities.
Knows .NET desktop packaging basics: dotnet publish, self-contained deployment. Creates MSIX packages through Visual Studio. Understands Framework-dependent vs Self-contained deployment.
Configures MSIX packaging with Windows Application Packaging Project. Creates WiX installers for enterprise. Signs packages through signtool. Automates packaging through MSBuild targets.
Defines .NET desktop distribution strategy. Coordinates packaging with CI/CD, establishes signing and notarization standards. Plans enterprise distribution through Intune/SCCM.
Shapes enterprise packaging standards for .NET desktop. Evaluates deployment technologies (MSIX, ClickOnce, WiX, Squirrel). Designs scalable distribution infrastructure.
Desktop Patterns 2
▼
Understands IPC in .NET: Named Pipes (System.IO.Pipes), Memory-Mapped Files. Implements simple communication through NamedPipeServerStream/NamedPipeClientStream. Uses Process for launching child processes.
Develops IPC through gRPC (Grpc.Net) for structured communication. Uses Memory-Mapped Files for shared data. Implements single-instance through Mutex. Applies SignalR for local real-time communication.
Defines IPC strategy for .NET desktop platform. Establishes protocol standards, coordinates compatibility between .NET and native components through P/Invoke.
Shapes enterprise IPC standards for .NET desktop. Designs scalable IPC infrastructure. Evaluates new approaches (.NET Channels, StreamJsonRpc).
Understands MVVM in WPF/WinUI context. Uses CommunityToolkit.Mvvm with ObservableObject and RelayCommand. Implements DataBinding through {Binding} and {x:Bind}. Separates View and ViewModel.
Applies MVVM with ObservableValidator for validation. Uses IMessenger (WeakReferenceMessenger) for inter-ViewModel communication. Organizes navigation through INavigationService. Implements async commands.
Defines MVVM standards for .NET desktop team. Establishes coding guidelines, conducts architecture review. Mentors on MVVM patterns in WPF/WinUI.
Shapes UI architecture standards for .NET desktop organization. Evaluates MVVM vs MVU (Comet/Fabulous) for different projects. Defines enterprise UI patterns.
Git & Workflows 1
▼
Uses Git for daily work: commit, push, pull, branch. Understands gitflow for .NET projects. Works with .gitignore to exclude bin/obj/packages.
Applies Git rebase, cherry-pick, bisect. Configures Git hooks with dotnet-format pre-commit. Works with Git submodules for shared libraries. Resolves merge conflicts in .csproj and XAML.
Defines Git strategy for .NET desktop team. Establishes branching model and release process. Coordinates merge policies.
Shapes enterprise Git strategy for .NET desktop. Evaluates monorepo vs polyrepo. Defines Git governance for the organization.
Memory Management 2
▼
Understands GC in .NET: Gen0/Gen1/Gen2, LOH. Uses using/IDisposable for unmanaged resources. Knows the difference between class and struct. Avoids memory leaks through event unsubscription in WPF.
Manages memory through Span<T>, Memory<T>, ArrayPool<T>. Analyzes GC pressure through dotnet-counters. Optimizes struct vs class selection for hot paths. Uses WeakReference for cache patterns.
Defines memory management strategy for .NET desktop. Establishes memory budgets. Coordinates GC tuning and optimization sprints.
Shapes enterprise memory standards for .NET desktop. Evaluates .NET runtime memory improvements. Defines memory architecture for the organization.
Uses Visual Studio Diagnostic Tools for .NET memory analysis. Knows dotnet-dump for heap analysis. Interprets memory snapshots for finding leaks in WPF.
Profiles .NET desktop through dotMemory or VS Memory Profiler. Analyzes allocation timeline, finds retention paths. Uses EventPipe for lightweight profiling in production.
Defines memory profiling strategy for .NET desktop. Establishes memory SLA and regression policies. Coordinates memory optimization sprints.
Shapes enterprise memory profiling standards for .NET desktop. Evaluates profiling tools (dotMemory, PerfView, VS). Defines memory requirements for the organization.
Native Desktop Development 1
▼
Knows WPF/WinUI 3 and XAML basics. Creates simple windows with DataBinding and styles. Works in Visual Studio with XAML Designer, uses basic controls (Button, TextBox, ListView).
Independently develops WPF/WinUI applications with MVVM through CommunityToolkit.Mvvm. Creates custom UserControl and ControlTemplate. Works with DataTemplate, IValueConverter. Uses Navigation through Frame.
Defines .NET desktop technical strategy (WPF vs WinUI 3 vs MAUI). Establishes UI standards and component library. Conducts architecture review, plans migration to new .NET versions.
Defines .NET desktop UI strategy at organizational level. Evaluates WPF/WinUI 3/MAUI for enterprise scenarios. Shapes enterprise UI framework and design system.
OOP & Design Patterns 2
▼
Knows patterns in .NET: Observer (INotifyPropertyChanged), Singleton (DI singleton), Factory (IServiceProvider). Applies Command through ICommand/RelayCommand in WPF/WinUI. Uses Repository pattern.
Implements MVVM with Command, Mediator (MediatR), Observer. Applies Strategy through DI for swappable algorithms. Uses Decorator for cross-cutting concerns (logging, caching). Understands Unit of Work with EF Core.
Defines architectural patterns for .NET desktop team. Conducts design reviews, selects optimal patterns. Establishes pattern catalog for the team.
Shapes pattern catalog for .NET desktop organization. Adapts patterns for WPF/WinUI/MAUI. Publishes best practices on architectural patterns.
Understands OOP in C#: classes, interfaces, inheritance, polymorphism. Uses abstract/virtual/override. Knows the difference between class and record. Applies encapsulation through properties and init-only setters.
Designs classes following SOLID in WPF/WinUI context. Uses dependency injection through constructor injection. Applies interfaces for testability. Understands pattern matching with is/switch expressions.
Defines OOP standards for .NET desktop team. Conducts design review. Establishes coding guidelines for composition, DI, interface design.
Shapes OOP standards for .NET desktop organization. Defines balance between OOP, FP (LINQ, pattern matching) and data-oriented design. Consults architects.
Optimization 1
▼
Measures UI operation latency via Stopwatch. Understands 16ms budget for 60fps. Avoids blocking calls on UI thread. Uses VS Performance Profiler.
Optimizes startup through lazy loading, ReadyToRun, trimming. Reduces UI render latency through VirtualizingStackPanel. Uses async rendering for heavy UI. Profiles with PerfView.
Defines latency SLA for .NET desktop. Coordinates latency optimization. Introduces automated latency monitoring in CI.
Shapes enterprise latency standards for .NET desktop. Evaluates NativeAOT and ahead-of-time compilation. Defines latency architecture.
Profiling 1
▼
Uses Visual Studio Performance Profiler for CPU analysis. Knows dotnet-trace for collection. Interprets flame graphs to find hot methods in .NET.
Profiles .NET desktop through dotnet-trace and PerfView. Analyzes JIT compilation and GC pause times. Uses BenchmarkDotNet for micro-benchmarks. Optimizes hot paths.
Defines CPU profiling strategy for .NET desktop. Establishes performance budgets. Coordinates performance optimization sprints.
Shapes enterprise CPU profiling standards for .NET desktop. Evaluates .NET runtime optimizations. Defines performance architecture.
Unit Testing 1
▼
Writes unit tests through xUnit/NUnit for .NET desktop. Uses Assert, [Fact], [Theory] with InlineData. Tests ViewModel logic separately from View. Understands Arrange-Act-Assert.
Structures tests by modules. Uses Moq/NSubstitute for dependency mocking. Introduces code coverage through coverlet. Applies FluentAssertions for readable assertions.
Defines testing strategy for .NET desktop team. Establishes coverage targets and quality gates. Coordinates test infrastructure.
Shapes enterprise testing standards for .NET desktop. Evaluates testing frameworks and methodologies. Defines testing maturity model.
Web Frameworks 1
▼
Knows ASP.NET basics for desktop-backend. Uses HttpClient for API calls. Understands DI through IServiceCollection. Works with Entity Framework Core at basic level.
Develops embedded web server through Kestrel/WebApplication for desktop. Uses SignalR for real-time communication. Applies EF Core with migrations for local database. Implements background services through IHostedService.
Defines .NET platform strategy for desktop. Coordinates shared code between desktop and web. Establishes .NET best practices for the team.
Shapes enterprise .NET strategy for desktop. Evaluates .NET roadmap (MAUI, Blazor Hybrid, AOT). Defines .NET adoption strategy for the organization.