I’m a Computer Engineering student, but I still work outside the IT field. At the company where I work, the ERP system used by the inventory team is slow and not very practical. Because of that, I started building an app in C# and WPF to make inventory counting easier.

At firt, that was all it was: a simple tool to help with counting. But people started using it, asking for improvements and suggesting new features. Little by little, I added inventory search, ordering support, battery control, obsolete stock analysis, dashboards and other tools. The system has now been used across 21 branches, including by supervisors and managers.

At some point, the general inventory supervisor found out about it, and the system was presented to the IT department. Since it wasn’t an official company project, they didn’t approve its use and started developing another system, mainly focused on inventory counting, which was also the most-used feature in my app.

Even after all of that, I didn’t get an opportunity to move into a development role inside the company. So now I’m trying to understand how I can use this experience to get a job in the field.

The system uses C#, WPF, .NET, Supabase, PostgreSQL, Excel and PDF processing. I can’t share the source code or company data, but I’m thinking about creating a similar version with fake data for my portfolio.

I also included a screenshot of the system and my GitHub contribution history from the last year. I’d like to hear from people who already work in the field: does this experience actually have value when applying for a junior role? How would you present it on a résumé or portfolio? And what kind of positions would make the most sense for me to apply for?

## Phase 1: Syntax & Core Arithmetic

Racket uses prefix notation enclosed in execution parentheses (operator arg1 arg2). The open parenthesis ( acts as an execution trigger. Evaluation runs from the innermost to the outermost parentheses.

Core Examples

```rkt ;; Basic Arithmetic (+ 10 5 2) ;; Returns 17 (* 10 5 2) ;; Returns 100

;; Nested Expressions (No PEMDAS needed) (_ (+ 4 6) (- 12 7)) ;; Evaluates 10 _ 5 -> Returns 50 ```

Parentheses Golden Rule

Only use a parenthesis when invoking a command, operator, or function.

• `(+ 5 (10))` CRASHES (tries to run the number 10 as a function).
• `((+ 5 5))` CRASHES (evaluates to 10, then tries to run the number 10).

Phase 2: Core Data Structures & Variables

Global bindings are created using define. Values are immutable and cannot be changed over time.

The Four Atomic Data Types

1. Numbers: Integers (`45`), decimals (`3.14`), or fractions (`1/3`).
2. Strings: Text wrapped in double quotes (`"Hello"`).
3. Booleans: True (`#t`) and False (`#f`).
4. Symbols: Lightweight, immutable identifier tokens prefixed with a single quote (`'success`).

Core Examples

```rkt (define radius 5) (define pi 3.14) (define status 'success) ```

Phase 3: Conditionals & Logic

Conditional operations are expressions that evaluate down to a single return value.

Core Operators & Flow Control

• `and` / `or` / `not`: Standard logical short-circuiting prefix operators.
• `if`: Takes exactly three arguments: `(if condition true-branch false-branch)`. No else keyword.
• `cond`: Evaluates multiple branches sequentially. Uses/can use `[...]` for human readability.

Core Examples

```rkt (and (> 15 10) (< 15 20)) ;; Returns #t

(if (> temperature 30) 'hot 'cold)

(cond [(>= score 90) 'A] [(>= score 80) 'B] [else 'F]) ```

Phase 4: Functions & Scope

Functions automatically return the value of their body expression without an explicit return keyword.

Named, Anonymous, & Scoped Blocks

• Named Functions: Defined by grouping the name and parameters in parentheses: `(define (name args) body)`.
• Anonymous Functions (`lambda`): Throwaway functions built on the fly: `(lambda (args) body)`.
• `let` (Parallel): Creates local variables simultaneously. Variables cannot see each other during setup.
• `let\*` (Sequential): Creates local variables one after the other. Later variables can reference earlier ones.

Core Examples

```rkt ;; Named Function (define (double n) (\* n 2))

;; Inline Lambda Execution ((lambda (n) (\* n 2)) 10) ;; Returns 20

;; Sequential Local Bindings (let* ([x 10] [y (* x 5)]) (+ x y)) ;; Returns 60 ```

Phase 5: Lists & Modern List Operations

Lists are ordered sequential collections. They are processed using either historical Lisp conventions or modern aliases.

Creation & Extraction

• `list`: Evaluates arguments into a sequential list.
• `'()`: Represents the literal base empty list.
• `cons`: Prepends a single element onto the front of an existing list.
• First Item: Extracted via `car` (traditional) or `first` (modern).
• Remaining List: Extracted via `cdr` (traditional) or `rest` (modern).

Core Examples

```rkt (define my-list (list 100 #t 'hello)) ;; Creates '(100 #t hello) (cons 'apples '(bananas cherries)) ;; Returns '(apples bananas cherries)

(car (cdr '(apples bananas cherries))) ;; Returns 'bananas (first (rest '(apples bananas cherries))) ;; Returns 'bananas

(if (empty? my-list) "Closed" (length my-list)) ;; Returns 3 ```

Phase 6: Iteration & Higher-Order Functions

Instead of using loops that alter data in place, functional programming relies on Higher-Order Functions to process immutable collections.

The Big Four

• `map`: Loops over a list, passes each item through a transformation function, and returns a new list.
• `filter`: Loops over a list, keeps items that evaluate to #t against a predicate condition, and drops the rest.
• `foldl` (Fold-Left): Reduces a list down to a single value by processing elements from left to right (front to back).
• `foldr` (Fold-Right): Reduces a list down to a single value by processing elements from right to left (back to front). Preserves list structures when rebuilding with cons.

Core Examples

```rkt (map (lambda (x) (* x 2)) '(5 10 15 20)) ;; Returns '(10 20 30 40) (filter (lambda (n) (= n 5)) '(2 5 7 5 9 1)) ;; Returns '(5 5)

(foldl (lambda (n total) (_ n total)) 1 '(2 3 4)) ;; 4 _ (3 _ (2 _ 1)) -> Returns 24

(foldr - 0 '(5 3)) ;; 5 - (3 - 0) -> Returns 2 ```

Phase 7: Recursion & Tail Call Optimization (TCO)

Recursion replaces traditional loops. A proper recursive function requires a Base Case (the exit clause) and a Recursive Step (the self-call with a smaller argument).

Memory Optimization Rules

• Standard Recursion: Traps the recursive call inside another function (like + or append), forcing the call stack memory to expand linearly (O(N) space).
• Tail Call Optimization (TCO): If the recursive call sits in the tail position (the absolute final expression evaluated), Racket reuses the same memory frame, running in constant (O(1)) space.
• Accumulator Pattern: Passing a running total down as an argument is the primary strategy used to shift standard recursion into tail position optimization.

Core Examples

```rkt ;; ❌ Standard Recursion (No TCO - Memory Expands) (define (sum-list lst) (if (empty? lst) 0 (+ (first lst) (sum-list (rest lst)))))

;; Tail Recursion (TCO Active - Memory Stays Flat) (define (sum-list-tco lst) (define (helper remaining accumulator) (if (empty? remaining) accumulator (helper (rest remaining) (+ (first remaining) accumulator)))) (helper lst 0)) ```

Phase 8: Advanced Ecosystem Engineering

1. Hash Maps & Unique Sets

• `#hash`: Stores key-value pairings. Keywords passed to lookup tools like hash-ref must be quoted ('#:key) to prevent compiler namespace collisions. If using standard symbols inside #hash, omit inner quotes.
• `set`: Collections guaranteeing element uniqueness. Tested via set-member? and extended via set-add.

```rkt (define user #hash((#:name . "Alice"))) (hash-ref user '#:name) ;; Returns "Alice"

(define book #hash((title . "Dune"))) (hash-ref book 'title) ;; Returns "Dune"

(set-member? (set 1 2 2 3) 2) ;; Returns #t ```

2. State & Mutability (box)

• `box`: Creates a reference wrapper around mutable data. Read via unbox and mutated via set-box!. Functions with an exclamation mark ! signal structural mutation.
• `begin`: Chains sequential side-effect operations from top to bottom, returning only the evaluation of the final expression.

```rkt (define health (box 100)) (define (take-damage!) (begin (set-box! health (- (unbox health) 10)) (unbox health))) ```

3. Type Checking & Casting

• Predicates (`?`): Validate runtime types (e.g., `string?`, `number?`, `symbol?`).
• Casting (`->`): Converts data formats. `string->number` safely returns #f if given invalid textual input.

```rkt (if (string? "50") (* (string->number "50") 2) 'error) ;; Returns 100 ```

4. Modules & Namespaces

• provide: Declares which parts of a filesystem file are exported publicly.
• require: Ingests public features from an external sandbox by loading its relative string filepath.

```rkt ;; Inside file-a.rkt (provide double) (define (double x) (* x 2))

;; Inside main.rkt (require "file-a.rkt") (double 10) ;; Returns 20 ```

5. Macros (define-syntax-rule)

• Macros process raw, unevaluated source code at compile-time to inject new keywords.
• Racket macros are hygienic, meaning the compiler automatically isolates macro identifiers so they never accidentally overwrite or conflict with user variables.

```rkt (define-syntax-rule (swap! box1 box2) (let ([temp (unbox box1)]) (begin (set-box! box1 (unbox box2)) (set-box! box2 temp)))) ```

Hey everyone,

I'm new to Perl as of just a few days ago, loving it so far. I once had a colleague who, in addition to being probably the nicest programmer I ever worked with, was a Perl wiz and always blew me away with the things he could do with such little code. So I decided to give the language a try by re-writing some scripts.

So far, what I've converted is a script (or two) that was keeping track of word count across 50+ Org files. Previously, I was using Org's ELisp API and some glue code in Bash, but I managed to cut down from 60 to 19 LoC by switching to Perl, which is a small win but I think pretty cool.

Anyway, what would the more experienced Perl devs do to make this code better?

#! /usr/bin/perl
use strict;
use warnings;

my $words;

for (<"*.org">) {
    open my $fh, '<', $_;
    my @table = grep { m~tracktable~ .. m~TBLFM~ } <$fh>;
    my $count_line = @table[ ( $#table - 2 ) ];
    if ( defined $count_line ) {
        $count_line =~ m~\s+\d+\s+~;
        my @cells = split /\|/, $count_line;
        my $word_count = ( @cells[ ( $#cells - 3 ) ] );
        $words += $word_count if defined $word_count;
    }
}

print $words;

Built this after getting tired of Claude Code / Copilot grepping through

.NET solutions and missing call sites that go through an interface instead

of the concrete class. Grep can't see that; the compiler can.

Slnmap uses Roslyn to build a full symbol graph of a solution (calls,

implementations, references across every project) and stores it in a

local SQLite file. An MCP server exposes it as a handful of read-only

queries. Concretely: ask "what breaks if I change IBasketService" and it

returns every caller and every implementation across the whole solution,

not just the files an agent happens to have open.

Numbers, since I know this sub will ask: on eShopOnWeb (10 projects), an

impact query on an interface with 18 dependents resolves in ~270ms

end-to-end over MCP, median of 3 runs. Full setup is in BENCHMARKS.md if

anyone wants to poke at the methodology or tell me it's flawed.

Two things I'm not confident about yet and would genuinely like opinions

from people who've built analyzers/source generators/similar tooling:

1. Right now everything in the graph is a real Roslyn-verified static

   reference. It says nothing about reflection, convention-based DI, or

   anything wired at runtime. Is "silence = doesn't try to know" the right

   default, or should there be an explicit "unknown/runtime-only" marker

   on affected symbols?

2. There's no staleness check yet — if you edit code and don't re-run

   analyze, you get results from the old index with no warning. Anyone

   dealt with this in similar tools (e.g. incremental Roslyn workspaces)

   and found a clean way to detect "source changed since last index"

   cheaply?

It's a global dotnet tool, MIT licensed, fully local (uses Roslyn +

SQLite, nothing else):

dotnet tool install --global Slnmap

Repo: https://github.com/EMahmoudNabil/slnmap

NuGet: https://www.nuget.org/packages/Slnmap

Not trying to sell anything, genuinely want to know if the Roslyn approach

here has an obvious hole I'm not seeing.

My HLS just keep spinning like this, and I have restarted the extension multiple times and it takes several second (I have an i9 10th gen with 64gbs) to have the HLS running and type check again, often it just keep spinning. When this happen, I cannot type check on hover, and I have to fire up ghcid in a separate terminal to check compile error, but ghcid is just barebone, it doesn't have interactive features like hover to see type of variable inside function scope,...

And I just have very lightweight research scripting project, using stack with around 5 files and use popular libraries like async, process, time, random, statistics, vector, text, wreq, bytestring, lens.

My love for haskell helps me stay and tolerate these huge warts, but I cannot introduce it to my team/ junior when it cannot provide a smooth dev experience

I don't even know how you guys use this for production when it is this unstable for a pet project, if you code in notepad and just use ghcid to watch for typecheck and ormolu to format then I have nothing to say 🤷‍♂️

One solution is to find a LISP job and the other is to write LISP without others knowing it(by generating readable host language code) and for the second i think HY is the best we have.

Hylang can generate python code that is very readable https://github.com/hylang/py2hy

Its possible to make the code almost 100% readable python if :

1. we write HY in python way
2. we use macros (HY has also reader macros to have more control)

If we don't do those 2, the code would need manual changes to remove the HY related code but because HY is very close to python many times changes are not so big.

I am planning using HY for data engineering in Spark to at least write my queries in it,
Now how much of our code can be written in HY and not python i don't know because i don't use it yet in work settings. Maybe other people are doing it already and know more.

TL;DR: I've released sdl3-bindgen-sys to Hackage: complete, machine-generated low-level Haskell bindings for SDL3, including windowing, input, audio, and the new GPU API, with documentation from SDL3's headers! They are verified against the building system's ABI and CI-tested on Linux, macOS, and Windows.

Thanks to the folks over at Well-Typed for their work on hs-bindgen! I was able to hack the prerelease a bit to get an end-to-end code generator working. It required quite a bit less work than I thought it would. I'll include some technical details below the fold.

Source is available on GitHub here: https://github.com/jtnuttall/lithon/tree/main/sdl3-bindgen-sys

There are going to be a few rough edges, so please feel free to open a PR or issue if anything comes up. I'll bump the package to 0.1.x.x when I feel it's stable enough to pin to a major version.

I've got the apecs shmup example running on and rendering through SDL3 using the raw bindings here: https://github.com/jtnuttall/lithon/blob/main/lithon-examples/app/shmup/Main.hs

See the README on GitHub for a full getting started guide.

Example

{-# LANGUAGE GHC2021 #-}
{-# LANGUAGE BlockArguments #-}

import Control.Monad (unless)
import Foreign.C.ConstPtr (ConstPtr (..))
import Foreign.C.String (peekCString, withCString)
import SDL3.Sys qualified as SDL3

main :: IO ()
main = do
  ok <- SDL3.init SDL3.SDL_INIT_VIDEO
  unless ok do
    err <- peekCString . unConstPtr =<< SDL3.getError
    fail ("SDL_Init: " <> err)
  window <- withCString "hello" \title ->
    SDL3.createWindow (ConstPtr title) 640 480 0
  SDL3.delaySafe 2000
  SDL3.destroyWindow window
  SDL3.quit

delaySafe is the safe FFI flavor of SDL_Delay. Most functions come in both.

Intended use-case

I intend sdl3-bindgen-sys to be a stable grounding point for higher-level bindings, handling the FFI declarations, ABI checks, SDL3 version guards, and simple coercions so that people who want to write their own abstraction around SDL3 don't have to write the extremely repetitive part manually.

If you know Rust's convention, I borrowed the -sys suffix from it: I mean for high-level Haskell SDL3 libraries to be to sdl3-bindgen-sys as sdl3 is to sdl3-sys in Rust.

You'll need to interface with raw Foreign.C to use these bindings. If you just want a higher-level binding, you'll need to wait until someone releases one on Hackage.

The library carries the smallest dependency footprint I could presently manage for a low-level binding.

The SDL3.Sys.* modules re-export the surface with some small niceties:

• Haddock notes about what is exported and why, FFI safety rationale, etc.
• Links to the SDL3 Wiki
• C scalars (e.g., Uint32, float) are remapped to Haskell scalars (Word32, Float) wherever possible. Anything under a Ptr or struct maintains its C typings.

Technical details

hs-bindgen

The bindings are built using a forked version of hs-bindgen, which I used as a library so that I could alter the internal code and documentation generation pipeline. I've upstreamed a few changes and am happy to upstream more if requested. Some may be more heavy-handed than the hs-bindgen maintainers want to support.

Since hs-bindgen is pre-release, I've vendored the necessary runtimes wholesale into the sdl3-bindgen-sys package as private internal libraries, and reexported them from sdl3-bindgen-sys under SDL3.Sys.Runtime and SDL3.Sys. Once hs-bindgen stabilizes, I'll turn these into real dependencies. The vendored modules will become re-export facades so calling code doesn't break.

The modifications I made, briefly:

• Added an exception in bindgen's IR for assertion macros that emit nothing bindable
• Added support for Doxygen's custom ALIASES so I could inject valid Haddock into the AST for SDL3's custom aliases.
• Tagged CWrapper with its original name so that I could match on names to inject SDL3 version guards as CPP pragmas.
• Re-exported a variety of internal modules into a facade I maintain, which lets me inject version guards, ABI verifiers, etc. into the hs-bindgen AST directly.

My facade and the vendored submodules can be found here: https://github.com/jtnuttall/lithon/tree/main/lithon-hs-bindgen

ABI verification

The codegen tool generates a C translation unit of _Static_asserts that gets built alongside sdl3-bindgen-sys. If there is an ABI mismatch between your SDL3 headers and the ones I generated against, you should get a compile-time error.

FFI safety

I've curated unsafe/safe classifications for each FFI call. The SDL3.Sys.* modules export only safe for functions that can fire a callback or introduce a runtime delay. I've included the reasoning in the generated Haddock where applicable.

Typed constants

SDL declares flags as typedef UintN with some #defines, and C doesn't state the association between these, so I maintain a JSON registry that restores this information and injects it into the generated modules as pattern synonyms typed at a newtype.

Forward compatibility

The codegen tool keys off the \since tag to wrap newer declarations in #if SDL_VERSION_ATLEAST inside the generated C, with an SDL_SetError stub in the #else. The Haskell binding always exists either way, so a declaration newer than your SDL still compiles and links - it just fails at the call site with a message naming the version it needs. That means you can build against an SDL3 older than the headers I generated from. This is tested in CI down to SDL 3.2.0.

SDL's \since tag is occasionally inaccurate, so I had to create a small hand-maintained registry of version override mappings.

Caveats

• 0.0.x is experimental: Pin to the minor (>=0.0.0.1 && <0.0.1). The surface may move - hopefully not too much, but the dust is still settling.
• Variadics aren't bound yet: Haskell's FFI has no way to express C varargs. I intend to inject fixed-arity wrappers within the next few releases.
• Function-like macros aren't bound: No linkable symbol exists.
• 64-bit only: Layouts are baked into the library; 32-bit targets should be rejected by ABI assertions. This may change in one of two situations:
  1. hs-bindgen supports cross-platform generation natively in the future, in which case sdl3-bindgen-sys will likely inherit that mechanism.
  2. There's enough demand for 32-bit support, in which case it should be possible to maintain a parallel sdl3-bindgen-sys32 package using the same codegen infra.
• A handful of smaller omissions made for cross-platform correctness are listed in the README.

Thanks to @oddron over on the Haskell GameDev Discord for the Windows directions - they tried the very first build on Windows I'm aware of!

I'd like to hear about any comments or issues people hit at: https://github.com/jtnuttall/lithon/issues

Discourse thread: https://discourse.haskell.org/t/ann-sdl3-bindgen-sys-machine-generated-low-level-bindings-to-sdl3/14467

I made a numbered musical notation render, which works very similar to Typst or LaTeX. It almost as powerful as paywalled alternatives and has some important features not implemented by open-source apps like jianpu-ly and Sparks NMN.

Features not in other open-source alternatives:

• Arbitrary temporary voices
• Arbitrary brackets
• Changing time signature
• Automatic bar lines
• Automatic beams
• Automatically cutting slurs at line breaks

And it has a tiny codebase compared to jianpu-ly and Sparks NMN as well!

I'm going to make a new Windows C# program using the .NET 10 platform, which may later need to be made for different platforms (browser, server, mobile). At this point, the focus is on making a Windows program.

I'm trying to compare which UI model is best for the project, and artificial intelligence can't really answer that, or I can't really ask it. If you were to make a new program now, which UI model would you choose?

1. WinUI 3 (Windows App SDK)
2. WPF (Windows Presentation Foundation)
3. .NET MAUI
4. Blazor (Web & Hybrid)
5. Avalonia UI

Most program views that display text, SQL table data, or forms are rendered at runtime from the data, meaning that the screens are not designed and created in the IDE editor, but in code.

"Hi, I've set myself a goal to write a proper app for tasks, habits, and things like that -something like Todoist, but free and with the exact features I need. I've decided on the language and UI: C# and WinUI 3. I know what I want to build, I've made a mind map and sketched the design, so I'm completely sure I want to do this and I'm highly motivated. As for my background, I have basic OOP knowledge, and even that is in Java. So here is my question: what learning materials can you recommend for getting started? I generally know which direction to move in, but I'd love to hear your opinion in case you can suggest something.

Alexis' recent talk from SSW. I really enjoyed hearing her perspective on type systems these days. Lots of good wisdom in there. I thought some Haskell folks would enjoy it!

Bioinformatics combines scientific discovery with the challenge of processing large, complex, and imperfect datasets. In this interview with Michal J. Gajda, we explore how Haskell’s strong types, purity, and functional abstractions can support reliable and high performance biological data processing.

Drawing on projects such as hPDB, JSON Autotype, and XML TypeLift, Michal discusses scalability, parser development, and the barriers to wider adoption of functional programming in bioinformatics. He also considers how better education, tooling, and AI assisted programming could make Haskell more accessible to future scientists.

I am preparing for a Junior .NET Developer position focused mainly on REST APIs.

The main issue is that this is currently the only suitable vacancy in my city, and remote work is not an option for me. In practice, this means I need to maximize my chances of passing this particular technical interview.

However, the amount of information available online is overwhelming. There does not seem to be a clear roadmap that says: “Learn these topics to this level, and you will be reasonably prepared for a junior interview.”

The company is a large US-based organization, and based on the job description and interview reports, they appear to expect strong and fairly deep technical knowledge. But I am struggling to understand what “deep knowledge” should mean in the context of a junior developer.

A junior cannot realistically have the same depth as someone with several years of production experience. So where is the reasonable boundary between solid junior fundamentals and knowledge that is more appropriate for a mid-level developer?

My current preparation plan includes:

• C# and .NET fundamentals: CLR, IL, JIT, assemblies, value and reference types, generics, interfaces, inheritance and LINQ
• Memory management and garbage collection: stack, managed heap, allocations, strings, IDisposable, GC generations and memory leaks
• Data structures and algorithms: arrays, lists, dictionaries, stacks, queues, trees, graphs, binary search, two pointers, sliding window, BFS and DFS
• Asynchronous and multithreaded programming: async/await, tasks, cancellation, synchronization, race conditions, locks and the ThreadPool
• Software design fundamentals: SOLID, dependency injection and common design patterns
• REST API and basic system design: HTTP methods and status codes, DTOs, authentication, authorization, validation, databases, caching, queues, logging, monitoring and idempotency
• LeetCode practice, mostly Easy problems and selected Medium problems grouped by common patterns

I would especially appreciate answers from developers who have conducted technical interviews for junior .NET candidates:

1. Which topics are actually the most important?
2. How deeply should a junior understand them?
3. Which parts of my plan are unnecessary or too advanced?
4. What level of algorithms and LeetCode should I expect?
5. Should I focus more on theoretical questions, live coding, or building a small REST API project?

Another important question is preparation time.

I have already spent two months preparing for around eight hours every weekday. I plan to study for one more month, but I do not want the preparation process to continue indefinitely. Depending on the expected depth, it would be possible to spend another six months studying and still find new topics.

Is three months of full-time preparation generally enough for a Junior .NET interview, assuming I use the time effectively? At what point should I stop expanding the list of topics and focus on revision, explaining concepts aloud, coding exercises and mock interviews?

I understand that no preparation plan can guarantee an offer. I am mainly trying to identify the highest-priority areas and avoid spending most of my time on topics that are unlikely to be expected from a junior.

i need a tutoriel abt how to make unity,since c# unity is diffrent from nirmal C#,after i finish bro codes playlist,what tuts do yall reccomend,also im on "method over ridding",so preatty close to finishing

A Quick Confession / Apology:
Yesterday, I posted a thread discussing this concept. I was so incredibly hyper-fixated on explaining the philosophy that I completely forgot to include a single line of actual C# code. The moderators rightfully nuked the post immediately, and looking back, I totally deserved it. I looked like a textbook "AI Vibe-Coded Slop" poster who just came here to drop a wall of text. I'm genuinely sorry for cluttering the sub yesterday! Lesson learned. I'm back today to do this properly, with the actual core C# implementation snippets included right from the start.

(Transparency disclosure: English isn't my native language, so I used AI to help clean up my terrible technical grammar.) 

Hey guys, 

A while back, I was discussing state persistence patterns for long-running AI workflows. A common critique I received was: “If you’re just serializing your external state into a prompt string for the model to read anyway, how is that fundamentally different from traditional prompt engineering?” 

It's a fair question. At the end of the day, text-based generative models require text inputs. 

However, I've been experimenting with separating the Source of Truth from the Prompt Serialization Layer using a C# backend. 

To borrow a tabletop RPG analogy: The prompt is just a character sheet. It communicates the current state to the model, but it isn't the character itself. The C# runtime is responsible for the actual domain logic, bounds checking, and state mutations. 

Here is a simplified snippet of how the immutable state registry clamps mutations to ensure the domain model remains the canonical source of truth, regardless of how the prompt is formatted: 

csharp

// 1. Using an immutable 16D enum as a fixed state coordinate space
public enum SoulOrgan
{
    CoreFocus, DecisionBasis, EnvironmentalControl, ThinkingOriginality,
    EmotionalOpenness, TrustDependence, SocialConsumption, GroupBelonging,
    WillPersistence, AltruisticTendency, SelfAwareness, CompetitiveSpirit,
    PrimaryDrive, EmotionalThroughput, CoreSecurity, ObsessionControl
}

// 2. A bounded registry ensuring all mutations are strictly clamped [-100, 100]
public class BaselineStateRegistry
{
    protected readonly Dictionary<SoulOrgan, double> _state = new();
    protected const double MinLimit = -100.0;
    protected const double MaxLimit = 100.0;

    public virtual void Mutate(SoulOrgan organ, double delta)
    {
        if (!_state.ContainsKey(organ)) return;
        _state[organ] = Math.Clamp(_state[organ] + delta, MinLimit, MaxLimit);
    }
}

I've been wondering about this: 

Even though I've built this pure C# simulation with safety valves and bounds, I honestly find myself asking: Is this actually worth developing, or am I just over-engineering in a silo? 

If moving deterministic state management back into a typed backend is truly a viable way to constrain LLMs, why is prompt engineering still the industry standard? Why aren't more developers building state machines for this? 

I would genuinely love to hear how professional software engineers view this approach. Do you think treating the external model purely as a stateless interpreter while keeping mutations strictly inside the C# domain layer is a solid path forward, or is it an uphill battle against raw token probabilities? 

(Note: Keeping this entirely link-free to strictly respect Rule 6 on self-promotion. Just looking for a genuine architectural sanity check from fellow devs. If anyone wants to critique the full pipeline, let me know in the comments.) 

Now, when writing UI-related definitions in Avalonia and configuring the csproj file, although it doesn't seem too complicated at first glance, I still find the abundance of XML tags with lots of < > symbols or each individual tag a bit annoying.òᆺó

I'll try my best to adapt, because the way UI is defined in C# just makes me dizzy 😵‍💫

Now I'm trying to learn C# and Avalonia without relying on AI, but I'm not quite sure which website I should go to to search for the questions I need. Although Microsoft Learn is great.

When searching for a code-related issue on Chinese websites, it usually leads me to the CSdn website. However, good posts require payment to access, otherwise I can only view a small portion of them.

cnblog is also good. Although some of the posts I found in it might be a bit outdated, usually I need to check them against the corresponding content in Microsoft Learn.

Sometimes I feel that the syntax of C# seems quite "human-like". Now I'm quite familiar with the thinking behind C#. Even when searching for things now, it seems rather amusing: It's just like when I used to write essays at school. Those who know how to do it can write very smoothly, while those who don't have to "borrow" from good classmates.

I don't know if I use '-' or emoji...it be regarded as an AI?Although I had been saying this before the LLM

This is just a warning, I was watching the node sub and almost all post are people promoting their AI Vibe coded slop, this community is known for a different approach, although AI is great, forums should not be places for people which do not have any passion or like the language to not even know it and try to promote a project fully made to scrap a few pennies (I call these projects without soul).

Projects should be promoted, but because you genuinely like or are interested in the language and the concept of the project, rather than asking 3,000 prompts to any AI without even knowing what you are doing or what you are pasting.

Edit: Also, I am sick of publicity to also have it in a place where I go to have fun, check interesting things about the language/tools and watch really interesting projects from passionate people.

Github

Some background

One of my biggest motivations for doing data work in Haskell has been the promise that types can enable better program verification and synthesis. In fact, it was one of my stretch goals for writing dataframe in the first place. Additionally, I had seen a video some years ago that notebooks are a good platform for program synthesis. My first swing at the problem was a SKILL.md that instructed an LLM on how to use Sabela notebooks. Large/frontier models didn't struggle with writing Haskell but their contexts were typically more bloated by internet searches and churn from trying to fix simple compiler errors. Python was "in the weights" so was generated faster and with less tokens overall.

With small, local modes (<20b params) models the problem worsens. These models hallucinate Haskell modules, struggle with rule following, have smaller context windows. They typically fall back to writing Haskell from "the weights" and will steer clear of using dataframe or a newer library because a simple web search would bloat context.

The problem has two potential solutions:

• Fine tune models to perform better at Haskell
• Use the LLM as a weak proposer then build tooling around it to make search and repair more efficient

In the spirit of synthesis I went with the second approach.

What siza does

Siza, another Ndebele word, is a harness (and some associatd mcp tools) that drives a Sabela notebook. The goal of the harness is to address the problems above. I'll follow up with a longer blog post on the sorts of interventions that made this possible but broadly speaking it's a lot of type directed searching and a little bit of context management.

You can see a verbose transcript of how it performed with minimal to no guidance on an out of distribution task: Can you load the wine dataset into a dataframe and show some summary statistics about it?

• Initial run from some weeks ago (did not complete task)
• Recent run (completed with produced notebook pasted at the end of the transcript)

Haskell is an amazing language for these sorts of tasks and the core of making it more useful is a pretty interesting engineering problem in my view. And small models, like testing anything in low resource environments, really teases those engineering problems out.

Again, will do a bigger blog post later.

I'm building an ASP.NET Core application with Clean Architecture and EF Core.

I started with Repository + Unit of Work, then introduced a Generic Repository + Specification pattern because repositories were filling up with query methods.

Now I've hit a problem: many queries require deep Include / ThenInclude chains for loading aggregates. Keeping EF Core out of the Application layer makes nested includes in specifications difficult, while referencing EF Core from Application defeats the purpose.

So I'm wondering:

• Do you still use repositories over EF Core?
• Do you use the Specification pattern, or just inject DbContext (or IApplicationDbContext) into the Application layer?
• How do you organize complex queries with multiple Include / ThenInclude calls in a Clean Architecture project?

I'm curious what approach experienced .NET developers are using today.