İletişim / 05
Tanışalım
Yeni bir fikir veya anlamlı bir iş birliği için buradayım.
Aklındaki fikri, problemi ya da projeyi kısaca yaz; birlikte bakalım.
// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);// Application/Orders/CreateOrderHandler.cspublic sealed class CreateOrderHandler : IRequestHandler<CreateOrder, Result<OrderId>>{ public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct) { var order = Order.Create(cmd.CustomerId, cmd.Lines); await _repo.AddAsync(order, ct); await _uow.CommitAsync(ct); return Result.Ok(order.Id); }}# inference/pipeline.pydef predict(model, batch): features = normalize(batch) scores = model(features) return rank(scores, top_k=5)-- reports/latency.sqlSELECT service, p95(duration_ms)FROM tracesWHERE ts > now() - interval '1 day'ORDER BY 2 DESC;// domain/src/lib.rspub trait Repository<T> { fn find(&self, id: Id) -> Option<T>; fn save(&mut self, item: T) -> Result<()>;}// ui/useOrders.tsexport const useOrders = () => useQuery(['orders'], fetchOrders);İletişim / 05
Yeni bir fikir veya anlamlı bir iş birliği için buradayım.
Aklındaki fikri, problemi ya da projeyi kısaca yaz; birlikte bakalım.