1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

Yazılım Mimarisi · Yapay Zekâ · Algoritmalar · Programlama · 31 Ekim 2026

Teknoloji Notları

Yazılım mimarisi, yapay zekâ, algoritmalar ve modern programlama teknolojileri üzerine teknik yazılar ve deneyimler.

Teknoloji Notları

Yazılım geliştirme yalnızca kod yazmaktan ibaret değil; doğru problemleri anlamak, doğru teknolojileri seçmek ve sürdürülebilir çözümler üretmektir.

Bu blogda yazılım geliştirme sürecinde edindiğim deneyimleri, araştırmalarımı ve teknik notlarımı paylaşıyorum.

Yazılım Mimarisi

Clean Architecture, Domain-Driven Design (DDD), CQRS, modüler mimari ve sürdürülebilir yazılım geliştirme yaklaşımları.

Yapay Zekâ

Makine öğrenmesi, büyük dil modelleri (LLM), OCR ve yapay zekâ destekli uygulamalar.

Algoritmalar ve Programlama

Veri yapıları, algoritma analizi, Rust, C#, Python ve performans odaklı programlama.

Gerçek Projelerden Öğrendiklerim

Teorik bilgileri gerçek projelerde uygulamayı, karşılaştığım teknik problemleri ve geliştirdiğim çözümleri paylaşmayı önemsiyorum.

Öğrenmek, üretmek ve paylaşmak.